Copy disabled (too large)
Download .txt
Showing preview only (26,394K chars total). Download the full file to get everything.
Repository: OpenCalib/JointCalib
Branch: master
Commit: 6cb94c518b25
Files: 2358
Total size: 24.7 MB
Directory structure:
gitextract_9m3jpr9e/
├── .gitignore
├── 3rdparty/
│ ├── CMakeLists.txt
│ ├── ceres/
│ │ ├── .clang-format
│ │ ├── .travis.yml
│ │ ├── BUILD
│ │ ├── CMakeLists.txt
│ │ ├── CONTRIBUTING.md
│ │ ├── LICENSE
│ │ ├── README.md
│ │ ├── WORKSPACE
│ │ ├── bazel/
│ │ │ └── ceres.bzl
│ │ ├── cmake/
│ │ │ ├── AddCompileFlagsIfSupported.cmake
│ │ │ ├── AddGerritCommitHook.cmake
│ │ │ ├── AppendTargetProperty.cmake
│ │ │ ├── CeresCompileOptionsToComponents.cmake
│ │ │ ├── CeresConfig.cmake.in
│ │ │ ├── CeresThreadingModels.cmake
│ │ │ ├── CheckIfUnderscorePrefixedBesselFunctionsExist.cmake
│ │ │ ├── CreateCeresConfig.cmake
│ │ │ ├── DetectBrokenStackCheckMacOSXcodePairing.cmake
│ │ │ ├── EnableSanitizer.cmake
│ │ │ ├── FindAccelerateSparse.cmake
│ │ │ ├── FindCXSparse.cmake
│ │ │ ├── FindGlog.cmake
│ │ │ ├── FindSphinx.cmake
│ │ │ ├── FindSuiteSparse.cmake
│ │ │ ├── FindTBB.cmake
│ │ │ ├── PrettyPrintCMakeList.cmake
│ │ │ ├── ReadCeresVersionFromSource.cmake
│ │ │ ├── UpdateCacheVariable.cmake
│ │ │ ├── config.h.in
│ │ │ ├── iOS.cmake
│ │ │ └── uninstall.cmake.in
│ │ ├── config/
│ │ │ └── ceres/
│ │ │ └── internal/
│ │ │ └── config.h
│ │ ├── data/
│ │ │ ├── 2x2.foe
│ │ │ ├── 3x3.foe
│ │ │ ├── 5x5.foe
│ │ │ ├── README.foe
│ │ │ ├── ceres_noisy.pgm
│ │ │ ├── libmv-ba-problems/
│ │ │ │ └── Readme.txt
│ │ │ └── problem-16-22106-pre.txt
│ │ ├── docs/
│ │ │ ├── CMakeLists.txt
│ │ │ └── source/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── _templates/
│ │ │ │ └── layout.html
│ │ │ ├── analytical_derivatives.rst
│ │ │ ├── automatic_derivatives.rst
│ │ │ ├── bibliography.rst
│ │ │ ├── conf.py
│ │ │ ├── contributing.rst
│ │ │ ├── derivatives.rst
│ │ │ ├── faqs.rst
│ │ │ ├── features.rst
│ │ │ ├── gradient_solver.rst
│ │ │ ├── gradient_tutorial.rst
│ │ │ ├── index.rst
│ │ │ ├── installation.rst
│ │ │ ├── interfacing_with_autodiff.rst
│ │ │ ├── license.rst
│ │ │ ├── modeling_faqs.rst
│ │ │ ├── nnls_covariance.rst
│ │ │ ├── nnls_modeling.rst
│ │ │ ├── nnls_solving.rst
│ │ │ ├── nnls_tutorial.rst
│ │ │ ├── numerical_derivatives.rst
│ │ │ ├── solving_faqs.rst
│ │ │ ├── spivak_notation.rst
│ │ │ ├── tutorial.rst
│ │ │ ├── users.rst
│ │ │ └── version_history.rst
│ │ ├── include/
│ │ │ └── ceres/
│ │ │ ├── autodiff_cost_function.h
│ │ │ ├── autodiff_first_order_function.h
│ │ │ ├── autodiff_local_parameterization.h
│ │ │ ├── c_api.h
│ │ │ ├── ceres.h
│ │ │ ├── conditioned_cost_function.h
│ │ │ ├── context.h
│ │ │ ├── cost_function.h
│ │ │ ├── cost_function_to_functor.h
│ │ │ ├── covariance.h
│ │ │ ├── crs_matrix.h
│ │ │ ├── cubic_interpolation.h
│ │ │ ├── dynamic_autodiff_cost_function.h
│ │ │ ├── dynamic_cost_function.h
│ │ │ ├── dynamic_cost_function_to_functor.h
│ │ │ ├── dynamic_numeric_diff_cost_function.h
│ │ │ ├── evaluation_callback.h
│ │ │ ├── first_order_function.h
│ │ │ ├── gradient_checker.h
│ │ │ ├── gradient_problem.h
│ │ │ ├── gradient_problem_solver.h
│ │ │ ├── internal/
│ │ │ │ ├── algorithm.h
│ │ │ │ ├── array_selector.h
│ │ │ │ ├── autodiff.h
│ │ │ │ ├── config.h
│ │ │ │ ├── disable_warnings.h
│ │ │ │ ├── eigen.h
│ │ │ │ ├── fixed_array.h
│ │ │ │ ├── householder_vector.h
│ │ │ │ ├── integer_sequence.h
│ │ │ │ ├── integer_sequence_algorithm.h
│ │ │ │ ├── line_parameterization.h
│ │ │ │ ├── memory.h
│ │ │ │ ├── numeric_diff.h
│ │ │ │ ├── parameter_dims.h
│ │ │ │ ├── port.h
│ │ │ │ ├── reenable_warnings.h
│ │ │ │ └── variadic_evaluate.h
│ │ │ ├── iteration_callback.h
│ │ │ ├── jet.h
│ │ │ ├── local_parameterization.h
│ │ │ ├── loss_function.h
│ │ │ ├── normal_prior.h
│ │ │ ├── numeric_diff_cost_function.h
│ │ │ ├── numeric_diff_options.h
│ │ │ ├── ordered_groups.h
│ │ │ ├── problem.h
│ │ │ ├── rotation.h
│ │ │ ├── sized_cost_function.h
│ │ │ ├── solver.h
│ │ │ ├── tiny_solver.h
│ │ │ ├── tiny_solver_autodiff_function.h
│ │ │ ├── tiny_solver_cost_function_adapter.h
│ │ │ ├── types.h
│ │ │ └── version.h
│ │ ├── internal/
│ │ │ └── ceres/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── accelerate_sparse.cc
│ │ │ ├── accelerate_sparse.h
│ │ │ ├── algorithm_test.cc
│ │ │ ├── array_selector_test.cc
│ │ │ ├── array_utils.cc
│ │ │ ├── array_utils.h
│ │ │ ├── array_utils_test.cc
│ │ │ ├── autodiff_benchmarks/
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── autodiff_benchmarks.cc
│ │ │ │ ├── brdf_cost_function.h
│ │ │ │ ├── constant_cost_function.h
│ │ │ │ ├── linear_cost_functions.h
│ │ │ │ ├── photometric_error.h
│ │ │ │ ├── relative_pose_error.h
│ │ │ │ └── snavely_reprojection_error.h
│ │ │ ├── autodiff_cost_function_test.cc
│ │ │ ├── autodiff_first_order_function_test.cc
│ │ │ ├── autodiff_local_parameterization_test.cc
│ │ │ ├── autodiff_test.cc
│ │ │ ├── benchmarks/
│ │ │ │ ├── macbook-pro-2014-small_blas_gemm_benchmark.json
│ │ │ │ └── macbook-pro-2014-small_blas_gemv_benchmark.json
│ │ │ ├── blas.cc
│ │ │ ├── blas.h
│ │ │ ├── block_evaluate_preparer.cc
│ │ │ ├── block_evaluate_preparer.h
│ │ │ ├── block_jacobi_preconditioner.cc
│ │ │ ├── block_jacobi_preconditioner.h
│ │ │ ├── block_jacobi_preconditioner_test.cc
│ │ │ ├── block_jacobian_writer.cc
│ │ │ ├── block_jacobian_writer.h
│ │ │ ├── block_random_access_dense_matrix.cc
│ │ │ ├── block_random_access_dense_matrix.h
│ │ │ ├── block_random_access_dense_matrix_test.cc
│ │ │ ├── block_random_access_diagonal_matrix.cc
│ │ │ ├── block_random_access_diagonal_matrix.h
│ │ │ ├── block_random_access_diagonal_matrix_test.cc
│ │ │ ├── block_random_access_matrix.cc
│ │ │ ├── block_random_access_matrix.h
│ │ │ ├── block_random_access_sparse_matrix.cc
│ │ │ ├── block_random_access_sparse_matrix.h
│ │ │ ├── block_random_access_sparse_matrix_test.cc
│ │ │ ├── block_sparse_matrix.cc
│ │ │ ├── block_sparse_matrix.h
│ │ │ ├── block_sparse_matrix_test.cc
│ │ │ ├── block_structure.cc
│ │ │ ├── block_structure.h
│ │ │ ├── bundle_adjustment_test_util.h
│ │ │ ├── c_api.cc
│ │ │ ├── c_api_test.cc
│ │ │ ├── callbacks.cc
│ │ │ ├── callbacks.h
│ │ │ ├── canonical_views_clustering.cc
│ │ │ ├── canonical_views_clustering.h
│ │ │ ├── canonical_views_clustering_test.cc
│ │ │ ├── casts.h
│ │ │ ├── cgnr_linear_operator.h
│ │ │ ├── cgnr_solver.cc
│ │ │ ├── cgnr_solver.h
│ │ │ ├── compressed_col_sparse_matrix_utils.cc
│ │ │ ├── compressed_col_sparse_matrix_utils.h
│ │ │ ├── compressed_col_sparse_matrix_utils_test.cc
│ │ │ ├── compressed_row_jacobian_writer.cc
│ │ │ ├── compressed_row_jacobian_writer.h
│ │ │ ├── compressed_row_sparse_matrix.cc
│ │ │ ├── compressed_row_sparse_matrix.h
│ │ │ ├── compressed_row_sparse_matrix_test.cc
│ │ │ ├── concurrent_queue.h
│ │ │ ├── concurrent_queue_test.cc
│ │ │ ├── conditioned_cost_function.cc
│ │ │ ├── conditioned_cost_function_test.cc
│ │ │ ├── conjugate_gradients_solver.cc
│ │ │ ├── conjugate_gradients_solver.h
│ │ │ ├── conjugate_gradients_solver_test.cc
│ │ │ ├── context.cc
│ │ │ ├── context_impl.cc
│ │ │ ├── context_impl.h
│ │ │ ├── coordinate_descent_minimizer.cc
│ │ │ ├── coordinate_descent_minimizer.h
│ │ │ ├── corrector.cc
│ │ │ ├── corrector.h
│ │ │ ├── corrector_test.cc
│ │ │ ├── cost_function_to_functor_test.cc
│ │ │ ├── covariance.cc
│ │ │ ├── covariance_impl.cc
│ │ │ ├── covariance_impl.h
│ │ │ ├── covariance_test.cc
│ │ │ ├── cubic_interpolation_test.cc
│ │ │ ├── cxsparse.cc
│ │ │ ├── cxsparse.h
│ │ │ ├── dense_jacobian_writer.h
│ │ │ ├── dense_linear_solver_test.cc
│ │ │ ├── dense_normal_cholesky_solver.cc
│ │ │ ├── dense_normal_cholesky_solver.h
│ │ │ ├── dense_qr_solver.cc
│ │ │ ├── dense_qr_solver.h
│ │ │ ├── dense_sparse_matrix.cc
│ │ │ ├── dense_sparse_matrix.h
│ │ │ ├── dense_sparse_matrix_test.cc
│ │ │ ├── detect_structure.cc
│ │ │ ├── detect_structure.h
│ │ │ ├── detect_structure_test.cc
│ │ │ ├── dogleg_strategy.cc
│ │ │ ├── dogleg_strategy.h
│ │ │ ├── dogleg_strategy_test.cc
│ │ │ ├── dynamic_autodiff_cost_function_test.cc
│ │ │ ├── dynamic_compressed_row_finalizer.h
│ │ │ ├── dynamic_compressed_row_jacobian_writer.cc
│ │ │ ├── dynamic_compressed_row_jacobian_writer.h
│ │ │ ├── dynamic_compressed_row_sparse_matrix.cc
│ │ │ ├── dynamic_compressed_row_sparse_matrix.h
│ │ │ ├── dynamic_compressed_row_sparse_matrix_test.cc
│ │ │ ├── dynamic_numeric_diff_cost_function_test.cc
│ │ │ ├── dynamic_sparse_normal_cholesky_solver.cc
│ │ │ ├── dynamic_sparse_normal_cholesky_solver.h
│ │ │ ├── dynamic_sparse_normal_cholesky_solver_test.cc
│ │ │ ├── dynamic_sparsity_test.cc
│ │ │ ├── eigensparse.cc
│ │ │ ├── eigensparse.h
│ │ │ ├── evaluation_callback_test.cc
│ │ │ ├── evaluator.cc
│ │ │ ├── evaluator.h
│ │ │ ├── evaluator_test.cc
│ │ │ ├── evaluator_test_utils.cc
│ │ │ ├── evaluator_test_utils.h
│ │ │ ├── execution_summary.h
│ │ │ ├── file.cc
│ │ │ ├── file.h
│ │ │ ├── fixed_array_test.cc
│ │ │ ├── float_cxsparse.cc
│ │ │ ├── float_cxsparse.h
│ │ │ ├── float_suitesparse.cc
│ │ │ ├── float_suitesparse.h
│ │ │ ├── function_sample.cc
│ │ │ ├── function_sample.h
│ │ │ ├── generate_bundle_adjustment_tests.py
│ │ │ ├── generate_template_specializations.py
│ │ │ ├── generated/
│ │ │ │ ├── partitioned_matrix_view_2_2_2.cc
│ │ │ │ ├── partitioned_matrix_view_2_2_3.cc
│ │ │ │ ├── partitioned_matrix_view_2_2_4.cc
│ │ │ │ ├── partitioned_matrix_view_2_2_d.cc
│ │ │ │ ├── partitioned_matrix_view_2_3_3.cc
│ │ │ │ ├── partitioned_matrix_view_2_3_4.cc
│ │ │ │ ├── partitioned_matrix_view_2_3_6.cc
│ │ │ │ ├── partitioned_matrix_view_2_3_9.cc
│ │ │ │ ├── partitioned_matrix_view_2_3_d.cc
│ │ │ │ ├── partitioned_matrix_view_2_4_3.cc
│ │ │ │ ├── partitioned_matrix_view_2_4_4.cc
│ │ │ │ ├── partitioned_matrix_view_2_4_6.cc
│ │ │ │ ├── partitioned_matrix_view_2_4_8.cc
│ │ │ │ ├── partitioned_matrix_view_2_4_9.cc
│ │ │ │ ├── partitioned_matrix_view_2_4_d.cc
│ │ │ │ ├── partitioned_matrix_view_2_d_d.cc
│ │ │ │ ├── partitioned_matrix_view_3_3_3.cc
│ │ │ │ ├── partitioned_matrix_view_4_4_2.cc
│ │ │ │ ├── partitioned_matrix_view_4_4_3.cc
│ │ │ │ ├── partitioned_matrix_view_4_4_4.cc
│ │ │ │ ├── partitioned_matrix_view_4_4_d.cc
│ │ │ │ ├── partitioned_matrix_view_d_d_d.cc
│ │ │ │ ├── schur_eliminator_2_2_2.cc
│ │ │ │ ├── schur_eliminator_2_2_3.cc
│ │ │ │ ├── schur_eliminator_2_2_4.cc
│ │ │ │ ├── schur_eliminator_2_2_d.cc
│ │ │ │ ├── schur_eliminator_2_3_3.cc
│ │ │ │ ├── schur_eliminator_2_3_4.cc
│ │ │ │ ├── schur_eliminator_2_3_6.cc
│ │ │ │ ├── schur_eliminator_2_3_9.cc
│ │ │ │ ├── schur_eliminator_2_3_d.cc
│ │ │ │ ├── schur_eliminator_2_4_3.cc
│ │ │ │ ├── schur_eliminator_2_4_4.cc
│ │ │ │ ├── schur_eliminator_2_4_6.cc
│ │ │ │ ├── schur_eliminator_2_4_8.cc
│ │ │ │ ├── schur_eliminator_2_4_9.cc
│ │ │ │ ├── schur_eliminator_2_4_d.cc
│ │ │ │ ├── schur_eliminator_2_d_d.cc
│ │ │ │ ├── schur_eliminator_3_3_3.cc
│ │ │ │ ├── schur_eliminator_4_4_2.cc
│ │ │ │ ├── schur_eliminator_4_4_3.cc
│ │ │ │ ├── schur_eliminator_4_4_4.cc
│ │ │ │ ├── schur_eliminator_4_4_d.cc
│ │ │ │ └── schur_eliminator_d_d_d.cc
│ │ │ ├── generated_bundle_adjustment_tests/
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── ba_denseschur_auto_test.cc
│ │ │ │ ├── ba_denseschur_auto_threads_test.cc
│ │ │ │ ├── ba_denseschur_user_test.cc
│ │ │ │ ├── ba_denseschur_user_threads_test.cc
│ │ │ │ ├── ba_iterschur_acceleratesparse_clustjacobi_auto_test.cc
│ │ │ │ ├── ba_iterschur_acceleratesparse_clustjacobi_auto_threads_test.cc
│ │ │ │ ├── ba_iterschur_acceleratesparse_clustjacobi_user_test.cc
│ │ │ │ ├── ba_iterschur_acceleratesparse_clustjacobi_user_threads_test.cc
│ │ │ │ ├── ba_iterschur_acceleratesparse_clusttri_auto_test.cc
│ │ │ │ ├── ba_iterschur_acceleratesparse_clusttri_auto_threads_test.cc
│ │ │ │ ├── ba_iterschur_acceleratesparse_clusttri_user_test.cc
│ │ │ │ ├── ba_iterschur_acceleratesparse_clusttri_user_threads_test.cc
│ │ │ │ ├── ba_iterschur_cxsparse_clustjacobi_auto_test.cc
│ │ │ │ ├── ba_iterschur_cxsparse_clustjacobi_auto_threads_test.cc
│ │ │ │ ├── ba_iterschur_cxsparse_clustjacobi_user_test.cc
│ │ │ │ ├── ba_iterschur_cxsparse_clustjacobi_user_threads_test.cc
│ │ │ │ ├── ba_iterschur_cxsparse_clusttri_auto_test.cc
│ │ │ │ ├── ba_iterschur_cxsparse_clusttri_auto_threads_test.cc
│ │ │ │ ├── ba_iterschur_cxsparse_clusttri_user_test.cc
│ │ │ │ ├── ba_iterschur_cxsparse_clusttri_user_threads_test.cc
│ │ │ │ ├── ba_iterschur_eigensparse_clustjacobi_auto_test.cc
│ │ │ │ ├── ba_iterschur_eigensparse_clustjacobi_auto_threads_test.cc
│ │ │ │ ├── ba_iterschur_eigensparse_clustjacobi_user_test.cc
│ │ │ │ ├── ba_iterschur_eigensparse_clustjacobi_user_threads_test.cc
│ │ │ │ ├── ba_iterschur_eigensparse_clusttri_auto_test.cc
│ │ │ │ ├── ba_iterschur_eigensparse_clusttri_auto_threads_test.cc
│ │ │ │ ├── ba_iterschur_eigensparse_clusttri_user_test.cc
│ │ │ │ ├── ba_iterschur_eigensparse_clusttri_user_threads_test.cc
│ │ │ │ ├── ba_iterschur_jacobi_auto_test.cc
│ │ │ │ ├── ba_iterschur_jacobi_auto_threads_test.cc
│ │ │ │ ├── ba_iterschur_jacobi_user_test.cc
│ │ │ │ ├── ba_iterschur_jacobi_user_threads_test.cc
│ │ │ │ ├── ba_iterschur_schurjacobi_auto_test.cc
│ │ │ │ ├── ba_iterschur_schurjacobi_auto_threads_test.cc
│ │ │ │ ├── ba_iterschur_schurjacobi_user_test.cc
│ │ │ │ ├── ba_iterschur_schurjacobi_user_threads_test.cc
│ │ │ │ ├── ba_iterschur_suitesparse_clustjacobi_auto_test.cc
│ │ │ │ ├── ba_iterschur_suitesparse_clustjacobi_auto_threads_test.cc
│ │ │ │ ├── ba_iterschur_suitesparse_clustjacobi_user_test.cc
│ │ │ │ ├── ba_iterschur_suitesparse_clustjacobi_user_threads_test.cc
│ │ │ │ ├── ba_iterschur_suitesparse_clusttri_auto_test.cc
│ │ │ │ ├── ba_iterschur_suitesparse_clusttri_auto_threads_test.cc
│ │ │ │ ├── ba_iterschur_suitesparse_clusttri_user_test.cc
│ │ │ │ ├── ba_iterschur_suitesparse_clusttri_user_threads_test.cc
│ │ │ │ ├── ba_sparsecholesky_acceleratesparse_auto_test.cc
│ │ │ │ ├── ba_sparsecholesky_acceleratesparse_auto_threads_test.cc
│ │ │ │ ├── ba_sparsecholesky_acceleratesparse_user_test.cc
│ │ │ │ ├── ba_sparsecholesky_acceleratesparse_user_threads_test.cc
│ │ │ │ ├── ba_sparsecholesky_cxsparse_auto_test.cc
│ │ │ │ ├── ba_sparsecholesky_cxsparse_auto_threads_test.cc
│ │ │ │ ├── ba_sparsecholesky_cxsparse_user_test.cc
│ │ │ │ ├── ba_sparsecholesky_cxsparse_user_threads_test.cc
│ │ │ │ ├── ba_sparsecholesky_eigensparse_auto_test.cc
│ │ │ │ ├── ba_sparsecholesky_eigensparse_auto_threads_test.cc
│ │ │ │ ├── ba_sparsecholesky_eigensparse_user_test.cc
│ │ │ │ ├── ba_sparsecholesky_eigensparse_user_threads_test.cc
│ │ │ │ ├── ba_sparsecholesky_suitesparse_auto_test.cc
│ │ │ │ ├── ba_sparsecholesky_suitesparse_auto_threads_test.cc
│ │ │ │ ├── ba_sparsecholesky_suitesparse_user_test.cc
│ │ │ │ ├── ba_sparsecholesky_suitesparse_user_threads_test.cc
│ │ │ │ ├── ba_sparseschur_acceleratesparse_auto_test.cc
│ │ │ │ ├── ba_sparseschur_acceleratesparse_auto_threads_test.cc
│ │ │ │ ├── ba_sparseschur_acceleratesparse_user_test.cc
│ │ │ │ ├── ba_sparseschur_acceleratesparse_user_threads_test.cc
│ │ │ │ ├── ba_sparseschur_cxsparse_auto_test.cc
│ │ │ │ ├── ba_sparseschur_cxsparse_auto_threads_test.cc
│ │ │ │ ├── ba_sparseschur_cxsparse_user_test.cc
│ │ │ │ ├── ba_sparseschur_cxsparse_user_threads_test.cc
│ │ │ │ ├── ba_sparseschur_eigensparse_auto_test.cc
│ │ │ │ ├── ba_sparseschur_eigensparse_auto_threads_test.cc
│ │ │ │ ├── ba_sparseschur_eigensparse_user_test.cc
│ │ │ │ ├── ba_sparseschur_eigensparse_user_threads_test.cc
│ │ │ │ ├── ba_sparseschur_suitesparse_auto_test.cc
│ │ │ │ ├── ba_sparseschur_suitesparse_auto_threads_test.cc
│ │ │ │ ├── ba_sparseschur_suitesparse_user_test.cc
│ │ │ │ └── ba_sparseschur_suitesparse_user_threads_test.cc
│ │ │ ├── glog/
│ │ │ │ ├── logging.cc
│ │ │ │ └── logging.h
│ │ │ ├── gmock/
│ │ │ │ ├── gmock.h
│ │ │ │ └── mock-log.h
│ │ │ ├── gmock_gtest_all.cc
│ │ │ ├── gmock_main.cc
│ │ │ ├── gradient_checker.cc
│ │ │ ├── gradient_checker_test.cc
│ │ │ ├── gradient_checking_cost_function.cc
│ │ │ ├── gradient_checking_cost_function.h
│ │ │ ├── gradient_checking_cost_function_test.cc
│ │ │ ├── gradient_problem.cc
│ │ │ ├── gradient_problem_evaluator.h
│ │ │ ├── gradient_problem_solver.cc
│ │ │ ├── gradient_problem_solver_test.cc
│ │ │ ├── gradient_problem_test.cc
│ │ │ ├── graph.h
│ │ │ ├── graph_algorithms.h
│ │ │ ├── graph_algorithms_test.cc
│ │ │ ├── graph_test.cc
│ │ │ ├── gtest/
│ │ │ │ └── gtest.h
│ │ │ ├── householder_vector_test.cc
│ │ │ ├── implicit_schur_complement.cc
│ │ │ ├── implicit_schur_complement.h
│ │ │ ├── implicit_schur_complement_test.cc
│ │ │ ├── inner_product_computer.cc
│ │ │ ├── inner_product_computer.h
│ │ │ ├── inner_product_computer_test.cc
│ │ │ ├── integer_sequence_algorithm_test.cc
│ │ │ ├── integer_sequence_test.cc
│ │ │ ├── invert_psd_matrix.h
│ │ │ ├── invert_psd_matrix_benchmark.cc
│ │ │ ├── invert_psd_matrix_test.cc
│ │ │ ├── is_close.cc
│ │ │ ├── is_close.h
│ │ │ ├── is_close_test.cc
│ │ │ ├── iterative_refiner.cc
│ │ │ ├── iterative_refiner.h
│ │ │ ├── iterative_refiner_test.cc
│ │ │ ├── iterative_schur_complement_solver.cc
│ │ │ ├── iterative_schur_complement_solver.h
│ │ │ ├── iterative_schur_complement_solver_test.cc
│ │ │ ├── jet_test.cc
│ │ │ ├── lapack.cc
│ │ │ ├── lapack.h
│ │ │ ├── levenberg_marquardt_strategy.cc
│ │ │ ├── levenberg_marquardt_strategy.h
│ │ │ ├── levenberg_marquardt_strategy_test.cc
│ │ │ ├── line_search.cc
│ │ │ ├── line_search.h
│ │ │ ├── line_search_direction.cc
│ │ │ ├── line_search_direction.h
│ │ │ ├── line_search_minimizer.cc
│ │ │ ├── line_search_minimizer.h
│ │ │ ├── line_search_minimizer_test.cc
│ │ │ ├── line_search_preprocessor.cc
│ │ │ ├── line_search_preprocessor.h
│ │ │ ├── line_search_preprocessor_test.cc
│ │ │ ├── linear_least_squares_problems.cc
│ │ │ ├── linear_least_squares_problems.h
│ │ │ ├── linear_operator.cc
│ │ │ ├── linear_operator.h
│ │ │ ├── linear_solver.cc
│ │ │ ├── linear_solver.h
│ │ │ ├── local_parameterization.cc
│ │ │ ├── local_parameterization_test.cc
│ │ │ ├── loss_function.cc
│ │ │ ├── loss_function_test.cc
│ │ │ ├── low_rank_inverse_hessian.cc
│ │ │ ├── low_rank_inverse_hessian.h
│ │ │ ├── map_util.h
│ │ │ ├── miniglog/
│ │ │ │ └── glog/
│ │ │ │ ├── logging.cc
│ │ │ │ └── logging.h
│ │ │ ├── minimizer.cc
│ │ │ ├── minimizer.h
│ │ │ ├── minimizer_test.cc
│ │ │ ├── normal_prior.cc
│ │ │ ├── normal_prior_test.cc
│ │ │ ├── numeric_diff_cost_function_test.cc
│ │ │ ├── numeric_diff_test_utils.cc
│ │ │ ├── numeric_diff_test_utils.h
│ │ │ ├── ordered_groups_test.cc
│ │ │ ├── pair_hash.h
│ │ │ ├── parallel_for.h
│ │ │ ├── parallel_for_cxx.cc
│ │ │ ├── parallel_for_nothreads.cc
│ │ │ ├── parallel_for_openmp.cc
│ │ │ ├── parallel_for_test.cc
│ │ │ ├── parallel_utils.cc
│ │ │ ├── parallel_utils.h
│ │ │ ├── parallel_utils_test.cc
│ │ │ ├── parameter_block.h
│ │ │ ├── parameter_block_ordering.cc
│ │ │ ├── parameter_block_ordering.h
│ │ │ ├── parameter_block_ordering_test.cc
│ │ │ ├── parameter_block_test.cc
│ │ │ ├── parameter_dims_test.cc
│ │ │ ├── partitioned_matrix_view.cc
│ │ │ ├── partitioned_matrix_view.h
│ │ │ ├── partitioned_matrix_view_impl.h
│ │ │ ├── partitioned_matrix_view_template.py
│ │ │ ├── partitioned_matrix_view_test.cc
│ │ │ ├── polynomial.cc
│ │ │ ├── polynomial.h
│ │ │ ├── polynomial_test.cc
│ │ │ ├── preconditioner.cc
│ │ │ ├── preconditioner.h
│ │ │ ├── preprocessor.cc
│ │ │ ├── preprocessor.h
│ │ │ ├── problem.cc
│ │ │ ├── problem_impl.cc
│ │ │ ├── problem_impl.h
│ │ │ ├── problem_test.cc
│ │ │ ├── program.cc
│ │ │ ├── program.h
│ │ │ ├── program_evaluator.h
│ │ │ ├── program_test.cc
│ │ │ ├── random.h
│ │ │ ├── reorder_program.cc
│ │ │ ├── reorder_program.h
│ │ │ ├── reorder_program_test.cc
│ │ │ ├── residual_block.cc
│ │ │ ├── residual_block.h
│ │ │ ├── residual_block_test.cc
│ │ │ ├── residual_block_utils.cc
│ │ │ ├── residual_block_utils.h
│ │ │ ├── residual_block_utils_test.cc
│ │ │ ├── rotation_test.cc
│ │ │ ├── schur_complement_solver.cc
│ │ │ ├── schur_complement_solver.h
│ │ │ ├── schur_complement_solver_test.cc
│ │ │ ├── schur_eliminator.cc
│ │ │ ├── schur_eliminator.h
│ │ │ ├── schur_eliminator_benchmark.cc
│ │ │ ├── schur_eliminator_impl.h
│ │ │ ├── schur_eliminator_template.py
│ │ │ ├── schur_eliminator_test.cc
│ │ │ ├── schur_jacobi_preconditioner.cc
│ │ │ ├── schur_jacobi_preconditioner.h
│ │ │ ├── schur_templates.cc
│ │ │ ├── schur_templates.h
│ │ │ ├── scoped_thread_token.h
│ │ │ ├── scratch_evaluate_preparer.cc
│ │ │ ├── scratch_evaluate_preparer.h
│ │ │ ├── single_linkage_clustering.cc
│ │ │ ├── single_linkage_clustering.h
│ │ │ ├── single_linkage_clustering_test.cc
│ │ │ ├── small_blas.h
│ │ │ ├── small_blas_gemm_benchmark.cc
│ │ │ ├── small_blas_gemv_benchmark.cc
│ │ │ ├── small_blas_generic.h
│ │ │ ├── small_blas_test.cc
│ │ │ ├── solver.cc
│ │ │ ├── solver_test.cc
│ │ │ ├── solver_utils.cc
│ │ │ ├── solver_utils.h
│ │ │ ├── sparse_cholesky.cc
│ │ │ ├── sparse_cholesky.h
│ │ │ ├── sparse_cholesky_test.cc
│ │ │ ├── sparse_matrix.cc
│ │ │ ├── sparse_matrix.h
│ │ │ ├── sparse_normal_cholesky_solver.cc
│ │ │ ├── sparse_normal_cholesky_solver.h
│ │ │ ├── sparse_normal_cholesky_solver_test.cc
│ │ │ ├── split.cc
│ │ │ ├── split.h
│ │ │ ├── stl_util.h
│ │ │ ├── stringprintf.cc
│ │ │ ├── stringprintf.h
│ │ │ ├── subset_preconditioner.cc
│ │ │ ├── subset_preconditioner.h
│ │ │ ├── subset_preconditioner_test.cc
│ │ │ ├── suitesparse.cc
│ │ │ ├── suitesparse.h
│ │ │ ├── system_test.cc
│ │ │ ├── test_util.cc
│ │ │ ├── test_util.h
│ │ │ ├── thread_pool.cc
│ │ │ ├── thread_pool.h
│ │ │ ├── thread_pool_test.cc
│ │ │ ├── thread_token_provider.cc
│ │ │ ├── thread_token_provider.h
│ │ │ ├── tiny_solver_autodiff_function_test.cc
│ │ │ ├── tiny_solver_cost_function_adapter_test.cc
│ │ │ ├── tiny_solver_test.cc
│ │ │ ├── tiny_solver_test_util.h
│ │ │ ├── triplet_sparse_matrix.cc
│ │ │ ├── triplet_sparse_matrix.h
│ │ │ ├── triplet_sparse_matrix_test.cc
│ │ │ ├── trust_region_minimizer.cc
│ │ │ ├── trust_region_minimizer.h
│ │ │ ├── trust_region_minimizer_test.cc
│ │ │ ├── trust_region_preprocessor.cc
│ │ │ ├── trust_region_preprocessor.h
│ │ │ ├── trust_region_preprocessor_test.cc
│ │ │ ├── trust_region_step_evaluator.cc
│ │ │ ├── trust_region_step_evaluator.h
│ │ │ ├── trust_region_strategy.cc
│ │ │ ├── trust_region_strategy.h
│ │ │ ├── types.cc
│ │ │ ├── visibility.cc
│ │ │ ├── visibility.h
│ │ │ ├── visibility_based_preconditioner.cc
│ │ │ ├── visibility_based_preconditioner.h
│ │ │ ├── visibility_based_preconditioner_test.cc
│ │ │ ├── visibility_test.cc
│ │ │ ├── wall_time.cc
│ │ │ └── wall_time.h
│ │ ├── package.xml
│ │ ├── scripts/
│ │ │ ├── make_docs.py
│ │ │ └── make_release
│ │ └── travis/
│ │ ├── install_travis_linux_deps.sh
│ │ └── install_travis_osx_deps.sh
│ └── eigen3/
│ ├── .hgeol
│ ├── CMakeLists.txt
│ ├── COPYING.BSD
│ ├── COPYING.GPL
│ ├── COPYING.LGPL
│ ├── COPYING.MINPACK
│ ├── COPYING.MPL2
│ ├── COPYING.README
│ ├── CTestConfig.cmake
│ ├── CTestCustom.cmake.in
│ ├── Eigen/
│ │ ├── Cholesky
│ │ ├── CholmodSupport
│ │ ├── Core
│ │ ├── Dense
│ │ ├── Eigen
│ │ ├── Eigenvalues
│ │ ├── Geometry
│ │ ├── Householder
│ │ ├── IterativeLinearSolvers
│ │ ├── Jacobi
│ │ ├── KLUSupport
│ │ ├── LU
│ │ ├── MetisSupport
│ │ ├── OrderingMethods
│ │ ├── PaStiXSupport
│ │ ├── PardisoSupport
│ │ ├── QR
│ │ ├── QtAlignedMalloc
│ │ ├── SPQRSupport
│ │ ├── SVD
│ │ ├── Sparse
│ │ ├── SparseCholesky
│ │ ├── SparseCore
│ │ ├── SparseLU
│ │ ├── SparseQR
│ │ ├── StdDeque
│ │ ├── StdList
│ │ ├── StdVector
│ │ ├── SuperLUSupport
│ │ ├── UmfPackSupport
│ │ └── src/
│ │ ├── Cholesky/
│ │ │ ├── LDLT.h
│ │ │ ├── LLT.h
│ │ │ └── LLT_LAPACKE.h
│ │ ├── CholmodSupport/
│ │ │ └── CholmodSupport.h
│ │ ├── Core/
│ │ │ ├── ArithmeticSequence.h
│ │ │ ├── Array.h
│ │ │ ├── ArrayBase.h
│ │ │ ├── ArrayWrapper.h
│ │ │ ├── Assign.h
│ │ │ ├── AssignEvaluator.h
│ │ │ ├── Assign_MKL.h
│ │ │ ├── BandMatrix.h
│ │ │ ├── Block.h
│ │ │ ├── BooleanRedux.h
│ │ │ ├── CommaInitializer.h
│ │ │ ├── ConditionEstimator.h
│ │ │ ├── CoreEvaluators.h
│ │ │ ├── CoreIterators.h
│ │ │ ├── CwiseBinaryOp.h
│ │ │ ├── CwiseNullaryOp.h
│ │ │ ├── CwiseTernaryOp.h
│ │ │ ├── CwiseUnaryOp.h
│ │ │ ├── CwiseUnaryView.h
│ │ │ ├── DenseBase.h
│ │ │ ├── DenseCoeffsBase.h
│ │ │ ├── DenseStorage.h
│ │ │ ├── Diagonal.h
│ │ │ ├── DiagonalMatrix.h
│ │ │ ├── DiagonalProduct.h
│ │ │ ├── Dot.h
│ │ │ ├── EigenBase.h
│ │ │ ├── ForceAlignedAccess.h
│ │ │ ├── Fuzzy.h
│ │ │ ├── GeneralProduct.h
│ │ │ ├── GenericPacketMath.h
│ │ │ ├── GlobalFunctions.h
│ │ │ ├── IO.h
│ │ │ ├── IndexedView.h
│ │ │ ├── Inverse.h
│ │ │ ├── Map.h
│ │ │ ├── MapBase.h
│ │ │ ├── MathFunctions.h
│ │ │ ├── MathFunctionsImpl.h
│ │ │ ├── Matrix.h
│ │ │ ├── MatrixBase.h
│ │ │ ├── NestByValue.h
│ │ │ ├── NoAlias.h
│ │ │ ├── NumTraits.h
│ │ │ ├── PartialReduxEvaluator.h
│ │ │ ├── PermutationMatrix.h
│ │ │ ├── PlainObjectBase.h
│ │ │ ├── Product.h
│ │ │ ├── ProductEvaluators.h
│ │ │ ├── Random.h
│ │ │ ├── Redux.h
│ │ │ ├── Ref.h
│ │ │ ├── Replicate.h
│ │ │ ├── Reshaped.h
│ │ │ ├── ReturnByValue.h
│ │ │ ├── Reverse.h
│ │ │ ├── Select.h
│ │ │ ├── SelfAdjointView.h
│ │ │ ├── SelfCwiseBinaryOp.h
│ │ │ ├── Solve.h
│ │ │ ├── SolveTriangular.h
│ │ │ ├── SolverBase.h
│ │ │ ├── StableNorm.h
│ │ │ ├── StlIterators.h
│ │ │ ├── Stride.h
│ │ │ ├── Swap.h
│ │ │ ├── Transpose.h
│ │ │ ├── Transpositions.h
│ │ │ ├── TriangularMatrix.h
│ │ │ ├── VectorBlock.h
│ │ │ ├── VectorwiseOp.h
│ │ │ ├── Visitor.h
│ │ │ ├── arch/
│ │ │ │ ├── AVX/
│ │ │ │ │ ├── Complex.h
│ │ │ │ │ ├── MathFunctions.h
│ │ │ │ │ ├── PacketMath.h
│ │ │ │ │ └── TypeCasting.h
│ │ │ │ ├── AVX512/
│ │ │ │ │ ├── Complex.h
│ │ │ │ │ ├── MathFunctions.h
│ │ │ │ │ ├── PacketMath.h
│ │ │ │ │ └── TypeCasting.h
│ │ │ │ ├── AltiVec/
│ │ │ │ │ ├── Complex.h
│ │ │ │ │ ├── MathFunctions.h
│ │ │ │ │ └── PacketMath.h
│ │ │ │ ├── CUDA/
│ │ │ │ │ └── Complex.h
│ │ │ │ ├── Default/
│ │ │ │ │ ├── ConjHelper.h
│ │ │ │ │ ├── GenericPacketMathFunctions.h
│ │ │ │ │ ├── GenericPacketMathFunctionsFwd.h
│ │ │ │ │ ├── Half.h
│ │ │ │ │ ├── Settings.h
│ │ │ │ │ └── TypeCasting.h
│ │ │ │ ├── GPU/
│ │ │ │ │ ├── MathFunctions.h
│ │ │ │ │ ├── PacketMath.h
│ │ │ │ │ └── TypeCasting.h
│ │ │ │ ├── HIP/
│ │ │ │ │ └── hcc/
│ │ │ │ │ └── math_constants.h
│ │ │ │ ├── MSA/
│ │ │ │ │ ├── Complex.h
│ │ │ │ │ ├── MathFunctions.h
│ │ │ │ │ └── PacketMath.h
│ │ │ │ ├── NEON/
│ │ │ │ │ ├── Complex.h
│ │ │ │ │ ├── MathFunctions.h
│ │ │ │ │ ├── PacketMath.h
│ │ │ │ │ └── TypeCasting.h
│ │ │ │ ├── SSE/
│ │ │ │ │ ├── Complex.h
│ │ │ │ │ ├── MathFunctions.h
│ │ │ │ │ ├── PacketMath.h
│ │ │ │ │ └── TypeCasting.h
│ │ │ │ ├── SYCL/
│ │ │ │ │ ├── InteropHeaders.h
│ │ │ │ │ ├── MathFunctions.h
│ │ │ │ │ ├── PacketMath.h
│ │ │ │ │ ├── SyclMemoryModel.h
│ │ │ │ │ └── TypeCasting.h
│ │ │ │ └── ZVector/
│ │ │ │ ├── Complex.h
│ │ │ │ ├── MathFunctions.h
│ │ │ │ └── PacketMath.h
│ │ │ ├── functors/
│ │ │ │ ├── AssignmentFunctors.h
│ │ │ │ ├── BinaryFunctors.h
│ │ │ │ ├── NullaryFunctors.h
│ │ │ │ ├── StlFunctors.h
│ │ │ │ ├── TernaryFunctors.h
│ │ │ │ └── UnaryFunctors.h
│ │ │ ├── products/
│ │ │ │ ├── GeneralBlockPanelKernel.h
│ │ │ │ ├── GeneralMatrixMatrix.h
│ │ │ │ ├── GeneralMatrixMatrixTriangular.h
│ │ │ │ ├── GeneralMatrixMatrixTriangular_BLAS.h
│ │ │ │ ├── GeneralMatrixMatrix_BLAS.h
│ │ │ │ ├── GeneralMatrixVector.h
│ │ │ │ ├── GeneralMatrixVector_BLAS.h
│ │ │ │ ├── Parallelizer.h
│ │ │ │ ├── SelfadjointMatrixMatrix.h
│ │ │ │ ├── SelfadjointMatrixMatrix_BLAS.h
│ │ │ │ ├── SelfadjointMatrixVector.h
│ │ │ │ ├── SelfadjointMatrixVector_BLAS.h
│ │ │ │ ├── SelfadjointProduct.h
│ │ │ │ ├── SelfadjointRank2Update.h
│ │ │ │ ├── TriangularMatrixMatrix.h
│ │ │ │ ├── TriangularMatrixMatrix_BLAS.h
│ │ │ │ ├── TriangularMatrixVector.h
│ │ │ │ ├── TriangularMatrixVector_BLAS.h
│ │ │ │ ├── TriangularSolverMatrix.h
│ │ │ │ ├── TriangularSolverMatrix_BLAS.h
│ │ │ │ └── TriangularSolverVector.h
│ │ │ └── util/
│ │ │ ├── BlasUtil.h
│ │ │ ├── ConfigureVectorization.h
│ │ │ ├── Constants.h
│ │ │ ├── DisableStupidWarnings.h
│ │ │ ├── ForwardDeclarations.h
│ │ │ ├── IndexedViewHelper.h
│ │ │ ├── IntegralConstant.h
│ │ │ ├── MKL_support.h
│ │ │ ├── Macros.h
│ │ │ ├── Memory.h
│ │ │ ├── Meta.h
│ │ │ ├── NonMPL2.h
│ │ │ ├── ReenableStupidWarnings.h
│ │ │ ├── ReshapedHelper.h
│ │ │ ├── StaticAssert.h
│ │ │ ├── SymbolicIndex.h
│ │ │ └── XprHelper.h
│ │ ├── Eigenvalues/
│ │ │ ├── ComplexEigenSolver.h
│ │ │ ├── ComplexSchur.h
│ │ │ ├── ComplexSchur_LAPACKE.h
│ │ │ ├── EigenSolver.h
│ │ │ ├── GeneralizedEigenSolver.h
│ │ │ ├── GeneralizedSelfAdjointEigenSolver.h
│ │ │ ├── HessenbergDecomposition.h
│ │ │ ├── MatrixBaseEigenvalues.h
│ │ │ ├── RealQZ.h
│ │ │ ├── RealSchur.h
│ │ │ ├── RealSchur_LAPACKE.h
│ │ │ ├── SelfAdjointEigenSolver.h
│ │ │ ├── SelfAdjointEigenSolver_LAPACKE.h
│ │ │ └── Tridiagonalization.h
│ │ ├── Geometry/
│ │ │ ├── AlignedBox.h
│ │ │ ├── AngleAxis.h
│ │ │ ├── EulerAngles.h
│ │ │ ├── Homogeneous.h
│ │ │ ├── Hyperplane.h
│ │ │ ├── OrthoMethods.h
│ │ │ ├── ParametrizedLine.h
│ │ │ ├── Quaternion.h
│ │ │ ├── Rotation2D.h
│ │ │ ├── RotationBase.h
│ │ │ ├── Scaling.h
│ │ │ ├── Transform.h
│ │ │ ├── Translation.h
│ │ │ ├── Umeyama.h
│ │ │ └── arch/
│ │ │ └── Geometry_SSE.h
│ │ ├── Householder/
│ │ │ ├── BlockHouseholder.h
│ │ │ ├── Householder.h
│ │ │ └── HouseholderSequence.h
│ │ ├── IterativeLinearSolvers/
│ │ │ ├── BasicPreconditioners.h
│ │ │ ├── BiCGSTAB.h
│ │ │ ├── ConjugateGradient.h
│ │ │ ├── IncompleteCholesky.h
│ │ │ ├── IncompleteLUT.h
│ │ │ ├── IterativeSolverBase.h
│ │ │ ├── LeastSquareConjugateGradient.h
│ │ │ └── SolveWithGuess.h
│ │ ├── Jacobi/
│ │ │ └── Jacobi.h
│ │ ├── KLUSupport/
│ │ │ └── KLUSupport.h
│ │ ├── LU/
│ │ │ ├── Determinant.h
│ │ │ ├── FullPivLU.h
│ │ │ ├── InverseImpl.h
│ │ │ ├── PartialPivLU.h
│ │ │ ├── PartialPivLU_LAPACKE.h
│ │ │ └── arch/
│ │ │ └── Inverse_SSE.h
│ │ ├── MetisSupport/
│ │ │ └── MetisSupport.h
│ │ ├── OrderingMethods/
│ │ │ ├── Amd.h
│ │ │ ├── Eigen_Colamd.h
│ │ │ └── Ordering.h
│ │ ├── PaStiXSupport/
│ │ │ └── PaStiXSupport.h
│ │ ├── PardisoSupport/
│ │ │ └── PardisoSupport.h
│ │ ├── QR/
│ │ │ ├── ColPivHouseholderQR.h
│ │ │ ├── ColPivHouseholderQR_LAPACKE.h
│ │ │ ├── CompleteOrthogonalDecomposition.h
│ │ │ ├── FullPivHouseholderQR.h
│ │ │ ├── HouseholderQR.h
│ │ │ └── HouseholderQR_LAPACKE.h
│ │ ├── SPQRSupport/
│ │ │ └── SuiteSparseQRSupport.h
│ │ ├── SVD/
│ │ │ ├── BDCSVD.h
│ │ │ ├── JacobiSVD.h
│ │ │ ├── JacobiSVD_LAPACKE.h
│ │ │ ├── SVDBase.h
│ │ │ └── UpperBidiagonalization.h
│ │ ├── SparseCholesky/
│ │ │ ├── SimplicialCholesky.h
│ │ │ └── SimplicialCholesky_impl.h
│ │ ├── SparseCore/
│ │ │ ├── AmbiVector.h
│ │ │ ├── CompressedStorage.h
│ │ │ ├── ConservativeSparseSparseProduct.h
│ │ │ ├── MappedSparseMatrix.h
│ │ │ ├── SparseAssign.h
│ │ │ ├── SparseBlock.h
│ │ │ ├── SparseColEtree.h
│ │ │ ├── SparseCompressedBase.h
│ │ │ ├── SparseCwiseBinaryOp.h
│ │ │ ├── SparseCwiseUnaryOp.h
│ │ │ ├── SparseDenseProduct.h
│ │ │ ├── SparseDiagonalProduct.h
│ │ │ ├── SparseDot.h
│ │ │ ├── SparseFuzzy.h
│ │ │ ├── SparseMap.h
│ │ │ ├── SparseMatrix.h
│ │ │ ├── SparseMatrixBase.h
│ │ │ ├── SparsePermutation.h
│ │ │ ├── SparseProduct.h
│ │ │ ├── SparseRedux.h
│ │ │ ├── SparseRef.h
│ │ │ ├── SparseSelfAdjointView.h
│ │ │ ├── SparseSolverBase.h
│ │ │ ├── SparseSparseProductWithPruning.h
│ │ │ ├── SparseTranspose.h
│ │ │ ├── SparseTriangularView.h
│ │ │ ├── SparseUtil.h
│ │ │ ├── SparseVector.h
│ │ │ ├── SparseView.h
│ │ │ └── TriangularSolver.h
│ │ ├── SparseLU/
│ │ │ ├── SparseLU.h
│ │ │ ├── SparseLUImpl.h
│ │ │ ├── SparseLU_Memory.h
│ │ │ ├── SparseLU_Structs.h
│ │ │ ├── SparseLU_SupernodalMatrix.h
│ │ │ ├── SparseLU_Utils.h
│ │ │ ├── SparseLU_column_bmod.h
│ │ │ ├── SparseLU_column_dfs.h
│ │ │ ├── SparseLU_copy_to_ucol.h
│ │ │ ├── SparseLU_gemm_kernel.h
│ │ │ ├── SparseLU_heap_relax_snode.h
│ │ │ ├── SparseLU_kernel_bmod.h
│ │ │ ├── SparseLU_panel_bmod.h
│ │ │ ├── SparseLU_panel_dfs.h
│ │ │ ├── SparseLU_pivotL.h
│ │ │ ├── SparseLU_pruneL.h
│ │ │ └── SparseLU_relax_snode.h
│ │ ├── SparseQR/
│ │ │ └── SparseQR.h
│ │ ├── StlSupport/
│ │ │ ├── StdDeque.h
│ │ │ ├── StdList.h
│ │ │ ├── StdVector.h
│ │ │ └── details.h
│ │ ├── SuperLUSupport/
│ │ │ └── SuperLUSupport.h
│ │ ├── UmfPackSupport/
│ │ │ └── UmfPackSupport.h
│ │ ├── misc/
│ │ │ ├── Image.h
│ │ │ ├── Kernel.h
│ │ │ ├── RealSvd2x2.h
│ │ │ ├── blas.h
│ │ │ ├── lapack.h
│ │ │ ├── lapacke.h
│ │ │ └── lapacke_mangling.h
│ │ └── plugins/
│ │ ├── ArrayCwiseBinaryOps.h
│ │ ├── ArrayCwiseUnaryOps.h
│ │ ├── BlockMethods.h
│ │ ├── CommonCwiseBinaryOps.h
│ │ ├── CommonCwiseUnaryOps.h
│ │ ├── IndexedViewMethods.h
│ │ ├── MatrixCwiseBinaryOps.h
│ │ ├── MatrixCwiseUnaryOps.h
│ │ └── ReshapedMethods.h
│ ├── INSTALL
│ ├── README.md
│ ├── bench/
│ │ ├── BenchSparseUtil.h
│ │ ├── BenchTimer.h
│ │ ├── BenchUtil.h
│ │ ├── README.txt
│ │ ├── analyze-blocking-sizes.cpp
│ │ ├── basicbench.cxxlist
│ │ ├── basicbenchmark.cpp
│ │ ├── basicbenchmark.h
│ │ ├── benchBlasGemm.cpp
│ │ ├── benchCholesky.cpp
│ │ ├── benchEigenSolver.cpp
│ │ ├── benchFFT.cpp
│ │ ├── benchGeometry.cpp
│ │ ├── benchVecAdd.cpp
│ │ ├── bench_gemm.cpp
│ │ ├── bench_multi_compilers.sh
│ │ ├── bench_norm.cpp
│ │ ├── bench_reverse.cpp
│ │ ├── bench_sum.cpp
│ │ ├── bench_unrolling
│ │ ├── benchmark-blocking-sizes.cpp
│ │ ├── benchmark.cpp
│ │ ├── benchmarkSlice.cpp
│ │ ├── benchmarkX.cpp
│ │ ├── benchmarkXcwise.cpp
│ │ ├── benchmark_suite
│ │ ├── btl/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── COPYING
│ │ │ ├── README
│ │ │ ├── actions/
│ │ │ │ ├── action_aat_product.hh
│ │ │ │ ├── action_ata_product.hh
│ │ │ │ ├── action_atv_product.hh
│ │ │ │ ├── action_axpby.hh
│ │ │ │ ├── action_axpy.hh
│ │ │ │ ├── action_cholesky.hh
│ │ │ │ ├── action_ger.hh
│ │ │ │ ├── action_hessenberg.hh
│ │ │ │ ├── action_lu_decomp.hh
│ │ │ │ ├── action_lu_solve.hh
│ │ │ │ ├── action_matrix_matrix_product.hh
│ │ │ │ ├── action_matrix_matrix_product_bis.hh
│ │ │ │ ├── action_matrix_vector_product.hh
│ │ │ │ ├── action_partial_lu.hh
│ │ │ │ ├── action_rot.hh
│ │ │ │ ├── action_symv.hh
│ │ │ │ ├── action_syr2.hh
│ │ │ │ ├── action_trisolve.hh
│ │ │ │ ├── action_trisolve_matrix.hh
│ │ │ │ ├── action_trmm.hh
│ │ │ │ └── basic_actions.hh
│ │ │ ├── cmake/
│ │ │ │ ├── FindACML.cmake
│ │ │ │ ├── FindATLAS.cmake
│ │ │ │ ├── FindBLAZE.cmake
│ │ │ │ ├── FindBlitz.cmake
│ │ │ │ ├── FindCBLAS.cmake
│ │ │ │ ├── FindGMM.cmake
│ │ │ │ ├── FindMKL.cmake
│ │ │ │ ├── FindMTL4.cmake
│ │ │ │ ├── FindOPENBLAS.cmake
│ │ │ │ ├── FindPackageHandleStandardArgs.cmake
│ │ │ │ ├── FindTvmet.cmake
│ │ │ │ └── MacroOptionalAddSubdirectory.cmake
│ │ │ ├── data/
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── action_settings.txt
│ │ │ │ ├── gnuplot_common_settings.hh
│ │ │ │ ├── go_mean
│ │ │ │ ├── mean.cxx
│ │ │ │ ├── mk_gnuplot_script.sh
│ │ │ │ ├── mk_mean_script.sh
│ │ │ │ ├── mk_new_gnuplot.sh
│ │ │ │ ├── perlib_plot_settings.txt
│ │ │ │ ├── regularize.cxx
│ │ │ │ ├── smooth.cxx
│ │ │ │ └── smooth_all.sh
│ │ │ ├── generic_bench/
│ │ │ │ ├── bench.hh
│ │ │ │ ├── bench_parameter.hh
│ │ │ │ ├── btl.hh
│ │ │ │ ├── init/
│ │ │ │ │ ├── init_function.hh
│ │ │ │ │ ├── init_matrix.hh
│ │ │ │ │ └── init_vector.hh
│ │ │ │ ├── static/
│ │ │ │ │ ├── bench_static.hh
│ │ │ │ │ ├── intel_bench_fixed_size.hh
│ │ │ │ │ └── static_size_generator.hh
│ │ │ │ ├── timers/
│ │ │ │ │ ├── STL_perf_analyzer.hh
│ │ │ │ │ ├── STL_timer.hh
│ │ │ │ │ ├── mixed_perf_analyzer.hh
│ │ │ │ │ ├── portable_perf_analyzer.hh
│ │ │ │ │ ├── portable_perf_analyzer_old.hh
│ │ │ │ │ ├── portable_timer.hh
│ │ │ │ │ ├── x86_perf_analyzer.hh
│ │ │ │ │ └── x86_timer.hh
│ │ │ │ └── utils/
│ │ │ │ ├── size_lin_log.hh
│ │ │ │ ├── size_log.hh
│ │ │ │ ├── utilities.h
│ │ │ │ └── xy_file.hh
│ │ │ └── libs/
│ │ │ ├── BLAS/
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── blas.h
│ │ │ │ ├── blas_interface.hh
│ │ │ │ ├── blas_interface_impl.hh
│ │ │ │ ├── c_interface_base.h
│ │ │ │ └── main.cpp
│ │ │ ├── STL/
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── STL_interface.hh
│ │ │ │ └── main.cpp
│ │ │ ├── blaze/
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── blaze_interface.hh
│ │ │ │ └── main.cpp
│ │ │ ├── blitz/
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── blitz_LU_solve_interface.hh
│ │ │ │ ├── blitz_interface.hh
│ │ │ │ ├── btl_blitz.cpp
│ │ │ │ ├── btl_tiny_blitz.cpp
│ │ │ │ └── tiny_blitz_interface.hh
│ │ │ ├── eigen2/
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── btl_tiny_eigen2.cpp
│ │ │ │ ├── eigen2_interface.hh
│ │ │ │ ├── main_adv.cpp
│ │ │ │ ├── main_linear.cpp
│ │ │ │ ├── main_matmat.cpp
│ │ │ │ └── main_vecmat.cpp
│ │ │ ├── eigen3/
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── btl_tiny_eigen3.cpp
│ │ │ │ ├── eigen3_interface.hh
│ │ │ │ ├── main_adv.cpp
│ │ │ │ ├── main_linear.cpp
│ │ │ │ ├── main_matmat.cpp
│ │ │ │ └── main_vecmat.cpp
│ │ │ ├── gmm/
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── gmm_LU_solve_interface.hh
│ │ │ │ ├── gmm_interface.hh
│ │ │ │ └── main.cpp
│ │ │ ├── mtl4/
│ │ │ │ ├── .kdbgrc.main
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── main.cpp
│ │ │ │ ├── mtl4_LU_solve_interface.hh
│ │ │ │ └── mtl4_interface.hh
│ │ │ ├── tensors/
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── main_linear.cpp
│ │ │ │ ├── main_matmat.cpp
│ │ │ │ ├── main_vecmat.cpp
│ │ │ │ └── tensor_interface.hh
│ │ │ ├── tvmet/
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── main.cpp
│ │ │ │ └── tvmet_interface.hh
│ │ │ └── ublas/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── main.cpp
│ │ │ └── ublas_interface.hh
│ │ ├── check_cache_queries.cpp
│ │ ├── dense_solvers.cpp
│ │ ├── eig33.cpp
│ │ ├── geometry.cpp
│ │ ├── perf_monitoring/
│ │ │ ├── changesets.txt
│ │ │ ├── gemm.cpp
│ │ │ ├── gemm_common.h
│ │ │ ├── gemm_settings.txt
│ │ │ ├── gemm_square_settings.txt
│ │ │ ├── gemv.cpp
│ │ │ ├── gemv_common.h
│ │ │ ├── gemv_settings.txt
│ │ │ ├── gemv_square_settings.txt
│ │ │ ├── gemvt.cpp
│ │ │ ├── lazy_gemm.cpp
│ │ │ ├── lazy_gemm_settings.txt
│ │ │ ├── llt.cpp
│ │ │ ├── make_plot.sh
│ │ │ ├── resources/
│ │ │ │ ├── chart_footer.html
│ │ │ │ ├── chart_header.html
│ │ │ │ ├── footer.html
│ │ │ │ ├── header.html
│ │ │ │ ├── s1.js
│ │ │ │ └── s2.js
│ │ │ ├── run.sh
│ │ │ ├── runall.sh
│ │ │ ├── trmv_lo.cpp
│ │ │ ├── trmv_lot.cpp
│ │ │ ├── trmv_up.cpp
│ │ │ └── trmv_upt.cpp
│ │ ├── product_threshold.cpp
│ │ ├── quat_slerp.cpp
│ │ ├── quatmul.cpp
│ │ ├── sparse_cholesky.cpp
│ │ ├── sparse_dense_product.cpp
│ │ ├── sparse_lu.cpp
│ │ ├── sparse_product.cpp
│ │ ├── sparse_randomsetter.cpp
│ │ ├── sparse_setter.cpp
│ │ ├── sparse_transpose.cpp
│ │ ├── sparse_trisolver.cpp
│ │ ├── spbench/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── sp_solver.cpp
│ │ │ ├── spbench.dtd
│ │ │ ├── spbenchsolver.cpp
│ │ │ ├── spbenchsolver.h
│ │ │ ├── spbenchstyle.h
│ │ │ └── test_sparseLU.cpp
│ │ ├── spmv.cpp
│ │ ├── tensors/
│ │ │ ├── README
│ │ │ ├── benchmark.h
│ │ │ ├── benchmark_main.cc
│ │ │ ├── contraction_benchmarks_cpu.cc
│ │ │ ├── eigen_sycl_bench.sh
│ │ │ ├── eigen_sycl_bench_contract.sh
│ │ │ ├── tensor_benchmarks.h
│ │ │ ├── tensor_benchmarks_cpu.cc
│ │ │ ├── tensor_benchmarks_fp16_gpu.cu
│ │ │ ├── tensor_benchmarks_gpu.cu
│ │ │ ├── tensor_benchmarks_sycl.cc
│ │ │ └── tensor_contract_sycl_bench.cc
│ │ └── vdw_new.cpp
│ ├── blas/
│ │ ├── BandTriangularSolver.h
│ │ ├── CMakeLists.txt
│ │ ├── GeneralRank1Update.h
│ │ ├── PackedSelfadjointProduct.h
│ │ ├── PackedTriangularMatrixVector.h
│ │ ├── PackedTriangularSolverVector.h
│ │ ├── README.txt
│ │ ├── Rank2Update.h
│ │ ├── common.h
│ │ ├── complex_double.cpp
│ │ ├── complex_single.cpp
│ │ ├── double.cpp
│ │ ├── f2c/
│ │ │ ├── chbmv.c
│ │ │ ├── chpmv.c
│ │ │ ├── complexdots.c
│ │ │ ├── ctbmv.c
│ │ │ ├── d_cnjg.c
│ │ │ ├── datatypes.h
│ │ │ ├── drotm.c
│ │ │ ├── drotmg.c
│ │ │ ├── dsbmv.c
│ │ │ ├── dspmv.c
│ │ │ ├── dtbmv.c
│ │ │ ├── lsame.c
│ │ │ ├── r_cnjg.c
│ │ │ ├── srotm.c
│ │ │ ├── srotmg.c
│ │ │ ├── ssbmv.c
│ │ │ ├── sspmv.c
│ │ │ ├── stbmv.c
│ │ │ ├── zhbmv.c
│ │ │ ├── zhpmv.c
│ │ │ └── ztbmv.c
│ │ ├── fortran/
│ │ │ └── complexdots.f
│ │ ├── level1_cplx_impl.h
│ │ ├── level1_impl.h
│ │ ├── level1_real_impl.h
│ │ ├── level2_cplx_impl.h
│ │ ├── level2_impl.h
│ │ ├── level2_real_impl.h
│ │ ├── level3_impl.h
│ │ ├── single.cpp
│ │ ├── testing/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── cblat1.f
│ │ │ ├── cblat2.f
│ │ │ ├── cblat3.f
│ │ │ ├── dblat1.f
│ │ │ ├── dblat2.f
│ │ │ ├── dblat3.f
│ │ │ ├── runblastest.sh
│ │ │ ├── sblat1.f
│ │ │ ├── sblat2.f
│ │ │ ├── sblat3.f
│ │ │ ├── zblat1.f
│ │ │ ├── zblat2.f
│ │ │ └── zblat3.f
│ │ └── xerbla.cpp
│ ├── cmake/
│ │ ├── Eigen3Config.cmake.in
│ │ ├── Eigen3ConfigLegacy.cmake.in
│ │ ├── EigenConfigureTesting.cmake
│ │ ├── EigenDetermineOSVersion.cmake
│ │ ├── EigenDetermineVSServicePack.cmake
│ │ ├── EigenTesting.cmake
│ │ ├── EigenUninstall.cmake
│ │ ├── FindAdolc.cmake
│ │ ├── FindBLAS.cmake
│ │ ├── FindBLASEXT.cmake
│ │ ├── FindCholmod.cmake
│ │ ├── FindComputeCpp.cmake
│ │ ├── FindEigen2.cmake
│ │ ├── FindEigen3.cmake
│ │ ├── FindFFTW.cmake
│ │ ├── FindGLEW.cmake
│ │ ├── FindGMP.cmake
│ │ ├── FindGSL.cmake
│ │ ├── FindGoogleHash.cmake
│ │ ├── FindHWLOC.cmake
│ │ ├── FindKLU.cmake
│ │ ├── FindLAPACK.cmake
│ │ ├── FindMPFR.cmake
│ │ ├── FindMetis.cmake
│ │ ├── FindPTSCOTCH.cmake
│ │ ├── FindPastix.cmake
│ │ ├── FindSPQR.cmake
│ │ ├── FindScotch.cmake
│ │ ├── FindStandardMathLibrary.cmake
│ │ ├── FindSuperLU.cmake
│ │ ├── FindTriSYCL.cmake
│ │ ├── FindUmfpack.cmake
│ │ ├── RegexUtils.cmake
│ │ ├── UseEigen3.cmake
│ │ └── language_support.cmake
│ ├── debug/
│ │ ├── gdb/
│ │ │ ├── __init__.py
│ │ │ └── printers.py
│ │ └── msvc/
│ │ └── eigen.natvis
│ ├── demos/
│ │ ├── CMakeLists.txt
│ │ ├── mandelbrot/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── README
│ │ │ ├── mandelbrot.cpp
│ │ │ └── mandelbrot.h
│ │ ├── mix_eigen_and_c/
│ │ │ ├── README
│ │ │ ├── binary_library.cpp
│ │ │ ├── binary_library.h
│ │ │ └── example.c
│ │ └── opengl/
│ │ ├── CMakeLists.txt
│ │ ├── README
│ │ ├── camera.cpp
│ │ ├── camera.h
│ │ ├── gpuhelper.cpp
│ │ ├── gpuhelper.h
│ │ ├── icosphere.cpp
│ │ ├── icosphere.h
│ │ ├── quaternion_demo.cpp
│ │ ├── quaternion_demo.h
│ │ ├── trackball.cpp
│ │ └── trackball.h
│ ├── doc/
│ │ ├── AsciiQuickReference.txt
│ │ ├── B01_Experimental.dox
│ │ ├── CMakeLists.txt
│ │ ├── ClassHierarchy.dox
│ │ ├── CoeffwiseMathFunctionsTable.dox
│ │ ├── CustomizingEigen_CustomScalar.dox
│ │ ├── CustomizingEigen_InheritingMatrix.dox
│ │ ├── CustomizingEigen_NullaryExpr.dox
│ │ ├── CustomizingEigen_Plugins.dox
│ │ ├── DenseDecompositionBenchmark.dox
│ │ ├── Doxyfile.in
│ │ ├── FixedSizeVectorizable.dox
│ │ ├── FunctionsTakingEigenTypes.dox
│ │ ├── HiPerformance.dox
│ │ ├── InplaceDecomposition.dox
│ │ ├── InsideEigenExample.dox
│ │ ├── LeastSquares.dox
│ │ ├── Manual.dox
│ │ ├── MatrixfreeSolverExample.dox
│ │ ├── NewExpressionType.dox
│ │ ├── Overview.dox
│ │ ├── PassingByValue.dox
│ │ ├── Pitfalls.dox
│ │ ├── PreprocessorDirectives.dox
│ │ ├── QuickReference.dox
│ │ ├── QuickStartGuide.dox
│ │ ├── SparseLinearSystems.dox
│ │ ├── SparseQuickReference.dox
│ │ ├── StlContainers.dox
│ │ ├── StorageOrders.dox
│ │ ├── StructHavingEigenMembers.dox
│ │ ├── TemplateKeyword.dox
│ │ ├── TopicAliasing.dox
│ │ ├── TopicAssertions.dox
│ │ ├── TopicCMakeGuide.dox
│ │ ├── TopicEigenExpressionTemplates.dox
│ │ ├── TopicLazyEvaluation.dox
│ │ ├── TopicLinearAlgebraDecompositions.dox
│ │ ├── TopicMultithreading.dox
│ │ ├── TopicResizing.dox
│ │ ├── TopicScalarTypes.dox
│ │ ├── TopicVectorization.dox
│ │ ├── TutorialAdvancedInitialization.dox
│ │ ├── TutorialArrayClass.dox
│ │ ├── TutorialBlockOperations.dox
│ │ ├── TutorialGeometry.dox
│ │ ├── TutorialLinearAlgebra.dox
│ │ ├── TutorialMapClass.dox
│ │ ├── TutorialMatrixArithmetic.dox
│ │ ├── TutorialMatrixClass.dox
│ │ ├── TutorialReductionsVisitorsBroadcasting.dox
│ │ ├── TutorialReshape.dox
│ │ ├── TutorialSTL.dox
│ │ ├── TutorialSlicingIndexing.dox
│ │ ├── TutorialSparse.dox
│ │ ├── TutorialSparse_example_details.dox
│ │ ├── UnalignedArrayAssert.dox
│ │ ├── UsingBlasLapackBackends.dox
│ │ ├── UsingIntelMKL.dox
│ │ ├── UsingNVCC.dox
│ │ ├── WrongStackAlignment.dox
│ │ ├── eigen_navtree_hacks.js
│ │ ├── eigendoxy.css
│ │ ├── eigendoxy_footer.html.in
│ │ ├── eigendoxy_header.html.in
│ │ ├── eigendoxy_layout.xml.in
│ │ ├── eigendoxy_tabs.css
│ │ ├── examples/
│ │ │ ├── .krazy
│ │ │ ├── CMakeLists.txt
│ │ │ ├── CustomizingEigen_Inheritance.cpp
│ │ │ ├── Cwise_erf.cpp
│ │ │ ├── Cwise_erfc.cpp
│ │ │ ├── Cwise_lgamma.cpp
│ │ │ ├── DenseBase_middleCols_int.cpp
│ │ │ ├── DenseBase_middleRows_int.cpp
│ │ │ ├── DenseBase_template_int_middleCols.cpp
│ │ │ ├── DenseBase_template_int_middleRows.cpp
│ │ │ ├── QuickStart_example.cpp
│ │ │ ├── QuickStart_example2_dynamic.cpp
│ │ │ ├── QuickStart_example2_fixed.cpp
│ │ │ ├── TemplateKeyword_flexible.cpp
│ │ │ ├── TemplateKeyword_simple.cpp
│ │ │ ├── TutorialInplaceLU.cpp
│ │ │ ├── TutorialLinAlgComputeTwice.cpp
│ │ │ ├── TutorialLinAlgExComputeSolveError.cpp
│ │ │ ├── TutorialLinAlgExSolveColPivHouseholderQR.cpp
│ │ │ ├── TutorialLinAlgExSolveLDLT.cpp
│ │ │ ├── TutorialLinAlgInverseDeterminant.cpp
│ │ │ ├── TutorialLinAlgRankRevealing.cpp
│ │ │ ├── TutorialLinAlgSVDSolve.cpp
│ │ │ ├── TutorialLinAlgSelfAdjointEigenSolver.cpp
│ │ │ ├── TutorialLinAlgSetThreshold.cpp
│ │ │ ├── Tutorial_ArrayClass_accessors.cpp
│ │ │ ├── Tutorial_ArrayClass_addition.cpp
│ │ │ ├── Tutorial_ArrayClass_cwise_other.cpp
│ │ │ ├── Tutorial_ArrayClass_interop.cpp
│ │ │ ├── Tutorial_ArrayClass_interop_matrix.cpp
│ │ │ ├── Tutorial_ArrayClass_mult.cpp
│ │ │ ├── Tutorial_BlockOperations_block_assignment.cpp
│ │ │ ├── Tutorial_BlockOperations_colrow.cpp
│ │ │ ├── Tutorial_BlockOperations_corner.cpp
│ │ │ ├── Tutorial_BlockOperations_print_block.cpp
│ │ │ ├── Tutorial_BlockOperations_vector.cpp
│ │ │ ├── Tutorial_PartialLU_solve.cpp
│ │ │ ├── Tutorial_ReductionsVisitorsBroadcasting_broadcast_1nn.cpp
│ │ │ ├── Tutorial_ReductionsVisitorsBroadcasting_broadcast_simple.cpp
│ │ │ ├── Tutorial_ReductionsVisitorsBroadcasting_broadcast_simple_rowwise.cpp
│ │ │ ├── Tutorial_ReductionsVisitorsBroadcasting_colwise.cpp
│ │ │ ├── Tutorial_ReductionsVisitorsBroadcasting_maxnorm.cpp
│ │ │ ├── Tutorial_ReductionsVisitorsBroadcasting_reductions_bool.cpp
│ │ │ ├── Tutorial_ReductionsVisitorsBroadcasting_reductions_norm.cpp
│ │ │ ├── Tutorial_ReductionsVisitorsBroadcasting_reductions_operatornorm.cpp
│ │ │ ├── Tutorial_ReductionsVisitorsBroadcasting_rowwise.cpp
│ │ │ ├── Tutorial_ReductionsVisitorsBroadcasting_visitors.cpp
│ │ │ ├── Tutorial_simple_example_dynamic_size.cpp
│ │ │ ├── Tutorial_simple_example_fixed_size.cpp
│ │ │ ├── class_Block.cpp
│ │ │ ├── class_CwiseBinaryOp.cpp
│ │ │ ├── class_CwiseUnaryOp.cpp
│ │ │ ├── class_CwiseUnaryOp_ptrfun.cpp
│ │ │ ├── class_FixedBlock.cpp
│ │ │ ├── class_FixedReshaped.cpp
│ │ │ ├── class_FixedVectorBlock.cpp
│ │ │ ├── class_Reshaped.cpp
│ │ │ ├── class_VectorBlock.cpp
│ │ │ ├── function_taking_eigenbase.cpp
│ │ │ ├── function_taking_ref.cpp
│ │ │ ├── make_circulant.cpp
│ │ │ ├── make_circulant.cpp.entry
│ │ │ ├── make_circulant.cpp.evaluator
│ │ │ ├── make_circulant.cpp.expression
│ │ │ ├── make_circulant.cpp.main
│ │ │ ├── make_circulant.cpp.preamble
│ │ │ ├── make_circulant.cpp.traits
│ │ │ ├── make_circulant2.cpp
│ │ │ ├── matrixfree_cg.cpp
│ │ │ ├── nullary_indexing.cpp
│ │ │ ├── tut_arithmetic_add_sub.cpp
│ │ │ ├── tut_arithmetic_dot_cross.cpp
│ │ │ ├── tut_arithmetic_matrix_mul.cpp
│ │ │ ├── tut_arithmetic_redux_basic.cpp
│ │ │ ├── tut_arithmetic_scalar_mul_div.cpp
│ │ │ ├── tut_matrix_coefficient_accessors.cpp
│ │ │ ├── tut_matrix_resize.cpp
│ │ │ └── tut_matrix_resize_fixed_size.cpp
│ │ ├── snippets/
│ │ │ ├── .krazy
│ │ │ ├── AngleAxis_mimic_euler.cpp
│ │ │ ├── Array_initializer_list_23_cxx11.cpp
│ │ │ ├── Array_initializer_list_vector_cxx11.cpp
│ │ │ ├── Array_variadic_ctor_cxx11.cpp
│ │ │ ├── BiCGSTAB_simple.cpp
│ │ │ ├── BiCGSTAB_step_by_step.cpp
│ │ │ ├── CMakeLists.txt
│ │ │ ├── ColPivHouseholderQR_solve.cpp
│ │ │ ├── ComplexEigenSolver_compute.cpp
│ │ │ ├── ComplexEigenSolver_eigenvalues.cpp
│ │ │ ├── ComplexEigenSolver_eigenvectors.cpp
│ │ │ ├── ComplexSchur_compute.cpp
│ │ │ ├── ComplexSchur_matrixT.cpp
│ │ │ ├── ComplexSchur_matrixU.cpp
│ │ │ ├── Cwise_abs.cpp
│ │ │ ├── Cwise_abs2.cpp
│ │ │ ├── Cwise_acos.cpp
│ │ │ ├── Cwise_arg.cpp
│ │ │ ├── Cwise_array_power_array.cpp
│ │ │ ├── Cwise_asin.cpp
│ │ │ ├── Cwise_atan.cpp
│ │ │ ├── Cwise_boolean_and.cpp
│ │ │ ├── Cwise_boolean_not.cpp
│ │ │ ├── Cwise_boolean_or.cpp
│ │ │ ├── Cwise_boolean_xor.cpp
│ │ │ ├── Cwise_ceil.cpp
│ │ │ ├── Cwise_cos.cpp
│ │ │ ├── Cwise_cosh.cpp
│ │ │ ├── Cwise_cube.cpp
│ │ │ ├── Cwise_equal_equal.cpp
│ │ │ ├── Cwise_exp.cpp
│ │ │ ├── Cwise_floor.cpp
│ │ │ ├── Cwise_greater.cpp
│ │ │ ├── Cwise_greater_equal.cpp
│ │ │ ├── Cwise_inverse.cpp
│ │ │ ├── Cwise_isFinite.cpp
│ │ │ ├── Cwise_isInf.cpp
│ │ │ ├── Cwise_isNaN.cpp
│ │ │ ├── Cwise_less.cpp
│ │ │ ├── Cwise_less_equal.cpp
│ │ │ ├── Cwise_log.cpp
│ │ │ ├── Cwise_log10.cpp
│ │ │ ├── Cwise_max.cpp
│ │ │ ├── Cwise_min.cpp
│ │ │ ├── Cwise_minus.cpp
│ │ │ ├── Cwise_minus_equal.cpp
│ │ │ ├── Cwise_not_equal.cpp
│ │ │ ├── Cwise_plus.cpp
│ │ │ ├── Cwise_plus_equal.cpp
│ │ │ ├── Cwise_pow.cpp
│ │ │ ├── Cwise_product.cpp
│ │ │ ├── Cwise_quotient.cpp
│ │ │ ├── Cwise_rint.cpp
│ │ │ ├── Cwise_round.cpp
│ │ │ ├── Cwise_scalar_power_array.cpp
│ │ │ ├── Cwise_sign.cpp
│ │ │ ├── Cwise_sin.cpp
│ │ │ ├── Cwise_sinh.cpp
│ │ │ ├── Cwise_slash_equal.cpp
│ │ │ ├── Cwise_sqrt.cpp
│ │ │ ├── Cwise_square.cpp
│ │ │ ├── Cwise_tan.cpp
│ │ │ ├── Cwise_tanh.cpp
│ │ │ ├── Cwise_times_equal.cpp
│ │ │ ├── DenseBase_LinSpaced.cpp
│ │ │ ├── DenseBase_LinSpacedInt.cpp
│ │ │ ├── DenseBase_LinSpaced_seq_deprecated.cpp
│ │ │ ├── DenseBase_setLinSpaced.cpp
│ │ │ ├── DirectionWise_hnormalized.cpp
│ │ │ ├── DirectionWise_replicate.cpp
│ │ │ ├── DirectionWise_replicate_int.cpp
│ │ │ ├── EigenSolver_EigenSolver_MatrixType.cpp
│ │ │ ├── EigenSolver_compute.cpp
│ │ │ ├── EigenSolver_eigenvalues.cpp
│ │ │ ├── EigenSolver_eigenvectors.cpp
│ │ │ ├── EigenSolver_pseudoEigenvectors.cpp
│ │ │ ├── FullPivHouseholderQR_solve.cpp
│ │ │ ├── FullPivLU_image.cpp
│ │ │ ├── FullPivLU_kernel.cpp
│ │ │ ├── FullPivLU_solve.cpp
│ │ │ ├── GeneralizedEigenSolver.cpp
│ │ │ ├── HessenbergDecomposition_compute.cpp
│ │ │ ├── HessenbergDecomposition_matrixH.cpp
│ │ │ ├── HessenbergDecomposition_packedMatrix.cpp
│ │ │ ├── HouseholderQR_householderQ.cpp
│ │ │ ├── HouseholderQR_solve.cpp
│ │ │ ├── HouseholderSequence_HouseholderSequence.cpp
│ │ │ ├── IOFormat.cpp
│ │ │ ├── JacobiSVD_basic.cpp
│ │ │ ├── Jacobi_makeGivens.cpp
│ │ │ ├── Jacobi_makeJacobi.cpp
│ │ │ ├── LLT_example.cpp
│ │ │ ├── LLT_solve.cpp
│ │ │ ├── LeastSquaresNormalEquations.cpp
│ │ │ ├── LeastSquaresQR.cpp
│ │ │ ├── Map_general_stride.cpp
│ │ │ ├── Map_inner_stride.cpp
│ │ │ ├── Map_outer_stride.cpp
│ │ │ ├── Map_placement_new.cpp
│ │ │ ├── Map_simple.cpp
│ │ │ ├── MatrixBase_adjoint.cpp
│ │ │ ├── MatrixBase_all.cpp
│ │ │ ├── MatrixBase_applyOnTheLeft.cpp
│ │ │ ├── MatrixBase_applyOnTheRight.cpp
│ │ │ ├── MatrixBase_array.cpp
│ │ │ ├── MatrixBase_array_const.cpp
│ │ │ ├── MatrixBase_asDiagonal.cpp
│ │ │ ├── MatrixBase_block_int_int.cpp
│ │ │ ├── MatrixBase_block_int_int_int_int.cpp
│ │ │ ├── MatrixBase_bottomLeftCorner_int_int.cpp
│ │ │ ├── MatrixBase_bottomRightCorner_int_int.cpp
│ │ │ ├── MatrixBase_bottomRows_int.cpp
│ │ │ ├── MatrixBase_cast.cpp
│ │ │ ├── MatrixBase_col.cpp
│ │ │ ├── MatrixBase_colwise.cpp
│ │ │ ├── MatrixBase_colwise_iterator_cxx11.cpp
│ │ │ ├── MatrixBase_computeInverseAndDetWithCheck.cpp
│ │ │ ├── MatrixBase_computeInverseWithCheck.cpp
│ │ │ ├── MatrixBase_cwiseAbs.cpp
│ │ │ ├── MatrixBase_cwiseAbs2.cpp
│ │ │ ├── MatrixBase_cwiseEqual.cpp
│ │ │ ├── MatrixBase_cwiseInverse.cpp
│ │ │ ├── MatrixBase_cwiseMax.cpp
│ │ │ ├── MatrixBase_cwiseMin.cpp
│ │ │ ├── MatrixBase_cwiseNotEqual.cpp
│ │ │ ├── MatrixBase_cwiseProduct.cpp
│ │ │ ├── MatrixBase_cwiseQuotient.cpp
│ │ │ ├── MatrixBase_cwiseSign.cpp
│ │ │ ├── MatrixBase_cwiseSqrt.cpp
│ │ │ ├── MatrixBase_diagonal.cpp
│ │ │ ├── MatrixBase_diagonal_int.cpp
│ │ │ ├── MatrixBase_diagonal_template_int.cpp
│ │ │ ├── MatrixBase_eigenvalues.cpp
│ │ │ ├── MatrixBase_end_int.cpp
│ │ │ ├── MatrixBase_eval.cpp
│ │ │ ├── MatrixBase_fixedBlock_int_int.cpp
│ │ │ ├── MatrixBase_hnormalized.cpp
│ │ │ ├── MatrixBase_homogeneous.cpp
│ │ │ ├── MatrixBase_identity.cpp
│ │ │ ├── MatrixBase_identity_int_int.cpp
│ │ │ ├── MatrixBase_inverse.cpp
│ │ │ ├── MatrixBase_isDiagonal.cpp
│ │ │ ├── MatrixBase_isIdentity.cpp
│ │ │ ├── MatrixBase_isOnes.cpp
│ │ │ ├── MatrixBase_isOrthogonal.cpp
│ │ │ ├── MatrixBase_isUnitary.cpp
│ │ │ ├── MatrixBase_isZero.cpp
│ │ │ ├── MatrixBase_leftCols_int.cpp
│ │ │ ├── MatrixBase_noalias.cpp
│ │ │ ├── MatrixBase_ones.cpp
│ │ │ ├── MatrixBase_ones_int.cpp
│ │ │ ├── MatrixBase_ones_int_int.cpp
│ │ │ ├── MatrixBase_operatorNorm.cpp
│ │ │ ├── MatrixBase_prod.cpp
│ │ │ ├── MatrixBase_random.cpp
│ │ │ ├── MatrixBase_random_int.cpp
│ │ │ ├── MatrixBase_random_int_int.cpp
│ │ │ ├── MatrixBase_replicate.cpp
│ │ │ ├── MatrixBase_replicate_int_int.cpp
│ │ │ ├── MatrixBase_reshaped_auto.cpp
│ │ │ ├── MatrixBase_reshaped_fixed.cpp
│ │ │ ├── MatrixBase_reshaped_int_int.cpp
│ │ │ ├── MatrixBase_reshaped_to_vector.cpp
│ │ │ ├── MatrixBase_reverse.cpp
│ │ │ ├── MatrixBase_rightCols_int.cpp
│ │ │ ├── MatrixBase_row.cpp
│ │ │ ├── MatrixBase_rowwise.cpp
│ │ │ ├── MatrixBase_segment_int_int.cpp
│ │ │ ├── MatrixBase_select.cpp
│ │ │ ├── MatrixBase_selfadjointView.cpp
│ │ │ ├── MatrixBase_set.cpp
│ │ │ ├── MatrixBase_setIdentity.cpp
│ │ │ ├── MatrixBase_setOnes.cpp
│ │ │ ├── MatrixBase_setRandom.cpp
│ │ │ ├── MatrixBase_setZero.cpp
│ │ │ ├── MatrixBase_start_int.cpp
│ │ │ ├── MatrixBase_template_int_bottomRows.cpp
│ │ │ ├── MatrixBase_template_int_end.cpp
│ │ │ ├── MatrixBase_template_int_int_block_int_int_int_int.cpp
│ │ │ ├── MatrixBase_template_int_int_bottomLeftCorner.cpp
│ │ │ ├── MatrixBase_template_int_int_bottomLeftCorner_int_int.cpp
│ │ │ ├── MatrixBase_template_int_int_bottomRightCorner.cpp
│ │ │ ├── MatrixBase_template_int_int_bottomRightCorner_int_int.cpp
│ │ │ ├── MatrixBase_template_int_int_topLeftCorner.cpp
│ │ │ ├── MatrixBase_template_int_int_topLeftCorner_int_int.cpp
│ │ │ ├── MatrixBase_template_int_int_topRightCorner.cpp
│ │ │ ├── MatrixBase_template_int_int_topRightCorner_int_int.cpp
│ │ │ ├── MatrixBase_template_int_leftCols.cpp
│ │ │ ├── MatrixBase_template_int_rightCols.cpp
│ │ │ ├── MatrixBase_template_int_segment.cpp
│ │ │ ├── MatrixBase_template_int_start.cpp
│ │ │ ├── MatrixBase_template_int_topRows.cpp
│ │ │ ├── MatrixBase_topLeftCorner_int_int.cpp
│ │ │ ├── MatrixBase_topRightCorner_int_int.cpp
│ │ │ ├── MatrixBase_topRows_int.cpp
│ │ │ ├── MatrixBase_transpose.cpp
│ │ │ ├── MatrixBase_triangularView.cpp
│ │ │ ├── MatrixBase_zero.cpp
│ │ │ ├── MatrixBase_zero_int.cpp
│ │ │ ├── MatrixBase_zero_int_int.cpp
│ │ │ ├── Matrix_Map_stride.cpp
│ │ │ ├── Matrix_initializer_list_23_cxx11.cpp
│ │ │ ├── Matrix_initializer_list_vector_cxx11.cpp
│ │ │ ├── Matrix_resize_NoChange_int.cpp
│ │ │ ├── Matrix_resize_int.cpp
│ │ │ ├── Matrix_resize_int_NoChange.cpp
│ │ │ ├── Matrix_resize_int_int.cpp
│ │ │ ├── Matrix_setConstant_int.cpp
│ │ │ ├── Matrix_setConstant_int_int.cpp
│ │ │ ├── Matrix_setIdentity_int_int.cpp
│ │ │ ├── Matrix_setOnes_int.cpp
│ │ │ ├── Matrix_setOnes_int_int.cpp
│ │ │ ├── Matrix_setRandom_int.cpp
│ │ │ ├── Matrix_setRandom_int_int.cpp
│ │ │ ├── Matrix_setZero_int.cpp
│ │ │ ├── Matrix_setZero_int_int.cpp
│ │ │ ├── Matrix_variadic_ctor_cxx11.cpp
│ │ │ ├── PartialPivLU_solve.cpp
│ │ │ ├── PartialRedux_count.cpp
│ │ │ ├── PartialRedux_maxCoeff.cpp
│ │ │ ├── PartialRedux_minCoeff.cpp
│ │ │ ├── PartialRedux_norm.cpp
│ │ │ ├── PartialRedux_prod.cpp
│ │ │ ├── PartialRedux_squaredNorm.cpp
│ │ │ ├── PartialRedux_sum.cpp
│ │ │ ├── RealQZ_compute.cpp
│ │ │ ├── RealSchur_RealSchur_MatrixType.cpp
│ │ │ ├── RealSchur_compute.cpp
│ │ │ ├── SelfAdjointEigenSolver_SelfAdjointEigenSolver.cpp
│ │ │ ├── SelfAdjointEigenSolver_SelfAdjointEigenSolver_MatrixType.cpp
│ │ │ ├── SelfAdjointEigenSolver_SelfAdjointEigenSolver_MatrixType2.cpp
│ │ │ ├── SelfAdjointEigenSolver_compute_MatrixType.cpp
│ │ │ ├── SelfAdjointEigenSolver_compute_MatrixType2.cpp
│ │ │ ├── SelfAdjointEigenSolver_eigenvalues.cpp
│ │ │ ├── SelfAdjointEigenSolver_eigenvectors.cpp
│ │ │ ├── SelfAdjointEigenSolver_operatorInverseSqrt.cpp
│ │ │ ├── SelfAdjointEigenSolver_operatorSqrt.cpp
│ │ │ ├── SelfAdjointView_eigenvalues.cpp
│ │ │ ├── SelfAdjointView_operatorNorm.cpp
│ │ │ ├── Slicing_arrayexpr.cpp
│ │ │ ├── Slicing_custom_padding_cxx11.cpp
│ │ │ ├── Slicing_rawarray_cxx11.cpp
│ │ │ ├── Slicing_stdvector_cxx11.cpp
│ │ │ ├── SparseMatrix_coeffs.cpp
│ │ │ ├── TopicAliasing_block.cpp
│ │ │ ├── TopicAliasing_block_correct.cpp
│ │ │ ├── TopicAliasing_cwise.cpp
│ │ │ ├── TopicAliasing_mult1.cpp
│ │ │ ├── TopicAliasing_mult2.cpp
│ │ │ ├── TopicAliasing_mult3.cpp
│ │ │ ├── TopicAliasing_mult4.cpp
│ │ │ ├── TopicAliasing_mult5.cpp
│ │ │ ├── TopicStorageOrders_example.cpp
│ │ │ ├── Triangular_solve.cpp
│ │ │ ├── Tridiagonalization_Tridiagonalization_MatrixType.cpp
│ │ │ ├── Tridiagonalization_compute.cpp
│ │ │ ├── Tridiagonalization_decomposeInPlace.cpp
│ │ │ ├── Tridiagonalization_diagonal.cpp
│ │ │ ├── Tridiagonalization_householderCoefficients.cpp
│ │ │ ├── Tridiagonalization_packedMatrix.cpp
│ │ │ ├── Tutorial_AdvancedInitialization_Block.cpp
│ │ │ ├── Tutorial_AdvancedInitialization_CommaTemporary.cpp
│ │ │ ├── Tutorial_AdvancedInitialization_Join.cpp
│ │ │ ├── Tutorial_AdvancedInitialization_LinSpaced.cpp
│ │ │ ├── Tutorial_AdvancedInitialization_ThreeWays.cpp
│ │ │ ├── Tutorial_AdvancedInitialization_Zero.cpp
│ │ │ ├── Tutorial_Map_rowmajor.cpp
│ │ │ ├── Tutorial_Map_using.cpp
│ │ │ ├── Tutorial_ReshapeMat2Mat.cpp
│ │ │ ├── Tutorial_ReshapeMat2Vec.cpp
│ │ │ ├── Tutorial_SlicingCol.cpp
│ │ │ ├── Tutorial_SlicingVec.cpp
│ │ │ ├── Tutorial_commainit_01.cpp
│ │ │ ├── Tutorial_commainit_01b.cpp
│ │ │ ├── Tutorial_commainit_02.cpp
│ │ │ ├── Tutorial_range_for_loop_1d_cxx11.cpp
│ │ │ ├── Tutorial_range_for_loop_2d_cxx11.cpp
│ │ │ ├── Tutorial_reshaped_vs_resize_1.cpp
│ │ │ ├── Tutorial_reshaped_vs_resize_2.cpp
│ │ │ ├── Tutorial_solve_matrix_inverse.cpp
│ │ │ ├── Tutorial_solve_multiple_rhs.cpp
│ │ │ ├── Tutorial_solve_reuse_decomposition.cpp
│ │ │ ├── Tutorial_solve_singular.cpp
│ │ │ ├── Tutorial_solve_triangular.cpp
│ │ │ ├── Tutorial_solve_triangular_inplace.cpp
│ │ │ ├── Tutorial_std_sort.cpp
│ │ │ ├── Tutorial_std_sort_rows_cxx11.cpp
│ │ │ ├── VectorwiseOp_homogeneous.cpp
│ │ │ ├── Vectorwise_reverse.cpp
│ │ │ ├── class_FullPivLU.cpp
│ │ │ ├── compile_snippet.cpp.in
│ │ │ ├── tut_arithmetic_redux_minmax.cpp
│ │ │ ├── tut_arithmetic_transpose_aliasing.cpp
│ │ │ ├── tut_arithmetic_transpose_conjugate.cpp
│ │ │ ├── tut_arithmetic_transpose_inplace.cpp
│ │ │ └── tut_matrix_assignment_resizing.cpp
│ │ ├── special_examples/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── Tutorial_sparse_example.cpp
│ │ │ ├── Tutorial_sparse_example_details.cpp
│ │ │ └── random_cpp11.cpp
│ │ └── tutorial.cpp
│ ├── eigen3.pc.in
│ ├── failtest/
│ │ ├── CMakeLists.txt
│ │ ├── bdcsvd_int.cpp
│ │ ├── block_nonconst_ctor_on_const_xpr_0.cpp
│ │ ├── block_nonconst_ctor_on_const_xpr_1.cpp
│ │ ├── block_nonconst_ctor_on_const_xpr_2.cpp
│ │ ├── block_on_const_type_actually_const_0.cpp
│ │ ├── block_on_const_type_actually_const_1.cpp
│ │ ├── colpivqr_int.cpp
│ │ ├── const_qualified_block_method_retval_0.cpp
│ │ ├── const_qualified_block_method_retval_1.cpp
│ │ ├── const_qualified_diagonal_method_retval.cpp
│ │ ├── const_qualified_transpose_method_retval.cpp
│ │ ├── cwiseunaryview_nonconst_ctor_on_const_xpr.cpp
│ │ ├── cwiseunaryview_on_const_type_actually_const.cpp
│ │ ├── diagonal_nonconst_ctor_on_const_xpr.cpp
│ │ ├── diagonal_on_const_type_actually_const.cpp
│ │ ├── eigensolver_cplx.cpp
│ │ ├── eigensolver_int.cpp
│ │ ├── failtest_sanity_check.cpp
│ │ ├── fullpivlu_int.cpp
│ │ ├── fullpivqr_int.cpp
│ │ ├── initializer_list_1.cpp
│ │ ├── initializer_list_2.cpp
│ │ ├── jacobisvd_int.cpp
│ │ ├── ldlt_int.cpp
│ │ ├── llt_int.cpp
│ │ ├── map_nonconst_ctor_on_const_ptr_0.cpp
│ │ ├── map_nonconst_ctor_on_const_ptr_1.cpp
│ │ ├── map_nonconst_ctor_on_const_ptr_2.cpp
│ │ ├── map_nonconst_ctor_on_const_ptr_3.cpp
│ │ ├── map_nonconst_ctor_on_const_ptr_4.cpp
│ │ ├── map_on_const_type_actually_const_0.cpp
│ │ ├── map_on_const_type_actually_const_1.cpp
│ │ ├── partialpivlu_int.cpp
│ │ ├── qr_int.cpp
│ │ ├── ref_1.cpp
│ │ ├── ref_2.cpp
│ │ ├── ref_3.cpp
│ │ ├── ref_4.cpp
│ │ ├── ref_5.cpp
│ │ ├── selfadjointview_nonconst_ctor_on_const_xpr.cpp
│ │ ├── selfadjointview_on_const_type_actually_const.cpp
│ │ ├── sparse_ref_1.cpp
│ │ ├── sparse_ref_2.cpp
│ │ ├── sparse_ref_3.cpp
│ │ ├── sparse_ref_4.cpp
│ │ ├── sparse_ref_5.cpp
│ │ ├── sparse_storage_mismatch.cpp
│ │ ├── swap_1.cpp
│ │ ├── swap_2.cpp
│ │ ├── ternary_1.cpp
│ │ ├── ternary_2.cpp
│ │ ├── transpose_nonconst_ctor_on_const_xpr.cpp
│ │ ├── transpose_on_const_type_actually_const.cpp
│ │ ├── triangularview_nonconst_ctor_on_const_xpr.cpp
│ │ └── triangularview_on_const_type_actually_const.cpp
│ ├── lapack/
│ │ ├── CMakeLists.txt
│ │ ├── cholesky.cpp
│ │ ├── clacgv.f
│ │ ├── cladiv.f
│ │ ├── clarf.f
│ │ ├── clarfb.f
│ │ ├── clarfg.f
│ │ ├── clarft.f
│ │ ├── complex_double.cpp
│ │ ├── complex_single.cpp
│ │ ├── dladiv.f
│ │ ├── dlamch.f
│ │ ├── dlapy2.f
│ │ ├── dlapy3.f
│ │ ├── dlarf.f
│ │ ├── dlarfb.f
│ │ ├── dlarfg.f
│ │ ├── dlarft.f
│ │ ├── double.cpp
│ │ ├── dsecnd_NONE.f
│ │ ├── eigenvalues.cpp
│ │ ├── ilaclc.f
│ │ ├── ilaclr.f
│ │ ├── iladlc.f
│ │ ├── iladlr.f
│ │ ├── ilaslc.f
│ │ ├── ilaslr.f
│ │ ├── ilazlc.f
│ │ ├── ilazlr.f
│ │ ├── lapack_common.h
│ │ ├── lu.cpp
│ │ ├── second_NONE.f
│ │ ├── single.cpp
│ │ ├── sladiv.f
│ │ ├── slamch.f
│ │ ├── slapy2.f
│ │ ├── slapy3.f
│ │ ├── slarf.f
│ │ ├── slarfb.f
│ │ ├── slarfg.f
│ │ ├── slarft.f
│ │ ├── svd.cpp
│ │ ├── zlacgv.f
│ │ ├── zladiv.f
│ │ ├── zlarf.f
│ │ ├── zlarfb.f
│ │ ├── zlarfg.f
│ │ └── zlarft.f
│ ├── scripts/
│ │ ├── CMakeLists.txt
│ │ ├── buildtests.in
│ │ ├── cdashtesting.cmake.in
│ │ ├── check.in
│ │ ├── debug.in
│ │ ├── eigen_gen_credits.cpp
│ │ ├── eigen_gen_docs
│ │ ├── eigen_gen_split_test_help.cmake
│ │ ├── eigen_monitor_perf.sh
│ │ ├── release.in
│ │ └── relicense.py
│ ├── signature_of_eigen3_matrix_library
│ ├── test/
│ │ ├── AnnoyingScalar.h
│ │ ├── CMakeLists.txt
│ │ ├── adjoint.cpp
│ │ ├── array_cwise.cpp
│ │ ├── array_for_matrix.cpp
│ │ ├── array_of_string.cpp
│ │ ├── array_replicate.cpp
│ │ ├── array_reverse.cpp
│ │ ├── bandmatrix.cpp
│ │ ├── basicstuff.cpp
│ │ ├── bdcsvd.cpp
│ │ ├── bicgstab.cpp
│ │ ├── block.cpp
│ │ ├── boostmultiprec.cpp
│ │ ├── bug1213.cpp
│ │ ├── bug1213.h
│ │ ├── bug1213_main.cpp
│ │ ├── cholesky.cpp
│ │ ├── cholmod_support.cpp
│ │ ├── commainitializer.cpp
│ │ ├── conjugate_gradient.cpp
│ │ ├── conservative_resize.cpp
│ │ ├── constructor.cpp
│ │ ├── corners.cpp
│ │ ├── ctorleak.cpp
│ │ ├── denseLM.cpp
│ │ ├── dense_storage.cpp
│ │ ├── determinant.cpp
│ │ ├── diagonal.cpp
│ │ ├── diagonal_matrix_variadic_ctor.cpp
│ │ ├── diagonalmatrices.cpp
│ │ ├── dontalign.cpp
│ │ ├── dynalloc.cpp
│ │ ├── eigen2support.cpp
│ │ ├── eigensolver_complex.cpp
│ │ ├── eigensolver_generalized_real.cpp
│ │ ├── eigensolver_generic.cpp
│ │ ├── eigensolver_selfadjoint.cpp
│ │ ├── evaluator_common.h
│ │ ├── evaluators.cpp
│ │ ├── exceptions.cpp
│ │ ├── fastmath.cpp
│ │ ├── first_aligned.cpp
│ │ ├── geo_alignedbox.cpp
│ │ ├── geo_eulerangles.cpp
│ │ ├── geo_homogeneous.cpp
│ │ ├── geo_hyperplane.cpp
│ │ ├── geo_orthomethods.cpp
│ │ ├── geo_parametrizedline.cpp
│ │ ├── geo_quaternion.cpp
│ │ ├── geo_transformations.cpp
│ │ ├── gpu_basic.cu
│ │ ├── gpu_common.h
│ │ ├── half_float.cpp
│ │ ├── hessenberg.cpp
│ │ ├── householder.cpp
│ │ ├── incomplete_cholesky.cpp
│ │ ├── indexed_view.cpp
│ │ ├── initializer_list_construction.cpp
│ │ ├── inplace_decomposition.cpp
│ │ ├── integer_types.cpp
│ │ ├── inverse.cpp
│ │ ├── io.cpp
│ │ ├── is_same_dense.cpp
│ │ ├── jacobi.cpp
│ │ ├── jacobisvd.cpp
│ │ ├── klu_support.cpp
│ │ ├── linearstructure.cpp
│ │ ├── lscg.cpp
│ │ ├── lu.cpp
│ │ ├── main.h
│ │ ├── mapped_matrix.cpp
│ │ ├── mapstaticmethods.cpp
│ │ ├── mapstride.cpp
│ │ ├── meta.cpp
│ │ ├── metis_support.cpp
│ │ ├── miscmatrices.cpp
│ │ ├── mixingtypes.cpp
│ │ ├── mpl2only.cpp
│ │ ├── nestbyvalue.cpp
│ │ ├── nesting_ops.cpp
│ │ ├── nomalloc.cpp
│ │ ├── nullary.cpp
│ │ ├── num_dimensions.cpp
│ │ ├── numext.cpp
│ │ ├── packetmath.cpp
│ │ ├── packetmath_test_shared.h
│ │ ├── pardiso_support.cpp
│ │ ├── pastix_support.cpp
│ │ ├── permutationmatrices.cpp
│ │ ├── prec_inverse_4x4.cpp
│ │ ├── product.h
│ │ ├── product_extra.cpp
│ │ ├── product_large.cpp
│ │ ├── product_mmtr.cpp
│ │ ├── product_notemporary.cpp
│ │ ├── product_selfadjoint.cpp
│ │ ├── product_small.cpp
│ │ ├── product_symm.cpp
│ │ ├── product_syrk.cpp
│ │ ├── product_trmm.cpp
│ │ ├── product_trmv.cpp
│ │ ├── product_trsolve.cpp
│ │ ├── qr.cpp
│ │ ├── qr_colpivoting.cpp
│ │ ├── qr_fullpivoting.cpp
│ │ ├── qtvector.cpp
│ │ ├── rand.cpp
│ │ ├── real_qz.cpp
│ │ ├── redux.cpp
│ │ ├── ref.cpp
│ │ ├── reshape.cpp
│ │ ├── resize.cpp
│ │ ├── rvalue_types.cpp
│ │ ├── schur_complex.cpp
│ │ ├── schur_real.cpp
│ │ ├── selfadjoint.cpp
│ │ ├── simplicial_cholesky.cpp
│ │ ├── sizeof.cpp
│ │ ├── sizeoverflow.cpp
│ │ ├── smallvectors.cpp
│ │ ├── solverbase.h
│ │ ├── sparse.h
│ │ ├── sparseLM.cpp
│ │ ├── sparse_basic.cpp
│ │ ├── sparse_block.cpp
│ │ ├── sparse_permutations.cpp
│ │ ├── sparse_product.cpp
│ │ ├── sparse_ref.cpp
│ │ ├── sparse_solver.h
│ │ ├── sparse_solvers.cpp
│ │ ├── sparse_vector.cpp
│ │ ├── sparselu.cpp
│ │ ├── sparseqr.cpp
│ │ ├── special_numbers.cpp
│ │ ├── split_test_helper.h
│ │ ├── spqr_support.cpp
│ │ ├── stable_norm.cpp
│ │ ├── stddeque.cpp
│ │ ├── stddeque_overload.cpp
│ │ ├── stdlist.cpp
│ │ ├── stdlist_overload.cpp
│ │ ├── stdvector.cpp
│ │ ├── stdvector_overload.cpp
│ │ ├── stl_iterators.cpp
│ │ ├── superlu_support.cpp
│ │ ├── svd_common.h
│ │ ├── svd_fill.h
│ │ ├── swap.cpp
│ │ ├── symbolic_index.cpp
│ │ ├── triangular.cpp
│ │ ├── type_alias.cpp
│ │ ├── umeyama.cpp
│ │ ├── umfpack_support.cpp
│ │ ├── unalignedassert.cpp
│ │ ├── unalignedcount.cpp
│ │ ├── upperbidiagonalization.cpp
│ │ ├── vectorization_logic.cpp
│ │ ├── vectorwiseop.cpp
│ │ ├── visitor.cpp
│ │ └── zerosized.cpp
│ └── unsupported/
│ ├── CMakeLists.txt
│ ├── Eigen/
│ │ ├── AdolcForward
│ │ ├── AlignedVector3
│ │ ├── ArpackSupport
│ │ ├── AutoDiff
│ │ ├── BVH
│ │ ├── CMakeLists.txt
│ │ ├── CXX11/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── Tensor
│ │ │ ├── TensorSymmetry
│ │ │ ├── ThreadPool
│ │ │ └── src/
│ │ │ ├── Tensor/
│ │ │ │ ├── README.md
│ │ │ │ ├── Tensor.h
│ │ │ │ ├── TensorArgMax.h
│ │ │ │ ├── TensorAssign.h
│ │ │ │ ├── TensorBase.h
│ │ │ │ ├── TensorBlock.h
│ │ │ │ ├── TensorBroadcasting.h
│ │ │ │ ├── TensorChipping.h
│ │ │ │ ├── TensorConcatenation.h
│ │ │ │ ├── TensorContraction.h
│ │ │ │ ├── TensorContractionBlocking.h
│ │ │ │ ├── TensorContractionCuda.h
│ │ │ │ ├── TensorContractionGpu.h
│ │ │ │ ├── TensorContractionMapper.h
│ │ │ │ ├── TensorContractionSycl.h
│ │ │ │ ├── TensorContractionThreadPool.h
│ │ │ │ ├── TensorConversion.h
│ │ │ │ ├── TensorConvolution.h
│ │ │ │ ├── TensorConvolutionSycl.h
│ │ │ │ ├── TensorCostModel.h
│ │ │ │ ├── TensorCustomOp.h
│ │ │ │ ├── TensorDevice.h
│ │ │ │ ├── TensorDeviceCuda.h
│ │ │ │ ├── TensorDeviceDefault.h
│ │ │ │ ├── TensorDeviceGpu.h
│ │ │ │ ├── TensorDeviceSycl.h
│ │ │ │ ├── TensorDeviceThreadPool.h
│ │ │ │ ├── TensorDimensionList.h
│ │ │ │ ├── TensorDimensions.h
│ │ │ │ ├── TensorEvalTo.h
│ │ │ │ ├── TensorEvaluator.h
│ │ │ │ ├── TensorExecutor.h
│ │ │ │ ├── TensorExpr.h
│ │ │ │ ├── TensorFFT.h
│ │ │ │ ├── TensorFixedSize.h
│ │ │ │ ├── TensorForcedEval.h
│ │ │ │ ├── TensorForwardDeclarations.h
│ │ │ │ ├── TensorFunctors.h
│ │ │ │ ├── TensorGenerator.h
│ │ │ │ ├── TensorGlobalFunctions.h
│ │ │ │ ├── TensorGpuHipCudaDefines.h
│ │ │ │ ├── TensorGpuHipCudaUndefines.h
│ │ │ │ ├── TensorIO.h
│ │ │ │ ├── TensorImagePatch.h
│ │ │ │ ├── TensorIndexList.h
│ │ │ │ ├── TensorInflation.h
│ │ │ │ ├── TensorInitializer.h
│ │ │ │ ├── TensorIntDiv.h
│ │ │ │ ├── TensorLayoutSwap.h
│ │ │ │ ├── TensorMacros.h
│ │ │ │ ├── TensorMap.h
│ │ │ │ ├── TensorMeta.h
│ │ │ │ ├── TensorMorphing.h
│ │ │ │ ├── TensorPadding.h
│ │ │ │ ├── TensorPatch.h
│ │ │ │ ├── TensorRandom.h
│ │ │ │ ├── TensorReduction.h
│ │ │ │ ├── TensorReductionCuda.h
│ │ │ │ ├── TensorReductionGpu.h
│ │ │ │ ├── TensorReductionSycl.h
│ │ │ │ ├── TensorRef.h
│ │ │ │ ├── TensorReverse.h
│ │ │ │ ├── TensorScan.h
│ │ │ │ ├── TensorScanSycl.h
│ │ │ │ ├── TensorShuffling.h
│ │ │ │ ├── TensorStorage.h
│ │ │ │ ├── TensorStriding.h
│ │ │ │ ├── TensorTrace.h
│ │ │ │ ├── TensorTraits.h
│ │ │ │ ├── TensorUInt128.h
│ │ │ │ └── TensorVolumePatch.h
│ │ │ ├── TensorSymmetry/
│ │ │ │ ├── DynamicSymmetry.h
│ │ │ │ ├── StaticSymmetry.h
│ │ │ │ ├── Symmetry.h
│ │ │ │ └── util/
│ │ │ │ └── TemplateGroupTheory.h
│ │ │ ├── ThreadPool/
│ │ │ │ ├── Barrier.h
│ │ │ │ ├── EventCount.h
│ │ │ │ ├── NonBlockingThreadPool.h
│ │ │ │ ├── RunQueue.h
│ │ │ │ ├── ThreadCancel.h
│ │ │ │ ├── ThreadEnvironment.h
│ │ │ │ ├── ThreadLocal.h
│ │ │ │ ├── ThreadPoolInterface.h
│ │ │ │ └── ThreadYield.h
│ │ │ └── util/
│ │ │ ├── CXX11Meta.h
│ │ │ ├── CXX11Workarounds.h
│ │ │ ├── EmulateArray.h
│ │ │ └── MaxSizeVector.h
│ │ ├── EulerAngles
│ │ ├── FFT
│ │ ├── IterativeSolvers
│ │ ├── KroneckerProduct
│ │ ├── LevenbergMarquardt
│ │ ├── MPRealSupport
│ │ ├── MatrixFunctions
│ │ ├── MoreVectorization
│ │ ├── NonLinearOptimization
│ │ ├── NumericalDiff
│ │ ├── OpenGLSupport
│ │ ├── Polynomials
│ │ ├── Skyline
│ │ ├── SparseExtra
│ │ ├── SpecialFunctions
│ │ ├── Splines
│ │ └── src/
│ │ ├── AutoDiff/
│ │ │ ├── AutoDiffJacobian.h
│ │ │ ├── AutoDiffScalar.h
│ │ │ └── AutoDiffVector.h
│ │ ├── BVH/
│ │ │ ├── BVAlgorithms.h
│ │ │ └── KdBVH.h
│ │ ├── Eigenvalues/
│ │ │ └── ArpackSelfAdjointEigenSolver.h
│ │ ├── EulerAngles/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── EulerAngles.h
│ │ │ └── EulerSystem.h
│ │ ├── FFT/
│ │ │ ├── ei_fftw_impl.h
│ │ │ └── ei_kissfft_impl.h
│ │ ├── IterativeSolvers/
│ │ │ ├── ConstrainedConjGrad.h
│ │ │ ├── DGMRES.h
│ │ │ ├── GMRES.h
│ │ │ ├── IncompleteLU.h
│ │ │ ├── IterationController.h
│ │ │ ├── MINRES.h
│ │ │ └── Scaling.h
│ │ ├── KroneckerProduct/
│ │ │ └── KroneckerTensorProduct.h
│ │ ├── LevenbergMarquardt/
│ │ │ ├── CopyrightMINPACK.txt
│ │ │ ├── LMcovar.h
│ │ │ ├── LMonestep.h
│ │ │ ├── LMpar.h
│ │ │ ├── LMqrsolv.h
│ │ │ └── LevenbergMarquardt.h
│ │ ├── MatrixFunctions/
│ │ │ ├── MatrixExponential.h
│ │ │ ├── MatrixFunction.h
│ │ │ ├── MatrixLogarithm.h
│ │ │ ├── MatrixPower.h
│ │ │ ├── MatrixSquareRoot.h
│ │ │ └── StemFunction.h
│ │ ├── MoreVectorization/
│ │ │ └── MathFunctions.h
│ │ ├── NonLinearOptimization/
│ │ │ ├── HybridNonLinearSolver.h
│ │ │ ├── LevenbergMarquardt.h
│ │ │ ├── chkder.h
│ │ │ ├── covar.h
│ │ │ ├── dogleg.h
│ │ │ ├── fdjac1.h
│ │ │ ├── lmpar.h
│ │ │ ├── qrsolv.h
│ │ │ ├── r1mpyq.h
│ │ │ ├── r1updt.h
│ │ │ └── rwupdt.h
│ │ ├── NumericalDiff/
│ │ │ └── NumericalDiff.h
│ │ ├── Polynomials/
│ │ │ ├── Companion.h
│ │ │ ├── PolynomialSolver.h
│ │ │ └── PolynomialUtils.h
│ │ ├── Skyline/
│ │ │ ├── SkylineInplaceLU.h
│ │ │ ├── SkylineMatrix.h
│ │ │ ├── SkylineMatrixBase.h
│ │ │ ├── SkylineProduct.h
│ │ │ ├── SkylineStorage.h
│ │ │ └── SkylineUtil.h
│ │ ├── SparseExtra/
│ │ │ ├── BlockOfDynamicSparseMatrix.h
│ │ │ ├── BlockSparseMatrix.h
│ │ │ ├── DynamicSparseMatrix.h
│ │ │ ├── MarketIO.h
│ │ │ ├── MatrixMarketIterator.h
│ │ │ └── RandomSetter.h
│ │ ├── SpecialFunctions/
│ │ │ ├── BesselFunctionsArrayAPI.h
│ │ │ ├── BesselFunctionsFunctors.h
│ │ │ ├── BesselFunctionsHalf.h
│ │ │ ├── BesselFunctionsImpl.h
│ │ │ ├── BesselFunctionsPacketMath.h
│ │ │ ├── HipVectorCompatibility.h
│ │ │ ├── SpecialFunctionsArrayAPI.h
│ │ │ ├── SpecialFunctionsFunctors.h
│ │ │ ├── SpecialFunctionsHalf.h
│ │ │ ├── SpecialFunctionsImpl.h
│ │ │ ├── SpecialFunctionsPacketMath.h
│ │ │ └── arch/
│ │ │ └── GPU/
│ │ │ └── GpuSpecialFunctions.h
│ │ └── Splines/
│ │ ├── Spline.h
│ │ ├── SplineFitting.h
│ │ └── SplineFwd.h
│ ├── README.txt
│ ├── bench/
│ │ └── bench_svd.cpp
│ ├── doc/
│ │ ├── CMakeLists.txt
│ │ ├── Overview.dox
│ │ ├── SYCL.dox
│ │ ├── eigendoxy_layout.xml.in
│ │ ├── examples/
│ │ │ ├── BVH_Example.cpp
│ │ │ ├── CMakeLists.txt
│ │ │ ├── EulerAngles.cpp
│ │ │ ├── FFT.cpp
│ │ │ ├── MatrixExponential.cpp
│ │ │ ├── MatrixFunction.cpp
│ │ │ ├── MatrixLogarithm.cpp
│ │ │ ├── MatrixPower.cpp
│ │ │ ├── MatrixPower_optimal.cpp
│ │ │ ├── MatrixSine.cpp
│ │ │ ├── MatrixSinh.cpp
│ │ │ ├── MatrixSquareRoot.cpp
│ │ │ ├── PolynomialSolver1.cpp
│ │ │ ├── PolynomialUtils1.cpp
│ │ │ └── SYCL/
│ │ │ ├── CMakeLists.txt
│ │ │ └── CwiseMul.cpp
│ │ └── snippets/
│ │ └── CMakeLists.txt
│ └── test/
│ ├── BVH.cpp
│ ├── CMakeLists.txt
│ ├── EulerAngles.cpp
│ ├── FFT.cpp
│ ├── FFTW.cpp
│ ├── NonLinearOptimization.cpp
│ ├── NumericalDiff.cpp
│ ├── alignedvector3.cpp
│ ├── autodiff.cpp
│ ├── autodiff_scalar.cpp
│ ├── bessel_functions.cpp
│ ├── cxx11_eventcount.cpp
│ ├── cxx11_maxsizevector.cpp
│ ├── cxx11_meta.cpp
│ ├── cxx11_non_blocking_thread_pool.cpp
│ ├── cxx11_runqueue.cpp
│ ├── cxx11_tensor_argmax.cpp
│ ├── cxx11_tensor_argmax_gpu.cu
│ ├── cxx11_tensor_argmax_sycl.cpp
│ ├── cxx11_tensor_assign.cpp
│ ├── cxx11_tensor_block_access.cpp
│ ├── cxx11_tensor_block_eval.cpp
│ ├── cxx11_tensor_block_io.cpp
│ ├── cxx11_tensor_broadcast_sycl.cpp
│ ├── cxx11_tensor_broadcasting.cpp
│ ├── cxx11_tensor_builtins_sycl.cpp
│ ├── cxx11_tensor_cast_float16_gpu.cu
│ ├── cxx11_tensor_casts.cpp
│ ├── cxx11_tensor_chipping.cpp
│ ├── cxx11_tensor_chipping_sycl.cpp
│ ├── cxx11_tensor_comparisons.cpp
│ ├── cxx11_tensor_complex_cwise_ops_gpu.cu
│ ├── cxx11_tensor_complex_gpu.cu
│ ├── cxx11_tensor_concatenation.cpp
│ ├── cxx11_tensor_concatenation_sycl.cpp
│ ├── cxx11_tensor_const.cpp
│ ├── cxx11_tensor_contract_gpu.cu
│ ├── cxx11_tensor_contract_sycl.cpp
│ ├── cxx11_tensor_contraction.cpp
│ ├── cxx11_tensor_convolution.cpp
│ ├── cxx11_tensor_convolution_sycl.cpp
│ ├── cxx11_tensor_custom_index.cpp
│ ├── cxx11_tensor_custom_op.cpp
│ ├── cxx11_tensor_custom_op_sycl.cpp
│ ├── cxx11_tensor_device.cu
│ ├── cxx11_tensor_device_sycl.cpp
│ ├── cxx11_tensor_dimension.cpp
│ ├── cxx11_tensor_empty.cpp
│ ├── cxx11_tensor_executor.cpp
│ ├── cxx11_tensor_expr.cpp
│ ├── cxx11_tensor_fft.cpp
│ ├── cxx11_tensor_fixed_size.cpp
│ ├── cxx11_tensor_forced_eval.cpp
│ ├── cxx11_tensor_forced_eval_sycl.cpp
│ ├── cxx11_tensor_generator.cpp
│ ├── cxx11_tensor_generator_sycl.cpp
│ ├── cxx11_tensor_gpu.cu
│ ├── cxx11_tensor_ifft.cpp
│ ├── cxx11_tensor_image_op_sycl.cpp
│ ├── cxx11_tensor_image_patch.cpp
│ ├── cxx11_tensor_image_patch_sycl.cpp
│ ├── cxx11_tensor_index_list.cpp
│ ├── cxx11_tensor_inflation.cpp
│ ├── cxx11_tensor_inflation_sycl.cpp
│ ├── cxx11_tensor_intdiv.cpp
│ ├── cxx11_tensor_io.cpp
│ ├── cxx11_tensor_layout_swap.cpp
│ ├── cxx11_tensor_layout_swap_sycl.cpp
│ ├── cxx11_tensor_lvalue.cpp
│ ├── cxx11_tensor_map.cpp
│ ├── cxx11_tensor_math.cpp
│ ├── cxx11_tensor_math_sycl.cpp
│ ├── cxx11_tensor_mixed_indices.cpp
│ ├── cxx11_tensor_morphing.cpp
│ ├── cxx11_tensor_morphing_sycl.cpp
│ ├── cxx11_tensor_move.cpp
│ ├── cxx11_tensor_notification.cpp
│ ├── cxx11_tensor_of_complex.cpp
│ ├── cxx11_tensor_of_const_values.cpp
│ ├── cxx11_tensor_of_float16_gpu.cu
│ ├── cxx11_tensor_of_strings.cpp
│ ├── cxx11_tensor_padding.cpp
│ ├── cxx11_tensor_padding_sycl.cpp
│ ├── cxx11_tensor_patch.cpp
│ ├── cxx11_tensor_patch_sycl.cpp
│ ├── cxx11_tensor_random.cpp
│ ├── cxx11_tensor_random_gpu.cu
│ ├── cxx11_tensor_random_sycl.cpp
│ ├── cxx11_tensor_reduction.cpp
│ ├── cxx11_tensor_reduction_gpu.cu
│ ├── cxx11_tensor_reduction_sycl.cpp
│ ├── cxx11_tensor_ref.cpp
│ ├── cxx11_tensor_reverse.cpp
│ ├── cxx11_tensor_reverse_sycl.cpp
│ ├── cxx11_tensor_roundings.cpp
│ ├── cxx11_tensor_scan.cpp
│ ├── cxx11_tensor_scan_gpu.cu
│ ├── cxx11_tensor_scan_sycl.cpp
│ ├── cxx11_tensor_shuffling.cpp
│ ├── cxx11_tensor_shuffling_sycl.cpp
│ ├── cxx11_tensor_simple.cpp
│ ├── cxx11_tensor_striding.cpp
│ ├── cxx11_tensor_striding_sycl.cpp
│ ├── cxx11_tensor_sugar.cpp
│ ├── cxx11_tensor_sycl.cpp
│ ├── cxx11_tensor_symmetry.cpp
│ ├── cxx11_tensor_thread_local.cpp
│ ├── cxx11_tensor_thread_pool.cpp
│ ├── cxx11_tensor_trace.cpp
│ ├── cxx11_tensor_uint128.cpp
│ ├── cxx11_tensor_volume_patch.cpp
│ ├── cxx11_tensor_volume_patch_sycl.cpp
│ ├── dgmres.cpp
│ ├── forward_adolc.cpp
│ ├── gmres.cpp
│ ├── kronecker_product.cpp
│ ├── levenberg_marquardt.cpp
│ ├── matrix_exponential.cpp
│ ├── matrix_function.cpp
│ ├── matrix_functions.h
│ ├── matrix_power.cpp
│ ├── matrix_square_root.cpp
│ ├── minres.cpp
│ ├── mpreal/
│ │ └── mpreal.h
│ ├── mpreal_support.cpp
│ ├── openglsupport.cpp
│ ├── polynomialsolver.cpp
│ ├── polynomialutils.cpp
│ ├── sparse_extra.cpp
│ ├── special_functions.cpp
│ ├── special_packetmath.cpp
│ └── splines.cpp
├── CMakeLists.txt
├── README.md
├── data/
│ └── circle.csv
├── include/
│ ├── camera_calibrator.hpp
│ ├── logging.hpp
│ ├── nonlinear_optimizer.hpp
│ ├── params.hpp
│ ├── reprojection_error.hpp
│ └── termination_checking.hpp
├── src/
│ ├── camera_calibrator.cpp
│ ├── lidar2camera.cpp
│ └── nonlinear_optimizer.cpp
└── tool/
├── LidarCircleDetect/
│ ├── CMakeLists.txt
│ ├── data/
│ │ ├── 2022-01-18-15-25-03-449.pcd
│ │ ├── 2022-01-18-15-25-03-549.pcd
│ │ ├── 2022-01-18-15-25-03-649.pcd
│ │ ├── 2022-01-18-15-25-03-749.pcd
│ │ ├── 2022-01-18-15-25-03-849.pcd
│ │ ├── 2022-01-18-15-25-03-949.pcd
│ │ ├── 2022-01-18-15-25-04-049.pcd
│ │ ├── 2022-01-18-15-25-04-149.pcd
│ │ ├── 2022-01-18-15-25-04-249.pcd
│ │ └── 2022-01-18-15-25-04-349.pcd
│ ├── include/
│ │ ├── lidar_pattern.h
│ │ └── logging.hpp
│ └── src/
│ ├── lidar_pattern.cpp
│ └── run_lidar_detection.cpp
└── README.md
================================================
FILE CONTENTS
================================================
================================================
FILE: .gitignore
================================================
lib/
bin/
build/
cmake-build-debug/
cmake-build-release/
.idea
.vscode
__pycache__/
*.py[cod]
*$py.class
================================================
FILE: 3rdparty/CMakeLists.txt
================================================
project(3rdparty)
add_subdirectory(eigen3)
add_subdirectory(ceres)
================================================
FILE: 3rdparty/ceres/.clang-format
================================================
BasedOnStyle: Google
BinPackArguments: false
BinPackParameters: false
PointerAlignment: Left
DerivePointerAlignment: false
================================================
FILE: 3rdparty/ceres/.travis.yml
================================================
language: cpp
matrix:
fast_finish: true
include:
- os: linux
dist: bionic
sudo: required
compiler: gcc
env: CERES_BUILD_TARGET=LINUX
- os: linux
dist: bionic
sudo: required
compiler: gcc
env: CERES_BUILD_TARGET=ANDROID
- os: osx
osx_image: xcode11.2
env: CERES_BUILD_TARGET=OSX
- os: osx
osx_image: xcode11.2
env: CERES_BUILD_TARGET=IOS
env:
# As per http://docs.travis-ci.com/user/languages/cpp/#OpenMP-projects don't be greedy with OpenMP.
- OMP_NUM_THREADS=4
before_install:
- if [ $TRAVIS_OS_NAME = linux ]; then sudo apt-get update -qq; fi
- |
if [[ "$CERES_BUILD_TARGET" == "ANDROID" ]]; then
cd /tmp
wget https://dl.google.com/android/repository/android-ndk-r20b-linux-x86_64.zip
unzip -qq android-ndk-r20b-linux-x86_64.zip
fi
install:
- if [ $TRAVIS_OS_NAME = linux ]; then $TRAVIS_BUILD_DIR/travis/install_travis_linux_deps.sh; fi
- if [ $TRAVIS_OS_NAME = osx ]; then $TRAVIS_BUILD_DIR/travis/install_travis_osx_deps.sh; fi
before_script:
- mkdir /tmp/ceres-build
- cd /tmp/ceres-build
script:
# NOTE: TRAVIS_BUILD_DIR is actually the source directory for Ceres.
- |
if [[ "$CERES_BUILD_TARGET" == "LINUX" || "$CERES_BUILD_TARGET" == "OSX" ]]; then
cmake $TRAVIS_BUILD_DIR
fi
- |
if [[ "$CERES_BUILD_TARGET" == "ANDROID" ]]; then
cmake -DCMAKE_TOOLCHAIN_FILE=/tmp/android-ndk-r20b/build/cmake/android.toolchain.cmake -DEigen3_DIR=/usr/lib/cmake/eigen3 -DANDROID_ABI=arm64-v8a -DANDROID_STL=c++_shared -DANDROID_NATIVE_API_LEVEL=android-29 -DMINIGLOG=ON -DBUILD_EXAMPLES=OFF $TRAVIS_BUILD_DIR
fi
- |
if [[ "$CERES_BUILD_TARGET" == "IOS" ]]; then
cmake -DCMAKE_TOOLCHAIN_FILE=$TRAVIS_BUILD_DIR/cmake/iOS.cmake -DEigen3_DIR=/usr/local/share/eigen3/cmake -DIOS_PLATFORM=OS $TRAVIS_BUILD_DIR
fi
- make -j 4
- |
if [[ "$CERES_BUILD_TARGET" == "LINUX" || "$CERES_BUILD_TARGET" == "OSX" ]]; then
sudo make install
ctest --output-on-failure -j 4
fi
notifications:
email:
- alexs.mac@gmail.com
- sandwichmaker@gmail.com
- keir@google.com
- wjr@google.com
================================================
FILE: 3rdparty/ceres/BUILD
================================================
# Ceres Solver - A fast non-linear least squares minimizer
# Copyright 2018 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: mierle@gmail.com (Keir Mierle)
#
# These are Bazel rules to build Ceres. It's currently in Alpha state, and does
# not support parameterization around threading choice or sparse backends.
load("//:bazel/ceres.bzl", "ceres_library")
ceres_library(
name = "ceres",
restrict_schur_specializations = False,
)
cc_library(
name = "test_util",
srcs = ["internal/ceres/" + x for x in [
"evaluator_test_utils.cc",
"numeric_diff_test_utils.cc",
"test_util.cc",
"gmock_gtest_all.cc",
"gmock_main.cc",
"gmock/gmock.h",
"gmock/mock-log.h",
"gtest/gtest.h",
]],
hdrs = [
"internal/ceres/gmock/gmock.h",
"internal/ceres/gmock/mock-log.h",
"internal/ceres/gtest/gtest.h",
],
copts = [
"-Wno-sign-compare",
"-DCERES_TEST_SRCDIR_SUFFIX=\\\"data/\\\"",
],
includes = [
"internal",
"internal/ceres",
],
deps = [
"//:ceres",
"@com_github_gflags_gflags//:gflags",
],
)
CERES_TESTS = [
"array_utils",
"autodiff_cost_function",
"autodiff_local_parameterization",
"autodiff",
"block_jacobi_preconditioner",
"block_random_access_dense_matrix",
"block_random_access_diagonal_matrix",
"block_random_access_sparse_matrix",
"block_sparse_matrix",
"canonical_views_clustering",
"c_api",
"compressed_col_sparse_matrix_utils",
"compressed_row_sparse_matrix",
"concurrent_queue",
"conditioned_cost_function",
"conjugate_gradients_solver",
"corrector",
"cost_function_to_functor",
"covariance",
"cubic_interpolation",
"dense_linear_solver",
"dense_sparse_matrix",
"detect_structure",
"dogleg_strategy",
"dynamic_autodiff_cost_function",
"dynamic_compressed_row_sparse_matrix",
"dynamic_numeric_diff_cost_function",
"dynamic_sparse_normal_cholesky_solver",
"dynamic_sparsity",
"evaluation_callback",
"evaluator",
"gradient_checker",
"gradient_checking_cost_function",
"gradient_problem_solver",
"gradient_problem",
"graph_algorithms",
"graph",
"householder_vector",
"implicit_schur_complement",
"inner_product_computer",
"invert_psd_matrix",
"is_close",
"iterative_refiner",
"iterative_schur_complement_solver",
"jet",
"levenberg_marquardt_strategy",
"line_search_minimizer",
"line_search_preprocessor",
"local_parameterization",
"loss_function",
"minimizer",
"normal_prior",
"numeric_diff_cost_function",
"ordered_groups",
"parallel_for",
"parallel_utils",
"parameter_block_ordering",
"parameter_block",
"partitioned_matrix_view",
"polynomial",
"problem",
"program",
"reorder_program",
"residual_block",
"residual_block_utils",
"rotation",
"schur_complement_solver",
"schur_eliminator",
"single_linkage_clustering",
"small_blas",
"solver",
"sparse_cholesky",
"sparse_normal_cholesky_solver",
"subset_preconditioner",
"system",
"thread_pool",
"tiny_solver_autodiff_function",
"tiny_solver_cost_function_adapter",
"tiny_solver",
"triplet_sparse_matrix",
"trust_region_minimizer",
"trust_region_preprocessor",
"visibility_based_preconditioner",
"visibility",
]
TEST_COPTS = [
# Needed to silence GFlags complaints.
"-Wno-sign-compare",
# These two warnings don't work well in conjunction with GMock, and
# trigger incorrectly on parts of rotation_test. For now, disable them,
# but in the future disable these warnings only for rotation_test.
# TODO(keir): When the tests are macro-ified, apply these selectively.
"-Wno-nonnull-compare",
"-Wno-address",
]
TEST_DEPS = [
"//:ceres",
"//:test_util",
"@com_github_eigen_eigen//:eigen",
"@com_github_gflags_gflags//:gflags",
]
# Instantiate all the tests with a template.
[cc_test(
name = test_name + "_test",
timeout = "short",
srcs = ["internal/ceres/" + test_name + "_test.cc"],
copts = TEST_COPTS,
deps = TEST_DEPS,
) for test_name in CERES_TESTS]
# Instantiate all the bundle adjustment tests. These are separate to
# parallelize the execution of the tests; otherwise the tests take a long time.
#
# Note: While it is possible to run the Python script to generate the .cc files
# as part of the build, it introduces an undesirable build-time Python
# dependency that we'd prefer to avoid.
[cc_test(
name = test_filename.split("/")[-1][:-3], # Remove .cc.
timeout = "moderate",
srcs = [test_filename],
copts = TEST_COPTS,
# This is the data set that is bundled for the testing.
data = [":data/problem-16-22106-pre.txt"],
deps = TEST_DEPS,
) for test_filename in glob([
"internal/ceres/generated_bundle_adjustment_tests/*_test.cc",
])]
# Build the benchmarks.
[cc_binary(
name = benchmark_name,
srcs = ["internal/ceres/" + benchmark_name + ".cc"],
copts = TEST_COPTS,
deps = TEST_DEPS + ["@com_github_google_benchmark//:benchmark"],
) for benchmark_name in [
"autodiff_cost_function_benchmark",
"small_blas_gemm_benchmark",
"small_blas_gemv_benchmark",
]]
================================================
FILE: 3rdparty/ceres/CMakeLists.txt
================================================
## Modified by WANG JIADONG <wangjiadong@sensetime.com> for adas sdk
message(STATUS "${BoldGreen}[3RDPARTY : Ceres]${ColourReset}")
# 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.
#
# Authors: keir@google.com (Keir Mierle)
# alexs.mac@gmail.com (Alex Stewart)
cmake_minimum_required(VERSION 3.5)
cmake_policy(VERSION 3.5)
# Set the C++ version (must be >= C++11) when compiling Ceres.
#
# Reflect a user-specified (via -D) CMAKE_CXX_STANDARD if present, otherwise
# default to C++11.
set(DEFAULT_CXX_STANDARD ${CMAKE_CXX_STANDARD})
if (NOT DEFAULT_CXX_STANDARD)
set(DEFAULT_CXX_STANDARD 11)
endif()
set(CMAKE_CXX_STANDARD ${DEFAULT_CXX_STANDARD} CACHE STRING
"C++ standard (minimum 11)" FORCE)
# Restrict CMAKE_CXX_STANDARD to the valid versions permitted and ensure that
# if one was forced via -D that it is in the valid set.
set(ALLOWED_CXX_STANDARDS 11 14 17)
set_property(CACHE CMAKE_CXX_STANDARD PROPERTY STRINGS ${ALLOWED_CXX_STANDARDS})
list(FIND ALLOWED_CXX_STANDARDS ${CMAKE_CXX_STANDARD} POSITION)
if (POSITION LESS 0)
message(FATAL_ERROR "Invalid CMAKE_CXX_STANDARD: ${CMAKE_CXX_STANDARD}. "
"Must be one of: ${ALLOWED_CXX_STANDARDS}")
endif()
# Specify the standard as a hard requirement, otherwise CMAKE_CXX_STANDARD is
# interpreted as a suggestion that can decay *back* to lower versions.
set(CMAKE_CXX_STANDARD_REQUIRED ON CACHE BOOL "")
mark_as_advanced(CMAKE_CXX_STANDARD_REQUIRED)
# MSVC versions < 2013 did not fully support >= C++11.
if (MSVC AND CMAKE_CXX_COMPILER_VERSION VERSION_LESS 12.0)
message(FATAL_ERROR "Invalid CMAKE_CXX_COMPILER_VERSION: "
"${CMAKE_CXX_COMPILER_VERSION}. Ceres requires at least MSVC 2013 Update 4+")
endif()
if(OPT_BUILD_QCOM)
message(STATUS "Ceres Crosscompile for Qualcomm Platform")
set(OPENMP OFF)
set(LAPACK OFF)
else()
set(OPENMP ON)
endif()
# On macOS, add the Homebrew prefix (with appropriate suffixes) to the
# respective HINTS directories (after any user-specified locations). This
# handles Homebrew installations into non-standard locations (not /usr/local).
# We do not use CMAKE_PREFIX_PATH for this as given the search ordering of
# find_xxx(), doing so would override any user-specified HINTS locations with
# the Homebrew version if it exists.
if (CMAKE_SYSTEM_NAME MATCHES "Darwin")
find_program(HOMEBREW_EXECUTABLE brew)
mark_as_advanced(FORCE HOMEBREW_EXECUTABLE)
if (HOMEBREW_EXECUTABLE)
# Detected a Homebrew install, query for its install prefix.
execute_process(COMMAND ${HOMEBREW_EXECUTABLE} --prefix
OUTPUT_VARIABLE HOMEBREW_INSTALL_PREFIX
OUTPUT_STRIP_TRAILING_WHITESPACE)
message(STATUS "Detected Homebrew with install prefix: "
"${HOMEBREW_INSTALL_PREFIX}, adding to CMake search paths.")
list(APPEND HOMEBREW_INCLUDE_DIR_HINTS "${HOMEBREW_INSTALL_PREFIX}/include")
endif()
endif()
project(Ceres C CXX)
# NOTE: The 'generic' CMake variables CMAKE_[SOURCE/BINARY]_DIR should not be
# used. Always use the project-specific variants (generated by CMake):
# <PROJECT_NAME_MATCHING_CASE>_[SOURCE/BINARY]_DIR, e.g.
# Ceres_SOURCE_DIR (note, *not* CERES_SOURCE_DIR) instead, as these will
# always point to the correct directories for the Ceres project, even if
# it is nested inside another source tree, whereas the 'generic'
# CMake variables refer to the *first* project() declaration, i.e. the
# top-level project, not Ceres, if Ceres is nested.
# Make CMake aware of the cmake folder for local FindXXX scripts,
# append rather than set in case the user has passed their own
# additional paths via -D.
list(APPEND CMAKE_MODULE_PATH "${Ceres_SOURCE_DIR}/cmake")
include(AddCompileFlagsIfSupported)
include(UpdateCacheVariable)
# Xcode 11.0-1 with macOS 10.15 (Catalina) broke alignment.
include(DetectBrokenStackCheckMacOSXcodePairing)
detect_broken_stack_check_macos_xcode_pairing()
# Set up the git hook to make Gerrit Change-Id: lines in commit messages.
include(AddGerritCommitHook)
add_gerrit_commit_hook(${Ceres_SOURCE_DIR} ${Ceres_BINARY_DIR})
set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${Ceres_BINARY_DIR}/bin)
set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${Ceres_BINARY_DIR}/lib)
set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${Ceres_BINARY_DIR}/lib)
# Set postfixes for generated libraries based on buildtype.
set(CMAKE_RELEASE_POSTFIX "")
set(CMAKE_DEBUG_POSTFIX "-debug")
# Read the Ceres version from the source, such that we only ever have a single
# definition of the Ceres version.
include(ReadCeresVersionFromSource)
read_ceres_version_from_source(${Ceres_SOURCE_DIR})
enable_testing()
include(CeresThreadingModels)
if (OPENMP)
message(STATUS "STill Building OPENMP ${OPENMP}")
include(PrettyPrintCMakeList)
find_available_ceres_threading_models(CERES_THREADING_MODELS_AVAILABLE)
pretty_print_cmake_list(PRETTY_CERES_THREADING_MODELS_AVAILABLE
${CERES_THREADING_MODELS_AVAILABLE})
message("-- Detected available Ceres threading models: "
"${PRETTY_CERES_THREADING_MODELS_AVAILABLE}")
set(CERES_THREADING_MODEL "${CERES_THREADING_MODEL}" CACHE STRING
"Ceres threading back-end" FORCE)
if (NOT CERES_THREADING_MODEL)
list(GET CERES_THREADING_MODELS_AVAILABLE 0 DEFAULT_THREADING_MODEL)
update_cache_variable(CERES_THREADING_MODEL ${DEFAULT_THREADING_MODEL})
endif()
set_property(CACHE CERES_THREADING_MODEL PROPERTY STRINGS
${CERES_THREADING_MODELS_AVAILABLE})
else()
set(CERES_THREADING_MODEL "CXX11_THREADS" CACHE STRING
"Ceres threading back-end" FORCE)
set_property(CACHE CERES_THREADING_MODEL PROPERTY STRINGS
${CERES_THREADING_MODELS_AVAILABLE})
endif()
option(MINIGLOG "Use a stripped down version of glog." OFF)
option(GFLAGS "Enable Google Flags." ON)
option(SUITESPARSE "Enable SuiteSparse." ON)
option(CXSPARSE "Enable CXSparse." ON)
if (APPLE)
option(ACCELERATESPARSE
"Enable use of sparse solvers in Apple's Accelerate framework." ON)
endif()
option(LAPACK "Enable use of LAPACK directly within Ceres." ON)
# Template specializations for the Schur complement based solvers. If
# compile time, binary size or compiler performance is an issue, you
# may consider disabling this.
option(SCHUR_SPECIALIZATIONS "Enable fixed-size schur specializations." ON)
option(CUSTOM_BLAS
"Use handcoded BLAS routines (usually faster) instead of Eigen."
ON)
# Enable the use of Eigen as a sparse linear algebra library for
# solving the nonlinear least squares problems.
option(EIGENSPARSE "Enable Eigen as a sparse linear algebra library." ON)
option(EXPORT_BUILD_DIR
"Export build directory using CMake (enables external use without install)." OFF)
option(BUILD_TESTING "Enable tests" OFF)
option(BUILD_DOCUMENTATION "Build User's Guide (html)" OFF)
option(BUILD_EXAMPLES "Build examples" OFF)
option(BUILD_BENCHMARKS "Build Ceres benchmarking suite" OFF)
option(BUILD_SHARED_LIBS "Build Ceres as a shared library." OFF)
option(PROVIDE_UNINSTALL_TARGET "Add a custom target to ease removal of installed targets" ON)
set(SANITIZERS "" CACHE STRING "Semicolon-separated list of sanitizers to use (e.g address, memory, thread)")
include(EnableSanitizer)
enable_sanitizer(${SANITIZERS})
if (ANDROID)
option(ANDROID_STRIP_DEBUG_SYMBOLS "Strip debug symbols from Android builds (reduces file sizes)" ON)
endif()
if (MSVC)
option(MSVC_USE_STATIC_CRT
"MS Visual Studio: Use static C-Run Time Library in place of shared." OFF)
if (BUILD_TESTING AND BUILD_SHARED_LIBS)
message(
"-- Disabling tests. The flags BUILD_TESTING and BUILD_SHARED_LIBS"
" are incompatible with MSVC.")
update_cache_variable(BUILD_TESTING OFF)
endif (BUILD_TESTING AND BUILD_SHARED_LIBS)
endif (MSVC)
# Allow user to specify a suffix for the library install directory, the only
# really sensible option (other than "") being "64", such that:
# ${CMAKE_INSTALL_PREFIX}/lib -> ${CMAKE_INSTALL_PREFIX}/lib64.
#
# Heuristic for determining LIB_SUFFIX. FHS recommends that 64-bit systems
# install native libraries to lib64 rather than lib. Most distros seem to
# follow this convention with a couple notable exceptions (Debian-based and
# Arch-based distros) which we try to detect here.
if (CMAKE_SYSTEM_NAME MATCHES "Linux" AND
NOT DEFINED LIB_SUFFIX AND
NOT CMAKE_CROSSCOMPILING AND
CMAKE_SIZEOF_VOID_P EQUAL "8" AND
NOT EXISTS "/etc/debian_version" AND
NOT EXISTS "/etc/arch-release")
message("-- Detected non-Debian/Arch-based 64-bit Linux distribution. "
"Defaulting to library install directory: lib${LIB_SUFFIX}. You can "
"override this by specifying LIB_SUFFIX.")
set(LIB_SUFFIX "64")
endif ()
# Only create the cache variable (for the CMake GUI) after attempting to detect
# the suffix *if not specified by the user* (NOT DEFINED LIB_SUFFIX in if())
# s/t the user could override our autodetected suffix with "" if desired.
set(LIB_SUFFIX "${LIB_SUFFIX}" CACHE STRING
"Suffix of library install directory (to support lib/lib64)." FORCE)
# IOS is defined iff using the iOS.cmake CMake toolchain to build a static
# library for iOS.
if (IOS)
message(STATUS "Building Ceres for iOS platform: ${IOS_PLATFORM}")
# Ceres requires at least iOS 7.0+.
if (IOS_DEPLOYMENT_TARGET VERSION_LESS 7.0)
message(FATAL_ERROR "Unsupported iOS version: ${IOS_DEPLOYMENT_TARGET}, Ceres "
"requires at least iOS version 7.0")
endif()
update_cache_variable(MINIGLOG ON)
message(STATUS "Building for iOS: Forcing use of miniglog instead of glog.")
# Apple claims that the BLAS call dsyrk_ is a private API, and will not allow
# you to submit to the Apple Store if the symbol is present.
update_cache_variable(LAPACK OFF)
message(STATUS "Building for iOS: SuiteSparse, CXSparse, LAPACK, gflags, "
"and OpenMP are not available.")
update_cache_variable(BUILD_EXAMPLES OFF)
message(STATUS "Building for iOS: Will not build examples.")
endif (IOS)
unset(CERES_COMPILE_OPTIONS)
message("-- Building with C++${CMAKE_CXX_STANDARD}")
# Eigen.
# Eigen delivers Eigen3Config.cmake since v3.3.3
find_package(Eigen3 3.3 CONFIG REQUIRED
HINTS ${HOMEBREW_INCLUDE_DIR_HINTS})
if (EIGEN3_FOUND)
message("-- Found Eigen version ${EIGEN3_VERSION_STRING}: ${EIGEN3_INCLUDE_DIRS}")
if (CMAKE_SYSTEM_PROCESSOR MATCHES "^(aarch64.*|AARCH64.*)" AND
EIGEN3_VERSION_STRING VERSION_LESS 3.3.4)
# As per issue #289: https://github.com/ceres-solver/ceres-solver/issues/289
# the bundle_adjustment_test will fail for Eigen < 3.3.4 on aarch64.
message(FATAL_ERROR "-- Ceres requires Eigen version >= 3.3.4 on aarch64. "
"Detected version of Eigen is: ${EIGEN3_VERSION_STRING}.")
endif()
if (EIGENSPARSE)
message("-- Enabling use of Eigen as a sparse linear algebra library.")
list(APPEND CERES_COMPILE_OPTIONS CERES_USE_EIGEN_SPARSE)
else (EIGENSPARSE)
message("-- Disabling use of Eigen as a sparse linear algebra library.")
message(" This does not affect the covariance estimation algorithm ")
message(" which can still use the EIGEN_SPARSE_QR algorithm.")
add_definitions(-DEIGEN_MPL2_ONLY)
endif (EIGENSPARSE)
endif (EIGEN3_FOUND)
if (LAPACK)
find_package(LAPACK QUIET)
set(LAPACK_FOUND OFF)
if (LAPACK_FOUND)
message("-- Found LAPACK library: ${LAPACK_LIBRARIES}")
else (LAPACK_FOUND)
message("-- Did not find LAPACK library, disabling LAPACK support.")
update_cache_variable(LAPACK OFF)
list(APPEND CERES_COMPILE_OPTIONS CERES_NO_LAPACK)
endif (LAPACK_FOUND)
else (LAPACK)
message("-- Building without LAPACK.")
list(APPEND CERES_COMPILE_OPTIONS CERES_NO_LAPACK)
endif (LAPACK)
if (SUITESPARSE)
# By default, if SuiteSparse and all dependencies are found, Ceres is
# built with SuiteSparse support.
# Check for SuiteSparse and dependencies.
find_package(SuiteSparse)
if (SUITESPARSE_FOUND)
# On Ubuntu the system install of SuiteSparse (v3.4.0) up to at least
# Ubuntu 13.10 cannot be used to link shared libraries.
if (BUILD_SHARED_LIBS AND
SUITESPARSE_IS_BROKEN_SHARED_LINKING_UBUNTU_SYSTEM_VERSION)
message(FATAL_ERROR "You are attempting to build Ceres as a shared "
"library on Ubuntu using a system package install of SuiteSparse "
"3.4.0. This package is broken and does not support the "
"construction of shared libraries (you can still build Ceres as "
"a static library). If you wish to build a shared version of Ceres "
"you should uninstall the system install of SuiteSparse "
"(libsuitesparse-dev) and perform a source install of SuiteSparse "
"(we recommend that you use the latest version), "
"see http://ceres-solver.org/building.html for more information.")
endif (BUILD_SHARED_LIBS AND
SUITESPARSE_IS_BROKEN_SHARED_LINKING_UBUNTU_SYSTEM_VERSION)
# By default, if all of SuiteSparse's dependencies are found, Ceres is
# built with SuiteSparse support.
message("-- Found SuiteSparse ${SUITESPARSE_VERSION}, "
"building with SuiteSparse.")
else (SUITESPARSE_FOUND)
# Disable use of SuiteSparse if it cannot be found and continue.
message("-- Did not find all SuiteSparse dependencies, disabling "
"SuiteSparse support.")
update_cache_variable(SUITESPARSE OFF)
list(APPEND CERES_COMPILE_OPTIONS CERES_NO_SUITESPARSE)
endif (SUITESPARSE_FOUND)
else (SUITESPARSE)
message("-- Building without SuiteSparse.")
list(APPEND CERES_COMPILE_OPTIONS CERES_NO_SUITESPARSE)
endif (SUITESPARSE)
# CXSparse.
if (CXSPARSE)
# Don't search with REQUIRED as we can continue without CXSparse.
find_package(CXSparse)
if (CXSPARSE_FOUND)
# By default, if CXSparse and all dependencies are found, Ceres is
# built with CXSparse support.
message("-- Found CXSparse version: ${CXSPARSE_VERSION}, "
"building with CXSparse.")
else (CXSPARSE_FOUND)
# Disable use of CXSparse if it cannot be found and continue.
message("-- Did not find CXSparse, Building without CXSparse.")
update_cache_variable(CXSPARSE OFF)
list(APPEND CERES_COMPILE_OPTIONS CERES_NO_CXSPARSE)
endif (CXSPARSE_FOUND)
else (CXSPARSE)
message("-- Building without CXSparse.")
list(APPEND CERES_COMPILE_OPTIONS CERES_NO_CXSPARSE)
# Mark as advanced (remove from default GUI view) the CXSparse search
# variables in case user enabled CXSPARSE, FindCXSparse did not find it, so
# made search variables visible in GUI for user to set, but then user disables
# CXSPARSE instead of setting them.
mark_as_advanced(FORCE CXSPARSE_INCLUDE_DIR
CXSPARSE_LIBRARY)
endif (CXSPARSE)
if (ACCELERATESPARSE)
find_package(AccelerateSparse)
if (AccelerateSparse_FOUND)
message("-- Found Apple's Accelerate framework with sparse solvers, "
"building with Accelerate sparse support.")
else()
message("-- Failed to find Apple's Accelerate framework with sparse solvers, "
"building without Accelerate sparse support.")
update_cache_variable(ACCELERATESPARSE OFF)
list(APPEND CERES_COMPILE_OPTIONS CERES_NO_ACCELERATE_SPARSE)
endif()
else()
message("-- Building without Apple's Accelerate sparse support.")
list(APPEND CERES_COMPILE_OPTIONS CERES_NO_ACCELERATE_SPARSE)
mark_as_advanced(FORCE AccelerateSparse_INCLUDE_DIR
AccelerateSparse_LIBRARY)
endif()
# Ensure that the user understands they have disabled all sparse libraries.
if (NOT SUITESPARSE AND NOT CXSPARSE AND NOT EIGENSPARSE AND NOT ACCELERATESPARSE)
message(" ===============================================================")
message(" Compiling without any sparse library: SuiteSparse, CXSparse ")
message(" EigenSparse & Apple's Accelerate are all disabled or unavailable. ")
message(" No sparse linear solvers (SPARSE_NORMAL_CHOLESKY & SPARSE_SCHUR)")
message(" will be available when Ceres is used.")
message(" ===============================================================")
endif()
# ANDROID define is set by the Android CMake toolchain file.
if (ANDROID)
message(" ================================================================")
if (ANDROID_STRIP_DEBUG_SYMBOLS)
# Strip debug information unconditionally to avoid +200MB library file sizes.
set( CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -s" )
set( CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -s" )
message(" Stripping debug information from Android build of Ceres library ")
message(" to avoid +200MB library files.")
else()
message(" Warning: not stripping debug information from Android build of ")
message(" Ceres library. This will result in a large (+200MB) library.")
endif()
message("")
message(" You can control whether debug information is stripped via the ")
message(" ANDROID_STRIP_DEBUG_SYMBOLS CMake option when configuring Ceres.")
message(" ================================================================")
endif()
# GFlags.
if (GFLAGS)
# Don't search with REQUIRED as we can continue without gflags.
find_package(gflags 2.2.0 CONFIG
HINTS "${HOMEBREW_INCLUDE_DIR_HINTS}")
if (gflags_FOUND)
message("-- Found Google Flags version ${gflags_VERSION}: ${GFLAGS_INCLUDE_DIR}")
else (gflags_FOUND)
message("-- Did not find Google Flags (gflags), Building without gflags "
"- no tests or tools will be built!")
update_cache_variable(GFLAGS OFF)
endif (gflags_FOUND)
else (GFLAGS)
message("-- Google Flags disabled; no tests or tools will be built!")
# Mark as advanced (remove from default GUI view) the gflags search
# variables in case user enabled GFLAGS, FindGflags did not find it, so
# made search variables visible in GUI for user to set, but then user disables
# GFLAGS instead of setting them.
mark_as_advanced(FORCE GFLAGS_INCLUDE_DIR
GFLAGS_LIBRARY
GFLAGS_NAMESPACE)
endif (GFLAGS)
# MiniGLog.
set(MINIGLOG TRUE)
if (MINIGLOG)
message("-- Compiling minimal glog substitute into Ceres.")
set(GLOG_INCLUDE_DIRS internal/ceres/miniglog)
set(MINIGLOG_MAX_LOG_LEVEL 2 CACHE STRING "The maximum message severity level to be logged")
add_definitions("-DMAX_LOG_LEVEL=${MINIGLOG_MAX_LOG_LEVEL}")
message("-- Using minimal glog substitute (include): ${GLOG_INCLUDE_DIRS}")
message("-- Max log level for minimal glog substitute: ${MINIGLOG_MAX_LOG_LEVEL}")
# Mark as advanced (remove from default GUI view) the glog search
# variables in case user disables MINIGLOG, FindGlog did not find it, so
# made search variables visible in GUI for user to set, but then user enables
# MINIGLOG instead of setting them.
mark_as_advanced(FORCE GLOG_INCLUDE_DIR
GLOG_LIBRARY)
else (MINIGLOG)
unset(MINIGLOG_MAX_LOG_LEVEL CACHE)
# Don't search with REQUIRED so that configuration continues if not found and
# we can output an error messages explaining MINIGLOG option.
find_package(Glog)
if (NOT GLOG_FOUND)
message(FATAL_ERROR "Can't find Google Log (glog). Please set either: "
"glog_DIR (newer CMake built versions of glog) or GLOG_INCLUDE_DIR & "
"GLOG_LIBRARY or enable MINIGLOG option to use minimal glog "
"implementation.")
endif(NOT GLOG_FOUND)
# By default, assume gflags was found, updating the message if it was not.
set(GLOG_GFLAGS_DEPENDENCY_MESSAGE
" Assuming glog was built with gflags support as gflags was found. "
"This will make gflags a public dependency of Ceres.")
if (NOT gflags_FOUND)
set(GLOG_GFLAGS_DEPENDENCY_MESSAGE
" Assuming glog was NOT built with gflags support as gflags was "
"not found. If glog was built with gflags, please set the "
"gflags search locations such that it can be found by Ceres. "
"Otherwise, Ceres may fail to link due to missing gflags symbols.")
endif(NOT gflags_FOUND)
message("-- Found Google Log (glog)." ${GLOG_GFLAGS_DEPENDENCY_MESSAGE})
endif (MINIGLOG)
if (NOT SCHUR_SPECIALIZATIONS)
list(APPEND CERES_COMPILE_OPTIONS CERES_RESTRICT_SCHUR_SPECIALIZATION)
message("-- Disabling Schur specializations (faster compiles)")
endif (NOT SCHUR_SPECIALIZATIONS)
if (NOT CUSTOM_BLAS)
list(APPEND CERES_COMPILE_OPTIONS CERES_NO_CUSTOM_BLAS)
message("-- Disabling custom blas")
endif (NOT CUSTOM_BLAS)
if (OPENMP)
set_ceres_threading_model("${CERES_THREADING_MODEL}")
else()
set_ceres_threading_model("${CERES_THREADING_MODEL}")
endif()
if (BUILD_BENCHMARKS)
find_package(benchmark QUIET)
if (benchmark_FOUND)
message("-- Found Google benchmark library. Building Ceres benchmarks.")
else()
message("-- Failed to find Google benchmark library, disabling build of benchmarks.")
update_cache_variable(BUILD_BENCHMARKS OFF)
endif()
mark_as_advanced(benchmark_DIR)
endif()
if (BUILD_SHARED_LIBS)
message("-- Building Ceres as a shared library.")
# The CERES_BUILDING_SHARED_LIBRARY compile definition is NOT stored in
# CERES_COMPILE_OPTIONS as it must only be defined when Ceres is compiled
# not when it is used as it controls the CERES_EXPORT macro which provides
# dllimport/export support in MSVC.
add_definitions(-DCERES_BUILDING_SHARED_LIBRARY)
list(APPEND CERES_COMPILE_OPTIONS CERES_USING_SHARED_LIBRARY)
else (BUILD_SHARED_LIBS)
message("-- Building Ceres as a static library.")
endif (BUILD_SHARED_LIBS)
# Change the default build type from Debug to Release, while still
# supporting overriding the build type.
#
# The CACHE STRING logic here and elsewhere is needed to force CMake
# to pay attention to the value of these variables.
if (NOT CMAKE_BUILD_TYPE)
message("-- No build type specified; defaulting to CMAKE_BUILD_TYPE=Release.")
set(CMAKE_BUILD_TYPE Release CACHE STRING
"Choose the type of build, options are: None Debug Release RelWithDebInfo MinSizeRel."
FORCE)
else (NOT CMAKE_BUILD_TYPE)
if (CMAKE_BUILD_TYPE STREQUAL "Debug")
message("\n=================================================================================")
message("\n-- Build type: Debug. Performance will be terrible!")
message("-- Add -DCMAKE_BUILD_TYPE=Release to the CMake command line to get an optimized build.")
message("\n=================================================================================")
endif (CMAKE_BUILD_TYPE STREQUAL "Debug")
endif (NOT CMAKE_BUILD_TYPE)
if (MINGW)
# MinGW produces code that segfaults when performing matrix multiplications
# in Eigen when compiled with -O3 (see [1]), as such force the use of -O2
# which works.
#
# [1] http://eigen.tuxfamily.org/bz/show_bug.cgi?id=556
message("-- MinGW detected, forcing -O2 instead of -O3 in Release for Eigen due "
"to a MinGW bug: http://eigen.tuxfamily.org/bz/show_bug.cgi?id=556")
string(REPLACE "-O3" "-O2" CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE}")
update_cache_variable(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE}")
endif (MINGW)
# After the tweaks for the compile settings, disable some warnings on MSVC.
if (MSVC)
# On MSVC, math constants are not included in <cmath> or <math.h> unless
# _USE_MATH_DEFINES is defined [1]. As we use M_PI in the examples, ensure
# that _USE_MATH_DEFINES is defined before the first inclusion of <cmath>.
#
# [1] https://msdn.microsoft.com/en-us/library/4hwaceh6.aspx
add_definitions("-D_USE_MATH_DEFINES")
# Disable signed/unsigned int conversion warnings.
add_compile_options("/wd4018" "/wd4267")
# Disable warning about using struct/class for the same symobl.
add_compile_options("/wd4099")
# Disable warning about the insecurity of using "std::copy".
add_compile_options("/wd4996")
# Disable performance warning about int-to-bool conversion.
add_compile_options("/wd4800")
# Disable performance warning about fopen insecurity.
add_compile_options("/wd4996")
# Disable warning about int64 to int32 conversion. Disabling
# this warning may not be correct; needs investigation.
# TODO(keir): Investigate these warnings in more detail.
add_compile_options("/wd4244")
# It's not possible to use STL types in DLL interfaces in a portable and
# reliable way. However, that's what happens with Google Log and Google Flags
# on Windows. MSVC gets upset about this and throws warnings that we can't do
# much about. The real solution is to link static versions of Google Log and
# Google Test, but that seems tricky on Windows. So, disable the warning.
add_compile_options("/wd4251")
# Add bigobj flag otherwise the build would fail due to large object files
# probably resulting from generated headers (like the fixed-size schur
# specializations).
add_compile_options("/bigobj")
# Google Flags doesn't have their DLL import/export stuff set up correctly,
# which results in linker warnings. This is irrelevant for Ceres, so ignore
# the warnings.
set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /ignore:4049")
# Update the C/CXX flags for MSVC to use either the static or shared
# C-Run Time (CRT) library based on the user option: MSVC_USE_STATIC_CRT.
list(APPEND C_CXX_FLAGS
CMAKE_CXX_FLAGS
CMAKE_CXX_FLAGS_DEBUG
CMAKE_CXX_FLAGS_RELEASE
CMAKE_CXX_FLAGS_MINSIZEREL
CMAKE_CXX_FLAGS_RELWITHDEBINFO)
foreach(FLAG_VAR ${C_CXX_FLAGS})
if (MSVC_USE_STATIC_CRT)
# Use static CRT.
if (${FLAG_VAR} MATCHES "/MD")
string(REGEX REPLACE "/MD" "/MT" ${FLAG_VAR} "${${FLAG_VAR}}")
endif (${FLAG_VAR} MATCHES "/MD")
else (MSVC_USE_STATIC_CRT)
# Use shared, not static, CRT.
if (${FLAG_VAR} MATCHES "/MT")
string(REGEX REPLACE "/MT" "/MD" ${FLAG_VAR} "${${FLAG_VAR}}")
endif (${FLAG_VAR} MATCHES "/MT")
endif (MSVC_USE_STATIC_CRT)
endforeach()
# Tuple sizes of 10 are used by Gtest.
add_definitions("-D_VARIADIC_MAX=10")
include(CheckIfUnderscorePrefixedBesselFunctionsExist)
check_if_underscore_prefixed_bessel_functions_exist(
HAVE_UNDERSCORE_PREFIXED_BESSEL_FUNCTIONS)
if (HAVE_UNDERSCORE_PREFIXED_BESSEL_FUNCTIONS)
list(APPEND CERES_COMPILE_OPTIONS
CERES_MSVC_USE_UNDERSCORE_PREFIXED_BESSEL_FUNCTIONS)
endif()
endif (MSVC)
if (UNIX)
# Flags which we add to GCC to make it more picky about stuff
# we do care about,
add_cxx_compiler_flag_if_supported(CERES_STRICT_CXX_FLAGS
-Wmissing-declarations)
# Flags which we add to GCC to silence lots of annoying false-positives.
add_cxx_compiler_flag_if_supported(CERES_STRICT_CXX_FLAGS
-Wno-unknown-pragmas)
add_cxx_compiler_flag_if_supported(CERES_STRICT_CXX_FLAGS
-Wno-sign-compare)
add_cxx_compiler_flag_if_supported(CERES_STRICT_CXX_FLAGS
-Wno-unused-parameter)
add_cxx_compiler_flag_if_supported(CERES_STRICT_CXX_FLAGS
-Wno-missing-field-initializers)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CERES_STRICT_CXX_FLAGS}")
endif (UNIX)
# Use a larger inlining threshold for Clang, since it hobbles Eigen,
# resulting in an unreasonably slow version of the blas routines. The
# -Qunused-arguments is needed because CMake passes the inline
# threshold to the linker and clang complains about it and dies.
if (CMAKE_CXX_COMPILER_ID MATCHES "Clang") # Matches Clang & AppleClang.
set(CMAKE_CXX_FLAGS
"${CMAKE_CXX_FLAGS} -Qunused-arguments -mllvm -inline-threshold=600")
# Older versions of Clang (<= 2.9) do not support the 'return-type-c-linkage'
# option, so check for its presence before adding it to the default flags set.
include(CheckCXXCompilerFlag)
check_cxx_compiler_flag("-Wno-return-type-c-linkage"
HAVE_RETURN_TYPE_C_LINKAGE)
if (HAVE_RETURN_TYPE_C_LINKAGE)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-return-type-c-linkage")
endif(HAVE_RETURN_TYPE_C_LINKAGE)
endif ()
# Configure the Ceres config.h compile options header using the current
# compile options and put the configured header into the Ceres build
# directory. Note that the ceres/internal subdir in <build>/config where
# the configured config.h is placed is important, because Ceres will be
# built against this configured header, it needs to have the same relative
# include path as it would if it were in the source tree (or installed).
list(REMOVE_DUPLICATES CERES_COMPILE_OPTIONS)
include(CreateCeresConfig)
create_ceres_config("${CERES_COMPILE_OPTIONS}"
${Ceres_BINARY_DIR}/config/ceres/internal)
add_subdirectory(internal/ceres)
# Setup installation of Ceres public headers.
file(GLOB CERES_HDRS ${Ceres_SOURCE_DIR}/include/ceres/*.h)
# install(FILES ${CERES_HDRS} DESTINATION include/ceres)
file(GLOB CERES_PUBLIC_INTERNAL_HDRS ${Ceres_SOURCE_DIR}/include/ceres/internal/*.h)
# install(FILES ${CERES_PUBLIC_INTERNAL_HDRS} DESTINATION include/ceres/internal)
# Also setup installation of Ceres config.h configured with the current
# build options into the installed headers directory.
# install(FILES ${Ceres_BINARY_DIR}/config/ceres/internal/config.h
# DESTINATION include/ceres/internal)
if (MINIGLOG)
# Install miniglog header if being used as logging #includes appear in
# installed public Ceres headers.
# install(FILES ${Ceres_SOURCE_DIR}/internal/ceres/miniglog/glog/logging.h
# DESTINATION include/ceres/internal/miniglog/glog)
endif (MINIGLOG)
# Ceres supports two mechanisms by which it can be detected & imported into
# client code which uses CMake via find_package(Ceres):
#
# 1) Installation (e.g. to /usr/local), using CMake's install() function.
#
# 2) (Optional) Export of the current build directory into the local CMake
# package registry, using CMake's export() function. This allows use of
# Ceres from other projects without requiring installation.
#
# In both cases, we need to generate a configured CeresConfig.cmake which
# includes additional autogenerated files which in concert create an imported
# target for Ceres in a client project when find_package(Ceres) is invoked.
# The key distinctions are where this file is located, and whether client code
# references installed copies of the compiled Ceres headers/libraries,
# (option #1: installation), or the originals in the source/build directories
# (option #2: export of build directory).
#
# NOTE: If Ceres is both exported and installed, provided that the installation
# path is present in CMAKE_MODULE_PATH when find_package(Ceres) is called,
# the installed version is preferred.
# Build the list of Ceres components for CeresConfig.cmake from the current set
# of compile options.
include(CeresCompileOptionsToComponents)
ceres_compile_options_to_components("${CERES_COMPILE_OPTIONS}"
CERES_COMPILED_COMPONENTS)
include(CMakePackageConfigHelpers)
# Create a CeresConfigVersion.cmake file containing the version information,
# used by both export() & install().
write_basic_package_version_file("${Ceres_BINARY_DIR}/CeresConfigVersion.cmake"
VERSION ${CERES_VERSION}
COMPATIBILITY SameMajorVersion)
# Install method #1: Put Ceres in CMAKE_INSTALL_PREFIX: /usr/local or equivalent.
# Set the install path for the installed CeresConfig.cmake configuration file
# relative to CMAKE_INSTALL_PREFIX.
if (WIN32)
set(RELATIVE_CMAKECONFIG_INSTALL_DIR CMake)
else ()
set(RELATIVE_CMAKECONFIG_INSTALL_DIR lib${LIB_SUFFIX}/cmake/Ceres)
endif ()
# This "exports" for installation all targets which have been put into the
# export set "CeresExport". This generates a CeresTargets.cmake file which,
# when read in by a client project as part of find_package(Ceres) creates
# imported library targets for Ceres (with dependency relations) which can be
# used in target_link_libraries() calls in the client project to use Ceres.
# install(EXPORT CeresExport
# DESTINATION ${RELATIVE_CMAKECONFIG_INSTALL_DIR} FILE CeresTargets.cmake)
# Save the relative path from the installed CeresConfig.cmake file to the
# install prefix. We do not save an absolute path in case the installed package
# is subsequently relocated after installation (on Windows).
file(RELATIVE_PATH INSTALL_ROOT_REL_CONFIG_INSTALL_DIR
${CMAKE_INSTALL_PREFIX}/${RELATIVE_CMAKECONFIG_INSTALL_DIR}
${CMAKE_INSTALL_PREFIX})
# Configure a CeresConfig.cmake file for an installed version of Ceres from the
# template, reflecting the current build options.
#
# NOTE: The -install suffix is necessary to distinguish the install version from
# the exported version, which must be named CeresConfig.cmake in
# Ceres_BINARY_DIR to be detected. The suffix is removed when
# it is installed.
set(SETUP_CERES_CONFIG_FOR_INSTALLATION TRUE)
configure_file("${Ceres_SOURCE_DIR}/cmake/CeresConfig.cmake.in"
"${Ceres_BINARY_DIR}/CeresConfig-install.cmake" @ONLY)
# Install the configuration files into the same directory as the autogenerated
# CeresTargets.cmake file. We include the find_package() scripts for libraries
# whose headers are included in the public API of Ceres and should thus be
# present in CERES_INCLUDE_DIRS.
# install(FILES "${Ceres_BINARY_DIR}/CeresConfig-install.cmake"
# RENAME CeresConfig.cmake
# DESTINATION ${RELATIVE_CMAKECONFIG_INSTALL_DIR})
# install(FILES "${Ceres_BINARY_DIR}/CeresConfigVersion.cmake"
# "${Ceres_SOURCE_DIR}/cmake/FindGlog.cmake"
# DESTINATION ${RELATIVE_CMAKECONFIG_INSTALL_DIR})
if (PROVIDE_UNINSTALL_TARGET)
# Create an uninstall target to remove all installed files.
configure_file("${Ceres_SOURCE_DIR}/cmake/uninstall.cmake.in"
"${Ceres_BINARY_DIR}/cmake/uninstall.cmake"
@ONLY)
add_custom_target(uninstall
COMMAND ${CMAKE_COMMAND} -P ${Ceres_BINARY_DIR}/cmake/uninstall.cmake)
endif()
# Install method #2: Put Ceres build into local CMake registry.
#
# Optionally export the Ceres build directory into the local CMake package
# registry (~/.cmake/packages on *nix & OS X). This allows the detection &
# use of Ceres without requiring that it be installed.
set(EXPORT_BUILD_DIR OFF)
if (EXPORT_BUILD_DIR)
message("-- Export Ceres build directory to local CMake package registry.")
# Save the relative path from the build directory to the source directory.
file(RELATIVE_PATH INSTALL_ROOT_REL_CONFIG_INSTALL_DIR
${Ceres_BINARY_DIR}
${Ceres_SOURCE_DIR})
# Analogously to install(EXPORT ...), export the Ceres target from the build
# directory as a package called Ceres into the local CMake package registry.
export(TARGETS ceres FILE ${Ceres_BINARY_DIR}/CeresTargets.cmake)
export(PACKAGE ${CMAKE_PROJECT_NAME})
# Configure a CeresConfig.cmake file for the export of the Ceres build
# directory from the template, reflecting the current build options.
set(SETUP_CERES_CONFIG_FOR_INSTALLATION FALSE)
configure_file("${Ceres_SOURCE_DIR}/cmake/CeresConfig.cmake.in"
"${Ceres_BINARY_DIR}/CeresConfig.cmake" @ONLY)
endif (EXPORT_BUILD_DIR)
================================================
FILE: 3rdparty/ceres/CONTRIBUTING.md
================================================
---------------------------------
Do not make GitHub pull requests!
---------------------------------
Ceres development happens on
[Gerrit](https://ceres-solver.googlesource.com/), including both
repository hosting and code reviews.
This GitHub Repository is a continuously updated mirror which is
primarily meant for issue tracking.
Please see our
[Contributing to Ceres Guide](http://ceres-solver.org/contributing.html)
for more details.
================================================
FILE: 3rdparty/ceres/LICENSE
================================================
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.
================================================
FILE: 3rdparty/ceres/README.md
================================================
[](https://travis-ci.org/ceres-solver/ceres-solver)
Ceres Solver
============
Ceres Solver is an open source C++ library for modeling and solving
large, complicated optimization problems. It is a feature rich, mature
and performant library which has been used in production at Google
since 2010. Ceres Solver can solve two kinds of problems.
1. Non-linear Least Squares problems with bounds constraints.
2. General unconstrained optimization problems.
Please see [ceres-solver.org](http://ceres-solver.org/) for more
information.
================================================
FILE: 3rdparty/ceres/WORKSPACE
================================================
# Ceres Solver - A fast non-linear least squares minimizer
# Copyright 2018 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.
#
# Authors: mierle@gmail.com (Keir Mierle)
#
# Bazel workspace file to enable building Ceres with Bazel.
workspace(name = "com_google_ceres_solver")
load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")
# External dependency: Google Flags; has Bazel build already.
http_archive(
name = "com_github_gflags_gflags",
sha256 = "6e16c8bc91b1310a44f3965e616383dbda48f83e8c1eaa2370a215057b00cabe",
strip_prefix = "gflags-77592648e3f3be87d6c7123eb81cbad75f9aef5a",
urls = [
"https://mirror.bazel.build/github.com/gflags/gflags/archive/77592648e3f3be87d6c7123eb81cbad75f9aef5a.tar.gz",
"https://github.com/gflags/gflags/archive/77592648e3f3be87d6c7123eb81cbad75f9aef5a.tar.gz",
],
)
# External dependency: Google Log; has Bazel build already.
http_archive(
name = "com_github_google_glog",
sha256 = "7083af285bed3995b5dc2c982f7de39bced9f0e6fd78d631f3285490922a0c3d",
strip_prefix = "glog-3106945d8d3322e5cbd5658d482c9ffed2d892c0",
urls = [
"https://github.com/drigz/glog/archive/3106945d8d3322e5cbd5658d482c9ffed2d892c0.tar.gz",
],
)
# External dependency: Eigen; has no Bazel build.
http_archive(
name = "com_github_eigen_eigen",
sha256 = "dd254beb0bafc695d0f62ae1a222ff85b52dbaa3a16f76e781dce22d0d20a4a6",
strip_prefix = "eigen-eigen-5a0156e40feb",
urls = [
"http://bitbucket.org/eigen/eigen/get/3.3.4.tar.bz2",
],
build_file_content =
"""
# TODO(keir): Replace this with a better version, like from TensorFlow.
# See https://github.com/ceres-solver/ceres-solver/issues/337.
cc_library(
name = 'eigen',
srcs = [],
includes = ['.'],
hdrs = glob(['Eigen/**']),
visibility = ['//visibility:public'],
)
"""
)
# External dependency: Google Benchmark; has no Bazel build.
http_archive(
name = "com_github_google_benchmark",
urls = ["https://github.com/google/benchmark/archive/56f52ee228783547f544d9ac4a533574b9010e3f.zip"],
sha256 = "8c1c6e90cd320b07504fabb86400f390faff2e599183ebd9396908817968ae79",
strip_prefix = "benchmark-56f52ee228783547f544d9ac4a533574b9010e3f",
build_file_content =
"""
cc_library(
name = "benchmark",
srcs = glob([
"src/*.h",
"src/*.cc",
]),
hdrs = glob(["include/benchmark/*.h"]),
copts = [
"-DHAVE_STD_REGEX",
],
includes = [
"include",
],
visibility = ["//visibility:public"],
)
"""
)
================================================
FILE: 3rdparty/ceres/bazel/ceres.bzl
================================================
# Ceres Solver - A fast non-linear least squares minimizer
# Copyright 2018 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.
#
# Support for building Ceres Solver with a specific configuration.
CERES_SRCS = ["internal/ceres/" + filename for filename in [
"accelerate_sparse.cc",
"array_utils.cc",
"blas.cc",
"block_evaluate_preparer.cc",
"block_jacobian_writer.cc",
"block_jacobi_preconditioner.cc",
"block_random_access_dense_matrix.cc",
"block_random_access_diagonal_matrix.cc",
"block_random_access_matrix.cc",
"block_random_access_sparse_matrix.cc",
"block_sparse_matrix.cc",
"block_structure.cc",
"c_api.cc",
"callbacks.cc",
"canonical_views_clustering.cc",
"cgnr_solver.cc",
"compressed_col_sparse_matrix_utils.cc",
"compressed_row_jacobian_writer.cc",
"compressed_row_sparse_matrix.cc",
"conditioned_cost_function.cc",
"conjugate_gradients_solver.cc",
"context.cc",
"context_impl.cc",
"coordinate_descent_minimizer.cc",
"corrector.cc",
"covariance.cc",
"covariance_impl.cc",
"dense_normal_cholesky_solver.cc",
"dense_qr_solver.cc",
"dense_sparse_matrix.cc",
"detect_structure.cc",
"dogleg_strategy.cc",
"dynamic_compressed_row_jacobian_writer.cc",
"dynamic_compressed_row_sparse_matrix.cc",
"dynamic_sparse_normal_cholesky_solver.cc",
"eigensparse.cc",
"evaluator.cc",
"file.cc",
"function_sample.cc",
"gradient_checker.cc",
"gradient_checking_cost_function.cc",
"gradient_problem.cc",
"gradient_problem_solver.cc",
"is_close.cc",
"implicit_schur_complement.cc",
"inner_product_computer.cc",
"iterative_refiner.cc",
"iterative_schur_complement_solver.cc",
"lapack.cc",
"levenberg_marquardt_strategy.cc",
"line_search.cc",
"line_search_direction.cc",
"line_search_minimizer.cc",
"linear_least_squares_problems.cc",
"linear_operator.cc",
"line_search_preprocessor.cc",
"linear_solver.cc",
"local_parameterization.cc",
"loss_function.cc",
"low_rank_inverse_hessian.cc",
"minimizer.cc",
"normal_prior.cc",
"parallel_for_cxx.cc",
"parallel_for_openmp.cc",
"parallel_utils.cc",
"parameter_block_ordering.cc",
"partitioned_matrix_view.cc",
"polynomial.cc",
"preconditioner.cc",
"preprocessor.cc",
"problem.cc",
"problem_impl.cc",
"program.cc",
"reorder_program.cc",
"residual_block.cc",
"residual_block_utils.cc",
"schur_complement_solver.cc",
"schur_eliminator.cc",
"schur_jacobi_preconditioner.cc",
"schur_templates.cc",
"scratch_evaluate_preparer.cc",
"single_linkage_clustering.cc",
"solver.cc",
"solver_utils.cc",
"sparse_cholesky.cc",
"sparse_matrix.cc",
"sparse_normal_cholesky_solver.cc",
"split.cc",
"stringprintf.cc",
"subset_preconditioner.cc",
"suitesparse.cc",
"thread_pool.cc",
"thread_token_provider.cc",
"triplet_sparse_matrix.cc",
"trust_region_minimizer.cc",
"trust_region_preprocessor.cc",
"trust_region_step_evaluator.cc",
"trust_region_strategy.cc",
"types.cc",
"visibility_based_preconditioner.cc",
"visibility.cc",
"wall_time.cc",
]]
# TODO(rodrigoq): add support to configure Ceres into various permutations,
# like SuiteSparse or not, threading or not, glog or not, and so on.
# See https://github.com/ceres-solver/ceres-solver/issues/335.
def ceres_library(name,
restrict_schur_specializations=False):
# The path to internal/ depends on whether Ceres is the main workspace or
# an external repository.
if native.repository_name() != '@':
internal = 'external/%s/internal' % native.repository_name().lstrip('@')
else:
internal = 'internal'
# The fixed-size Schur eliminator template instantiations incur a large
# binary size penalty, and are slow to compile, so support disabling them.
schur_eliminator_copts = []
if restrict_schur_specializations:
schur_eliminator_copts.append("-DCERES_RESTRICT_SCHUR_SPECIALIZATION")
schur_sources = [
"internal/ceres/generated/schur_eliminator_d_d_d.cc",
"internal/ceres/generated/partitioned_matrix_view_d_d_d.cc",
]
else:
schur_sources = native.glob(["internal/ceres/generated/*.cc"])
native.cc_library(
name = name,
# Internal sources, options, and dependencies.
srcs = CERES_SRCS + schur_sources + native.glob([
"include/ceres/internal/*.h",
]) + native.glob([
"internal/ceres/*.h",
]),
# These headers are made available to other targets.
hdrs =
native.glob(["include/ceres/*.h"]) + native.glob([
"include/ceres/internal/*.h",
]) +
# This is an empty config, since the Bazel-based build does not
# generate a config.h from config.h.in. This is fine, since Bazel
# properly handles propagating -D defines to dependent targets.
native.glob([
"config/ceres/internal/config.h",
]),
copts = [
"-I" + internal,
"-Wno-sign-compare",
] + schur_eliminator_copts,
# These include directories and defines are propagated to other targets
# depending on Ceres.
# TODO(keir): These defines are placeholders for now to facilitate getting
# started with a Bazel build. However, these should become configurable as
# part of a Skylark Ceres target macro.
# https://github.com/ceres-solver/ceres-solver/issues/396
defines = [
"CERES_NO_SUITESPARSE",
"CERES_NO_CXSPARSE",
"CERES_NO_ACCELERATE_SPARSE",
"CERES_NO_LAPACK",
"CERES_USE_EIGEN_SPARSE",
"CERES_USE_CXX11_THREADS",
],
includes = [
"config",
"include",
],
visibility = ["//visibility:public"],
deps = [
"@com_github_eigen_eigen//:eigen",
"@com_github_google_glog//:glog",
],
)
================================================
FILE: 3rdparty/ceres/cmake/AddCompileFlagsIfSupported.cmake
================================================
# Ceres Solver - A fast non-linear least squares minimizer
# Copyright 2017 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: sergey.vfx@gmail.com (Sergey Sharybin)
function(add_cxx_compiler_flag_if_supported
AGGREGATED_CXX_FLAGS_VAR
FLAG_TO_ADD_IF_SUPPORTED)
include(CheckCXXCompilerFlag)
# Use of whitespace or '-' in variable names (used by CheckCXXSourceCompiles
# as #defines) will trigger errors.
string(STRIP "${FLAG_TO_ADD_IF_SUPPORTED}" FLAG_TO_ADD_IF_SUPPORTED)
# Build an informatively named test result variable so that it will be evident
# which tests were performed/succeeded in the CMake output, e.g for -Wall:
#
# -- Performing Test CHECK_CXX_FLAG_Wall - Success
#
# NOTE: This variable is also used to cache test result.
string(REPLACE "-" "_" CHECK_CXX_FLAG
"CHECK_CXX_FLAG${FLAG_TO_ADD_IF_SUPPORTED}")
check_cxx_compiler_flag(${FLAG_TO_ADD_IF_SUPPORTED} ${CHECK_CXX_FLAG})
if (${CHECK_CXX_FLAG})
set(${AGGREGATED_CXX_FLAGS_VAR}
"${${AGGREGATED_CXX_FLAGS_VAR}} ${FLAG_TO_ADD_IF_SUPPORTED}" PARENT_SCOPE)
endif()
endfunction()
================================================
FILE: 3rdparty/ceres/cmake/AddGerritCommitHook.cmake
================================================
# 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.
#
# Authors: keir@google.com (Keir Mierle)
# alexs.mac@gmail.com (Alex Stewart)
# Set up the git hook to make Gerrit Change-Id: lines in commit messages.
function(ADD_GERRIT_COMMIT_HOOK SOURCE_DIR BINARY_DIR)
if (NOT (EXISTS ${SOURCE_DIR} AND IS_DIRECTORY ${SOURCE_DIR}))
message(FATAL_ERROR "Specified SOURCE_DIR: ${SOURCE_DIR} does not exist, "
"or is not a directory, cannot add Gerrit commit hook.")
endif()
if (NOT (EXISTS ${BINARY_DIR} AND IS_DIRECTORY ${BINARY_DIR}))
message(FATAL_ERROR "Specified BINARY_DIR: ${BINARY_DIR} does not exist, "
"or is not a directory, cannot add Gerrit commit hook.")
endif()
unset (LOCAL_GIT_DIRECTORY)
if (EXISTS ${SOURCE_DIR}/.git)
if (IS_DIRECTORY ${SOURCE_DIR}/.git)
# .git directory can be found on Unix based system, or on Windows with
# Git Bash (shipped with msysgit).
set (LOCAL_GIT_DIRECTORY ${SOURCE_DIR}/.git)
else(IS_DIRECTORY ${SOURCE_DIR}/.git)
# .git is a file, this means Ceres is a git submodule of another project
# and our .git file contains the path to the git directory which manages
# Ceres, so we should add the gerrit hook there.
file(READ ${SOURCE_DIR}/.git GIT_SUBMODULE_FILE_CONTENTS)
# Strip any trailing newline characters, s/t we get a valid path.
string(REGEX REPLACE "gitdir:[ ]*([^$].*)[\n].*" "${SOURCE_DIR}/\\1"
GIT_SUBMODULE_GIT_DIRECTORY_PATH "${GIT_SUBMODULE_FILE_CONTENTS}")
get_filename_component(GIT_SUBMODULE_GIT_DIRECTORY_PATH
"${GIT_SUBMODULE_GIT_DIRECTORY_PATH}" ABSOLUTE)
if (EXISTS ${GIT_SUBMODULE_GIT_DIRECTORY_PATH}
AND IS_DIRECTORY ${GIT_SUBMODULE_GIT_DIRECTORY_PATH})
set(LOCAL_GIT_DIRECTORY "${GIT_SUBMODULE_GIT_DIRECTORY_PATH}")
endif()
endif()
else (EXISTS ${SOURCE_DIR}/.git)
# TODO(keir) Add proper Windows support.
endif (EXISTS ${SOURCE_DIR}/.git)
if (EXISTS ${LOCAL_GIT_DIRECTORY})
if (NOT EXISTS ${LOCAL_GIT_DIRECTORY}/hooks/commit-msg)
message(STATUS "Detected Ceres being used as a git submodule, adding "
"commit hook for Gerrit to: ${LOCAL_GIT_DIRECTORY}")
# Download the hook only if it is not already present.
file(DOWNLOAD https://ceres-solver-review.googlesource.com/tools/hooks/commit-msg
${BINARY_DIR}/commit-msg)
# Make the downloaded file executable, since it is not by default.
file(COPY ${BINARY_DIR}/commit-msg
DESTINATION ${LOCAL_GIT_DIRECTORY}/hooks/
FILE_PERMISSIONS
OWNER_READ OWNER_WRITE OWNER_EXECUTE
GROUP_READ GROUP_WRITE GROUP_EXECUTE
WORLD_READ WORLD_EXECUTE)
endif (NOT EXISTS ${LOCAL_GIT_DIRECTORY}/hooks/commit-msg)
endif (EXISTS ${LOCAL_GIT_DIRECTORY})
endfunction()
================================================
FILE: 3rdparty/ceres/cmake/AppendTargetProperty.cmake
================================================
# 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: alexs.mac@gmail.com (Alex Stewart)
# Append item(s) to a property on a declared CMake target:
#
# append_target_property(target property item_to_append1
# [... item_to_appendN])
#
# The set_target_properties() CMake function will overwrite the contents of the
# specified target property. This function instead appends to it, so can
# be called multiple times with the same target & property to iteratively
# populate it.
function(append_target_property TARGET PROPERTY)
if (NOT TARGET ${TARGET})
message(FATAL_ERROR "Invalid target: ${TARGET} cannot append: ${ARGN} "
"to property: ${PROPERTY}")
endif()
if (NOT PROPERTY)
message(FATAL_ERROR "Invalid property to update for target: ${TARGET}")
endif()
# Get the initial state of the specified property for the target s/t
# we can append to it (not overwrite it).
get_target_property(INITIAL_PROPERTY_STATE ${TARGET} ${PROPERTY})
if (NOT INITIAL_PROPERTY_STATE)
# Ensure that if the state is unset, we do not insert the XXX-NOTFOUND
# returned by CMake into the property.
set(INITIAL_PROPERTY_STATE "")
endif()
# Delistify (remove ; separators) the potentially set of items to append
# to the specified target property.
string(REPLACE ";" " " ITEMS_TO_APPEND "${ARGN}")
set_target_properties(${TARGET} PROPERTIES ${PROPERTY}
"${INITIAL_PROPERTY_STATE} ${ITEMS_TO_APPEND}")
endfunction()
================================================
FILE: 3rdparty/ceres/cmake/CeresCompileOptionsToComponents.cmake
================================================
# Ceres Solver - A fast non-linear least squares minimizer
# Copyright 2016 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.
#
# Authors: alexs.mac@gmail.com (Alex Stewart)
#
# Conditionally add a value to the output list based on whether the specified
# value is found in the input list.
function(update_output_if_found INPUT_LIST_VAR OUTPUT_LIST_VAR ITEM_TO_FIND VAR_TO_COPY_IF_FOUND VAR_TO_COPY_IF_NOT_FOUND)
list(FIND ${INPUT_LIST_VAR} "${ITEM_TO_FIND}" HAVE_ITEM)
# list(FIND ..) returns -1 if the element was not in the list, but CMake
# interprets if (VAR) to be true if VAR is any non-zero number, even
# negative ones, hence we have to explicitly check for >= 0.
if (HAVE_ITEM GREATER -1)
list(APPEND ${OUTPUT_LIST_VAR} "${VAR_TO_COPY_IF_FOUND}")
else()
list(APPEND ${OUTPUT_LIST_VAR} "${VAR_TO_COPY_IF_NOT_FOUND}")
endif()
set(${OUTPUT_LIST_VAR} ${${OUTPUT_LIST_VAR}} PARENT_SCOPE)
endfunction()
# Helpers for update_output_if_found() to improve legibility when dealing with
# USE_XXX & NO_XXX option types in ceres_compile_options_to_components().
macro(add_to_output_if_found INPUT_LIST_VAR OUTPUT_LIST_VAR ITEM_TO_FIND VAR_TO_COPY_IF_FOUND)
update_output_if_found(${INPUT_LIST_VAR}
${OUTPUT_LIST_VAR}
"${ITEM_TO_FIND}"
"${VAR_TO_COPY_IF_FOUND}"
"") # Copy nothing if not found.
endmacro()
macro(add_to_output_if_not_found INPUT_LIST_VAR OUTPUT_LIST_VAR ITEM_TO_FIND VAR_TO_COPY_IF_NOT_FOUND)
update_output_if_found(${INPUT_LIST_VAR}
${OUTPUT_LIST_VAR}
"${ITEM_TO_FIND}"
"" # Copy nothing if found
"${VAR_TO_COPY_IF_NOT_FOUND}")
endmacro()
# Convert the Ceres compile options specified by: CURRENT_CERES_COMPILE_OPTIONS
# into the corresponding list of Ceres components (names), which may be used in:
# find_package(Ceres COMPONENTS <XXX>).
function(ceres_compile_options_to_components CURRENT_CERES_COMPILE_OPTIONS CERES_COMPONENTS_VAR)
# To enable users to specify that they want *a* sparse linear algebra backend
# without having to specify explicitly which one, for each sparse library we
# add the 'meta-module': SparseLinearAlgebraLibrary in addition to their own
# module name.
add_to_output_if_found(CURRENT_CERES_COMPILE_OPTIONS ${CERES_COMPONENTS_VAR}
CERES_USE_EIGEN_SPARSE "EigenSparse;SparseLinearAlgebraLibrary")
add_to_output_if_not_found(CURRENT_CERES_COMPILE_OPTIONS ${CERES_COMPONENTS_VAR}
CERES_NO_LAPACK "LAPACK")
add_to_output_if_not_found(CURRENT_CERES_COMPILE_OPTIONS ${CERES_COMPONENTS_VAR}
CERES_NO_SUITESPARSE "SuiteSparse;SparseLinearAlgebraLibrary")
add_to_output_if_not_found(CURRENT_CERES_COMPILE_OPTIONS ${CERES_COMPONENTS_VAR}
CERES_NO_CXSPARSE "CXSparse;SparseLinearAlgebraLibrary")
add_to_output_if_not_found(CURRENT_CERES_COMPILE_OPTIONS ${CERES_COMPONENTS_VAR}
CERES_NO_ACCELERATE_SPARSE "AccelerateSparse;SparseLinearAlgebraLibrary")
add_to_output_if_not_found(CURRENT_CERES_COMPILE_OPTIONS ${CERES_COMPONENTS_VAR}
CERES_RESTRICT_SCHUR_SPECIALIZATION "SchurSpecializations")
add_to_output_if_found(CURRENT_CERES_COMPILE_OPTIONS ${CERES_COMPONENTS_VAR}
CERES_USE_OPENMP "OpenMP;Multithreading")
# Remove duplicates of SparseLinearAlgebraLibrary if multiple sparse backends
# are present.
list(REMOVE_DUPLICATES ${CERES_COMPONENTS_VAR})
set(${CERES_COMPONENTS_VAR} "${${CERES_COMPONENTS_VAR}}" PARENT_SCOPE)
endfunction()
================================================
FILE: 3rdparty/ceres/cmake/CeresConfig.cmake.in
================================================
# 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.
#
# Authors: pablo.speciale@gmail.com (Pablo Speciale)
# alexs.mac@gmail.com (Alex Stewart)
#
# Config file for Ceres Solver - Find Ceres & dependencies.
#
# This file is used by CMake when find_package(Ceres) is invoked and either
# the directory containing this file either is present in CMAKE_MODULE_PATH
# (if Ceres was installed), or exists in the local CMake package registry if
# the Ceres build directory was exported.
#
# This module defines the following variables:
#
# Ceres_FOUND / CERES_FOUND: True if Ceres has been successfully
# found. Both variables are set as although
# FindPackage() only references Ceres_FOUND
# in Config mode, given the conventions for
# <package>_FOUND when FindPackage() is
# called in Module mode, users could
# reasonably expect to use CERES_FOUND
# instead.
#
# CERES_VERSION: Version of Ceres found.
#
# CERES_LIBRARIES: Libraries for Ceres and all
# dependencies against which Ceres was
# compiled. This will not include any optional
# dependencies that were disabled when Ceres was
# compiled.
#
# NOTE: There is no equivalent of CERES_INCLUDE_DIRS as the exported
# CMake target already includes the definition of its public
# include directories.
include(CMakeFindDependencyMacro)
# Called if we failed to find Ceres or any of its required dependencies,
# unsets all public (designed to be used externally) variables and reports
# error message at priority depending upon [REQUIRED/QUIET/<NONE>] argument.
macro(CERES_REPORT_NOT_FOUND REASON_MSG)
# FindPackage() only references Ceres_FOUND, and requires it to be
# explicitly set FALSE to denote not found (not merely undefined).
set(Ceres_FOUND FALSE)
set(CERES_FOUND FALSE)
unset(CERES_INCLUDE_DIR)
unset(CERES_INCLUDE_DIRS)
unset(CERES_LIBRARIES)
# Reset the CMake module path to its state when this script was called.
set(CMAKE_MODULE_PATH ${CALLERS_CMAKE_MODULE_PATH})
# Note <package>_FIND_[REQUIRED/QUIETLY] variables defined by
# FindPackage() use the camelcase library name, not uppercase.
if (Ceres_FIND_QUIETLY)
message(STATUS "Failed to find Ceres - " ${REASON_MSG} ${ARGN})
elseif (Ceres_FIND_REQUIRED)
message(FATAL_ERROR "Failed to find Ceres - " ${REASON_MSG} ${ARGN})
else()
# Neither QUIETLY nor REQUIRED, use SEND_ERROR which emits an error
# that prevents generation, but continues configuration.
message(SEND_ERROR "Failed to find Ceres - " ${REASON_MSG} ${ARGN})
endif ()
return()
endmacro(CERES_REPORT_NOT_FOUND)
# ceres_pretty_print_cmake_list( OUTPUT_VAR [item1 [item2 ... ]] )
#
# Sets ${OUTPUT_VAR} in the caller's scope to a human-readable string
# representation of the list passed as the remaining arguments formed
# as: "[item1, item2, ..., itemN]".
function(ceres_pretty_print_cmake_list OUTPUT_VAR)
string(REPLACE ";" ", " PRETTY_LIST_STRING "[${ARGN}]")
set(${OUTPUT_VAR} "${PRETTY_LIST_STRING}" PARENT_SCOPE)
endfunction()
# The list of (optional) components this version of Ceres was compiled with.
set(CERES_COMPILED_COMPONENTS "@CERES_COMPILED_COMPONENTS@")
# If Ceres was not installed, then by definition it was exported
# from a build directory.
set(CERES_WAS_INSTALLED @SETUP_CERES_CONFIG_FOR_INSTALLATION@)
# Record the state of the CMake module path when this script was
# called so that we can ensure that we leave it in the same state on
# exit as it was on entry, but modify it locally.
set(CALLERS_CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH})
# Get the (current, i.e. installed) directory containing this file.
get_filename_component(CERES_CURRENT_CONFIG_DIR
"${CMAKE_CURRENT_LIST_FILE}" PATH)
if (CERES_WAS_INSTALLED)
# Reset CMake module path to the installation directory of this
# script, thus we will use the FindPackage() scripts shipped with
# Ceres to find Ceres' dependencies, even if the user has equivalently
# named FindPackage() scripts in their project.
set(CMAKE_MODULE_PATH ${CERES_CURRENT_CONFIG_DIR})
# Build the absolute root install directory as a relative path
# (determined when Ceres was configured & built) from the current
# install directory for this this file. This allows for the install
# tree to be relocated, after Ceres was built, outside of CMake.
get_filename_component(CURRENT_ROOT_INSTALL_DIR
"${CERES_CURRENT_CONFIG_DIR}/@INSTALL_ROOT_REL_CONFIG_INSTALL_DIR@"
ABSOLUTE)
if (NOT EXISTS ${CURRENT_ROOT_INSTALL_DIR})
ceres_report_not_found(
"Ceres install root: ${CURRENT_ROOT_INSTALL_DIR}, "
"determined from relative path from CeresConfig.cmake install location: "
"${CERES_CURRENT_CONFIG_DIR}, does not exist. Either the install "
"directory was deleted, or the install tree was only partially relocated "
"outside of CMake after Ceres was built.")
endif (NOT EXISTS ${CURRENT_ROOT_INSTALL_DIR})
else(CERES_WAS_INSTALLED)
# Ceres was exported from the build tree.
set(CERES_EXPORTED_BUILD_DIR ${CERES_CURRENT_CONFIG_DIR})
get_filename_component(CERES_EXPORTED_SOURCE_DIR
"${CERES_EXPORTED_BUILD_DIR}/@INSTALL_ROOT_REL_CONFIG_INSTALL_DIR@"
ABSOLUTE)
if (NOT EXISTS ${CERES_EXPORTED_SOURCE_DIR})
ceres_report_not_found(
"Ceres exported source directory: ${CERES_EXPORTED_SOURCE_DIR}, "
"determined from relative path from CeresConfig.cmake exported build "
"directory: ${CERES_EXPORTED_BUILD_DIR} does not exist.")
endif()
# Reset CMake module path to the cmake directory in the Ceres source
# tree which was exported, thus we will use the FindPackage() scripts shipped
# with Ceres to find Ceres' dependencies, even if the user has equivalently
# named FindPackage() scripts in their project.
set(CMAKE_MODULE_PATH ${CERES_EXPORTED_SOURCE_DIR}/cmake)
endif(CERES_WAS_INSTALLED)
# Set the version.
set(CERES_VERSION @CERES_VERSION@ )
include(CMakeFindDependencyMacro)
find_dependency(Threads)
# Eigen.
# Flag set during configuration and build of Ceres.
set(CERES_EIGEN_VERSION @EIGEN3_VERSION_STRING@)
# Search quietly to control the timing of the error message if not found. The
# search should be for an exact match, but for usability reasons do a soft
# match and reject with an explanation below.
find_package(Eigen3 ${CERES_EIGEN_VERSION} CONFIG QUIET)
if (EIGEN3_FOUND)
if (NOT EIGEN3_VERSION_STRING VERSION_EQUAL CERES_EIGEN_VERSION)
# CMake's VERSION check in FIND_PACKAGE() will accept any version >= the
# specified version. However, only version = is supported. Improve
# usability by explaining why we don't accept non-exact version matching.
ceres_report_not_found("Found Eigen dependency, but the version of Eigen "
"found (${EIGEN3_VERSION_STRING}) does not exactly match the version of Eigen "
"Ceres was compiled with (${CERES_EIGEN_VERSION}). This can cause subtle "
"bugs by triggering violations of the One Definition Rule. See the "
"Wikipedia article http://en.wikipedia.org/wiki/One_Definition_Rule "
"for more details")
endif ()
message(STATUS "Found required Ceres dependency: "
"Eigen version ${CERES_EIGEN_VERSION} in ${EIGEN3_INCLUDE_DIRS}")
else (EIGEN3_FOUND)
ceres_report_not_found("Missing required Ceres "
"dependency: Eigen version ${CERES_EIGEN_VERSION}, please set "
"Eigen3_DIR.")
endif (EIGEN3_FOUND)
# Glog.
# Flag set during configuration and build of Ceres.
set(CERES_USES_MINIGLOG @MINIGLOG@)
set(CERES_USES_GFLAGS @GFLAGS@)
set(CERES_GFLAGS_VERSION @gflags_VERSION@)
if (CERES_USES_MINIGLOG)
# Output message at standard log level (not the lower STATUS) so that
# the message is output in GUI during configuration to warn user.
message("-- Found Ceres compiled with miniglog substitute "
"for glog, beware this will likely cause problems if glog is later linked.")
else(CERES_USES_MINIGLOG)
# As imported CMake targets are not re-exported when a dependent target is
# exported, we must invoke find_package(XXX) here to reload the definition
# of their targets. Without this, the dependency target names (e.g.
# 'gflags-shared') which will be present in the ceres target would not be
# defined, and so CMake will assume that they refer to a library name and
# fail to link correctly.
# Append the locations of glog when Ceres was built to the search path hints.
set(GLOG_WAS_BUILT_WITH_CMAKE @FOUND_INSTALLED_GLOG_CMAKE_CONFIGURATION@)
if (GLOG_WAS_BUILT_WITH_CMAKE)
set(glog_DIR "@glog_DIR@")
set(GLOG_PREFER_EXPORTED_GLOG_CMAKE_CONFIGURATION TRUE)
else()
list(APPEND GLOG_INCLUDE_DIR_HINTS "@GLOG_INCLUDE_DIR@")
get_filename_component(CERES_BUILD_GLOG_LIBRARY_DIR "@GLOG_LIBRARY@" PATH)
list(APPEND GLOG_LIBRARY_DIR_HINTS ${CERES_BUILD_GLOG_LIBRARY_DIR})
endif()
# Search quietly s/t we control the timing of the error message if not found.
find_package(Glog QUIET)
if (GLOG_FOUND)
message(STATUS "Found required Ceres dependency: glog")
else()
ceres_report_not_found("Missing required Ceres "
"dependency: glog. Searched using GLOG_INCLUDE_DIR_HINTS: "
"${GLOG_INCLUDE_DIR_HINTS} and glog_DIR: ${glog_DIR}.")
endif()
# gflags is only a public dependency of Ceres via glog, thus is not required
# if Ceres was built with MINIGLOG.
if (CERES_USES_GFLAGS)
# Search quietly s/t we control the timing of the error message if not found.
find_package(gflags ${CERES_GFLAGS_VERSION} CONFIG QUIET)
if (gflags_FOUND)
message(STATUS "Found required Ceres dependency: gflags")
else()
ceres_report_not_found("Missing required Ceres "
"dependency: gflags.")
endif()
endif()
endif(CERES_USES_MINIGLOG)
# Import exported Ceres targets, if they have not already been imported.
if (NOT TARGET ceres AND NOT Ceres_BINARY_DIR)
include(${CERES_CURRENT_CONFIG_DIR}/CeresTargets.cmake)
endif (NOT TARGET ceres AND NOT Ceres_BINARY_DIR)
# Set the expected XX_LIBRARIES variable for FindPackage().
set(CERES_LIBRARIES ceres)
# Reset CMake module path to its state when this script was called.
set(CMAKE_MODULE_PATH ${CALLERS_CMAKE_MODULE_PATH})
# Build the detected Ceres version string to correctly capture whether it
# was installed, or exported.
ceres_pretty_print_cmake_list(CERES_COMPILED_COMPONENTS_STRING
${CERES_COMPILED_COMPONENTS})
if (CERES_WAS_INSTALLED)
set(CERES_DETECTED_VERSION_STRING "Ceres version: ${CERES_VERSION} "
"installed in: ${CURRENT_ROOT_INSTALL_DIR} with components: "
"${CERES_COMPILED_COMPONENTS_STRING}")
else (CERES_WAS_INSTALLED)
set(CERES_DETECTED_VERSION_STRING "Ceres version: ${CERES_VERSION} "
"exported from build directory: ${CERES_EXPORTED_BUILD_DIR} with "
"components: ${CERES_COMPILED_COMPONENTS_STRING}")
endif()
# If the user called this script through find_package() whilst specifying
# particular Ceres components that should be found via:
# find_package(Ceres COMPONENTS XXX YYY), check the requested components against
# those with which Ceres was compiled. In this case, we should only report
# Ceres as found if all the requested components have been found.
if (Ceres_FIND_COMPONENTS)
foreach (REQUESTED_COMPONENT ${Ceres_FIND_COMPONENTS})
list(FIND CERES_COMPILED_COMPONENTS ${REQUESTED_COMPONENT} HAVE_REQUESTED_COMPONENT)
# list(FIND ..) returns -1 if the element was not in the list, but CMake
# interprets if (VAR) to be true if VAR is any non-zero number, even
# negative ones, hence we have to explicitly check for >= 0.
if (HAVE_REQUESTED_COMPONENT EQUAL -1)
# Check for the presence of all requested components before reporting
# not found, such that we report all of the missing components rather
# than just the first.
list(APPEND MISSING_CERES_COMPONENTS ${REQUESTED_COMPONENT})
endif()
endforeach()
if (MISSING_CERES_COMPONENTS)
ceres_pretty_print_cmake_list(REQUESTED_CERES_COMPONENTS_STRING
${Ceres_FIND_COMPONENTS})
ceres_pretty_print_cmake_list(MISSING_CERES_COMPONENTS_STRING
${MISSING_CERES_COMPONENTS})
ceres_report_not_found("Missing requested Ceres components: "
"${MISSING_CERES_COMPONENTS_STRING} (components requested: "
"${REQUESTED_CERES_COMPONENTS_STRING}). Detected "
"${CERES_DETECTED_VERSION_STRING}.")
endif()
endif()
# As we use CERES_REPORT_NOT_FOUND() to abort, if we reach this point we have
# found Ceres and all required dependencies.
message(STATUS "Found " ${CERES_DETECTED_VERSION_STRING})
# Set CERES_FOUND to be equivalent to Ceres_FOUND, which is set to
# TRUE by FindPackage() if this file is found and run, and after which
# Ceres_FOUND is not (explicitly, i.e. undefined does not count) set
# to FALSE.
set(CERES_FOUND TRUE)
================================================
FILE: 3rdparty/ceres/cmake/CeresThreadingModels.cmake
================================================
# Ceres Solver - A fast non-linear least squares minimizer
# Copyright 2018 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: alexs.mac@gmail.com (Alex Stewart)
# Ordered by expected preference.
set(CERES_THREADING_MODELS "CXX11_THREADS;OPENMP;NO_THREADS")
function(find_available_ceres_threading_models CERES_THREADING_MODELS_AVAILABLE_VAR)
set(CERES_THREADING_MODELS_AVAILABLE ${CERES_THREADING_MODELS})
# Remove any threading models for which the dependencies are not available.
find_package(OpenMP QUIET)
if (NOT OPENMP_FOUND)
list(REMOVE_ITEM CERES_THREADING_MODELS_AVAILABLE "OPENMP")
endif()
if (NOT CERES_THREADING_MODELS_AVAILABLE)
# At least NO_THREADS should never be removed. This check is purely
# protective against future threading model updates.
message(FATAL_ERROR "Ceres bug: Removed all threading models.")
endif()
set(${CERES_THREADING_MODELS_AVAILABLE_VAR}
${CERES_THREADING_MODELS_AVAILABLE} PARENT_SCOPE)
endfunction()
macro(set_ceres_threading_model_to_cxx11_threads)
list(APPEND CERES_COMPILE_OPTIONS CERES_USE_CXX11_THREADS)
endmacro()
macro(set_ceres_threading_model_to_openmp)
find_package(OpenMP REQUIRED)
list(APPEND CERES_COMPILE_OPTIONS CERES_USE_OPENMP)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${OpenMP_CXX_FLAGS}")
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${OpenMP_C_FLAGS}")
endmacro()
macro(set_ceres_threading_model_to_no_threads)
list(APPEND CERES_COMPILE_OPTIONS CERES_NO_THREADS)
endmacro()
macro(set_ceres_threading_model CERES_THREADING_MODEL_TO_SET)
if ("${CERES_THREADING_MODEL_TO_SET}" STREQUAL "CXX11_THREADS")
set_ceres_threading_model_to_cxx11_threads()
elseif ("${CERES_THREADING_MODEL_TO_SET}" STREQUAL "OPENMP")
set_ceres_threading_model_to_openmp()
elseif ("${CERES_THREADING_MODEL_TO_SET}" STREQUAL "NO_THREADS")
set_ceres_threading_model_to_no_threads()
else()
include(PrettyPrintCMakeList)
find_available_ceres_threading_models(_AVAILABLE_THREADING_MODELS)
pretty_print_cmake_list(
_AVAILABLE_THREADING_MODELS ${_AVAILABLE_THREADING_MODELS})
message(FATAL_ERROR "Unknown threading model specified: "
"'${CERES_THREADING_MODEL_TO_SET}'. Available threading models for "
"this platform are: ${_AVAILABLE_THREADING_MODELS}")
endif()
message("-- Using Ceres threading model: ${CERES_THREADING_MODEL_TO_SET}")
endmacro()
================================================
FILE: 3rdparty/ceres/cmake/CheckIfUnderscorePrefixedBesselFunctionsExist.cmake
================================================
# Ceres Solver - A fast non-linear least squares minimizer
# Copyright 2017 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: alexs.mac@gmail.com (Alex Stewart)
# Microsoft deprecated the POSIX Bessel functions: j[0,1,n]() in favour
# of _j[0,1,n](), it appears since at least MSVC 2005 [1]. This function
# checks if the underscore prefixed versions of the Bessel functions are
# defined, and sets ${HAVE_UNDERSCORE_PREFIXED_BESSEL_FUNCTIONS_VAR} to
# TRUE if they do.
#
# [1] https://msdn.microsoft.com/en-us/library/ms235384(v=vs.100).aspx
function(check_if_underscore_prefixed_bessel_functions_exist
HAVE_UNDERSCORE_PREFIXED_BESSEL_FUNCTIONS_VAR)
include(CheckCXXSourceCompiles)
check_cxx_source_compiles(
"#include <math.h>
int main(int argc, char * argv[]) {
double result;
result = _j0(1.2345);
result = _j1(1.2345);
result = _jn(2, 1.2345);
return 0;
}"
HAVE_UNDERSCORE_PREFIXED_BESSEL_FUNCTIONS)
set(${HAVE_UNDERSCORE_PREFIXED_BESSEL_FUNCTIONS_VAR}
${HAVE_UNDERSCORE_PREFIXED_BESSEL_FUNCTIONS}
PARENT_SCOPE)
endfunction()
================================================
FILE: 3rdparty/ceres/cmake/CreateCeresConfig.cmake
================================================
# 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: alexs.mac@gmail.com (Alex Stewart)
# This must take place outside of CONFIGURE_CERES_CONFIG() in order that
# we can determine where *this* file is, and thus the relative path to
# config.h.in. Inside of CONFIGURE_CERES_CONFIG(), CMAKE_CURRENT_LIST_DIR
# refers to the caller of CONFIGURE_CERES_CONFIG(), not this file.
set(CERES_CONFIG_IN_FILE "${CMAKE_CURRENT_LIST_DIR}/config.h.in")
# CreateCeresConfig.cmake - Create the config.h for Ceres.
#
# This function configures the Ceres config.h file based on the current
# compile options and copies it into the specified location. It should be
# called before Ceres is built so that the correct config.h is used when
# Ceres is compiled.
#
# INPUTS:
# CURRENT_CERES_COMPILE_OPTIONS: List of currently enabled Ceres compile
# options. These are compared against the
# full list of valid options, which are read
# from config.h.in. Any options present
# which are not part of the valid set will
# invoke an error. Any valid option present
# will be enabled in the resulting config.h,
# all other options will be disabled.
#
# CERES_CONFIG_OUTPUT_DIRECTORY: Path to output directory in which to save
# the configured config.h. Typically this
# will be <src>/include/ceres/internal.
function(CREATE_CERES_CONFIG CURRENT_CERES_COMPILE_OPTIONS CERES_CONFIG_OUTPUT_DIRECTORY)
# Create the specified output directory if it does not exist.
if (NOT EXISTS "${CERES_CONFIG_OUTPUT_DIRECTORY}")
message(STATUS "Creating configured Ceres config.h output directory: "
"${CERES_CONFIG_OUTPUT_DIRECTORY}")
file(MAKE_DIRECTORY "${CERES_CONFIG_OUTPUT_DIRECTORY}")
endif()
if (EXISTS "${CERES_CONFIG_OUTPUT_DIRECTORY}" AND
NOT IS_DIRECTORY "${CERES_CONFIG_OUTPUT_DIRECTORY}")
message(FATAL_ERROR "Ceres Bug: Specified CERES_CONFIG_OUTPUT_DIRECTORY: "
"${CERES_CONFIG_OUTPUT_DIRECTORY} exists, but is not a directory.")
endif()
# Read all possible configurable compile options from config.h.in, this avoids
# us having to hard-code in this file what the valid options are.
file(READ ${CERES_CONFIG_IN_FILE} CERES_CONFIG_IN_CONTENTS)
string(REGEX MATCHALL "@[^@ $]+@"
ALL_CONFIGURABLE_CERES_OPTIONS "${CERES_CONFIG_IN_CONTENTS}")
# Removing @ symbols at beginning and end of each option.
string(REPLACE "@" ""
ALL_CONFIGURABLE_CERES_OPTIONS "${ALL_CONFIGURABLE_CERES_OPTIONS}")
# Ensure that there are no repetitions in the current compile options.
list(REMOVE_DUPLICATES CURRENT_CERES_COMPILE_OPTIONS)
foreach (CERES_OPTION ${ALL_CONFIGURABLE_CERES_OPTIONS})
# Try and find the option in the list of current compile options, if it
# is present, then the option is enabled, otherwise it is disabled.
list(FIND CURRENT_CERES_COMPILE_OPTIONS ${CERES_OPTION} OPTION_ENABLED)
# list(FIND ..) returns -1 if the element was not in the list, but CMake
# interprets if (VAR) to be true if VAR is any non-zero number, even
# negative ones, hence we have to explicitly check for >= 0.
if (OPTION_ENABLED GREATER -1)
message(STATUS "Enabling ${CERES_OPTION} in Ceres config.h")
set(${CERES_OPTION} "#define ${CERES_OPTION}")
# Remove the item from the list of current options so that we can identify
# any options that were in CURRENT_CERES_COMPILE_OPTIONS, but not in
# ALL_CONFIGURABLE_CERES_OPTIONS (which is an error).
list(REMOVE_ITEM CURRENT_CERES_COMPILE_OPTIONS ${CERES_OPTION})
else()
set(${CERES_OPTION} "// #define ${CERES_OPTION}")
endif()
endforeach()
# CURRENT_CERES_COMPILE_OPTIONS should now be an empty list, any elements
# remaining were not present in ALL_CONFIGURABLE_CERES_OPTIONS read from
# config.h.in.
if (CURRENT_CERES_COMPILE_OPTIONS)
message(FATAL_ERROR "Ceres Bug: CURRENT_CERES_COMPILE_OPTIONS contained "
"the following options which were not present in config.h.in: "
"${CURRENT_CERES_COMPILE_OPTIONS}")
endif()
configure_file(${CERES_CONFIG_IN_FILE}
"${CERES_CONFIG_OUTPUT_DIRECTORY}/config.h" @ONLY)
endfunction()
================================================
FILE: 3rdparty/ceres/cmake/DetectBrokenStackCheckMacOSXcodePairing.cmake
================================================
# Ceres Solver - A fast non-linear least squares minimizer
# Copyright 2019 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: alexs.mac@gmail.com (Alex Stewart)
# As detailed in [1] the combination of macOS 10.15.x (Catalina) and
# Xcode 11.0-1 enables by default a broken version of -fstack-check which
# can break the alignment requirements for SIMD instructions resulting in
# segfaults from within Eigen. This issue was apparently fixed in Xcode 11.2
# despite not appearing in the official release notes.
#
# Although this can be worked around by compiling with -fno-stack-check, we
# instead prevent generation as the update to Xcode 11.2 is free and failing
# to include -fno-stack-check *everywhere* could still result in random
# segfaults.
#
# [1]: https://forums.developer.apple.com/thread/121887
function(detect_broken_stack_check_macos_xcode_pairing)
if (NOT APPLE)
return()
endif()
execute_process(COMMAND sw_vers -productVersion
OUTPUT_VARIABLE MACOS_VERSION
ERROR_QUIET
OUTPUT_STRIP_TRAILING_WHITESPACE)
if (MACOS_VERSION VERSION_LESS 10.15)
# Only 10.15 (Catalina) is likely to be affected, irrespective of the Xcode
# version. Although it is possible to recreate the issue on 10.14 (Mojave)
# and Xcode 11.0-1 if -fstack-check is forced on, this is not the default.
return()
endif()
execute_process(COMMAND xcodebuild -version
OUTPUT_VARIABLE XCODE_VERSION
ERROR_QUIET
OUTPUT_STRIP_TRAILING_WHITESPACE)
string(REGEX MATCH "Xcode [0-9\\.]+" XCODE_VERSION "${XCODE_VERSION}")
string(REGEX REPLACE "Xcode ([0-9\\.]+)" "\\1" XCODE_VERSION "${XCODE_VERSION}")
if ((XCODE_VERSION VERSION_EQUAL 11.0) OR
(XCODE_VERSION VERSION_EQUAL 11.1))
message(FATAL_ERROR "Detected macOS version: ${MACOS_VERSION} and "
"Xcode version: ${XCODE_VERSION} which combined exhibit an "
"-fstack-check bug which can break alignment requirements for at least "
"AVX instructions as detailed here [1]."
"\n"
"This bug affected Xcode 11.0 and 11.1 but only when used with 10.15 "
"(Catalina), and was fixed in Xcode 11.2. Without the fix in place, "
"random segfaults will occur in Eigen operations used by Ceres that use "
"AVX instructions."
"\n"
"Please update to at least Xcode 11.2."
"\n"
"[1]: https://forums.developer.apple.com/thread/121887")
endif()
endfunction()
================================================
FILE: 3rdparty/ceres/cmake/EnableSanitizer.cmake
================================================
# Ceres Solver - A fast non-linear least squares minimizer
# Copyright 2019 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: alexs.mac@gmail.com (Alex Stewart)
# Usage: enable_sanitizer(REQUIRED_SANITIZERS) where REQUIRED_SANITIZERS should
# contain the list of sanitizers to enable by updating CMAKE_CXX_FLAGS and
# CMAKE_EXE_LINKER_FLAGS.
#
# The specified sanitizers will be checked both for compatibility with the
# current compiler and with each other as some sanitizers are mutually
# exclusive.
macro(enable_sanitizer)
# According to the Clang documentation [1] the following sanitizers are
# mututally exclusive.
# [1]: https://clang.llvm.org/docs/UsersManual.html#controlling-code-generation
set(INCOMPATIBLE_SANITIZERS address thread memory)
# Set the recommended additional common compile flags for any sanitizer to
# get the best possible output, e.g [2] but make them visible in the cache
# so that the user can edit them if required.
# [2]: https://clang.llvm.org/docs/AddressSanitizer.html#usage
set(COMMON_SANITIZER_COMPILE_OPTIONS
"-g -fno-omit-frame-pointer -fno-optimize-sibling-calls"
CACHE STRING "Common compile flags enabled for any sanitizer")
# Check that the specified list of sanitizers to enable does not include
# multiple entries from the incompatible list.
set(MERGED_SANITIZERS ${ARGN} ${INCOMPATIBLE_SANITIZERS})
list(LENGTH MERGED_SANITIZERS COMBINED_LENGTH)
list(REMOVE_DUPLICATES MERGED_SANITIZERS)
list(LENGTH MERGED_SANITIZERS COMBINED_LENGTH_NO_DUPLICATES)
math(EXPR VALID_LENGTH "${COMBINED_LENGTH} - 1")
if (COMBINED_LENGTH_NO_DUPLICATES LESS VALID_LENGTH)
include(PrettyPrintCMakeList)
pretty_print_cmake_list(REQUESTED_SANITIZERS ${ARGN})
pretty_print_cmake_list(
PRETTY_INCOMPATIBLE_SANITIZERS ${INCOMPATIBLE_SANITIZERS})
message(FATAL_ERROR "Found incompatible sanitizers in requested set: "
"${REQUESTED_SANITIZERS}. The following sanitizers are mutually "
"exclusive: ${PRETTY_INCOMPATIBLE_SANITIZERS}")
endif()
# Until CMake 3.14 and CMAKE_REQUIRED_LINK_OPTIONS there was no equivalent to
# CMAKE_REQUIRED_FLAGS for try_compile() for linker flags. However, in CMake
# 3.2 CMP0056 was introduced that when enabled passes CMAKE_EXE_LINKER_FLAGS
# to try_compile() which allows us to achieve the same effect.
cmake_policy(SET CMP0056 NEW)
include(CheckCXXCompilerFlag)
unset(ADDED_SANITIZER)
foreach(REQUESTED_SANITIZER ${ARGN})
set(SANITIZER_FLAG -fsanitize=${REQUESTED_SANITIZER})
# Save the current CMAKE_EXE_LINKER_FLAGS before modifying it to test for
# the existence of the sanitizer flag so that we can revert after the test.
set(INITIAL_CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS}")
set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${SANITIZER_FLAG}")
check_cxx_compiler_flag(${SANITIZER_FLAG} HAVE_SANITIZER)
set(CMAKE_EXE_LINKER_FLAGS "${INITIAL_CMAKE_EXE_LINKER_FLAGS}")
if (NOT HAVE_SANITIZER)
message(FATAL_ERROR "Specified sanitizer: ${REQUESTED_SANITIZER} is not "
"supported by the compiler.")
endif()
message(STATUS "Enabling sanitizer: ${REQUESTED_SANITIZER}")
set(ADDED_SANITIZER TRUE)
# As per the Clang documentation, the sanitizer flags must be added to both
# the compiler and linker flags.
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${SANITIZER_FLAG}")
set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${SANITIZER_FLAG}")
endforeach()
if (ADDED_SANITIZER)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${COMMON_SANITIZER_COMPILE_OPTIONS}")
endif()
endmacro()
================================================
FILE: 3rdparty/ceres/cmake/FindAccelerateSparse.cmake
================================================
# Ceres Solver - A fast non-linear least squares minimizer
# Copyright 2018 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: alexs.mac@gmail.com (Alex Stewart)
#
# FindAccelerateSparse.cmake - Find the sparse solvers in Apple's Accelerate
# framework, introduced in Xcode 9.0 (2017).
# Note that this is distinct from the Accelerate
# framework on its own, which existed in previous
# versions but without the sparse solvers.
#
# This module defines the following variables which should be referenced
# by the caller to use the library.
#
# AccelerateSparse_FOUND: TRUE iff an Accelerate framework including the sparse
# solvers, and all dependencies, has been found.
# AccelerateSparse_INCLUDE_DIRS: Include directories for Accelerate framework.
# AccelerateSparse_LIBRARIES: Libraries for Accelerate framework and all
# dependencies.
#
# The following variables are also defined by this module, but in line with
# CMake recommended FindPackage() module style should NOT be referenced directly
# by callers (use the plural variables detailed above instead). These variables
# do however affect the behaviour of the module via FIND_[PATH/LIBRARY]() which
# are NOT re-called (i.e. search for library is not repeated) if these variables
# are set with valid values _in the CMake cache_. This means that if these
# variables are set directly in the cache, either by the user in the CMake GUI,
# or by the user passing -DVAR=VALUE directives to CMake when called (which
# explicitly defines a cache variable), then they will be used verbatim,
# bypassing the HINTS variables and other hard-coded search locations.
#
# AccelerateSparse_INCLUDE_DIR: Include directory for Accelerate framework, not
# including the include directory of any
# dependencies.
# AccelerateSparse_LIBRARY: Accelerate framework, not including the libraries of
# any dependencies.
# Called if we failed to find the Accelerate framework with the sparse solvers.
# Unsets all public (designed to be used externally) variables and reports
# error message at priority depending upon [REQUIRED/QUIET/<NONE>] argument.
macro(accelerate_sparse_report_not_found REASON_MSG)
unset(AccelerateSparse_FOUND)
unset(AccelerateSparse_INCLUDE_DIRS)
unset(AccelerateSparse_LIBRARIES)
# Make results of search visible in the CMake GUI if Accelerate has not
# been found so that user does not have to toggle to advanced view.
mark_as_advanced(CLEAR AccelerateSparse_INCLUDE_DIR
AccelerateSparse_LIBRARY)
# Note <package>_FIND_[REQUIRED/QUIETLY] variables defined by FindPackage()
# use the camelcase library name, not uppercase.
if (AccelerateSparse_FIND_QUIETLY)
message(STATUS "Failed to find Accelerate framework with sparse solvers - "
${REASON_MSG} ${ARGN})
elseif (AccelerateSparse_FIND_REQUIRED)
message(FATAL_ERROR "Failed to find Accelerate framework with sparse solvers - "
${REASON_MSG} ${ARGN})
else()
# Neither QUIETLY nor REQUIRED, use no priority which emits a message
# but continues configuration and allows generation.
message("-- Failed to find Accelerate framework with sparse solvers - "
${REASON_MSG} ${ARGN})
endif()
return()
endmacro()
unset(AccelerateSparse_FOUND)
find_path(AccelerateSparse_INCLUDE_DIR NAMES Accelerate.h)
if (NOT AccelerateSparse_INCLUDE_DIR OR
NOT EXISTS ${AccelerateSparse_INCLUDE_DIR})
accelerate_sparse_report_not_found(
"Could not find Accelerate framework headers. Set "
"AccelerateSparse_INCLUDE_DIR to the directory containing Accelerate.h")
endif()
find_library(AccelerateSparse_LIBRARY NAMES Accelerate)
if (NOT AccelerateSparse_LIBRARY OR
NOT EXISTS ${AccelerateSparse_LIBRARY})
accelerate_sparse_report_not_found(
"Could not find Accelerate framework. Set AccelerateSparse_LIBRARY "
"to the Accelerate.framework directory")
endif()
set(AccelerateSparse_FOUND TRUE)
# Determine if the Accelerate framework detected includes the sparse solvers.
include(CheckCXXSourceCompiles)
set(CMAKE_REQUIRED_INCLUDES ${AccelerateSparse_INCLUDE_DIR})
set(CMAKE_REQUIRED_LIBRARIES ${AccelerateSparse_LIBRARY})
check_cxx_source_compiles(
"#include <Accelerate.h>
int main() {
SparseMatrix_Double A;
SparseFactor(SparseFactorizationCholesky, A);
return 0;
}"
ACCELERATE_FRAMEWORK_HAS_SPARSE_SOLVER)
unset(CMAKE_REQUIRED_INCLUDES)
unset(CMAKE_REQUIRED_LIBRARIES)
if (NOT ACCELERATE_FRAMEWORK_HAS_SPARSE_SOLVER)
accelerate_sparse_report_not_found(
"Detected Accelerate framework: ${AccelerateSparse_LIBRARY} does not "
"include the sparse solvers.")
endif()
if (AccelerateSparse_FOUND)
set(AccelerateSparse_INCLUDE_DIRS ${AccelerateSparse_INCLUDE_DIR})
set(AccelerateSparse_LIBRARIES ${AccelerateSparse_LIBRARY})
endif()
# Handle REQUIRED / QUIET optional arguments and version.
include(FindPackageHandleStandardArgs)
find_package_handle_standard_args(AccelerateSparse
REQUIRED_VARS AccelerateSparse_INCLUDE_DIRS AccelerateSparse_LIBRARIES)
if (AccelerateSparse_FOUND)
mark_as_advanced(FORCE AccelerateSparse_INCLUDE_DIR
AccelerateSparse_LIBRARY)
endif()
================================================
FILE: 3rdparty/ceres/cmake/FindCXSparse.cmake
================================================
# 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: alexs.mac@gmail.com (Alex Stewart)
#
# FindCXSparse.cmake - Find CXSparse libraries & dependencies.
#
# This module defines the following variables which should be referenced
# by the caller to use the library.
#
# CXSPARSE_FOUND: TRUE iff CXSparse and all dependencies have been found.
# CXSPARSE_INCLUDE_DIRS: Include directories for CXSparse.
# CXSPARSE_LIBRARIES: Libraries for CXSparse and all dependencies.
#
# CXSPARSE_VERSION: Extracted from cs.h.
# CXSPARSE_MAIN_VERSION: Equal to 3 if CXSPARSE_VERSION = 3.1.2
# CXSPARSE_SUB_VERSION: Equal to 1 if CXSPARSE_VERSION = 3.1.2
# CXSPARSE_SUBSUB_VERSION: Equal to 2 if CXSPARSE_VERSION = 3.1.2
#
# The following variables control the behaviour of this module:
#
# CXSPARSE_INCLUDE_DIR_HINTS: List of additional directories in which to
# search for CXSparse includes,
# e.g: /timbuktu/include.
# CXSPARSE_LIBRARY_DIR_HINTS: List of additional directories in which to
# search for CXSparse libraries, e.g: /timbuktu/lib.
#
# The following variables are also defined by this module, but in line with
# CMake recommended FindPackage() module style should NOT be referenced directly
# by callers (use the plural variables detailed above instead). These variables
# do however affect the behaviour of the module via FIND_[PATH/LIBRARY]() which
# are NOT re-called (i.e. search for library is not repeated) if these variables
# are set with valid values _in the CMake cache_. This means that if these
# variables are set directly in the cache, either by the user in the CMake GUI,
# or by the user passing -DVAR=VALUE directives to CMake when called (which
# explicitly defines a cache variable), then they will be used verbatim,
# bypassing the HINTS variables and other hard-coded search locations.
#
# CXSPARSE_INCLUDE_DIR: Include directory for CXSparse, not including the
# include directory of any dependencies.
# CXSPARSE_LIBRARY: CXSparse library, not including the libraries of any
# dependencies.
# Reset CALLERS_CMAKE_FIND_LIBRARY_PREFIXES to its value when
# FindCXSparse was invoked.
macro(CXSPARSE_RESET_FIND_LIBRARY_PREFIX)
if (MSVC)
set(CMAKE_FIND_LIBRARY_PREFIXES "${CALLERS_CMAKE_FIND_LIBRARY_PREFIXES}")
endif (MSVC)
endmacro(CXSPARSE_RESET_FIND_LIBRARY_PREFIX)
# Called if we failed to find CXSparse or any of it's required dependencies,
# unsets all public (designed to be used externally) variables and reports
# error message at priority depending upon [REQUIRED/QUIET/<NONE>] argument.
macro(CXSPARSE_REPORT_NOT_FOUND REASON_MSG)
unset(CXSPARSE_FOUND)
unset(CXSPARSE_INCLUDE_DIRS)
unset(CXSPARSE_LIBRARIES)
# Make results of search visible in the CMake GUI if CXSparse has not
# been found so that user does not have to toggle to advanced view.
mark_as_advanced(CLEAR CXSPARSE_INCLUDE_DIR
CXSPARSE_LIBRARY)
cxsparse_reset_find_library_prefix()
# Note <package>_FIND_[REQUIRED/QUIETLY] variables defined by FindPackage()
# use the camelcase library name, not uppercase.
if (CXSparse_FIND_QUIETLY)
message(STATUS "Failed to find CXSparse - " ${REASON_MSG} ${ARGN})
elseif (CXSparse_FIND_REQUIRED)
message(FATAL_ERROR "Failed to find CXSparse - " ${REASON_MSG} ${ARGN})
else()
# Neither QUIETLY nor REQUIRED, use no priority which emits a message
# but continues configuration and allows generation.
message("-- Failed to find CXSparse - " ${REASON_MSG} ${ARGN})
endif ()
return()
endmacro(CXSPARSE_REPORT_NOT_FOUND)
# Protect against any alternative find_package scripts for this library having
# been called previously (in a client project) which set CXSPARSE_FOUND, but not
# the other variables we require / set here which could cause the search logic
# here to fail.
unset(CXSPARSE_FOUND)
# Handle possible presence of lib prefix for libraries on MSVC, see
# also CXSPARSE_RESET_FIND_LIBRARY_PREFIX().
if (MSVC)
# Preserve the caller's original values for CMAKE_FIND_LIBRARY_PREFIXES
# s/t we can set it back before returning.
set(CALLERS_CMAKE_FIND_LIBRARY_PREFIXES "${CMAKE_FIND_LIBRARY_PREFIXES}")
# The empty string in this list is important, it represents the case when
# the libraries have no prefix (shared libraries / DLLs).
set(CMAKE_FIND_LIBRARY_PREFIXES "lib" "" "${CMAKE_FIND_LIBRARY_PREFIXES}")
endif (MSVC)
# On macOS, add the Homebrew prefix (with appropriate suffixes) to the
# respective HINTS directories (after any user-specified locations). This
# handles Homebrew installations into non-standard locations (not /usr/local).
# We do not use CMAKE_PREFIX_PATH for this as given the search ordering of
# find_xxx(), doing so would override any user-specified HINTS locations with
# the Homebrew version if it exists.
if (CMAKE_SYSTEM_NAME MATCHES "Darwin")
find_program(HOMEBREW_EXECUTABLE brew)
mark_as_advanced(FORCE HOMEBREW_EXECUTABLE)
if (HOMEBREW_EXECUTABLE)
# Detected a Homebrew install, query for its install prefix.
execute_process(COMMAND ${HOMEBREW_EXECUTABLE} --prefix
OUTPUT_VARIABLE HOMEBREW_INSTALL_PREFIX
OUTPUT_STRIP_TRAILING_WHITESPACE)
message(STATUS "Detected Homebrew with install prefix: "
"${HOMEBREW_INSTALL_PREFIX}, adding to CMake search paths.")
list(APPEND CXSPARSE_INCLUDE_DIR_HINTS "${HOMEBREW_INSTALL_PREFIX}/include")
list(APPEND CXSPARSE_LIBRARY_DIR_HINTS "${HOMEBREW_INSTALL_PREFIX}/lib")
endif()
endif()
# Search user-installed locations first, so that we prefer user installs
# to system installs where both exist.
#
# TODO: Add standard Windows search locations for CXSparse.
list(APPEND CXSPARSE_CHECK_INCLUDE_DIRS
/usr/local/include
/usr/local/homebrew/include # Mac OS X
/opt/local/var/macports/software # Mac OS X.
/opt/local/include
/usr/include)
list(APPEND CXSPARSE_CHECK_LIBRARY_DIRS
/usr/local/lib
/usr/local/homebrew/lib # Mac OS X.
/opt/local/lib
/usr/lib)
# Additional suffixes to try appending to each search path.
list(APPEND CXSPARSE_CHECK_PATH_SUFFIXES
suitesparse) # Linux/Windows
# Search supplied hint directories first if supplied.
find_path(CXSPARSE_INCLUDE_DIR
NAMES cs.h
HINTS ${CXSPARSE_INCLUDE_DIR_HINTS}
PATHS ${CXSPARSE_CHECK_INCLUDE_DIRS}
PATH_SUFFIXES ${CXSPARSE_CHECK_PATH_SUFFIXES})
if (NOT CXSPARSE_INCLUDE_DIR OR
NOT EXISTS ${CXSPARSE_INCLUDE_DIR})
cxsparse_report_not_found(
"Could not find CXSparse include directory, set CXSPARSE_INCLUDE_DIR "
"to directory containing cs.h")
endif (NOT CXSPARSE_INCLUDE_DIR OR
NOT EXISTS ${CXSPARSE_INCLUDE_DIR})
find_library(CXSPARSE_LIBRARY NAMES cxsparse
HINTS ${CXSPARSE_LIBRARY_DIR_HINTS}
PATHS ${CXSPARSE_CHECK_LIBRARY_DIRS}
PATH_SUFFIXES ${CXSPARSE_CHECK_PATH_SUFFIXES})
if (NOT CXSPARSE_LIBRARY OR
NOT EXISTS ${CXSPARSE_LIBRARY})
cxsparse_report_not_found(
"Could not find CXSparse library, set CXSPARSE_LIBRARY "
"to full path to libcxsparse.")
endif (NOT CXSPARSE_LIBRARY OR
NOT EXISTS ${CXSPARSE_LIBRARY})
# Mark internally as found, then verify. CXSPARSE_REPORT_NOT_FOUND() unsets
# if called.
set(CXSPARSE_FOUND TRUE)
# Extract CXSparse version from cs.h
if (CXSPARSE_INCLUDE_DIR)
set(CXSPARSE_VERSION_FILE ${CXSPARSE_INCLUDE_DIR}/cs.h)
if (NOT EXISTS ${CXSPARSE_VERSION_FILE})
cxsparse_report_not_found(
"Could not find file: ${CXSPARSE_VERSION_FILE} "
"containing version information in CXSparse install located at: "
"${CXSPARSE_INCLUDE_DIR}.")
else (NOT EXISTS ${CXSPARSE_VERSION_FILE})
file(READ ${CXSPARSE_INCLUDE_DIR}/cs.h CXSPARSE_VERSION_FILE_CONTENTS)
string(REGEX MATCH "#define CS_VER [0-9]+"
CXSPARSE_MAIN_VERSION "${CXSPARSE_VERSION_FILE_CONTENTS}")
string(REGEX REPLACE "#define CS_VER ([0-9]+)" "\\1"
CXSPARSE_MAIN_VERSION "${CXSPARSE_MAIN_VERSION}")
string(REGEX MATCH "#define CS_SUBVER [0-9]+"
CXSPARSE_SUB_VERSION "${CXSPARSE_VERSION_FILE_CONTENTS}")
string(REGEX REPLACE "#define CS_SUBVER ([0-9]+)" "\\1"
CXSPARSE_SUB_VERSION "${CXSPARSE_SUB_VERSION}")
string(REGEX MATCH "#define CS_SUBSUB [0-9]+"
CXSPARSE_SUBSUB_VERSION "${CXSPARSE_VERSION_FILE_CONTENTS}")
string(REGEX REPLACE "#define CS_SUBSUB ([0-9]+)" "\\1"
CXSPARSE_SUBSUB_VERSION "${CXSPARSE_SUBSUB_VERSION}")
# This is on a single line s/t CMake does not interpret it as a list of
# elements and insert ';' separators which would result in 3.;1.;2 nonsense.
set(CXSPARSE_VERSION "${CXSPARSE_MAIN_VERSION}.${CXSPARSE_SUB_VERSION}.${CXSPARSE_SUBSUB_VERSION}")
endif (NOT EXISTS ${CXSPARSE_VERSION_FILE})
endif (CXSPARSE_INCLUDE_DIR)
# Catch the case when the caller has set CXSPARSE_LIBRARY in the cache / GUI and
# thus FIND_LIBRARY was not called, but specified library is invalid, otherwise
# we would report CXSparse as found.
# TODO: This regex for CXSparse library is pretty primitive, we use lowercase
# for comparison to handle Windows using CamelCase library names, could
# this check be better?
string(TOLOWER "${CXSPARSE_LIBRARY}" LOWERCASE_CXSPARSE_LIBRARY)
if (CXSPARSE_LIBRARY AND
EXISTS ${CXSPARSE_LIBRARY} AND
NOT "${LOWERCASE_CXSPARSE_LIBRARY}" MATCHES ".*cxsparse[^/]*")
cxsparse_report_not_found(
"Caller defined CXSPARSE_LIBRARY: "
"${CXSPARSE_LIBRARY} does not match CXSparse.")
endif (CXSPARSE_LIBRARY AND
EXISTS ${CXSPARSE_LIBRARY} AND
NOT "${LOWERCASE_CXSPARSE_LIBRARY}" MATCHES ".*cxsparse[^/]*")
# Set standard CMake FindPackage variables if found.
if (CXSPARSE_FOUND)
set(CXSPARSE_INCLUDE_DIRS ${CXSPARSE_INCLUDE_DIR})
set(CXSPARSE_LIBRARIES ${CXSPARSE_LIBRARY})
endif (CXSPARSE_FOUND)
cxsparse_reset_find_library_prefix()
# Handle REQUIRED / QUIET optional arguments and version.
include(FindPackageHandleStandardArgs)
find_package_handle_standard_args(CXSparse
REQUIRED_VARS CXSPARSE_INCLUDE_DIRS CXSPARSE_LIBRARIES
VERSION_VAR CXSPARSE_VERSION)
# Only mark internal variables as advanced if we found CXSparse, otherwise
# leave them visible in the standard GUI for the user to set manually.
if (CXSPARSE_FOUND)
mark_as_advanced(FORCE CXSPARSE_INCLUDE_DIR
CXSPARSE_LIBRARY)
endif (CXSPARSE_FOUND)
================================================
FILE: 3rdparty/ceres/cmake/FindGlog.cmake
================================================
# 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: alexs.mac@gmail.com (Alex Stewart)
#
# FindGlog.cmake - Find Google glog logging library.
#
# This module defines the following variables:
#
# GLOG_FOUND: TRUE iff glog is found.
# GLOG_INCLUDE_DIRS: Include directories for glog.
# GLOG_LIBRARIES: Libraries required to link glog.
# FOUND_INSTALLED_GLOG_CMAKE_CONFIGURATION: True iff the version of glog found
# was built & installed / exported
# as a CMake package.
#
# The following variables control the behaviour of this module:
#
# GLOG_PREFER_EXPORTED_GLOG_CMAKE_CONFIGURATION: TRUE/FALSE, iff TRUE then
# then prefer using an exported CMake configuration
# generated by glog > 0.3.4 over searching for the
# glog components manually. Otherwise (FALSE)
# ignore any exported glog CMake configurations and
# always perform a manual search for the components.
# Default: TRUE iff user does not define this variable
# before we are called, and does NOT specify either
# GLOG_INCLUDE_DIR_HINTS or GLOG_LIBRARY_DIR_HINTS
# otherwise FALSE.
# GLOG_INCLUDE_DIR_HINTS: List of additional directories in which to
# search for glog includes, e.g: /timbuktu/include.
# GLOG_LIBRARY_DIR_HINTS: List of additional directories in which to
# search for glog libraries, e.g: /timbuktu/lib.
#
# The following variables are also defined by this module, but in line with
# CMake recommended FindPackage() module style should NOT be referenced directly
# by callers (use the plural variables detailed above instead). These variables
# do however affect the behaviour of the module via FIND_[PATH/LIBRARY]() which
# are NOT re-called (i.e. search for library is not repeated) if these variables
# are set with valid values _in the CMake cache_. This means that if these
# variables are set directly in the cache, either by the user in the CMake GUI,
# or by the user passing -DVAR=VALUE directives to CMake when called (which
# explicitly defines a cache variable), then they will be used verbatim,
# bypassing the HINTS variables and other hard-coded search locations.
#
# GLOG_INCLUDE_DIR: Include directory for glog, not including the
# include directory of any dependencies.
# GLOG_LIBRARY: glog library, not including the libraries of any
# dependencies.
# Reset CALLERS_CMAKE_FIND_LIBRARY_PREFIXES to its value when
# FindGlog was invoked.
macro(GLOG_RESET_FIND_LIBRARY_PREFIX)
if (MSVC AND CALLERS_CMAKE_FIND_LIBRARY_PREFIXES)
set(CMAKE_FIND_LIBRARY_PREFIXES "${CALLERS_CMAKE_FIND_LIBRARY_PREFIXES}")
endif()
endmacro(GLOG_RESET_FIND_LIBRARY_PREFIX)
# Called if we failed to find glog or any of it's required dependencies,
# unsets all public (designed to be used externally) variables and reports
# error message at priority depending upon [REQUIRED/QUIET/<NONE>] argument.
macro(GLOG_REPORT_NOT_FOUND REASON_MSG)
unset(GLOG_FOUND)
unset(GLOG_INCLUDE_DIRS)
unset(GLOG_LIBRARIES)
# Make results of search visible in the CMake GUI if glog has not
# been found so that user does not have to toggle to advanced view.
mark_as_advanced(CLEAR GLOG_INCLUDE_DIR
GLOG_LIBRARY)
glog_reset_find_library_prefix()
# Note <package>_FIND_[REQUIRED/QUIETLY] variables defined by FindPackage()
# use the camelcase library name, not uppercase.
if (Glog_FIND_QUIETLY)
message(STATUS "Failed to find glog - " ${REASON_MSG} ${ARGN})
elseif (Glog_FIND_REQUIRED)
message(FATAL_ERROR "Failed to find glog - " ${REASON_MSG} ${ARGN})
else()
# Neither QUIETLY nor REQUIRED, use no priority which emits a message
# but continues configuration and allows generation.
message("-- Failed to find glog - " ${REASON_MSG} ${ARGN})
endif ()
return()
endmacro(GLOG_REPORT_NOT_FOUND)
# Protect against any alternative find_package scripts for this library having
# been called previously (in a client project) which set GLOG_FOUND, but not
# the other variables we require / set here which could cause the search logic
# here to fail.
unset(GLOG_FOUND)
# -----------------------------------------------------------------
# By default, if the user has expressed no preference for using an exported
# glog CMake configuration over performing a search for the installed
# components, and has not specified any hints for the search locations, then
# prefer a glog exported configuration if available.
if (NOT DEFINED GLOG_PREFER_EXPORTED_GLOG_CMAKE_CONFIGURATION
AND NOT GLOG_INCLUDE_DIR_HINTS
AND NOT GLOG_LIBRARY_DIR_HINTS)
message(STATUS "No preference for use of exported glog CMake configuration "
"set, and no hints for include/library directories provided. "
"Defaulting to preferring an installed/exported glog CMake configuration "
"if available.")
set(GLOG_PREFER_EXPORTED_GLOG_CMAKE_CONFIGURATION TRUE)
endif()
# On macOS, add the Homebrew prefix (with appropriate suffixes) to the
# respective HINTS directories (after any user-specified locations). This
# handles Homebrew installations into non-standard locations (not /usr/local).
# We do not use CMAKE_PREFIX_PATH for this as given the search ordering of
# find_xxx(), doing so would override any user-specified HINTS locations with
# the Homebrew version if it exists.
if (CMAKE_SYSTEM_NAME MATCHES "Darwin")
find_program(HOMEBREW_EXECUTABLE brew)
mark_as_advanced(FORCE HOMEBREW_EXECUTABLE)
if (HOMEBREW_EXECUTABLE)
# Detected a Homebrew install, query for its install prefix.
execute_process(COMMAND ${HOMEBREW_EXECUTABLE} --prefix
OUTPUT_VARIABLE HOMEBREW_INSTALL_PREFIX
OUTPUT_STRIP_TRAILING_WHITESPACE)
message(STATUS "Detected Homebrew with install prefix: "
"${HOMEBREW_INSTALL_PREFIX}, adding to CMake search paths.")
list(APPEND GLOG_INCLUDE_DIR_HINTS "${HOMEBREW_INSTALL_PREFIX}/include")
list(APPEND GLOG_LIBRARY_DIR_HINTS "${HOMEBREW_INSTALL_PREFIX}/lib")
endif()
endif()
if (GLOG_PREFER_EXPORTED_GLOG_CMAKE_CONFIGURATION)
# Try to find an exported CMake configuration for glog, as generated by
# glog versions > 0.3.4
#
# We search twice, s/t we can invert the ordering of precedence used by
# find_package() for exported package build directories, and installed
# packages (found via CMAKE_SYSTEM_PREFIX_PATH), listed as items 6) and 7)
# respectively in [1].
#
# By default, exported build directories are (in theory) detected first, and
# this is usually the case on Windows. However, on OS X & Linux, the install
# path (/usr/local) is typically present in the PATH environment variable
# which is checked in item 4) in [1] (i.e. before both of the above, unless
# NO_SYSTEM_ENVIRONMENT_PATH is passed). As such on those OSs installed
# packages are usually detected in preference to exported package build
# directories.
#
# To ensure a more consistent response across all OSs, and as users usually
# want to prefer an installed version of a package over a locally built one
# where both exist (esp. as the exported build directory might be removed
# after installation), we first search with NO_CMAKE_PACKAGE_REGISTRY which
# means any build directories exported by the user are ignored, and thus
# installed directories are preferred. If this fails to find the package
# we then research again, but without NO_CMAKE_PACKAGE_REGISTRY, so any
# exported build directories will now be detected.
#
# To prevent confusion on Windows, we also pass NO_CMAKE_BUILDS_PATH (which
# is item 5) in [1]), to not preferentially use projects that were built
# recently with the CMake GUI to ensure that we always prefer an installed
# version if available.
#
# NOTE: We use the NAMES option as glog erroneously uses 'google-glog' as its
# project name when built with CMake, but exports itself as just 'glog'.
# On Linux/OS X this does not break detection as the project name is
# not used as part of the install path for the CMake package files,
# e.g. /usr/local/lib/cmake/glog, where the <glog> suffix is hardcoded
# in glog's CMakeLists. However, on Windows the project name *is*
# part of the install prefix: C:/Program Files/google-glog/[include,lib].
# However, by default CMake checks:
# C:/Program Files/<FIND_PACKAGE_ARGUMENT_NAME='glog'> which does not
# exist and thus detection fails. Thus we use the NAMES to force the
# search to use both google-glog & glog.
#
# [1] http://www.cmake.org/cmake/help/v2.8.11/cmake.html#command:find_package
find_package(glog QUIET
NAMES google-glog glog
HINTS ${glog_DIR} ${HOMEBREW_INSTALL_PREFIX}
NO_MODULE
NO_CMAKE_PACKAGE_REGISTRY
NO_CMAKE_BUILDS_PATH)
if (glog_FOUND)
message(STATUS "Found installed version of glog: ${glog_DIR}")
else()
# Failed to find an installed version of glog, repeat search allowing
# exported build directories.
message(STATUS "Failed to find installed glog CMake configuration, "
"searching for glog build directories exported with CMake.")
# Again pass NO_CMAKE_BUILDS_PATH, as we know that glog is exported and
# do not want to treat projects built with the CMake GUI preferentially.
find_package(glog QUIET
NAMES google-glog glog
NO_MODULE
NO_CMAKE_BUILDS_PATH)
if (glog_FOUND)
message(STATUS "Found exported glog build directory: ${glog_DIR}")
endif(glog_FOUND)
endif(glog_FOUND)
set(FOUND_INSTALLED_GLOG_CMAKE_CONFIGURATION ${glog_FOUND})
if (FOUND_INSTALLED_GLOG_CMAKE_CONFIGURATION)
message(STATUS "Detected glog version: ${glog_VERSION}")
set(GLOG_FOUND ${glog_FOUND})
# glog wraps the include directories into the exported glog::glog target.
set(GLOG_INCLUDE_DIR "")
set(GLOG_LIBRARY glog::glog)
else (FOUND_INSTALLED_GLOG_CMAKE_CONFIGURATION)
message(STATUS "Failed to find an installed/exported CMake configuration "
"for glog, will perform search for installed glog components.")
endif (FOUND_INSTALLED_GLOG_CMAKE_CONFIGURATION)
endif(GLOG_PREFER_EXPORTED_GLOG_CMAKE_CONFIGURATION)
if (NOT GLOG_FOUND)
# Either failed to find an exported glog CMake configuration, or user
# told us not to use one. Perform a manual search for all glog components.
# Handle possible presence of lib prefix for libraries on MSVC, see
# also GLOG_RESET_FIND_LIBRARY_PREFIX().
if (MSVC)
# Preserve the caller's original values for CMAKE_FIND_LIBRARY_PREFIXES
# s/t we can set it back before returning.
set(CALLERS_CMAKE_FIND_LIBRARY_PREFIXES "${CMAKE_FIND_LIBRARY_PREFIXES}")
# The empty string in this list is important, it represents the case when
# the libraries have no prefix (shared libraries / DLLs).
set(CMAKE_FIND_LIBRARY_PREFIXES "lib" "" "${CMAKE_FIND_LIBRARY_PREFIXES}")
endif (MSVC)
# Search user-installed locations first, so that we prefer user installs
# to system installs where both exist.
list(APPEND GLOG_CHECK_INCLUDE_DIRS
/usr/local/include
/usr/local/homebrew/include # Mac OS X
/opt/local/var/macports/software # Mac OS X.
/opt/local/include
/usr/include)
# Windows (for C:/Program Files prefix).
list(APPEND GLOG_CHECK_PATH_SUFFIXES
glog/include
glog/Include
Glog/include
Glog/Include
google-glog/include # CMake installs with project name prefix.
google-glog/Include)
list(APPEND GLOG_CHECK_LIBRARY_DIRS
/usr/local/lib
/usr/local/homebrew/lib # Mac OS X.
/opt/local/lib
/usr/lib)
# Windows (for C:/Program Files prefix).
list(APPEND GLOG_CHECK_LIBRARY_SUFFIXES
glog/lib
glog/Lib
Glog/lib
Glog/Lib
google-glog/lib # CMake installs with project name prefix.
google-glog/Lib)
# Search supplied hint directories first if supplied.
find_path(GLOG_INCLUDE_DIR
NAMES glog/logging.h
HINTS ${GLOG_INCLUDE_DIR_HINTS}
PATHS ${GLOG_CHECK_INCLUDE_DIRS}
PATH_SUFFIXES ${GLOG_CHECK_PATH_SUFFIXES})
if (NOT GLOG_INCLUDE_DIR OR
NOT EXISTS ${GLOG_INCLUDE_DIR})
glog_report_not_found(
"Could not find glog include directory, set GLOG_INCLUDE_DIR "
"to directory containing glog/logging.h")
endif (NOT GLOG_INCLUDE_DIR OR
NOT EXISTS ${GLOG_INCLUDE_DIR})
find_library(GLOG_LIBRARY NAMES glog
HINTS ${GLOG_LIBRARY_DIR_HINTS}
PATHS ${GLOG_CHECK_LIBRARY_DIRS}
PATH_SUFFIXES ${GLOG_CHECK_LIBRARY_SUFFIXES})
if (NOT GLOG_LIBRARY OR
NOT EXISTS ${GLOG_LIBRARY})
glog_report_not_found(
"Could not find glog library, set GLOG_LIBRARY "
"to full path to libglog.")
endif (NOT GLOG_LIBRARY OR
NOT EXISTS ${GLOG_LIBRARY})
# Mark internally as found, then verify. GLOG_REPORT_NOT_FOUND() unsets
# if called.
set(GLOG_FOUND TRUE)
# Glog does not seem to provide any record of the version in its
# source tree, thus cannot extract version.
# Catch case when caller has set GLOG_INCLUDE_DIR in the cache / GUI and
# thus FIND_[PATH/LIBRARY] are not called, but specified locations are
# invalid, otherwise we would report the library as found.
if (GLOG_INCLUDE_DIR AND
NOT EXISTS ${GLOG_INCLUDE_DIR}/glog/logging.h)
glog_report_not_found(
"Caller defined GLOG_INCLUDE_DIR:"
" ${GLOG_INCLUDE_DIR} does not contain glog/logging.h header.")
endif (GLOG_INCLUDE_DIR AND
NOT EXISTS ${GLOG_INCLUDE_DIR}/glog/logging.h)
# TODO: This regex for glog library is pretty primitive, we use lowercase
# for comparison to handle Windows using CamelCase library names, could
# this check be better?
string(TOLOWER "${GLOG_LIBRARY}" LOWERCASE_GLOG_LIBRARY)
if (GLOG_LIBRARY AND
NOT "${LOWERCASE_GLOG_LIBRARY}" MATCHES ".*glog[^/]*")
glog_report_not_found(
"Caller defined GLOG_LIBRARY: "
"${GLOG_LIBRARY} does not match glog.")
endif (GLOG_LIBRARY AND
NOT "${LOWERCASE_GLOG_LIBRARY}" MATCHES ".*glog[^/]*")
glog_reset_find_library_prefix()
endif(NOT GLOG_FOUND)
# Set standard CMake FindPackage variables if found.
if (GLOG_FOUND)
set(GLOG_INCLUDE_DIRS ${GLOG_INCLUDE_DIR})
set(GLOG_LIBRARIES ${GLOG_LIBRARY})
endif (GLOG_FOUND)
# If we are using an exported CMake glog target, the include directories are
# wrapped into the target itself, and do not have to be (and are not)
# separately specified. In which case, we should not add GLOG_INCLUDE_DIRS
# to the list of required variables in order that glog be reported as found.
if (FOUND_INSTALLED_GLOG_CMAKE_CONFIGURATION)
set(GLOG_REQUIRED_VARIABLES GLOG_LIBRARIES)
else()
set(GLOG_REQUIRED_VARIABLES GLOG_INCLUDE_DIRS GLOG_LIBRARIES)
endif()
# Handle REQUIRED / QUIET optional arguments.
include(FindPackageHandleStandardArgs)
find_package_handle_standard_args(Glog DEFAULT_MSG
${GLOG_REQUIRED_VARIABLES})
# Only mark internal variables as advanced if we found glog, otherwise
# leave them visible in the standard GUI for the user to set manually.
if (GLOG_FOUND)
mark_as_advanced(FORCE GLOG_INCLUDE_DIR
GLOG_LIBRARY
glog_DIR) # Autogenerated by find_package(glog)
endif (GLOG_FOUND)
================================================
FILE: 3rdparty/ceres/cmake/FindSphinx.cmake
================================================
# 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: pablo.speciale@gmail.com (Pablo Speciale)
#
# Find the Sphinx documentation generator
#
# This modules defines
# SPHINX_EXECUTABLE
# SPHINX_FOUND
find_program(SPHINX_EXECUTABLE
NAMES sphinx-build
PATHS
/usr/bin
/usr/local/bin
/opt/local/bin
DOC "Sphinx documentation generator")
if (NOT SPHINX_EXECUTABLE)
set(_Python_VERSIONS 2.7 2.6 2.5 2.4 2.3 2.2 2.1 2.0 1.6 1.5)
foreach (_version ${_Python_VERSIONS})
set(_sphinx_NAMES sphinx-build-${_version})
find_program(SPHINX_EXECUTABLE
NAMES ${_sphinx_NAMES}
PATHS
/usr/bin
/usr/local/bin
/opt/local/bin
DOC "Sphinx documentation generator")
endforeach ()
endif ()
include(FindPackageHandleStandardArgs)
find_package_handle_standard_args(Sphinx DEFAULT_MSG SPHINX_EXECUTABLE)
mark_as_advanced(SPHINX_EXECUTABLE)
================================================
FILE: 3rdparty/ceres/cmake/FindSuiteSparse.cmake
================================================
# 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: alexs.mac@gmail.com (Alex Stewart)
#
# FindSuiteSparse.cmake - Find SuiteSparse libraries & dependencies.
#
# This module defines the following variables:
#
# SUITESPARSE_FOUND: TRUE iff SuiteSparse and all dependencies have been found.
# SUITESPARSE_INCLUDE_DIRS: Include directories for all SuiteSparse components.
# SUITESPARSE_LIBRARIES: Libraries for all SuiteSparse component libraries and
# dependencies.
# SUITESPARSE_VERSION: Extracted from UFconfig.h (<= v3) or
# SuiteSparse_config.h (>= v4).
# SUITESPARSE_MAIN_VERSION: Equal to 4 if SUITESPARSE_VERSION = 4.2.1
# SUITESPARSE_SUB_VERSION: Equal to 2 if SUITESPARSE_VERSION = 4.2.1
# SUITESPARSE_SUBSUB_VERSION: Equal to 1 if SUITESPARSE_VERSION = 4.2.1
#
# SUITESPARSE_IS_BROKEN_SHARED_LINKING_UBUNTU_SYSTEM_VERSION: TRUE iff running
# on Ubuntu, SUITESPARSE_VERSION is 3.4.0 and found SuiteSparse is a system
# install, in which case found version of SuiteSparse cannot be used to link
# a shared library due to a bug (static linking is unaffected).
#
# The following variables control the behaviour of this module:
#
# SUITESPARSE_INCLUDE_DIR_HINTS: List of additional directories in which to
# search for SuiteSparse includes,
# e.g: /timbuktu/include.
# SUITESPARSE_LIBRARY_DIR_HINTS: List of additional directories in which to
# search for SuiteSparse libraries,
# e.g: /timbuktu/lib.
#
# The following variables define the presence / includes & libraries for the
# SuiteSparse components searched for, the SUITESPARSE_XX variables are the
# union of the variables for all components.
#
# == Symmetric Approximate Minimum Degree (AMD)
# AMD_FOUND
# AMD_INCLUDE_DIR
# AMD_LIBRARY
#
# == Constrained Approximate Minimum Degree (CAMD)
# CAMD_FOUND
# CAMD_INCLUDE_DIR
# CAMD_LIBRARY
#
# == Column Approximate Minimum Degree (COLAMD)
# COLAMD_FOUND
# COLAMD_INCLUDE_DIR
# COLAMD_LIBRARY
#
# Constrained Column Approximate Minimum Degree (CCOLAMD)
# CCOLAMD_FOUND
# CCOLAMD_INCLUDE_DIR
# CCOLAMD_LIBRARY
#
# == Sparse Supernodal Cholesky Factorization and Update/Downdate (CHOLMOD)
# CHOLMOD_FOUND
# CHOLMOD_INCLUDE_DIR
# CHOLMOD_LIBRARY
#
# == Multifrontal Sparse QR (SuiteSparseQR)
# SUITESPARSEQR_FOUND
# SUITESPARSEQR_INCLUDE_DIR
# SUITESPARSEQR_LIBRARY
#
# == Common configuration for all but CSparse (SuiteSparse version >= 4).
# SUITESPARSE_CONFIG_FOUND
# SUITESPARSE_CONFIG_INCLUDE_DIR
# SUITESPARSE_CONFIG_LIBRARY
#
# == Common configuration for all but CSparse (SuiteSparse version < 4).
# UFCONFIG_FOUND
# UFCONFIG_INCLUDE_DIR
#
# Optional SuiteSparse Dependencies:
#
# == Serial Graph Partitioning and Fill-reducing Matrix Ordering (METIS)
# METIS_FOUND
# METIS_LIBRARY
# Reset CALLERS_CMAKE_FIND_LIBRARY_PREFIXES to its value when
# FindSuiteSparse was invoked.
macro(SUITESPARSE_RESET_FIND_LIBRARY_PREFIX)
if (MSVC)
set(CMAKE_FIND_LIBRARY_PREFIXES "${CALLERS_CMAKE_FIND_LIBRARY_PREFIXES}")
endif (MSVC)
endmacro(SUITESPARSE_RESET_FIND_LIBRARY_PREFIX)
# Called if we failed to find SuiteSparse or any of it's required dependencies,
# unsets all public (designed to be used externally) variables and reports
# error message at priority depending upon [REQUIRED/QUIET/<NONE>] argument.
macro(SUITESPARSE_REPORT_NOT_FOUND REASON_MSG)
unset(SUITESPARSE_FOUND)
unset(SUITESPARSE_INCLUDE_DIRS)
unset(SUITESPARSE_LIBRARIES)
unset(SUITESPARSE_VERSION)
unset(SUITESPARSE_MAIN_VERSION)
unset(SUITESPARSE_SUB_VERSION)
unset(SUITESPARSE_SUBSUB_VERSION)
# Do NOT unset SUITESPARSE_FOUND_REQUIRED_VARS here, as it is used by
# FindPackageHandleStandardArgs() to generate the automatic error message on
# failure which highlights which components are missing.
suitesparse_reset_find_library_prefix()
# Note <package>_FIND_[REQUIRED/QUIETLY] variables defined by FindPackage()
# use the camelcase library name, not uppercase.
if (SuiteSparse_FIND_QUIETLY)
message(STATUS "Failed to find SuiteSparse - " ${REASON_MSG} ${ARGN})
elseif (SuiteSparse_FIND_REQUIRED)
message(FATAL_ERROR "Failed to find SuiteSparse - " ${REASON_MSG} ${ARGN})
else()
# Neither QUIETLY nor REQUIRED, use no priority which emits a message
# but continues configuration and allows generation.
message("-- Failed to find SuiteSparse - " ${REASON_MSG} ${ARGN})
endif (SuiteSparse_FIND_QUIETLY)
# Do not call return(), s/t we keep processing if not called with REQUIRED
# and report all missing components, rather than bailing after failing to find
# the first.
endmacro(SUITESPARSE_REPORT_NOT_FOUND)
# Protect against any alternative find_package scripts for this library having
# been called previously (in a client project) which set SUITESPARSE_FOUND, but
# not the other variables we require / set here which could cause the search
# logic here to fail.
unset(SUITESPARSE_FOUND)
# Handle possible presence of lib prefix for libraries on MSVC, see
# also SUITESPARSE_RESET_FIND_LIBRARY_PREFIX().
if (MSVC)
# Preserve the caller's original values for CMAKE_FIND_LIBRARY_PREFIXES
# s/t we can set it back before returning.
set(CALLERS_CMAKE_FIND_LIBRARY_PREFIXES "${CMAKE_FIND_LIBRARY_PREFIXES}")
# The empty string in this list is important, it represents the case when
# the libraries have no prefix (shared libraries / DLLs).
set(CMAKE_FIND_LIBRARY_PREFIXES "lib" "" "${CMAKE_FIND_LIBRARY_PREFIXES}")
endif (MSVC)
# On macOS, add the Homebrew prefix (with appropriate suffixes) to the
# respective HINTS directories (after any user-specified locations). This
# handles Homebrew installations into non-standard locations (not /usr/local).
# We do not use CMAKE_PREFIX_PATH for this as given the search ordering of
# find_xxx(), doing so would override any user-specified HINTS locations with
# the Homebrew version if it exists.
if (CMAKE_SYSTEM_NAME MATCHES "Darwin")
find_program(HOMEBREW_EXECUTABLE brew)
mark_as_advanced(FORCE HOMEBREW_EXECUTABLE)
if (HOMEBREW_EXECUTABLE)
# Detected a Homebrew install, query for its install prefix.
execute_process(COMMAND ${HOMEBREW_EXECUTABLE} --prefix
OUTPUT_VARIABLE HOMEBREW_INSTALL_PREFIX
OUTPUT_STRIP_TRAILING_WHITESPACE)
message(STATUS "Detected Homebrew with install prefix: "
"${HOMEBREW_INSTALL_PREFIX}, adding to CMake search paths.")
list(APPEND SUITESPARSE_INCLUDE_DIR_HINTS "${HOMEBREW_INSTALL_PREFIX}/include")
list(APPEND SUITESPARSE_LIBRARY_DIR_HINTS "${HOMEBREW_INSTALL_PREFIX}/lib")
endif()
endif()
# Specify search directories for include files and libraries (this is the union
# of the search directories for all OSs). Search user-specified hint
# directories first if supplied, and search user-installed locations first
# so that we prefer user installs to system installs where both exist.
list(APPEND SUITESPARSE_CHECK_INCLUDE_DIRS
/opt/local/include
/opt/local/include/ufsparse # Mac OS X
/usr/local/homebrew/include # Mac OS X
/usr/local/include
/usr/include)
list(APPEND SUITESPARSE_CHECK_LIBRARY_DIRS
/opt/local/lib
/opt/local/lib/ufsparse # Mac OS X
/usr/local/homebrew/lib # Mac OS X
/usr/local/lib
/usr/lib)
# Additional suffixes to try appending to each search path.
list(APPEND SUITESPARSE_CHECK_PATH_SUFFIXES
suitesparse) # Windows/Ubuntu
# Wrappers to find_path/library that pass the SuiteSparse search hints/paths.
#
# suitesparse_find_component(<component> [FILES name1 [name2 ...]]
# [LIBRARIES name1 [name2 ...]]
# [REQUIRED])
macro(suitesparse_find_component COMPONENT)
include(CMakeParseArguments)
set(OPTIONS REQUIRED)
set(MULTI_VALUE_ARGS FILES LIBRARIES)
cmake_parse_arguments(SUITESPARSE_FIND_${COMPONENT}
"${OPTIONS}" "" "${MULTI_VALUE_ARGS}" ${ARGN})
if (SUITESPARSE_FIND_${COMPONENT}_REQUIRED)
list(APPEND SUITESPARSE_FOUND_REQUIRED_VARS ${COMPONENT}_FOUND)
endif()
set(${COMPONENT}_FOUND TRUE)
if (SUITESPARSE_FIND_${COMPONENT}_FILES)
find_path(${COMPONENT}_INCLUDE_DIR
NAMES ${SUITESPARSE_FIND_${COMPONENT}_FILES}
HINTS ${SUITESPARSE_INCLUDE_DIR_HINTS}
PATHS ${SUITESPARSE_CHECK_INCLUDE_DIRS}
PATH_SUFFIXES ${SUITESPARSE_CHECK_PATH_SUFFIXES})
if (${COMPONENT}_INCLUDE_DIR)
message(STATUS "Found ${COMPONENT} headers in: "
"${${COMPONENT}_INCLUDE_DIR}")
mark_as_advanced(${COMPONENT}_INCLUDE_DIR)
else()
# Specified headers not found.
set(${COMPONENT}_FOUND FALSE)
if (SUITESPARSE_FIND_${COMPONENT}_REQUIRED)
suitesparse_report_not_found(
"Did not find ${COMPONENT} header (required SuiteSparse component).")
else()
message(STATUS "Did not find ${COMPONENT} header (optional "
"SuiteSparse component).")
# Hide optional vars from CMake GUI even if not found.
mark_as_advanced(${COMPONENT}_INCLUDE_DIR)
endif()
endif()
endif()
if (SUITESPARSE_FIND_${COMPONENT}_LIBRARIES)
find_library(${COMPONENT}_LIBRARY
NAMES ${SUITESPARSE_FIND_${COMPONENT}_LIBRARIES}
HINTS ${SUITESPARSE_LIBRARY_DIR_HINTS}
PATHS ${SUITESPARSE_CHECK_LIBRARY_DIRS}
PATH_SUFFIXES ${SUITESPARSE_CHECK_PATH_SUFFIXES})
if (${COMPONENT}_LIBRARY)
message(STATUS "Found ${COMPONENT} library: ${${COMPONENT}_LIBRARY}")
mark_as_advanced(${COMPONENT}_LIBRARY)
else ()
# Specified libraries not found.
set(${COMPONENT}_FOUND FALSE)
if (SUITESPARSE_FIND_${COMPONENT}_REQUIRED)
suitesparse_report_not_found(
"Did not find ${COMPONENT} library (required SuiteSparse component).")
else()
message(STATUS "Did not find ${COMPONENT} library (optional SuiteSparse "
"dependency)")
# Hide optional vars from CMake GUI even if not found.
mark_as_advanced(${COMPONENT}_LIBRARY)
endif()
endif()
endif()
endmacro()
# Given the number of components of SuiteSparse, and to ensure that the
# automatic failure message generated by FindPackageHandleStandardArgs()
# when not all required components are found is helpful, we maintain a list
# of all variables that must be defined for SuiteSparse to be considered found.
unset(SUITESPARSE_FOUND_REQUIRED_VARS)
# BLAS.
find_package(BLAS QUIET)
if (NOT BLAS_FOUND)
suitesparse_report_not_found(
"Did not find BLAS library (required for SuiteSparse).")
endif (NOT BLAS_FOUND)
list(APPEND SUITESPARSE_FOUND_REQUIRED_VARS BLAS_FOUND)
# LAPACK.
find_package(LAPACK QUIET)
if (NOT LAPACK_FOUND)
suitesparse_report_not_found(
"Did not find LAPACK library (required for SuiteSparse).")
endif (NOT LAPACK_FOUND)
list(APPEND SUITESPARSE_FOUND_REQUIRED_VARS LAPACK_FOUND)
suitesparse_find_component(AMD REQUIRED FILES amd.h LIBRARIES amd)
suitesparse_find_component(CAMD REQUIRED FILES camd.h LIBRARIES camd)
suitesparse_find_component(COLAMD REQUIRED FILES colamd.h LIBRARIES colamd)
suitesparse_find_component(CCOLAMD REQUIRED FILES ccolamd.h LIBRARIES ccolamd)
suitesparse_find_component(CHOLMOD REQUIRED FILES cholmod.h LIBRARIES cholmod)
suitesparse_find_component(
SUITESPARSEQR REQUIRED FILES SuiteSparseQR.hpp LIBRARIES spqr)
if (SUITESPARSEQR_FOUND)
# SuiteSparseQR may be compiled with Intel Threading Building Blocks,
# we assume that if TBB is installed, SuiteSparseQR was compiled with
# support for it, this will do no harm if it wasn't.
find_package(TBB QUIET)
if (TBB_FOUND)
message(STATUS "Found Intel Thread Building Blocks (TBB) library "
"(${TBB_VERSION}) assuming SuiteSparseQR was compiled "
"with TBB.")
# Add the TBB libraries to the SuiteSparseQR libraries (the only
# libraries to optionally depend on TBB).
list(APPEND SUITESPARSEQR_LIBRARY ${TBB_LIBRARIES})
else()
message(STATUS "Did not find Intel TBB library, assuming SuiteSparseQR was "
"not compiled with TBB.")
endif()
endif(SUITESPARSEQR_FOUND)
# UFconfig / SuiteSparse_config.
#
# If SuiteSparse version is >= 4 then SuiteSparse_config is required.
# For SuiteSparse 3, UFconfig.h is required.
suitesparse_find_component(
SUITESPARSE_CONFIG FILES SuiteSparse_config.h LIBRARIES suitesparseconfig)
if (SUITESPARSE_CONFIG_FOUND)
# SuiteSparse_config (SuiteSparse version >= 4) requires librt library for
# timing by default when compiled on Linux or Unix, but not on OSX (which
# does not have librt).
if (CMAKE_SYSTEM_NAME MATCHES "Linux" OR UNIX AND NOT APPLE)
suitesparse_find_component(LIBRT LIBRARIES rt)
if (LIBRT_FOUND)
message(STATUS "Adding librt: ${LIBRT_LIBRARY} to "
"SuiteSparse_config libraries (required on Linux & Unix [not OSX] if "
"SuiteSparse is compiled with timing).")
list(APPEND SUITESPARSE_CONFIG_LIBRARY ${LIBRT_LIBRARY})
else()
message(STATUS "Could not find librt, but found SuiteSparse_config, "
"assuming that SuiteSparse was compiled without timing.")
endif ()
endif (CMAKE_SYSTEM_NAME MATCHES "Linux" OR UNIX AND NOT APPLE)
else()
# Failed to find SuiteSparse_config (>= v4 installs), instead look for
# UFconfig header which should be present in < v4 installs.
suitesparse_find_component(UFCONFIG FILES UFconfig.h)
endif ()
if (NOT SUITESPARSE_CONFIG_FOUND AND
NOT UFCONFIG_FOUND)
suitesparse_report_not_found(
"Failed to find either: SuiteSparse_config header & library (should be "
"present in all SuiteSparse >= v4 installs), or UFconfig header (should "
"be present in all SuiteSparse < v4 installs).")
endif()
# Extract the SuiteSparse version from the appropriate header (UFconfig.h for
# <= v3, SuiteSparse_config.h for >= v4).
list(APPEND SUITESPARSE_FOUND_REQUIRED_VARS SUITESPARSE_VERSION)
if (UFCONFIG_FOUND)
# SuiteSparse version <= 3.
set(SUITESPARSE_VERSION_FILE ${UFCONFIG_INCLUDE_DIR}/UFconfig.h)
if (NOT EXISTS ${SUITESPARSE_VERSION_FILE})
suitesparse_report_not_found(
"Could not find file: ${SUITESPARSE_VERSION_FILE} containing version "
"information for <= v3 SuiteSparse installs, but UFconfig was found "
"(only present in <= v3 installs).")
else (NOT EXISTS ${SUITESPARSE_VERSION_FILE})
file(READ ${SUITESPARSE_VERSION_FILE} UFCONFIG_CONTENTS)
string(REGEX MATCH "#define SUITESPARSE_MAIN_VERSION [0-9]+"
SUITESPARSE_MAIN_VERSION "${UFCONFIG_CONTENTS}")
string(REGEX REPLACE "#define SUITESPARSE_MAIN_VERSION ([0-9]+)" "\\1"
SUITESPARSE_MAIN_VERSION "${SUITESPARSE_MAIN_VERSION}")
string(REGEX MATCH "#define SUITESPARSE_SUB_VERSION [0-9]+"
SUITESPARSE_SUB_VERSION "${UFCONFIG_CONTENTS}")
string(REGEX REPLACE "#define SUITESPARSE_SUB_VERSION ([0-9]+)" "\\1"
SUITESPARSE_SUB_VERSION "${SUITESPARSE_SUB_VERSION}")
string(REGEX MATCH "#define SUITESPARSE_SUBSUB_VERSION [0-9]+"
SUITESPARSE_SUBSUB_VERSION "${UFCONFIG_CONTENTS}")
string(REGEX REPLACE "#define SUITESPARSE_SUBSUB_VERSION ([0-9]+)" "\\1"
SUITESPARSE_SUBSUB_VERSION "${SUITESPARSE_SUBSUB_VERSION}")
# This is on a single line s/t CMake does not interpret it as a list of
# elements and insert ';' separators which would result in 4.;2.;1 nonsense.
set(SUITESPARSE_VERSION
"${SUITESPARSE_MAIN_VERSION}.${SUITESPARSE_SUB_VERSION}.${SUITESPARSE_SUBSUB_VERSION}")
endif (NOT EXISTS ${SUITESPARSE_VERSION_FILE})
endif (UFCONFIG_FOUND)
if (SUITESPARSE_CONFIG_FOUND)
# SuiteSparse version >= 4.
set(SUITESPARSE_VERSION_FILE
${SUITESPARSE_CONFIG_INCLUDE_DIR}/SuiteSparse_config.h)
if (NOT EXISTS ${SUITESPARSE_VERSION_FILE})
suitesparse_report_not_found(
"Could not find file: ${SUITESPARSE_VERSION_FILE} containing version "
"information for >= v4 SuiteSparse installs, but SuiteSparse_config was "
"found (only present in >= v4 installs).")
else (NOT EXISTS ${SUITESPARSE_VERSION_FILE})
file(READ ${SUITESPARSE_VERSION_FILE} SUITESPARSE_CONFIG_CONTENTS)
string(REGEX MATCH "#define SUITESPARSE_MAIN_VERSION [0-9]+"
SUITESPARSE_MAIN_VERSION "${SUITESPARSE_CONFIG_CONTENTS}")
string(REGEX REPLACE "#define SUITESPARSE_MAIN_VERSION ([0-9]+)" "\\1"
SUITESPARSE_MAIN_VERSION "${SUITESPARSE_MAIN_VERSION}")
string(REGEX MATCH "#define SUITESPARSE_SUB_VERSION [0-9]+"
SUITESPARSE_SUB_VERSION "${SUITESPARSE_CONFIG_CONTENTS}")
string(REGEX REPLACE "#define SUITESPARSE_SUB_VERSION ([0-9]+)" "\\1"
SUITESPARSE_SUB_VERSION "${SUITESPARSE_SUB_VERSION}")
string(REGEX MATCH "#define SUITESPARSE_SUBSUB_VERSION [0-9]+"
SUITESPARSE_SUBSUB_VERSION "${SUITESPARSE_CONFIG_CONTENTS}")
string(REGEX REPLACE "#define SUITESPARSE_SUBSUB_VERSION ([0-9]+)" "\\1"
SUITESPARSE_SUBSUB_VERSION "${SUITESPARSE_SUBSUB_VERSION}")
# This is on a single line s/t CMake does not interpret it as a list of
# elements and insert ';' separators which would result in 4.;2.;1 nonsense.
set(SUITESPARSE_VERSION
"${SUITESPARSE_MAIN_VERSION}.${SUITESPARSE_SUB_VERSION}.${SUITESPARSE_SUBSUB_VERSION}")
endif (NOT EXISTS ${SUITESPARSE_VERSION_FILE})
endif (SUITESPARSE_CONFIG_FOUND)
# METIS (Optional dependency).
suitesparse_find_component(METIS LIBRARIES metis)
# Only mark SuiteSparse as found if all required components and dependencies
# have been found.
set(SUITESPARSE_FOUND TRUE)
foreach(REQUIRED_VAR ${SUITESPARSE_FOUND_REQUIRED_VARS})
if (NOT ${REQUIRED_VAR})
set(SUITESPARSE_FOUND FALSE)
endif (NOT ${REQUIRED_VAR})
endforeach(REQUIRED_VAR ${SUITESPARSE_FOUND_REQUIRED_VARS})
if (SUITESPARSE_FOUND)
list(APPEND SUITESPARSE_INCLUDE_DIRS
${AMD_INCLUDE_DIR}
${CAMD_INCLUDE_DIR}
${COLAMD_INCLUDE_DIR}
${CCOLAMD_INCLUDE_DIR}
${CHOLMOD_INCLUDE_DIR}
${SUITESPARSEQR_INCLUDE_DIR})
# Handle config separately, as otherwise at least one of them will be set
# to NOTFOUND which would cause any check on SUITESPARSE_INCLUDE_DIRS to fail.
if (SUITESPARSE_CONFIG_FOUND)
list(APPEND SUITESPARSE_INCLUDE_DIRS
${SUITESPARSE_CONFIG_INCLUDE_DIR})
endif (SUITESPARSE_CONFIG_FOUND)
if (UFCONFIG_FOUND)
list(APPEND SUITESPARSE_INCLUDE_DIRS
${UFCONFIG_INCLUDE_DIR})
endif (UFCONFIG_FOUND)
# As SuiteSparse includes are often all in the same directory, remove any
# repetitions.
list(REMOVE_DUPLICATES SUITESPARSE_INCLUDE_DIRS)
# Important: The ordering of these libraries is *NOT* arbitrary, as these
# could potentially be static libraries their link ordering is important.
list(APPEND SUITESPARSE_LIBRARIES
${SUITESPARSEQR_LIBRARY}
${CHOLMOD_LIBRARY}
${CCOLAMD_LIBRARY}
${CAMD_LIBRARY}
${COLAMD_LIBRARY}
${AMD_LIBRARY}
${LAPACK_LIBRARIES}
${BLAS_LIBRARIES})
if (SUITESPARSE_CONFIG_FOUND)
list(APPEND SUITESPARSE_LIBRARIES
${SUITESPARSE_CONFIG_LIBRARY})
endif (SUITESPARSE_CONFIG_FOUND)
if (METIS_FOUND)
list(APPEND SUITESPARSE_LIBRARIES
${METIS_LIBRARY})
endif (METIS_FOUND)
endif()
# Determine if we are running on Ubuntu with the package install of SuiteSparse
# which is broken and does not support linking a shared library.
set(SUITESPARSE_IS_BROKEN_SHARED_LINKING_UBUNTU_SYSTEM_VERSION FALSE)
if (CMAKE_SYSTEM_NAME MATCHES "Linux" AND
SUITESPARSE_VERSION VERSION_EQUAL 3.4.0)
find_program(LSB_RELEASE_EXECUTABLE lsb_release)
if (LSB_RELEASE_EXECUTABLE)
# Any even moderately recent Ubuntu release (likely to be affected by
# this bug) should have lsb_release, if it isn't present we are likely
# on a different Linux distribution (should be fine).
execute_process(COMMAND ${LSB_RELEASE_EXECUTABLE} -si
OUTPUT_VARIABLE LSB_DISTRIBUTOR_ID
OUTPUT_STRIP_TRAILING_WHITESPACE)
if (LSB_DISTRIBUTOR_ID MATCHES "Ubuntu" AND
SUITESPARSE_LIBRARIES MATCHES "/usr/lib/libamd")
# We are on Ubuntu, and the SuiteSparse version matches the broken
# system install version and is a system install.
set(SUITESPARSE_IS_BROKEN_SHARED_LINKING_UBUNTU_SYSTEM_VERSION TRUE)
message(STATUS "Found system install of SuiteSparse "
"${SUITESPARSE_VERSION} running on Ubuntu, which has a known bug "
"preventing linking of shared libraries (static linking unaffected).")
endif (LSB_DISTRIBUTOR_ID MATCHES "Ubuntu" AND
SUITESPARSE_LIBRARIES MATCHES "/usr/lib/libamd")
endif (LSB_RELEASE_EXECUTABLE)
endif (CMAKE_SYSTEM_NAME MATCHES "Linux" AND
SUITESPARSE_VERSION VERSION_EQUAL 3.4.0)
suitesparse_reset_find_library_prefix()
# Handle REQUIRED and QUIET arguments to FIND_PACKAGE
include(FindPackageHandleStandardArgs)
if (SUITESPARSE_FOUND)
find_package_handle_standard_args(SuiteSparse
REQUIRED_VARS ${SUITESPARSE_FOUND_REQUIRED_VARS}
VERSION_VAR SUITESPARSE_VERSION
FAIL_MESSAGE "Failed to find some/all required components of SuiteSparse.")
else (SUITESPARSE_FOUND)
# Do not pass VERSION_VAR to FindPackageHandleStandardArgs() if we failed to
# find SuiteSparse to avoid a confusing autogenerated failure message
# that states 'not found (missing: FOO) (found version: x.y.z)'.
find_package_handle_standard_args(SuiteSparse
REQUIRED_VARS ${SUITESPARSE_FOUND_REQUIRED_VARS}
FAIL_MESSAGE "Failed to find some/all required components of SuiteSparse.")
endif (SUITESPARSE_FOUND)
================================================
FILE: 3rdparty/ceres/cmake/FindTBB.cmake
================================================
# The MIT License (MIT)
#
# Copyright (c) 2015 Justus Calvin
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in all
# copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
#
# FindTBB
# -------
#
# Find TBB include directories and libraries.
#
# Usage:
#
# find_package(TBB [major[.minor]] [EXACT]
# [QUIET] [REQUIRED]
# [[COMPONENTS] [components...]]
# [OPTIONAL_COMPONENTS components...])
#
# where the allowed components are tbbmalloc and tbb_preview. Users may modify
# the behavior of this module with the following variables:
#
# * TBB_ROOT_DIR - The base directory the of TBB installation.
# * TBB_INCLUDE_DIR - The directory that contains the TBB headers files.
# * TBB_LIBRARY - The directory that contains the TBB library files.
# * TBB_<library>_LIBRARY - The path of the TBB the corresponding TBB library.
# These libraries, if specified, override the
# corresponding library search results, where <library>
# may be tbb, tbb_debug, tbbmalloc, tbbmalloc_debug,
# tbb_preview, or tbb_preview_debug.
# * TBB_USE_DEBUG_BUILD - The debug version of tbb libraries, if present, will
# be used instead of the release version.
#
# Users may modify the behavior of this module with the following environment
# variables:
#
# * TBB_INSTALL_DIR
# * TBBROOT
# * LIBRARY_PATH
#
# This module will set the following variables:
#
# * TBB_FOUND - Set to false, or undefined, if we haven’t found, or
# don’t want to use TBB.
# * TBB_<component>_FOUND - If False, optional <component> part of TBB sytem is
# not available.
# * TBB_VERSION - The full version string
# * TBB_VERSION_MAJOR - The major version
# * TBB_VERSION_MINOR - The minor version
# * TBB_INTERFACE_VERSION - The interface version number defined in
# tbb/tbb_stddef.h.
# * TBB_<library>_LIBRARY_RELEASE - The path of the TBB release version of
# <library>, where <library> may be tbb, tbb_debug,
# tbbmalloc, tbbmalloc_debug, tbb_preview, or
# tbb_preview_debug.
# * TBB_<library>_LIBRARY_DEGUG - The path of the TBB release version of
# <library>, where <library> may be tbb, tbb_debug,
# tbbmalloc, tbbmalloc_debug, tbb_preview, or
# tbb_preview_debug.
#
# The following varibles should be used to build and link with TBB:
#
# * TBB_INCLUDE_DIRS - The include directory for TBB.
# * TBB_LIBRARIES - The libraries to link against to use TBB.
# * TBB_DEFINITIONS - Definitions to use when compiling code that uses TBB.
include(FindPackageHandleStandardArgs)
if(NOT TBB_FOUND)
##################################
# Check the build type
##################################
if(NOT DEFINED TBB_USE_DEBUG_BUILD)
if(CMAKE_BUILD_TYPE MATCHES "(Debug|DEBUG|debug|RelWithDebInfo|RELWITHDEBINFO|relwithdebinfo)")
set(TBB_USE_DEBUG_BUILD TRUE)
else()
set(TBB_USE_DEBUG_BUILD FALSE)
endif()
endif()
##################################
# Set the TBB search directories
##################################
# Define search paths based on user input and environment variables
set(TBB_SEARCH_DIR ${TBB_ROOT_DIR} $ENV{TBB_INSTALL_DIR} $ENV{TBBROOT})
# Define the search directories based on the current platform
if(CMAKE_SYSTEM_NAME STREQUAL "Windows")
set(TBB_DEFAULT_SEARCH_DIR "C:/Program Files/Intel/TBB"
"C:/Program Files (x86)/Intel/TBB")
# Set the target architecture
if(CMAKE_SIZEOF_VOID_P EQUAL 8)
set(TBB_ARCHITECTURE "intel64")
else()
set(TBB_ARCHITECTURE "ia32")
endif()
# Set the TBB search library path search suffix based on the version of VC
if(WINDOWS_STORE)
set(TBB_LIB_PATH_SUFFIX "lib/${TBB_ARCHITECTURE}/vc11_ui")
elseif(MSVC14)
set(TBB_LIB_PATH_SUFFIX "lib/${TBB_ARCHITECTURE}/vc14")
elseif(MSVC12)
set(TBB_LIB_PATH_SUFFIX "lib/${TBB_ARCHITECTURE}/vc12")
elseif(MSVC11)
set(TBB_LIB_PATH_SUFFIX "lib/${TBB_ARCHITECTURE}/vc11")
elseif(MSVC10)
set(TBB_LIB_PATH_SUFFIX "lib/${TBB_ARCHITECTURE}/vc10")
endif()
# Add the library path search suffix for the VC independent version of TBB
list(APPEND TBB_LIB_PATH_SUFFIX "lib/${TBB_ARCHITECTURE}/vc_mt")
elseif(CMAKE_SYSTEM_NAME STREQUAL "Darwin")
# OS X
set(TBB_DEFAULT_SEARCH_DIR "/opt/intel/tbb")
# TODO: Check to see which C++ library is being used by the compiler.
if(NOT ${CMAKE_SYSTEM_VERSION} VERSION_LESS 13.0)
# The default C++ library on OS X 10.9 and later is libc++
set(TBB_LIB_PATH_SUFFIX "lib/libc++")
else()
set(TBB_LIB_PATH_SUFFIX "lib")
endif()
elseif(CMAKE_SYSTEM_NAME STREQUAL "Linux")
# Linux
set(TBB_DEFAULT_SEARCH_DIR "/opt/intel/tbb")
# TODO: Check compiler version to see the suffix should be <arch>/gcc4.1 or
# <arch>/gcc4.1. For now, assume that the compiler is more recent than
# gcc 4.4.x or later.
if(CMAKE_SYSTEM_PROCESSOR STREQUAL "x86_64")
set(TBB_LIB_PATH_SUFFIX "lib/intel64/gcc4.4")
elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "^i.86$")
set(TBB_LIB_PATH_SUFFIX "lib/ia32/gcc4.4")
endif()
endif()
##################################
# Find the TBB include dir
##################################
find_path(TBB_INCLUDE_DIRS tbb/tbb.h
HINTS ${TBB_INCLUDE_DIR} ${TBB_SEARCH_DIR}
PATHS ${TBB_DEFAULT_SEARCH_DIR}
PATH_SUFFIXES include)
##################################
# Find TBB components
##################################
# Find each component
foreach(_comp tbb_preview tbbmalloc tbb)
# Search for the libraries
find_library(TBB_${_comp}_LIBRARY_RELEASE ${_comp}
HINTS ${TBB_LIBRARY} ${TBB_SEARCH_DIR}
PATHS ${TBB_DEFAULT_SEARCH_DIR}
PATH_SUFFIXES ${TBB_LIB_PATH_SUFFIX})
find_library(TBB_${_comp}_LIBRARY_DEBUG ${_comp}_debug
HINTS ${TBB_LIBRARY} ${TBB_SEARCH_DIR}
PATHS ${TBB_DEFAULT_SEARCH_DIR} ENV LIBRARY_PATH
PATH_SUFFIXES ${TBB_LIB_PATH_SUFFIX})
# Set the library to be used for the component
if(NOT TBB_${_comp}_LIBRARY)
if(TBB_USE_DEBUG_BUILD AND TBB_${_comp}_LIBRARY_DEBUG)
set(TBB_${_comp}_LIBRARY "${TBB_${_comp}_LIBRARY_DEBUG}")
elseif(TBB_${_comp}_LIBRARY_RELEASE)
set(TBB_${_comp}_LIBRARY "${TBB_${_comp}_LIBRARY_RELEASE}")
elseif(TBB_${_comp}_LIBRARY_DEBUG)
set(TBB_${_comp}_LIBRARY "${TBB_${_comp}_LIBRARY_DEBUG}")
endif()
endif()
# Set the TBB library list and component found variables
if(TBB_${_comp}_LIBRARY)
list(APPEND TBB_LIBRARIES "${TBB_${_comp}_LIBRARY}")
set(TBB_${_comp}_FOUND TRUE)
else()
set(TBB_${_comp}_FOUND FALSE)
endif()
mark_as_advanced(TBB_${_comp}_LIBRARY_RELEASE)
mark_as_advanced(TBB_${_comp}_LIBRARY_DEBUG)
mark_as_advanced(TBB_${_comp}_LIBRARY)
endforeach()
##################################
# Set compile flags
##################################
if(TBB_tbb_LIBRARY MATCHES "debug")
set(TBB_DEFINITIONS "-DTBB_USE_DEBUG=1")
endif()
##################################
# Set version strings
##################################
if(TBB_INCLUDE_DIRS)
file(READ "${TBB_INCLUDE_DIRS}/tbb/tbb_stddef.h" _tbb_version_file)
string(REGEX REPLACE ".*#define TBB_VERSION_MAJOR ([0-9]+).*" "\\1"
TBB_VERSION_MAJOR "${_tbb_version_file}")
string(REGEX REPLACE ".*#define TBB_VERSION_MINOR ([0-9]+).*" "\\1"
TBB_VERSION_MINOR "${_tbb_version_file}")
string(REGEX REPLACE ".*#define TBB_INTERFACE_VERSION ([0-9]+).*" "\\1"
TBB_INTERFACE_VERSION "${_tbb_version_file}")
set(TBB_VERSION "${TBB_VERSION_MAJOR}.${TBB_VERSION_MINOR}")
endif()
find_package_handle_standard_args(TBB
REQUIRED_VARS TBB_INCLUDE_DIRS TBB_LIBRARIES
HANDLE_COMPONENTS
VERSION_VAR TBB_VERSION)
mark_as_advanced(TBB_INCLUDE_DIRS TBB_LIBRARIES)
unset(TBB_ARCHITECTURE)
unset(TBB_LIB_PATH_SUFFIX)
unset(TBB_DEFAULT_SEARCH_DIR)
endif()
================================================
FILE: 3rdparty/ceres/cmake/PrettyPrintCMakeList.cmake
================================================
# Ceres Solver - A fast non-linear least squares minimizer
# Copyright 2018 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.
#
# Authors: alexs.mac@gmail.com (Alex Stewart)
# pretty_print_cmake_list( OUTPUT_VAR [item1 [item2 ... ]] )
#
# Sets ${OUTPUT_VAR} in the caller's scope to a human-readable string
# representation of the list passed as the remaining arguments formed
# as: "[item1, item2, ..., itemN]".
function(pretty_print_cmake_list OUTPUT_VAR)
string(REPLACE ";" ", " PRETTY_LIST_STRING "[${ARGN}]")
set(${OUTPUT_VAR} "${PRETTY_LIST_STRING}" PARENT_SCOPE)
endfunction()
================================================
FILE: 3rdparty/ceres/cmake/ReadCeresVersionFromSource.cmake
================================================
# 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: alexs.mac@gmail.com (Alex Stewart)
#
# Extract Ceres version from <CERES_SOURCE_ROOT>/include/ceres/version.h
# so that we only have a single definition of the Ceres version, not two
# one in the source and one in the CMakeLists.txt.
macro(read_ceres_version_from_source CERES_SOURCE_ROOT)
set(CERES_VERSION_FILE ${CERES_SOURCE_ROOT}/include/ceres/version.h)
if (NOT EXISTS ${CERES_VERSION_FILE})
message(FATAL_ERROR "Cannot find Ceres version.h file in specified "
"Ceres source directory: ${CERES_SOURCE_ROOT}, it is not here: "
"${CERES_VERSION_FILE}")
endif()
file(READ ${CERES_VERSION_FILE} CERES_VERSION_FILE_CONTENTS)
string(REGEX MATCH "#define CERES_VERSION_MAJOR [0-9]+"
CERES_VERSION_MAJOR "${CERES_VERSION_FILE_CONTENTS}")
string(REGEX REPLACE "#define CERES_VERSION_MAJOR ([0-9]+)" "\\1"
CERES_VERSION_MAJOR "${CERES_VERSION_MAJOR}")
# NOTE: if (VAR) is FALSE if VAR is numeric and <= 0, as such we cannot use
# it for testing version numbers, which might well be zero, at least
# for the patch version, hence check for empty string explicitly.
if ("${CERES_VERSION_MAJOR}" STREQUAL "")
message(FATAL_ERROR "Failed to extract Ceres major version from "
"${CERES_VERSION_FILE}")
endif()
string(REGEX MATCH "#define CERES_VERSION_MINOR [0-9]+"
CERES_VERSION_MINOR "${CERES_VERSION_FILE_CONTENTS}")
string(REGEX REPLACE "#define CERES_VERSION_MINOR ([0-9]+)" "\\1"
CERES_VERSION_MINOR "${CERES_VERSION_MINOR}")
if ("${CERES_VERSION_MINOR}" STREQUAL "")
message(FATAL_ERROR "Failed to extract Ceres minor version from "
"${CERES_VERSION_FILE}")
endif()
string(REGEX MATCH "#define CERES_VERSION_REVISION [0-9]+"
CERES_VERSION_PATCH "${CERES_VERSION_FILE_CONTENTS}")
string(REGEX REPLACE "#define CERES_VERSION_REVISION ([0-9]+)" "\\1"
CERES_VERSION_PATCH "${CERES_VERSION_PATCH}")
if ("${CERES_VERSION_PATCH}" STREQUAL "")
message(FATAL_ERROR "Failed to extract Ceres patch version from "
"${CERES_VERSION_FILE}")
endif()
# This is on a single line s/t CMake does not interpret it as a list of
# elements and insert ';' separators which would result in 3.;2.;0 nonsense.
set(CERES_VERSION "${CERES_VERSION_MAJOR}.${CERES_VERSION_MINOR}.${CERES_VERSION_PATCH}")
message(STATUS "Detected Ceres version: ${CERES_VERSION} from "
"${CERES_VERSION_FILE}")
endmacro()
================================================
FILE: 3rdparty/ceres/cmake/UpdateCacheVariable.cmake
================================================
# 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: alexs.mac@gmail.com (Alex Stewart)
# By default, there is no easy way in CMake to set the value of a cache
# variable without reinitialising it, which involves resetting its
# associated help string. This is particularly annoying for CMake options
# where they need to programmatically updated.
#
# This function automates this process by getting the current help string
# for the cache variable to update, then reinitialising it with the new
# value, but with the original help string.
function(UPDATE_CACHE_VARIABLE VAR_NAME VALUE)
get_property(IS_DEFINED_IN_CACHE CACHE ${VAR_NAME} PROPERTY VALUE SET)
if (NOT IS_DEFINED_IN_CACHE)
message(FATAL_ERROR "Specified variable to update in cache: "
"${VAR_NAME} has not been set in the cache.")
endif()
get_property(HELP_STRING CACHE ${VAR_NAME} PROPERTY HELPSTRING)
get_property(VAR_TYPE CACHE ${VAR_NAME} PROPERTY TYPE)
set(${VAR_NAME} ${VALUE} CACHE ${VAR_TYPE} "${HELP_STRING}" FORCE)
endfunction()
================================================
FILE: 3rdparty/ceres/cmake/config.h.in
================================================
// 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: alexs.mac@gmail.com (Alex Stewart)
// Configuration options for Ceres.
//
// Do not edit this file, it was automatically configured by CMake when
// Ceres was compiled with the relevant configuration for the machine
// on which Ceres was compiled.
//
// Ceres Developers: All options should have the same name as their mapped
// CMake options, in the preconfigured version of this file
// all options should be enclosed in '@'.
#ifndef CERES_PUBLIC_INTERNAL_CONFIG_H_
#define CERES_PUBLIC_INTERNAL_CONFIG_H_
// If defined, use the LGPL code in Eigen.
@CERES_USE_EIGEN_SPARSE@
// If defined, Ceres was compiled without LAPACK.
@CERES_NO_LAPACK@
// If defined, Ceres was compiled without SuiteSparse.
@CERES_NO_SUITESPARSE@
// If defined, Ceres was compiled without CXSparse.
@CERES_NO_CXSPARSE@
// If defined, Ceres was compiled without Apple's Accelerate framework solvers.
@CERES_NO_ACCELERATE_SPARSE@
#if defined(CERES_NO_SUITESPARSE) && \
defined(CERES_NO_ACCELERATE_SPARSE) && \
defined(CERES_NO_CXSPARSE) && \
!defined(CERES_USE_EIGEN_SPARSE) // NOLINT
// If defined Ceres was compiled without any sparse linear algebra support.
#define CERES_NO_SPARSE
#endif
// If defined, Ceres was compiled without Schur specializations.
@CERES_RESTRICT_SCHUR_SPECIALIZATION@
// If defined, Ceres was compiled to use Eigen instead of hardcoded BLAS
// routines.
@CERES_NO_CUSTOM_BLAS@
// If defined, Ceres was compiled without multithreading support.
@CERES_NO_THREADS@
// If defined Ceres was compiled with OpenMP multithreading support.
@CERES_USE_OPENMP@
// If defined Ceres was compiled with C++11 thread support.
@CERES_USE_CXX11_THREADS@
// If defined, Ceres was built as a shared library.
@CERES_USING_SHARED_LIBRARY@
// If defined, Ceres was compiled with a version MSVC >= 2005 which
// deprecated the standard POSIX names for bessel functions, replacing them
// with underscore prefixed versions (e.g. j0() -> _j0()).
@CERES_MSVC_USE_UNDERSCORE_PREFIXED_BESSEL_FUNCTIONS@
#endif // CERES_PUBLIC_INTERNAL_CONFIG_H_
================================================
FILE: 3rdparty/ceres/cmake/iOS.cmake
================================================
# This file is part of the ios-cmake project. It was retrieved from
# https://github.com/cristeab/ios-cmake.git, which is a fork of
# https://code.google.com/p/ios-cmake/. Which in turn is based off of
# the Platform/Darwin.cmake and Platform/UnixPaths.cmake files which
# are included with CMake 2.8.4
#
# The ios-cmake project is licensed under the new BSD license.
#
# Copyright (c) 2014, Bogdan Cristea and LTE Engineering Software,
# Kitware, Inc., Insight Software Consortium. All rights reserved.
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
# 1. Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
#
# 2. 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.
#
# 3. Neither the name of the copyright holder nor the names of its
# contributors may be used to endorse or promote products derived from
# this software wi
gitextract_9m3jpr9e/
├── .gitignore
├── 3rdparty/
│ ├── CMakeLists.txt
│ ├── ceres/
│ │ ├── .clang-format
│ │ ├── .travis.yml
│ │ ├── BUILD
│ │ ├── CMakeLists.txt
│ │ ├── CONTRIBUTING.md
│ │ ├── LICENSE
│ │ ├── README.md
│ │ ├── WORKSPACE
│ │ ├── bazel/
│ │ │ └── ceres.bzl
│ │ ├── cmake/
│ │ │ ├── AddCompileFlagsIfSupported.cmake
│ │ │ ├── AddGerritCommitHook.cmake
│ │ │ ├── AppendTargetProperty.cmake
│ │ │ ├── CeresCompileOptionsToComponents.cmake
│ │ │ ├── CeresConfig.cmake.in
│ │ │ ├── CeresThreadingModels.cmake
│ │ │ ├── CheckIfUnderscorePrefixedBesselFunctionsExist.cmake
│ │ │ ├── CreateCeresConfig.cmake
│ │ │ ├── DetectBrokenStackCheckMacOSXcodePairing.cmake
│ │ │ ├── EnableSanitizer.cmake
│ │ │ ├── FindAccelerateSparse.cmake
│ │ │ ├── FindCXSparse.cmake
│ │ │ ├── FindGlog.cmake
│ │ │ ├── FindSphinx.cmake
│ │ │ ├── FindSuiteSparse.cmake
│ │ │ ├── FindTBB.cmake
│ │ │ ├── PrettyPrintCMakeList.cmake
│ │ │ ├── ReadCeresVersionFromSource.cmake
│ │ │ ├── UpdateCacheVariable.cmake
│ │ │ ├── config.h.in
│ │ │ ├── iOS.cmake
│ │ │ └── uninstall.cmake.in
│ │ ├── config/
│ │ │ └── ceres/
│ │ │ └── internal/
│ │ │ └── config.h
│ │ ├── data/
│ │ │ ├── 2x2.foe
│ │ │ ├── 3x3.foe
│ │ │ ├── 5x5.foe
│ │ │ ├── README.foe
│ │ │ ├── ceres_noisy.pgm
│ │ │ ├── libmv-ba-problems/
│ │ │ │ └── Readme.txt
│ │ │ └── problem-16-22106-pre.txt
│ │ ├── docs/
│ │ │ ├── CMakeLists.txt
│ │ │ └── source/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── _templates/
│ │ │ │ └── layout.html
│ │ │ ├── analytical_derivatives.rst
│ │ │ ├── automatic_derivatives.rst
│ │ │ ├── bibliography.rst
│ │ │ ├── conf.py
│ │ │ ├── contributing.rst
│ │ │ ├── derivatives.rst
│ │ │ ├── faqs.rst
│ │ │ ├── features.rst
│ │ │ ├── gradient_solver.rst
│ │ │ ├── gradient_tutorial.rst
│ │ │ ├── index.rst
│ │ │ ├── installation.rst
│ │ │ ├── interfacing_with_autodiff.rst
│ │ │ ├── license.rst
│ │ │ ├── modeling_faqs.rst
│ │ │ ├── nnls_covariance.rst
│ │ │ ├── nnls_modeling.rst
│ │ │ ├── nnls_solving.rst
│ │ │ ├── nnls_tutorial.rst
│ │ │ ├── numerical_derivatives.rst
│ │ │ ├── solving_faqs.rst
│ │ │ ├── spivak_notation.rst
│ │ │ ├── tutorial.rst
│ │ │ ├── users.rst
│ │ │ └── version_history.rst
│ │ ├── include/
│ │ │ └── ceres/
│ │ │ ├── autodiff_cost_function.h
│ │ │ ├── autodiff_first_order_function.h
│ │ │ ├── autodiff_local_parameterization.h
│ │ │ ├── c_api.h
│ │ │ ├── ceres.h
│ │ │ ├── conditioned_cost_function.h
│ │ │ ├── context.h
│ │ │ ├── cost_function.h
│ │ │ ├── cost_function_to_functor.h
│ │ │ ├── covariance.h
│ │ │ ├── crs_matrix.h
│ │ │ ├── cubic_interpolation.h
│ │ │ ├── dynamic_autodiff_cost_function.h
│ │ │ ├── dynamic_cost_function.h
│ │ │ ├── dynamic_cost_function_to_functor.h
│ │ │ ├── dynamic_numeric_diff_cost_function.h
│ │ │ ├── evaluation_callback.h
│ │ │ ├── first_order_function.h
│ │ │ ├── gradient_checker.h
│ │ │ ├── gradient_problem.h
│ │ │ ├── gradient_problem_solver.h
│ │ │ ├── internal/
│ │ │ │ ├── algorithm.h
│ │ │ │ ├── array_selector.h
│ │ │ │ ├── autodiff.h
│ │ │ │ ├── config.h
│ │ │ │ ├── disable_warnings.h
│ │ │ │ ├── eigen.h
│ │ │ │ ├── fixed_array.h
│ │ │ │ ├── householder_vector.h
│ │ │ │ ├── integer_sequence.h
│ │ │ │ ├── integer_sequence_algorithm.h
│ │ │ │ ├── line_parameterization.h
│ │ │ │ ├── memory.h
│ │ │ │ ├── numeric_diff.h
│ │ │ │ ├── parameter_dims.h
│ │ │ │ ├── port.h
│ │ │ │ ├── reenable_warnings.h
│ │ │ │ └── variadic_evaluate.h
│ │ │ ├── iteration_callback.h
│ │ │ ├── jet.h
│ │ │ ├── local_parameterization.h
│ │ │ ├── loss_function.h
│ │ │ ├── normal_prior.h
│ │ │ ├── numeric_diff_cost_function.h
│ │ │ ├── numeric_diff_options.h
│ │ │ ├── ordered_groups.h
│ │ │ ├── problem.h
│ │ │ ├── rotation.h
│ │ │ ├── sized_cost_function.h
│ │ │ ├── solver.h
│ │ │ ├── tiny_solver.h
│ │ │ ├── tiny_solver_autodiff_function.h
│ │ │ ├── tiny_solver_cost_function_adapter.h
│ │ │ ├── types.h
│ │ │ └── version.h
│ │ ├── internal/
│ │ │ └── ceres/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── accelerate_sparse.cc
│ │ │ ├── accelerate_sparse.h
│ │ │ ├── algorithm_test.cc
│ │ │ ├── array_selector_test.cc
│ │ │ ├── array_utils.cc
│ │ │ ├── array_utils.h
│ │ │ ├── array_utils_test.cc
│ │ │ ├── autodiff_benchmarks/
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── autodiff_benchmarks.cc
│ │ │ │ ├── brdf_cost_function.h
│ │ │ │ ├── constant_cost_function.h
│ │ │ │ ├── linear_cost_functions.h
│ │ │ │ ├── photometric_error.h
│ │ │ │ ├── relative_pose_error.h
│ │ │ │ └── snavely_reprojection_error.h
│ │ │ ├── autodiff_cost_function_test.cc
│ │ │ ├── autodiff_first_order_function_test.cc
│ │ │ ├── autodiff_local_parameterization_test.cc
│ │ │ ├── autodiff_test.cc
│ │ │ ├── benchmarks/
│ │ │ │ ├── macbook-pro-2014-small_blas_gemm_benchmark.json
│ │ │ │ └── macbook-pro-2014-small_blas_gemv_benchmark.json
│ │ │ ├── blas.cc
│ │ │ ├── blas.h
│ │ │ ├── block_evaluate_preparer.cc
│ │ │ ├── block_evaluate_preparer.h
│ │ │ ├── block_jacobi_preconditioner.cc
│ │ │ ├── block_jacobi_preconditioner.h
│ │ │ ├── block_jacobi_preconditioner_test.cc
│ │ │ ├── block_jacobian_writer.cc
│ │ │ ├── block_jacobian_writer.h
│ │ │ ├── block_random_access_dense_matrix.cc
│ │ │ ├── block_random_access_dense_matrix.h
│ │ │ ├── block_random_access_dense_matrix_test.cc
│ │ │ ├── block_random_access_diagonal_matrix.cc
│ │ │ ├── block_random_access_diagonal_matrix.h
│ │ │ ├── block_random_access_diagonal_matrix_test.cc
│ │ │ ├── block_random_access_matrix.cc
│ │ │ ├── block_random_access_matrix.h
│ │ │ ├── block_random_access_sparse_matrix.cc
│ │ │ ├── block_random_access_sparse_matrix.h
│ │ │ ├── block_random_access_sparse_matrix_test.cc
│ │ │ ├── block_sparse_matrix.cc
│ │ │ ├── block_sparse_matrix.h
│ │ │ ├── block_sparse_matrix_test.cc
│ │ │ ├── block_structure.cc
│ │ │ ├── block_structure.h
│ │ │ ├── bundle_adjustment_test_util.h
│ │ │ ├── c_api.cc
│ │ │ ├── c_api_test.cc
│ │ │ ├── callbacks.cc
│ │ │ ├── callbacks.h
│ │ │ ├── canonical_views_clustering.cc
│ │ │ ├── canonical_views_clustering.h
│ │ │ ├── canonical_views_clustering_test.cc
│ │ │ ├── casts.h
│ │ │ ├── cgnr_linear_operator.h
│ │ │ ├── cgnr_solver.cc
│ │ │ ├── cgnr_solver.h
│ │ │ ├── compressed_col_sparse_matrix_utils.cc
│ │ │ ├── compressed_col_sparse_matrix_utils.h
│ │ │ ├── compressed_col_sparse_matrix_utils_test.cc
│ │ │ ├── compressed_row_jacobian_writer.cc
│ │ │ ├── compressed_row_jacobian_writer.h
│ │ │ ├── compressed_row_sparse_matrix.cc
│ │ │ ├── compressed_row_sparse_matrix.h
│ │ │ ├── compressed_row_sparse_matrix_test.cc
│ │ │ ├── concurrent_queue.h
│ │ │ ├── concurrent_queue_test.cc
│ │ │ ├── conditioned_cost_function.cc
│ │ │ ├── conditioned_cost_function_test.cc
│ │ │ ├── conjugate_gradients_solver.cc
│ │ │ ├── conjugate_gradients_solver.h
│ │ │ ├── conjugate_gradients_solver_test.cc
│ │ │ ├── context.cc
│ │ │ ├── context_impl.cc
│ │ │ ├── context_impl.h
│ │ │ ├── coordinate_descent_minimizer.cc
│ │ │ ├── coordinate_descent_minimizer.h
│ │ │ ├── corrector.cc
│ │ │ ├── corrector.h
│ │ │ ├── corrector_test.cc
│ │ │ ├── cost_function_to_functor_test.cc
│ │ │ ├── covariance.cc
│ │ │ ├── covariance_impl.cc
│ │ │ ├── covariance_impl.h
│ │ │ ├── covariance_test.cc
│ │ │ ├── cubic_interpolation_test.cc
│ │ │ ├── cxsparse.cc
│ │ │ ├── cxsparse.h
│ │ │ ├── dense_jacobian_writer.h
│ │ │ ├── dense_linear_solver_test.cc
│ │ │ ├── dense_normal_cholesky_solver.cc
│ │ │ ├── dense_normal_cholesky_solver.h
│ │ │ ├── dense_qr_solver.cc
│ │ │ ├── dense_qr_solver.h
│ │ │ ├── dense_sparse_matrix.cc
│ │ │ ├── dense_sparse_matrix.h
│ │ │ ├── dense_sparse_matrix_test.cc
│ │ │ ├── detect_structure.cc
│ │ │ ├── detect_structure.h
│ │ │ ├── detect_structure_test.cc
│ │ │ ├── dogleg_strategy.cc
│ │ │ ├── dogleg_strategy.h
│ │ │ ├── dogleg_strategy_test.cc
│ │ │ ├── dynamic_autodiff_cost_function_test.cc
│ │ │ ├── dynamic_compressed_row_finalizer.h
│ │ │ ├── dynamic_compressed_row_jacobian_writer.cc
│ │ │ ├── dynamic_compressed_row_jacobian_writer.h
│ │ │ ├── dynamic_compressed_row_sparse_matrix.cc
│ │ │ ├── dynamic_compressed_row_sparse_matrix.h
│ │ │ ├── dynamic_compressed_row_sparse_matrix_test.cc
│ │ │ ├── dynamic_numeric_diff_cost_function_test.cc
│ │ │ ├── dynamic_sparse_normal_cholesky_solver.cc
│ │ │ ├── dynamic_sparse_normal_cholesky_solver.h
│ │ │ ├── dynamic_sparse_normal_cholesky_solver_test.cc
│ │ │ ├── dynamic_sparsity_test.cc
│ │ │ ├── eigensparse.cc
│ │ │ ├── eigensparse.h
│ │ │ ├── evaluation_callback_test.cc
│ │ │ ├── evaluator.cc
│ │ │ ├── evaluator.h
│ │ │ ├── evaluator_test.cc
│ │ │ ├── evaluator_test_utils.cc
│ │ │ ├── evaluator_test_utils.h
│ │ │ ├── execution_summary.h
│ │ │ ├── file.cc
│ │ │ ├── file.h
│ │ │ ├── fixed_array_test.cc
│ │ │ ├── float_cxsparse.cc
│ │ │ ├── float_cxsparse.h
│ │ │ ├── float_suitesparse.cc
│ │ │ ├── float_suitesparse.h
│ │ │ ├── function_sample.cc
│ │ │ ├── function_sample.h
│ │ │ ├── generate_bundle_adjustment_tests.py
│ │ │ ├── generate_template_specializations.py
│ │ │ ├── generated/
│ │ │ │ ├── partitioned_matrix_view_2_2_2.cc
│ │ │ │ ├── partitioned_matrix_view_2_2_3.cc
│ │ │ │ ├── partitioned_matrix_view_2_2_4.cc
│ │ │ │ ├── partitioned_matrix_view_2_2_d.cc
│ │ │ │ ├── partitioned_matrix_view_2_3_3.cc
│ │ │ │ ├── partitioned_matrix_view_2_3_4.cc
│ │ │ │ ├── partitioned_matrix_view_2_3_6.cc
│ │ │ │ ├── partitioned_matrix_view_2_3_9.cc
│ │ │ │ ├── partitioned_matrix_view_2_3_d.cc
│ │ │ │ ├── partitioned_matrix_view_2_4_3.cc
│ │ │ │ ├── partitioned_matrix_view_2_4_4.cc
│ │ │ │ ├── partitioned_matrix_view_2_4_6.cc
│ │ │ │ ├── partitioned_matrix_view_2_4_8.cc
│ │ │ │ ├── partitioned_matrix_view_2_4_9.cc
│ │ │ │ ├── partitioned_matrix_view_2_4_d.cc
│ │ │ │ ├── partitioned_matrix_view_2_d_d.cc
│ │ │ │ ├── partitioned_matrix_view_3_3_3.cc
│ │ │ │ ├── partitioned_matrix_view_4_4_2.cc
│ │ │ │ ├── partitioned_matrix_view_4_4_3.cc
│ │ │ │ ├── partitioned_matrix_view_4_4_4.cc
│ │ │ │ ├── partitioned_matrix_view_4_4_d.cc
│ │ │ │ ├── partitioned_matrix_view_d_d_d.cc
│ │ │ │ ├── schur_eliminator_2_2_2.cc
│ │ │ │ ├── schur_eliminator_2_2_3.cc
│ │ │ │ ├── schur_eliminator_2_2_4.cc
│ │ │ │ ├── schur_eliminator_2_2_d.cc
│ │ │ │ ├── schur_eliminator_2_3_3.cc
│ │ │ │ ├── schur_eliminator_2_3_4.cc
│ │ │ │ ├── schur_eliminator_2_3_6.cc
│ │ │ │ ├── schur_eliminator_2_3_9.cc
│ │ │ │ ├── schur_eliminator_2_3_d.cc
│ │ │ │ ├── schur_eliminator_2_4_3.cc
│ │ │ │ ├── schur_eliminator_2_4_4.cc
│ │ │ │ ├── schur_eliminator_2_4_6.cc
│ │ │ │ ├── schur_eliminator_2_4_8.cc
│ │ │ │ ├── schur_eliminator_2_4_9.cc
│ │ │ │ ├── schur_eliminator_2_4_d.cc
│ │ │ │ ├── schur_eliminator_2_d_d.cc
│ │ │ │ ├── schur_eliminator_3_3_3.cc
│ │ │ │ ├── schur_eliminator_4_4_2.cc
│ │ │ │ ├── schur_eliminator_4_4_3.cc
│ │ │ │ ├── schur_eliminator_4_4_4.cc
│ │ │ │ ├── schur_eliminator_4_4_d.cc
│ │ │ │ └── schur_eliminator_d_d_d.cc
│ │ │ ├── generated_bundle_adjustment_tests/
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── ba_denseschur_auto_test.cc
│ │ │ │ ├── ba_denseschur_auto_threads_test.cc
│ │ │ │ ├── ba_denseschur_user_test.cc
│ │ │ │ ├── ba_denseschur_user_threads_test.cc
│ │ │ │ ├── ba_iterschur_acceleratesparse_clustjacobi_auto_test.cc
│ │ │ │ ├── ba_iterschur_acceleratesparse_clustjacobi_auto_threads_test.cc
│ │ │ │ ├── ba_iterschur_acceleratesparse_clustjacobi_user_test.cc
│ │ │ │ ├── ba_iterschur_acceleratesparse_clustjacobi_user_threads_test.cc
│ │ │ │ ├── ba_iterschur_acceleratesparse_clusttri_auto_test.cc
│ │ │ │ ├── ba_iterschur_acceleratesparse_clusttri_auto_threads_test.cc
│ │ │ │ ├── ba_iterschur_acceleratesparse_clusttri_user_test.cc
│ │ │ │ ├── ba_iterschur_acceleratesparse_clusttri_user_threads_test.cc
│ │ │ │ ├── ba_iterschur_cxsparse_clustjacobi_auto_test.cc
│ │ │ │ ├── ba_iterschur_cxsparse_clustjacobi_auto_threads_test.cc
│ │ │ │ ├── ba_iterschur_cxsparse_clustjacobi_user_test.cc
│ │ │ │ ├── ba_iterschur_cxsparse_clustjacobi_user_threads_test.cc
│ │ │ │ ├── ba_iterschur_cxsparse_clusttri_auto_test.cc
│ │ │ │ ├── ba_iterschur_cxsparse_clusttri_auto_threads_test.cc
│ │ │ │ ├── ba_iterschur_cxsparse_clusttri_user_test.cc
│ │ │ │ ├── ba_iterschur_cxsparse_clusttri_user_threads_test.cc
│ │ │ │ ├── ba_iterschur_eigensparse_clustjacobi_auto_test.cc
│ │ │ │ ├── ba_iterschur_eigensparse_clustjacobi_auto_threads_test.cc
│ │ │ │ ├── ba_iterschur_eigensparse_clustjacobi_user_test.cc
│ │ │ │ ├── ba_iterschur_eigensparse_clustjacobi_user_threads_test.cc
│ │ │ │ ├── ba_iterschur_eigensparse_clusttri_auto_test.cc
│ │ │ │ ├── ba_iterschur_eigensparse_clusttri_auto_threads_test.cc
│ │ │ │ ├── ba_iterschur_eigensparse_clusttri_user_test.cc
│ │ │ │ ├── ba_iterschur_eigensparse_clusttri_user_threads_test.cc
│ │ │ │ ├── ba_iterschur_jacobi_auto_test.cc
│ │ │ │ ├── ba_iterschur_jacobi_auto_threads_test.cc
│ │ │ │ ├── ba_iterschur_jacobi_user_test.cc
│ │ │ │ ├── ba_iterschur_jacobi_user_threads_test.cc
│ │ │ │ ├── ba_iterschur_schurjacobi_auto_test.cc
│ │ │ │ ├── ba_iterschur_schurjacobi_auto_threads_test.cc
│ │ │ │ ├── ba_iterschur_schurjacobi_user_test.cc
│ │ │ │ ├── ba_iterschur_schurjacobi_user_threads_test.cc
│ │ │ │ ├── ba_iterschur_suitesparse_clustjacobi_auto_test.cc
│ │ │ │ ├── ba_iterschur_suitesparse_clustjacobi_auto_threads_test.cc
│ │ │ │ ├── ba_iterschur_suitesparse_clustjacobi_user_test.cc
│ │ │ │ ├── ba_iterschur_suitesparse_clustjacobi_user_threads_test.cc
│ │ │ │ ├── ba_iterschur_suitesparse_clusttri_auto_test.cc
│ │ │ │ ├── ba_iterschur_suitesparse_clusttri_auto_threads_test.cc
│ │ │ │ ├── ba_iterschur_suitesparse_clusttri_user_test.cc
│ │ │ │ ├── ba_iterschur_suitesparse_clusttri_user_threads_test.cc
│ │ │ │ ├── ba_sparsecholesky_acceleratesparse_auto_test.cc
│ │ │ │ ├── ba_sparsecholesky_acceleratesparse_auto_threads_test.cc
│ │ │ │ ├── ba_sparsecholesky_acceleratesparse_user_test.cc
│ │ │ │ ├── ba_sparsecholesky_acceleratesparse_user_threads_test.cc
│ │ │ │ ├── ba_sparsecholesky_cxsparse_auto_test.cc
│ │ │ │ ├── ba_sparsecholesky_cxsparse_auto_threads_test.cc
│ │ │ │ ├── ba_sparsecholesky_cxsparse_user_test.cc
│ │ │ │ ├── ba_sparsecholesky_cxsparse_user_threads_test.cc
│ │ │ │ ├── ba_sparsecholesky_eigensparse_auto_test.cc
│ │ │ │ ├── ba_sparsecholesky_eigensparse_auto_threads_test.cc
│ │ │ │ ├── ba_sparsecholesky_eigensparse_user_test.cc
│ │ │ │ ├── ba_sparsecholesky_eigensparse_user_threads_test.cc
│ │ │ │ ├── ba_sparsecholesky_suitesparse_auto_test.cc
│ │ │ │ ├── ba_sparsecholesky_suitesparse_auto_threads_test.cc
│ │ │ │ ├── ba_sparsecholesky_suitesparse_user_test.cc
│ │ │ │ ├── ba_sparsecholesky_suitesparse_user_threads_test.cc
│ │ │ │ ├── ba_sparseschur_acceleratesparse_auto_test.cc
│ │ │ │ ├── ba_sparseschur_acceleratesparse_auto_threads_test.cc
│ │ │ │ ├── ba_sparseschur_acceleratesparse_user_test.cc
│ │ │ │ ├── ba_sparseschur_acceleratesparse_user_threads_test.cc
│ │ │ │ ├── ba_sparseschur_cxsparse_auto_test.cc
│ │ │ │ ├── ba_sparseschur_cxsparse_auto_threads_test.cc
│ │ │ │ ├── ba_sparseschur_cxsparse_user_test.cc
│ │ │ │ ├── ba_sparseschur_cxsparse_user_threads_test.cc
│ │ │ │ ├── ba_sparseschur_eigensparse_auto_test.cc
│ │ │ │ ├── ba_sparseschur_eigensparse_auto_threads_test.cc
│ │ │ │ ├── ba_sparseschur_eigensparse_user_test.cc
│ │ │ │ ├── ba_sparseschur_eigensparse_user_threads_test.cc
│ │ │ │ ├── ba_sparseschur_suitesparse_auto_test.cc
│ │ │ │ ├── ba_sparseschur_suitesparse_auto_threads_test.cc
│ │ │ │ ├── ba_sparseschur_suitesparse_user_test.cc
│ │ │ │ └── ba_sparseschur_suitesparse_user_threads_test.cc
│ │ │ ├── glog/
│ │ │ │ ├── logging.cc
│ │ │ │ └── logging.h
│ │ │ ├── gmock/
│ │ │ │ ├── gmock.h
│ │ │ │ └── mock-log.h
│ │ │ ├── gmock_gtest_all.cc
│ │ │ ├── gmock_main.cc
│ │ │ ├── gradient_checker.cc
│ │ │ ├── gradient_checker_test.cc
│ │ │ ├── gradient_checking_cost_function.cc
│ │ │ ├── gradient_checking_cost_function.h
│ │ │ ├── gradient_checking_cost_function_test.cc
│ │ │ ├── gradient_problem.cc
│ │ │ ├── gradient_problem_evaluator.h
│ │ │ ├── gradient_problem_solver.cc
│ │ │ ├── gradient_problem_solver_test.cc
│ │ │ ├── gradient_problem_test.cc
│ │ │ ├── graph.h
│ │ │ ├── graph_algorithms.h
│ │ │ ├── graph_algorithms_test.cc
│ │ │ ├── graph_test.cc
│ │ │ ├── gtest/
│ │ │ │ └── gtest.h
│ │ │ ├── householder_vector_test.cc
│ │ │ ├── implicit_schur_complement.cc
│ │ │ ├── implicit_schur_complement.h
│ │ │ ├── implicit_schur_complement_test.cc
│ │ │ ├── inner_product_computer.cc
│ │ │ ├── inner_product_computer.h
│ │ │ ├── inner_product_computer_test.cc
│ │ │ ├── integer_sequence_algorithm_test.cc
│ │ │ ├── integer_sequence_test.cc
│ │ │ ├── invert_psd_matrix.h
│ │ │ ├── invert_psd_matrix_benchmark.cc
│ │ │ ├── invert_psd_matrix_test.cc
│ │ │ ├── is_close.cc
│ │ │ ├── is_close.h
│ │ │ ├── is_close_test.cc
│ │ │ ├── iterative_refiner.cc
│ │ │ ├── iterative_refiner.h
│ │ │ ├── iterative_refiner_test.cc
│ │ │ ├── iterative_schur_complement_solver.cc
│ │ │ ├── iterative_schur_complement_solver.h
│ │ │ ├── iterative_schur_complement_solver_test.cc
│ │ │ ├── jet_test.cc
│ │ │ ├── lapack.cc
│ │ │ ├── lapack.h
│ │ │ ├── levenberg_marquardt_strategy.cc
│ │ │ ├── levenberg_marquardt_strategy.h
│ │ │ ├── levenberg_marquardt_strategy_test.cc
│ │ │ ├── line_search.cc
│ │ │ ├── line_search.h
│ │ │ ├── line_search_direction.cc
│ │ │ ├── line_search_direction.h
│ │ │ ├── line_search_minimizer.cc
│ │ │ ├── line_search_minimizer.h
│ │ │ ├── line_search_minimizer_test.cc
│ │ │ ├── line_search_preprocessor.cc
│ │ │ ├── line_search_preprocessor.h
│ │ │ ├── line_search_preprocessor_test.cc
│ │ │ ├── linear_least_squares_problems.cc
│ │ │ ├── linear_least_squares_problems.h
│ │ │ ├── linear_operator.cc
│ │ │ ├── linear_operator.h
│ │ │ ├── linear_solver.cc
│ │ │ ├── linear_solver.h
│ │ │ ├── local_parameterization.cc
│ │ │ ├── local_parameterization_test.cc
│ │ │ ├── loss_function.cc
│ │ │ ├── loss_function_test.cc
│ │ │ ├── low_rank_inverse_hessian.cc
│ │ │ ├── low_rank_inverse_hessian.h
│ │ │ ├── map_util.h
│ │ │ ├── miniglog/
│ │ │ │ └── glog/
│ │ │ │ ├── logging.cc
│ │ │ │ └── logging.h
│ │ │ ├── minimizer.cc
│ │ │ ├── minimizer.h
│ │ │ ├── minimizer_test.cc
│ │ │ ├── normal_prior.cc
│ │ │ ├── normal_prior_test.cc
│ │ │ ├── numeric_diff_cost_function_test.cc
│ │ │ ├── numeric_diff_test_utils.cc
│ │ │ ├── numeric_diff_test_utils.h
│ │ │ ├── ordered_groups_test.cc
│ │ │ ├── pair_hash.h
│ │ │ ├── parallel_for.h
│ │ │ ├── parallel_for_cxx.cc
│ │ │ ├── parallel_for_nothreads.cc
│ │ │ ├── parallel_for_openmp.cc
│ │ │ ├── parallel_for_test.cc
│ │ │ ├── parallel_utils.cc
│ │ │ ├── parallel_utils.h
│ │ │ ├── parallel_utils_test.cc
│ │ │ ├── parameter_block.h
│ │ │ ├── parameter_block_ordering.cc
│ │ │ ├── parameter_block_ordering.h
│ │ │ ├── parameter_block_ordering_test.cc
│ │ │ ├── parameter_block_test.cc
│ │ │ ├── parameter_dims_test.cc
│ │ │ ├── partitioned_matrix_view.cc
│ │ │ ├── partitioned_matrix_view.h
│ │ │ ├── partitioned_matrix_view_impl.h
│ │ │ ├── partitioned_matrix_view_template.py
│ │ │ ├── partitioned_matrix_view_test.cc
│ │ │ ├── polynomial.cc
│ │ │ ├── polynomial.h
│ │ │ ├── polynomial_test.cc
│ │ │ ├── preconditioner.cc
│ │ │ ├── preconditioner.h
│ │ │ ├── preprocessor.cc
│ │ │ ├── preprocessor.h
│ │ │ ├── problem.cc
│ │ │ ├── problem_impl.cc
│ │ │ ├── problem_impl.h
│ │ │ ├── problem_test.cc
│ │ │ ├── program.cc
│ │ │ ├── program.h
│ │ │ ├── program_evaluator.h
│ │ │ ├── program_test.cc
│ │ │ ├── random.h
│ │ │ ├── reorder_program.cc
│ │ │ ├── reorder_program.h
│ │ │ ├── reorder_program_test.cc
│ │ │ ├── residual_block.cc
│ │ │ ├── residual_block.h
│ │ │ ├── residual_block_test.cc
│ │ │ ├── residual_block_utils.cc
│ │ │ ├── residual_block_utils.h
│ │ │ ├── residual_block_utils_test.cc
│ │ │ ├── rotation_test.cc
│ │ │ ├── schur_complement_solver.cc
│ │ │ ├── schur_complement_solver.h
│ │ │ ├── schur_complement_solver_test.cc
│ │ │ ├── schur_eliminator.cc
│ │ │ ├── schur_eliminator.h
│ │ │ ├── schur_eliminator_benchmark.cc
│ │ │ ├── schur_eliminator_impl.h
│ │ │ ├── schur_eliminator_template.py
│ │ │ ├── schur_eliminator_test.cc
│ │ │ ├── schur_jacobi_preconditioner.cc
│ │ │ ├── schur_jacobi_preconditioner.h
│ │ │ ├── schur_templates.cc
│ │ │ ├── schur_templates.h
│ │ │ ├── scoped_thread_token.h
│ │ │ ├── scratch_evaluate_preparer.cc
│ │ │ ├── scratch_evaluate_preparer.h
│ │ │ ├── single_linkage_clustering.cc
│ │ │ ├── single_linkage_clustering.h
│ │ │ ├── single_linkage_clustering_test.cc
│ │ │ ├── small_blas.h
│ │ │ ├── small_blas_gemm_benchmark.cc
│ │ │ ├── small_blas_gemv_benchmark.cc
│ │ │ ├── small_blas_generic.h
│ │ │ ├── small_blas_test.cc
│ │ │ ├── solver.cc
│ │ │ ├── solver_test.cc
│ │ │ ├── solver_utils.cc
│ │ │ ├── solver_utils.h
│ │ │ ├── sparse_cholesky.cc
│ │ │ ├── sparse_cholesky.h
│ │ │ ├── sparse_cholesky_test.cc
│ │ │ ├── sparse_matrix.cc
│ │ │ ├── sparse_matrix.h
│ │ │ ├── sparse_normal_cholesky_solver.cc
│ │ │ ├── sparse_normal_cholesky_solver.h
│ │ │ ├── sparse_normal_cholesky_solver_test.cc
│ │ │ ├── split.cc
│ │ │ ├── split.h
│ │ │ ├── stl_util.h
│ │ │ ├── stringprintf.cc
│ │ │ ├── stringprintf.h
│ │ │ ├── subset_preconditioner.cc
│ │ │ ├── subset_preconditioner.h
│ │ │ ├── subset_preconditioner_test.cc
│ │ │ ├── suitesparse.cc
│ │ │ ├── suitesparse.h
│ │ │ ├── system_test.cc
│ │ │ ├── test_util.cc
│ │ │ ├── test_util.h
│ │ │ ├── thread_pool.cc
│ │ │ ├── thread_pool.h
│ │ │ ├── thread_pool_test.cc
│ │ │ ├── thread_token_provider.cc
│ │ │ ├── thread_token_provider.h
│ │ │ ├── tiny_solver_autodiff_function_test.cc
│ │ │ ├── tiny_solver_cost_function_adapter_test.cc
│ │ │ ├── tiny_solver_test.cc
│ │ │ ├── tiny_solver_test_util.h
│ │ │ ├── triplet_sparse_matrix.cc
│ │ │ ├── triplet_sparse_matrix.h
│ │ │ ├── triplet_sparse_matrix_test.cc
│ │ │ ├── trust_region_minimizer.cc
│ │ │ ├── trust_region_minimizer.h
│ │ │ ├── trust_region_minimizer_test.cc
│ │ │ ├── trust_region_preprocessor.cc
│ │ │ ├── trust_region_preprocessor.h
│ │ │ ├── trust_region_preprocessor_test.cc
│ │ │ ├── trust_region_step_evaluator.cc
│ │ │ ├── trust_region_step_evaluator.h
│ │ │ ├── trust_region_strategy.cc
│ │ │ ├── trust_region_strategy.h
│ │ │ ├── types.cc
│ │ │ ├── visibility.cc
│ │ │ ├── visibility.h
│ │ │ ├── visibility_based_preconditioner.cc
│ │ │ ├── visibility_based_preconditioner.h
│ │ │ ├── visibility_based_preconditioner_test.cc
│ │ │ ├── visibility_test.cc
│ │ │ ├── wall_time.cc
│ │ │ └── wall_time.h
│ │ ├── package.xml
│ │ ├── scripts/
│ │ │ ├── make_docs.py
│ │ │ └── make_release
│ │ └── travis/
│ │ ├── install_travis_linux_deps.sh
│ │ └── install_travis_osx_deps.sh
│ └── eigen3/
│ ├── .hgeol
│ ├── CMakeLists.txt
│ ├── COPYING.BSD
│ ├── COPYING.GPL
│ ├── COPYING.LGPL
│ ├── COPYING.MINPACK
│ ├── COPYING.MPL2
│ ├── COPYING.README
│ ├── CTestConfig.cmake
│ ├── CTestCustom.cmake.in
│ ├── Eigen/
│ │ ├── Cholesky
│ │ ├── CholmodSupport
│ │ ├── Core
│ │ ├── Dense
│ │ ├── Eigen
│ │ ├── Eigenvalues
│ │ ├── Geometry
│ │ ├── Householder
│ │ ├── IterativeLinearSolvers
│ │ ├── Jacobi
│ │ ├── KLUSupport
│ │ ├── LU
│ │ ├── MetisSupport
│ │ ├── OrderingMethods
│ │ ├── PaStiXSupport
│ │ ├── PardisoSupport
│ │ ├── QR
│ │ ├── QtAlignedMalloc
│ │ ├── SPQRSupport
│ │ ├── SVD
│ │ ├── Sparse
│ │ ├── SparseCholesky
│ │ ├── SparseCore
│ │ ├── SparseLU
│ │ ├── SparseQR
│ │ ├── StdDeque
│ │ ├── StdList
│ │ ├── StdVector
│ │ ├── SuperLUSupport
│ │ ├── UmfPackSupport
│ │ └── src/
│ │ ├── Cholesky/
│ │ │ ├── LDLT.h
│ │ │ ├── LLT.h
│ │ │ └── LLT_LAPACKE.h
│ │ ├── CholmodSupport/
│ │ │ └── CholmodSupport.h
│ │ ├── Core/
│ │ │ ├── ArithmeticSequence.h
│ │ │ ├── Array.h
│ │ │ ├── ArrayBase.h
│ │ │ ├── ArrayWrapper.h
│ │ │ ├── Assign.h
│ │ │ ├── AssignEvaluator.h
│ │ │ ├── Assign_MKL.h
│ │ │ ├── BandMatrix.h
│ │ │ ├── Block.h
│ │ │ ├── BooleanRedux.h
│ │ │ ├── CommaInitializer.h
│ │ │ ├── ConditionEstimator.h
│ │ │ ├── CoreEvaluators.h
│ │ │ ├── CoreIterators.h
│ │ │ ├── CwiseBinaryOp.h
│ │ │ ├── CwiseNullaryOp.h
│ │ │ ├── CwiseTernaryOp.h
│ │ │ ├── CwiseUnaryOp.h
│ │ │ ├── CwiseUnaryView.h
│ │ │ ├── DenseBase.h
│ │ │ ├── DenseCoeffsBase.h
│ │ │ ├── DenseStorage.h
│ │ │ ├── Diagonal.h
│ │ │ ├── DiagonalMatrix.h
│ │ │ ├── DiagonalProduct.h
│ │ │ ├── Dot.h
│ │ │ ├── EigenBase.h
│ │ │ ├── ForceAlignedAccess.h
│ │ │ ├── Fuzzy.h
│ │ │ ├── GeneralProduct.h
│ │ │ ├── GenericPacketMath.h
│ │ │ ├── GlobalFunctions.h
│ │ │ ├── IO.h
│ │ │ ├── IndexedView.h
│ │ │ ├── Inverse.h
│ │ │ ├── Map.h
│ │ │ ├── MapBase.h
│ │ │ ├── MathFunctions.h
│ │ │ ├── MathFunctionsImpl.h
│ │ │ ├── Matrix.h
│ │ │ ├── MatrixBase.h
│ │ │ ├── NestByValue.h
│ │ │ ├── NoAlias.h
│ │ │ ├── NumTraits.h
│ │ │ ├── PartialReduxEvaluator.h
│ │ │ ├── PermutationMatrix.h
│ │ │ ├── PlainObjectBase.h
│ │ │ ├── Product.h
│ │ │ ├── ProductEvaluators.h
│ │ │ ├── Random.h
│ │ │ ├── Redux.h
│ │ │ ├── Ref.h
│ │ │ ├── Replicate.h
│ │ │ ├── Reshaped.h
│ │ │ ├── ReturnByValue.h
│ │ │ ├── Reverse.h
│ │ │ ├── Select.h
│ │ │ ├── SelfAdjointView.h
│ │ │ ├── SelfCwiseBinaryOp.h
│ │ │ ├── Solve.h
│ │ │ ├── SolveTriangular.h
│ │ │ ├── SolverBase.h
│ │ │ ├── StableNorm.h
│ │ │ ├── StlIterators.h
│ │ │ ├── Stride.h
│ │ │ ├── Swap.h
│ │ │ ├── Transpose.h
│ │ │ ├── Transpositions.h
│ │ │ ├── TriangularMatrix.h
│ │ │ ├── VectorBlock.h
│ │ │ ├── VectorwiseOp.h
│ │ │ ├── Visitor.h
│ │ │ ├── arch/
│ │ │ │ ├── AVX/
│ │ │ │ │ ├── Complex.h
│ │ │ │ │ ├── MathFunctions.h
│ │ │ │ │ ├── PacketMath.h
│ │ │ │ │ └── TypeCasting.h
│ │ │ │ ├── AVX512/
│ │ │ │ │ ├── Complex.h
│ │ │ │ │ ├── MathFunctions.h
│ │ │ │ │ ├── PacketMath.h
│ │ │ │ │ └── TypeCasting.h
│ │ │ │ ├── AltiVec/
│ │ │ │ │ ├── Complex.h
│ │ │ │ │ ├── MathFunctions.h
│ │ │ │ │ └── PacketMath.h
│ │ │ │ ├── CUDA/
│ │ │ │ │ └── Complex.h
│ │ │ │ ├── Default/
│ │ │ │ │ ├── ConjHelper.h
│ │ │ │ │ ├── GenericPacketMathFunctions.h
│ │ │ │ │ ├── GenericPacketMathFunctionsFwd.h
│ │ │ │ │ ├── Half.h
│ │ │ │ │ ├── Settings.h
│ │ │ │ │ └── TypeCasting.h
│ │ │ │ ├── GPU/
│ │ │ │ │ ├── MathFunctions.h
│ │ │ │ │ ├── PacketMath.h
│ │ │ │ │ └── TypeCasting.h
│ │ │ │ ├── HIP/
│ │ │ │ │ └── hcc/
│ │ │ │ │ └── math_constants.h
│ │ │ │ ├── MSA/
│ │ │ │ │ ├── Complex.h
│ │ │ │ │ ├── MathFunctions.h
│ │ │ │ │ └── PacketMath.h
│ │ │ │ ├── NEON/
│ │ │ │ │ ├── Complex.h
│ │ │ │ │ ├── MathFunctions.h
│ │ │ │ │ ├── PacketMath.h
│ │ │ │ │ └── TypeCasting.h
│ │ │ │ ├── SSE/
│ │ │ │ │ ├── Complex.h
│ │ │ │ │ ├── MathFunctions.h
│ │ │ │ │ ├── PacketMath.h
│ │ │ │ │ └── TypeCasting.h
│ │ │ │ ├── SYCL/
│ │ │ │ │ ├── InteropHeaders.h
│ │ │ │ │ ├── MathFunctions.h
│ │ │ │ │ ├── PacketMath.h
│ │ │ │ │ ├── SyclMemoryModel.h
│ │ │ │ │ └── TypeCasting.h
│ │ │ │ └── ZVector/
│ │ │ │ ├── Complex.h
│ │ │ │ ├── MathFunctions.h
│ │ │ │ └── PacketMath.h
│ │ │ ├── functors/
│ │ │ │ ├── AssignmentFunctors.h
│ │ │ │ ├── BinaryFunctors.h
│ │ │ │ ├── NullaryFunctors.h
│ │ │ │ ├── StlFunctors.h
│ │ │ │ ├── TernaryFunctors.h
│ │ │ │ └── UnaryFunctors.h
│ │ │ ├── products/
│ │ │ │ ├── GeneralBlockPanelKernel.h
│ │ │ │ ├── GeneralMatrixMatrix.h
│ │ │ │ ├── GeneralMatrixMatrixTriangular.h
│ │ │ │ ├── GeneralMatrixMatrixTriangular_BLAS.h
│ │ │ │ ├── GeneralMatrixMatrix_BLAS.h
│ │ │ │ ├── GeneralMatrixVector.h
│ │ │ │ ├── GeneralMatrixVector_BLAS.h
│ │ │ │ ├── Parallelizer.h
│ │ │ │ ├── SelfadjointMatrixMatrix.h
│ │ │ │ ├── SelfadjointMatrixMatrix_BLAS.h
│ │ │ │ ├── SelfadjointMatrixVector.h
│ │ │ │ ├── SelfadjointMatrixVector_BLAS.h
│ │ │ │ ├── SelfadjointProduct.h
│ │ │ │ ├── SelfadjointRank2Update.h
│ │ │ │ ├── TriangularMatrixMatrix.h
│ │ │ │ ├── TriangularMatrixMatrix_BLAS.h
│ │ │ │ ├── TriangularMatrixVector.h
│ │ │ │ ├── TriangularMatrixVector_BLAS.h
│ │ │ │ ├── TriangularSolverMatrix.h
│ │ │ │ ├── TriangularSolverMatrix_BLAS.h
│ │ │ │ └── TriangularSolverVector.h
│ │ │ └── util/
│ │ │ ├── BlasUtil.h
│ │ │ ├── ConfigureVectorization.h
│ │ │ ├── Constants.h
│ │ │ ├── DisableStupidWarnings.h
│ │ │ ├── ForwardDeclarations.h
│ │ │ ├── IndexedViewHelper.h
│ │ │ ├── IntegralConstant.h
│ │ │ ├── MKL_support.h
│ │ │ ├── Macros.h
│ │ │ ├── Memory.h
│ │ │ ├── Meta.h
│ │ │ ├── NonMPL2.h
│ │ │ ├── ReenableStupidWarnings.h
│ │ │ ├── ReshapedHelper.h
│ │ │ ├── StaticAssert.h
│ │ │ ├── SymbolicIndex.h
│ │ │ └── XprHelper.h
│ │ ├── Eigenvalues/
│ │ │ ├── ComplexEigenSolver.h
│ │ │ ├── ComplexSchur.h
│ │ │ ├── ComplexSchur_LAPACKE.h
│ │ │ ├── EigenSolver.h
│ │ │ ├── GeneralizedEigenSolver.h
│ │ │ ├── GeneralizedSelfAdjointEigenSolver.h
│ │ │ ├── HessenbergDecomposition.h
│ │ │ ├── MatrixBaseEigenvalues.h
│ │ │ ├── RealQZ.h
│ │ │ ├── RealSchur.h
│ │ │ ├── RealSchur_LAPACKE.h
│ │ │ ├── SelfAdjointEigenSolver.h
│ │ │ ├── SelfAdjointEigenSolver_LAPACKE.h
│ │ │ └── Tridiagonalization.h
│ │ ├── Geometry/
│ │ │ ├── AlignedBox.h
│ │ │ ├── AngleAxis.h
│ │ │ ├── EulerAngles.h
│ │ │ ├── Homogeneous.h
│ │ │ ├── Hyperplane.h
│ │ │ ├── OrthoMethods.h
│ │ │ ├── ParametrizedLine.h
│ │ │ ├── Quaternion.h
│ │ │ ├── Rotation2D.h
│ │ │ ├── RotationBase.h
│ │ │ ├── Scaling.h
│ │ │ ├── Transform.h
│ │ │ ├── Translation.h
│ │ │ ├── Umeyama.h
│ │ │ └── arch/
│ │ │ └── Geometry_SSE.h
│ │ ├── Householder/
│ │ │ ├── BlockHouseholder.h
│ │ │ ├── Householder.h
│ │ │ └── HouseholderSequence.h
│ │ ├── IterativeLinearSolvers/
│ │ │ ├── BasicPreconditioners.h
│ │ │ ├── BiCGSTAB.h
│ │ │ ├── ConjugateGradient.h
│ │ │ ├── IncompleteCholesky.h
│ │ │ ├── IncompleteLUT.h
│ │ │ ├── IterativeSolverBase.h
│ │ │ ├── LeastSquareConjugateGradient.h
│ │ │ └── SolveWithGuess.h
│ │ ├── Jacobi/
│ │ │ └── Jacobi.h
│ │ ├── KLUSupport/
│ │ │ └── KLUSupport.h
│ │ ├── LU/
│ │ │ ├── Determinant.h
│ │ │ ├── FullPivLU.h
│ │ │ ├── InverseImpl.h
│ │ │ ├── PartialPivLU.h
│ │ │ ├── PartialPivLU_LAPACKE.h
│ │ │ └── arch/
│ │ │ └── Inverse_SSE.h
│ │ ├── MetisSupport/
│ │ │ └── MetisSupport.h
│ │ ├── OrderingMethods/
│ │ │ ├── Amd.h
│ │ │ ├── Eigen_Colamd.h
│ │ │ └── Ordering.h
│ │ ├── PaStiXSupport/
│ │ │ └── PaStiXSupport.h
│ │ ├── PardisoSupport/
│ │ │ └── PardisoSupport.h
│ │ ├── QR/
│ │ │ ├── ColPivHouseholderQR.h
│ │ │ ├── ColPivHouseholderQR_LAPACKE.h
│ │ │ ├── CompleteOrthogonalDecomposition.h
│ │ │ ├── FullPivHouseholderQR.h
│ │ │ ├── HouseholderQR.h
│ │ │ └── HouseholderQR_LAPACKE.h
│ │ ├── SPQRSupport/
│ │ │ └── SuiteSparseQRSupport.h
│ │ ├── SVD/
│ │ │ ├── BDCSVD.h
│ │ │ ├── JacobiSVD.h
│ │ │ ├── JacobiSVD_LAPACKE.h
│ │ │ ├── SVDBase.h
│ │ │ └── UpperBidiagonalization.h
│ │ ├── SparseCholesky/
│ │ │ ├── SimplicialCholesky.h
│ │ │ └── SimplicialCholesky_impl.h
│ │ ├── SparseCore/
│ │ │ ├── AmbiVector.h
│ │ │ ├── CompressedStorage.h
│ │ │ ├── ConservativeSparseSparseProduct.h
│ │ │ ├── MappedSparseMatrix.h
│ │ │ ├── SparseAssign.h
│ │ │ ├── SparseBlock.h
│ │ │ ├── SparseColEtree.h
│ │ │ ├── SparseCompressedBase.h
│ │ │ ├── SparseCwiseBinaryOp.h
│ │ │ ├── SparseCwiseUnaryOp.h
│ │ │ ├── SparseDenseProduct.h
│ │ │ ├── SparseDiagonalProduct.h
│ │ │ ├── SparseDot.h
│ │ │ ├── SparseFuzzy.h
│ │ │ ├── SparseMap.h
│ │ │ ├── SparseMatrix.h
│ │ │ ├── SparseMatrixBase.h
│ │ │ ├── SparsePermutation.h
│ │ │ ├── SparseProduct.h
│ │ │ ├── SparseRedux.h
│ │ │ ├── SparseRef.h
│ │ │ ├── SparseSelfAdjointView.h
│ │ │ ├── SparseSolverBase.h
│ │ │ ├── SparseSparseProductWithPruning.h
│ │ │ ├── SparseTranspose.h
│ │ │ ├── SparseTriangularView.h
│ │ │ ├── SparseUtil.h
│ │ │ ├── SparseVector.h
│ │ │ ├── SparseView.h
│ │ │ └── TriangularSolver.h
│ │ ├── SparseLU/
│ │ │ ├── SparseLU.h
│ │ │ ├── SparseLUImpl.h
│ │ │ ├── SparseLU_Memory.h
│ │ │ ├── SparseLU_Structs.h
│ │ │ ├── SparseLU_SupernodalMatrix.h
│ │ │ ├── SparseLU_Utils.h
│ │ │ ├── SparseLU_column_bmod.h
│ │ │ ├── SparseLU_column_dfs.h
│ │ │ ├── SparseLU_copy_to_ucol.h
│ │ │ ├── SparseLU_gemm_kernel.h
│ │ │ ├── SparseLU_heap_relax_snode.h
│ │ │ ├── SparseLU_kernel_bmod.h
│ │ │ ├── SparseLU_panel_bmod.h
│ │ │ ├── SparseLU_panel_dfs.h
│ │ │ ├── SparseLU_pivotL.h
│ │ │ ├── SparseLU_pruneL.h
│ │ │ └── SparseLU_relax_snode.h
│ │ ├── SparseQR/
│ │ │ └── SparseQR.h
│ │ ├── StlSupport/
│ │ │ ├── StdDeque.h
│ │ │ ├── StdList.h
│ │ │ ├── StdVector.h
│ │ │ └── details.h
│ │ ├── SuperLUSupport/
│ │ │ └── SuperLUSupport.h
│ │ ├── UmfPackSupport/
│ │ │ └── UmfPackSupport.h
│ │ ├── misc/
│ │ │ ├── Image.h
│ │ │ ├── Kernel.h
│ │ │ ├── RealSvd2x2.h
│ │ │ ├── blas.h
│ │ │ ├── lapack.h
│ │ │ ├── lapacke.h
│ │ │ └── lapacke_mangling.h
│ │ └── plugins/
│ │ ├── ArrayCwiseBinaryOps.h
│ │ ├── ArrayCwiseUnaryOps.h
│ │ ├── BlockMethods.h
│ │ ├── CommonCwiseBinaryOps.h
│ │ ├── CommonCwiseUnaryOps.h
│ │ ├── IndexedViewMethods.h
│ │ ├── MatrixCwiseBinaryOps.h
│ │ ├── MatrixCwiseUnaryOps.h
│ │ └── ReshapedMethods.h
│ ├── INSTALL
│ ├── README.md
│ ├── bench/
│ │ ├── BenchSparseUtil.h
│ │ ├── BenchTimer.h
│ │ ├── BenchUtil.h
│ │ ├── README.txt
│ │ ├── analyze-blocking-sizes.cpp
│ │ ├── basicbench.cxxlist
│ │ ├── basicbenchmark.cpp
│ │ ├── basicbenchmark.h
│ │ ├── benchBlasGemm.cpp
│ │ ├── benchCholesky.cpp
│ │ ├── benchEigenSolver.cpp
│ │ ├── benchFFT.cpp
│ │ ├── benchGeometry.cpp
│ │ ├── benchVecAdd.cpp
│ │ ├── bench_gemm.cpp
│ │ ├── bench_multi_compilers.sh
│ │ ├── bench_norm.cpp
│ │ ├── bench_reverse.cpp
│ │ ├── bench_sum.cpp
│ │ ├── bench_unrolling
│ │ ├── benchmark-blocking-sizes.cpp
│ │ ├── benchmark.cpp
│ │ ├── benchmarkSlice.cpp
│ │ ├── benchmarkX.cpp
│ │ ├── benchmarkXcwise.cpp
│ │ ├── benchmark_suite
│ │ ├── btl/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── COPYING
│ │ │ ├── README
│ │ │ ├── actions/
│ │ │ │ ├── action_aat_product.hh
│ │ │ │ ├── action_ata_product.hh
│ │ │ │ ├── action_atv_product.hh
│ │ │ │ ├── action_axpby.hh
│ │ │ │ ├── action_axpy.hh
│ │ │ │ ├── action_cholesky.hh
│ │ │ │ ├── action_ger.hh
│ │ │ │ ├── action_hessenberg.hh
│ │ │ │ ├── action_lu_decomp.hh
│ │ │ │ ├── action_lu_solve.hh
│ │ │ │ ├── action_matrix_matrix_product.hh
│ │ │ │ ├── action_matrix_matrix_product_bis.hh
│ │ │ │ ├── action_matrix_vector_product.hh
│ │ │ │ ├── action_partial_lu.hh
│ │ │ │ ├── action_rot.hh
│ │ │ │ ├── action_symv.hh
│ │ │ │ ├── action_syr2.hh
│ │ │ │ ├── action_trisolve.hh
│ │ │ │ ├── action_trisolve_matrix.hh
│ │ │ │ ├── action_trmm.hh
│ │ │ │ └── basic_actions.hh
│ │ │ ├── cmake/
│ │ │ │ ├── FindACML.cmake
│ │ │ │ ├── FindATLAS.cmake
│ │ │ │ ├── FindBLAZE.cmake
│ │ │ │ ├── FindBlitz.cmake
│ │ │ │ ├── FindCBLAS.cmake
│ │ │ │ ├── FindGMM.cmake
│ │ │ │ ├── FindMKL.cmake
│ │ │ │ ├── FindMTL4.cmake
│ │ │ │ ├── FindOPENBLAS.cmake
│ │ │ │ ├── FindPackageHandleStandardArgs.cmake
│ │ │ │ ├── FindTvmet.cmake
│ │ │ │ └── MacroOptionalAddSubdirectory.cmake
│ │ │ ├── data/
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── action_settings.txt
│ │ │ │ ├── gnuplot_common_settings.hh
│ │ │ │ ├── go_mean
│ │ │ │ ├── mean.cxx
│ │ │ │ ├── mk_gnuplot_script.sh
│ │ │ │ ├── mk_mean_script.sh
│ │ │ │ ├── mk_new_gnuplot.sh
│ │ │ │ ├── perlib_plot_settings.txt
│ │ │ │ ├── regularize.cxx
│ │ │ │ ├── smooth.cxx
│ │ │ │ └── smooth_all.sh
│ │ │ ├── generic_bench/
│ │ │ │ ├── bench.hh
│ │ │ │ ├── bench_parameter.hh
│ │ │ │ ├── btl.hh
│ │ │ │ ├── init/
│ │ │ │ │ ├── init_function.hh
│ │ │ │ │ ├── init_matrix.hh
│ │ │ │ │ └── init_vector.hh
│ │ │ │ ├── static/
│ │ │ │ │ ├── bench_static.hh
│ │ │ │ │ ├── intel_bench_fixed_size.hh
│ │ │ │ │ └── static_size_generator.hh
│ │ │ │ ├── timers/
│ │ │ │ │ ├── STL_perf_analyzer.hh
│ │ │ │ │ ├── STL_timer.hh
│ │ │ │ │ ├── mixed_perf_analyzer.hh
│ │ │ │ │ ├── portable_perf_analyzer.hh
│ │ │ │ │ ├── portable_perf_analyzer_old.hh
│ │ │ │ │ ├── portable_timer.hh
│ │ │ │ │ ├── x86_perf_analyzer.hh
│ │ │ │ │ └── x86_timer.hh
│ │ │ │ └── utils/
│ │ │ │ ├── size_lin_log.hh
│ │ │ │ ├── size_log.hh
│ │ │ │ ├── utilities.h
│ │ │ │ └── xy_file.hh
│ │ │ └── libs/
│ │ │ ├── BLAS/
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── blas.h
│ │ │ │ ├── blas_interface.hh
│ │ │ │ ├── blas_interface_impl.hh
│ │ │ │ ├── c_interface_base.h
│ │ │ │ └── main.cpp
│ │ │ ├── STL/
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── STL_interface.hh
│ │ │ │ └── main.cpp
│ │ │ ├── blaze/
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── blaze_interface.hh
│ │ │ │ └── main.cpp
│ │ │ ├── blitz/
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── blitz_LU_solve_interface.hh
│ │ │ │ ├── blitz_interface.hh
│ │ │ │ ├── btl_blitz.cpp
│ │ │ │ ├── btl_tiny_blitz.cpp
│ │ │ │ └── tiny_blitz_interface.hh
│ │ │ ├── eigen2/
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── btl_tiny_eigen2.cpp
│ │ │ │ ├── eigen2_interface.hh
│ │ │ │ ├── main_adv.cpp
│ │ │ │ ├── main_linear.cpp
│ │ │ │ ├── main_matmat.cpp
│ │ │ │ └── main_vecmat.cpp
│ │ │ ├── eigen3/
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── btl_tiny_eigen3.cpp
│ │ │ │ ├── eigen3_interface.hh
│ │ │ │ ├── main_adv.cpp
│ │ │ │ ├── main_linear.cpp
│ │ │ │ ├── main_matmat.cpp
│ │ │ │ └── main_vecmat.cpp
│ │ │ ├── gmm/
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── gmm_LU_solve_interface.hh
│ │ │ │ ├── gmm_interface.hh
│ │ │ │ └── main.cpp
│ │ │ ├── mtl4/
│ │ │ │ ├── .kdbgrc.main
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── main.cpp
│ │ │ │ ├── mtl4_LU_solve_interface.hh
│ │ │ │ └── mtl4_interface.hh
│ │ │ ├── tensors/
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── main_linear.cpp
│ │ │ │ ├── main_matmat.cpp
│ │ │ │ ├── main_vecmat.cpp
│ │ │ │ └── tensor_interface.hh
│ │ │ ├── tvmet/
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── main.cpp
│ │ │ │ └── tvmet_interface.hh
│ │ │ └── ublas/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── main.cpp
│ │ │ └── ublas_interface.hh
│ │ ├── check_cache_queries.cpp
│ │ ├── dense_solvers.cpp
│ │ ├── eig33.cpp
│ │ ├── geometry.cpp
│ │ ├── perf_monitoring/
│ │ │ ├── changesets.txt
│ │ │ ├── gemm.cpp
│ │ │ ├── gemm_common.h
│ │ │ ├── gemm_settings.txt
│ │ │ ├── gemm_square_settings.txt
│ │ │ ├── gemv.cpp
│ │ │ ├── gemv_common.h
│ │ │ ├── gemv_settings.txt
│ │ │ ├── gemv_square_settings.txt
│ │ │ ├── gemvt.cpp
│ │ │ ├── lazy_gemm.cpp
│ │ │ ├── lazy_gemm_settings.txt
│ │ │ ├── llt.cpp
│ │ │ ├── make_plot.sh
│ │ │ ├── resources/
│ │ │ │ ├── chart_footer.html
│ │ │ │ ├── chart_header.html
│ │ │ │ ├── footer.html
│ │ │ │ ├── header.html
│ │ │ │ ├── s1.js
│ │ │ │ └── s2.js
│ │ │ ├── run.sh
│ │ │ ├── runall.sh
│ │ │ ├── trmv_lo.cpp
│ │ │ ├── trmv_lot.cpp
│ │ │ ├── trmv_up.cpp
│ │ │ └── trmv_upt.cpp
│ │ ├── product_threshold.cpp
│ │ ├── quat_slerp.cpp
│ │ ├── quatmul.cpp
│ │ ├── sparse_cholesky.cpp
│ │ ├── sparse_dense_product.cpp
│ │ ├── sparse_lu.cpp
│ │ ├── sparse_product.cpp
│ │ ├── sparse_randomsetter.cpp
│ │ ├── sparse_setter.cpp
│ │ ├── sparse_transpose.cpp
│ │ ├── sparse_trisolver.cpp
│ │ ├── spbench/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── sp_solver.cpp
│ │ │ ├── spbench.dtd
│ │ │ ├── spbenchsolver.cpp
│ │ │ ├── spbenchsolver.h
│ │ │ ├── spbenchstyle.h
│ │ │ └── test_sparseLU.cpp
│ │ ├── spmv.cpp
│ │ ├── tensors/
│ │ │ ├── README
│ │ │ ├── benchmark.h
│ │ │ ├── benchmark_main.cc
│ │ │ ├── contraction_benchmarks_cpu.cc
│ │ │ ├── eigen_sycl_bench.sh
│ │ │ ├── eigen_sycl_bench_contract.sh
│ │ │ ├── tensor_benchmarks.h
│ │ │ ├── tensor_benchmarks_cpu.cc
│ │ │ ├── tensor_benchmarks_fp16_gpu.cu
│ │ │ ├── tensor_benchmarks_gpu.cu
│ │ │ ├── tensor_benchmarks_sycl.cc
│ │ │ └── tensor_contract_sycl_bench.cc
│ │ └── vdw_new.cpp
│ ├── blas/
│ │ ├── BandTriangularSolver.h
│ │ ├── CMakeLists.txt
│ │ ├── GeneralRank1Update.h
│ │ ├── PackedSelfadjointProduct.h
│ │ ├── PackedTriangularMatrixVector.h
│ │ ├── PackedTriangularSolverVector.h
│ │ ├── README.txt
│ │ ├── Rank2Update.h
│ │ ├── common.h
│ │ ├── complex_double.cpp
│ │ ├── complex_single.cpp
│ │ ├── double.cpp
│ │ ├── f2c/
│ │ │ ├── chbmv.c
│ │ │ ├── chpmv.c
│ │ │ ├── complexdots.c
│ │ │ ├── ctbmv.c
│ │ │ ├── d_cnjg.c
│ │ │ ├── datatypes.h
│ │ │ ├── drotm.c
│ │ │ ├── drotmg.c
│ │ │ ├── dsbmv.c
│ │ │ ├── dspmv.c
│ │ │ ├── dtbmv.c
│ │ │ ├── lsame.c
│ │ │ ├── r_cnjg.c
│ │ │ ├── srotm.c
│ │ │ ├── srotmg.c
│ │ │ ├── ssbmv.c
│ │ │ ├── sspmv.c
│ │ │ ├── stbmv.c
│ │ │ ├── zhbmv.c
│ │ │ ├── zhpmv.c
│ │ │ └── ztbmv.c
│ │ ├── fortran/
│ │ │ └── complexdots.f
│ │ ├── level1_cplx_impl.h
│ │ ├── level1_impl.h
│ │ ├── level1_real_impl.h
│ │ ├── level2_cplx_impl.h
│ │ ├── level2_impl.h
│ │ ├── level2_real_impl.h
│ │ ├── level3_impl.h
│ │ ├── single.cpp
│ │ ├── testing/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── cblat1.f
│ │ │ ├── cblat2.f
│ │ │ ├── cblat3.f
│ │ │ ├── dblat1.f
│ │ │ ├── dblat2.f
│ │ │ ├── dblat3.f
│ │ │ ├── runblastest.sh
│ │ │ ├── sblat1.f
│ │ │ ├── sblat2.f
│ │ │ ├── sblat3.f
│ │ │ ├── zblat1.f
│ │ │ ├── zblat2.f
│ │ │ └── zblat3.f
│ │ └── xerbla.cpp
│ ├── cmake/
│ │ ├── Eigen3Config.cmake.in
│ │ ├── Eigen3ConfigLegacy.cmake.in
│ │ ├── EigenConfigureTesting.cmake
│ │ ├── EigenDetermineOSVersion.cmake
│ │ ├── EigenDetermineVSServicePack.cmake
│ │ ├── EigenTesting.cmake
│ │ ├── EigenUninstall.cmake
│ │ ├── FindAdolc.cmake
│ │ ├── FindBLAS.cmake
│ │ ├── FindBLASEXT.cmake
│ │ ├── FindCholmod.cmake
│ │ ├── FindComputeCpp.cmake
│ │ ├── FindEigen2.cmake
│ │ ├── FindEigen3.cmake
│ │ ├── FindFFTW.cmake
│ │ ├── FindGLEW.cmake
│ │ ├── FindGMP.cmake
│ │ ├── FindGSL.cmake
│ │ ├── FindGoogleHash.cmake
│ │ ├── FindHWLOC.cmake
│ │ ├── FindKLU.cmake
│ │ ├── FindLAPACK.cmake
│ │ ├── FindMPFR.cmake
│ │ ├── FindMetis.cmake
│ │ ├── FindPTSCOTCH.cmake
│ │ ├── FindPastix.cmake
│ │ ├── FindSPQR.cmake
│ │ ├── FindScotch.cmake
│ │ ├── FindStandardMathLibrary.cmake
│ │ ├── FindSuperLU.cmake
│ │ ├── FindTriSYCL.cmake
│ │ ├── FindUmfpack.cmake
│ │ ├── RegexUtils.cmake
│ │ ├── UseEigen3.cmake
│ │ └── language_support.cmake
│ ├── debug/
│ │ ├── gdb/
│ │ │ ├── __init__.py
│ │ │ └── printers.py
│ │ └── msvc/
│ │ └── eigen.natvis
│ ├── demos/
│ │ ├── CMakeLists.txt
│ │ ├── mandelbrot/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── README
│ │ │ ├── mandelbrot.cpp
│ │ │ └── mandelbrot.h
│ │ ├── mix_eigen_and_c/
│ │ │ ├── README
│ │ │ ├── binary_library.cpp
│ │ │ ├── binary_library.h
│ │ │ └── example.c
│ │ └── opengl/
│ │ ├── CMakeLists.txt
│ │ ├── README
│ │ ├── camera.cpp
│ │ ├── camera.h
│ │ ├── gpuhelper.cpp
│ │ ├── gpuhelper.h
│ │ ├── icosphere.cpp
│ │ ├── icosphere.h
│ │ ├── quaternion_demo.cpp
│ │ ├── quaternion_demo.h
│ │ ├── trackball.cpp
│ │ └── trackball.h
│ ├── doc/
│ │ ├── AsciiQuickReference.txt
│ │ ├── B01_Experimental.dox
│ │ ├── CMakeLists.txt
│ │ ├── ClassHierarchy.dox
│ │ ├── CoeffwiseMathFunctionsTable.dox
│ │ ├── CustomizingEigen_CustomScalar.dox
│ │ ├── CustomizingEigen_InheritingMatrix.dox
│ │ ├── CustomizingEigen_NullaryExpr.dox
│ │ ├── CustomizingEigen_Plugins.dox
│ │ ├── DenseDecompositionBenchmark.dox
│ │ ├── Doxyfile.in
│ │ ├── FixedSizeVectorizable.dox
│ │ ├── FunctionsTakingEigenTypes.dox
│ │ ├── HiPerformance.dox
│ │ ├── InplaceDecomposition.dox
│ │ ├── InsideEigenExample.dox
│ │ ├── LeastSquares.dox
│ │ ├── Manual.dox
│ │ ├── MatrixfreeSolverExample.dox
│ │ ├── NewExpressionType.dox
│ │ ├── Overview.dox
│ │ ├── PassingByValue.dox
│ │ ├── Pitfalls.dox
│ │ ├── PreprocessorDirectives.dox
│ │ ├── QuickReference.dox
│ │ ├── QuickStartGuide.dox
│ │ ├── SparseLinearSystems.dox
│ │ ├── SparseQuickReference.dox
│ │ ├── StlContainers.dox
│ │ ├── StorageOrders.dox
│ │ ├── StructHavingEigenMembers.dox
│ │ ├── TemplateKeyword.dox
│ │ ├── TopicAliasing.dox
│ │ ├── TopicAssertions.dox
│ │ ├── TopicCMakeGuide.dox
│ │ ├── TopicEigenExpressionTemplates.dox
│ │ ├── TopicLazyEvaluation.dox
│ │ ├── TopicLinearAlgebraDecompositions.dox
│ │ ├── TopicMultithreading.dox
│ │ ├── TopicResizing.dox
│ │ ├── TopicScalarTypes.dox
│ │ ├── TopicVectorization.dox
│ │ ├── TutorialAdvancedInitialization.dox
│ │ ├── TutorialArrayClass.dox
│ │ ├── TutorialBlockOperations.dox
│ │ ├── TutorialGeometry.dox
│ │ ├── TutorialLinearAlgebra.dox
│ │ ├── TutorialMapClass.dox
│ │ ├── TutorialMatrixArithmetic.dox
│ │ ├── TutorialMatrixClass.dox
│ │ ├── TutorialReductionsVisitorsBroadcasting.dox
│ │ ├── TutorialReshape.dox
│ │ ├── TutorialSTL.dox
│ │ ├── TutorialSlicingIndexing.dox
│ │ ├── TutorialSparse.dox
│ │ ├── TutorialSparse_example_details.dox
│ │ ├── UnalignedArrayAssert.dox
│ │ ├── UsingBlasLapackBackends.dox
│ │ ├── UsingIntelMKL.dox
│ │ ├── UsingNVCC.dox
│ │ ├── WrongStackAlignment.dox
│ │ ├── eigen_navtree_hacks.js
│ │ ├── eigendoxy.css
│ │ ├── eigendoxy_footer.html.in
│ │ ├── eigendoxy_header.html.in
│ │ ├── eigendoxy_layout.xml.in
│ │ ├── eigendoxy_tabs.css
│ │ ├── examples/
│ │ │ ├── .krazy
│ │ │ ├── CMakeLists.txt
│ │ │ ├── CustomizingEigen_Inheritance.cpp
│ │ │ ├── Cwise_erf.cpp
│ │ │ ├── Cwise_erfc.cpp
│ │ │ ├── Cwise_lgamma.cpp
│ │ │ ├── DenseBase_middleCols_int.cpp
│ │ │ ├── DenseBase_middleRows_int.cpp
│ │ │ ├── DenseBase_template_int_middleCols.cpp
│ │ │ ├── DenseBase_template_int_middleRows.cpp
│ │ │ ├── QuickStart_example.cpp
│ │ │ ├── QuickStart_example2_dynamic.cpp
│ │ │ ├── QuickStart_example2_fixed.cpp
│ │ │ ├── TemplateKeyword_flexible.cpp
│ │ │ ├── TemplateKeyword_simple.cpp
│ │ │ ├── TutorialInplaceLU.cpp
│ │ │ ├── TutorialLinAlgComputeTwice.cpp
│ │ │ ├── TutorialLinAlgExComputeSolveError.cpp
│ │ │ ├── TutorialLinAlgExSolveColPivHouseholderQR.cpp
│ │ │ ├── TutorialLinAlgExSolveLDLT.cpp
│ │ │ ├── TutorialLinAlgInverseDeterminant.cpp
│ │ │ ├── TutorialLinAlgRankRevealing.cpp
│ │ │ ├── TutorialLinAlgSVDSolve.cpp
│ │ │ ├── TutorialLinAlgSelfAdjointEigenSolver.cpp
│ │ │ ├── TutorialLinAlgSetThreshold.cpp
│ │ │ ├── Tutorial_ArrayClass_accessors.cpp
│ │ │ ├── Tutorial_ArrayClass_addition.cpp
│ │ │ ├── Tutorial_ArrayClass_cwise_other.cpp
│ │ │ ├── Tutorial_ArrayClass_interop.cpp
│ │ │ ├── Tutorial_ArrayClass_interop_matrix.cpp
│ │ │ ├── Tutorial_ArrayClass_mult.cpp
│ │ │ ├── Tutorial_BlockOperations_block_assignment.cpp
│ │ │ ├── Tutorial_BlockOperations_colrow.cpp
│ │ │ ├── Tutorial_BlockOperations_corner.cpp
│ │ │ ├── Tutorial_BlockOperations_print_block.cpp
│ │ │ ├── Tutorial_BlockOperations_vector.cpp
│ │ │ ├── Tutorial_PartialLU_solve.cpp
│ │ │ ├── Tutorial_ReductionsVisitorsBroadcasting_broadcast_1nn.cpp
│ │ │ ├── Tutorial_ReductionsVisitorsBroadcasting_broadcast_simple.cpp
│ │ │ ├── Tutorial_ReductionsVisitorsBroadcasting_broadcast_simple_rowwise.cpp
│ │ │ ├── Tutorial_ReductionsVisitorsBroadcasting_colwise.cpp
│ │ │ ├── Tutorial_ReductionsVisitorsBroadcasting_maxnorm.cpp
│ │ │ ├── Tutorial_ReductionsVisitorsBroadcasting_reductions_bool.cpp
│ │ │ ├── Tutorial_ReductionsVisitorsBroadcasting_reductions_norm.cpp
│ │ │ ├── Tutorial_ReductionsVisitorsBroadcasting_reductions_operatornorm.cpp
│ │ │ ├── Tutorial_ReductionsVisitorsBroadcasting_rowwise.cpp
│ │ │ ├── Tutorial_ReductionsVisitorsBroadcasting_visitors.cpp
│ │ │ ├── Tutorial_simple_example_dynamic_size.cpp
│ │ │ ├── Tutorial_simple_example_fixed_size.cpp
│ │ │ ├── class_Block.cpp
│ │ │ ├── class_CwiseBinaryOp.cpp
│ │ │ ├── class_CwiseUnaryOp.cpp
│ │ │ ├── class_CwiseUnaryOp_ptrfun.cpp
│ │ │ ├── class_FixedBlock.cpp
│ │ │ ├── class_FixedReshaped.cpp
│ │ │ ├── class_FixedVectorBlock.cpp
│ │ │ ├── class_Reshaped.cpp
│ │ │ ├── class_VectorBlock.cpp
│ │ │ ├── function_taking_eigenbase.cpp
│ │ │ ├── function_taking_ref.cpp
│ │ │ ├── make_circulant.cpp
│ │ │ ├── make_circulant.cpp.entry
│ │ │ ├── make_circulant.cpp.evaluator
│ │ │ ├── make_circulant.cpp.expression
│ │ │ ├── make_circulant.cpp.main
│ │ │ ├── make_circulant.cpp.preamble
│ │ │ ├── make_circulant.cpp.traits
│ │ │ ├── make_circulant2.cpp
│ │ │ ├── matrixfree_cg.cpp
│ │ │ ├── nullary_indexing.cpp
│ │ │ ├── tut_arithmetic_add_sub.cpp
│ │ │ ├── tut_arithmetic_dot_cross.cpp
│ │ │ ├── tut_arithmetic_matrix_mul.cpp
│ │ │ ├── tut_arithmetic_redux_basic.cpp
│ │ │ ├── tut_arithmetic_scalar_mul_div.cpp
│ │ │ ├── tut_matrix_coefficient_accessors.cpp
│ │ │ ├── tut_matrix_resize.cpp
│ │ │ └── tut_matrix_resize_fixed_size.cpp
│ │ ├── snippets/
│ │ │ ├── .krazy
│ │ │ ├── AngleAxis_mimic_euler.cpp
│ │ │ ├── Array_initializer_list_23_cxx11.cpp
│ │ │ ├── Array_initializer_list_vector_cxx11.cpp
│ │ │ ├── Array_variadic_ctor_cxx11.cpp
│ │ │ ├── BiCGSTAB_simple.cpp
│ │ │ ├── BiCGSTAB_step_by_step.cpp
│ │ │ ├── CMakeLists.txt
│ │ │ ├── ColPivHouseholderQR_solve.cpp
│ │ │ ├── ComplexEigenSolver_compute.cpp
│ │ │ ├── ComplexEigenSolver_eigenvalues.cpp
│ │ │ ├── ComplexEigenSolver_eigenvectors.cpp
│ │ │ ├── ComplexSchur_compute.cpp
│ │ │ ├── ComplexSchur_matrixT.cpp
│ │ │ ├── ComplexSchur_matrixU.cpp
│ │ │ ├── Cwise_abs.cpp
│ │ │ ├── Cwise_abs2.cpp
│ │ │ ├── Cwise_acos.cpp
│ │ │ ├── Cwise_arg.cpp
│ │ │ ├── Cwise_array_power_array.cpp
│ │ │ ├── Cwise_asin.cpp
│ │ │ ├── Cwise_atan.cpp
│ │ │ ├── Cwise_boolean_and.cpp
│ │ │ ├── Cwise_boolean_not.cpp
│ │ │ ├── Cwise_boolean_or.cpp
│ │ │ ├── Cwise_boolean_xor.cpp
│ │ │ ├── Cwise_ceil.cpp
│ │ │ ├── Cwise_cos.cpp
│ │ │ ├── Cwise_cosh.cpp
│ │ │ ├── Cwise_cube.cpp
│ │ │ ├── Cwise_equal_equal.cpp
│ │ │ ├── Cwise_exp.cpp
│ │ │ ├── Cwise_floor.cpp
│ │ │ ├── Cwise_greater.cpp
│ │ │ ├── Cwise_greater_equal.cpp
│ │ │ ├── Cwise_inverse.cpp
│ │ │ ├── Cwise_isFinite.cpp
│ │ │ ├── Cwise_isInf.cpp
│ │ │ ├── Cwise_isNaN.cpp
│ │ │ ├── Cwise_less.cpp
│ │ │ ├── Cwise_less_equal.cpp
│ │ │ ├── Cwise_log.cpp
│ │ │ ├── Cwise_log10.cpp
│ │ │ ├── Cwise_max.cpp
│ │ │ ├── Cwise_min.cpp
│ │ │ ├── Cwise_minus.cpp
│ │ │ ├── Cwise_minus_equal.cpp
│ │ │ ├── Cwise_not_equal.cpp
│ │ │ ├── Cwise_plus.cpp
│ │ │ ├── Cwise_plus_equal.cpp
│ │ │ ├── Cwise_pow.cpp
│ │ │ ├── Cwise_product.cpp
│ │ │ ├── Cwise_quotient.cpp
│ │ │ ├── Cwise_rint.cpp
│ │ │ ├── Cwise_round.cpp
│ │ │ ├── Cwise_scalar_power_array.cpp
│ │ │ ├── Cwise_sign.cpp
│ │ │ ├── Cwise_sin.cpp
│ │ │ ├── Cwise_sinh.cpp
│ │ │ ├── Cwise_slash_equal.cpp
│ │ │ ├── Cwise_sqrt.cpp
│ │ │ ├── Cwise_square.cpp
│ │ │ ├── Cwise_tan.cpp
│ │ │ ├── Cwise_tanh.cpp
│ │ │ ├── Cwise_times_equal.cpp
│ │ │ ├── DenseBase_LinSpaced.cpp
│ │ │ ├── DenseBase_LinSpacedInt.cpp
│ │ │ ├── DenseBase_LinSpaced_seq_deprecated.cpp
│ │ │ ├── DenseBase_setLinSpaced.cpp
│ │ │ ├── DirectionWise_hnormalized.cpp
│ │ │ ├── DirectionWise_replicate.cpp
│ │ │ ├── DirectionWise_replicate_int.cpp
│ │ │ ├── EigenSolver_EigenSolver_MatrixType.cpp
│ │ │ ├── EigenSolver_compute.cpp
│ │ │ ├── EigenSolver_eigenvalues.cpp
│ │ │ ├── EigenSolver_eigenvectors.cpp
│ │ │ ├── EigenSolver_pseudoEigenvectors.cpp
│ │ │ ├── FullPivHouseholderQR_solve.cpp
│ │ │ ├── FullPivLU_image.cpp
│ │ │ ├── FullPivLU_kernel.cpp
│ │ │ ├── FullPivLU_solve.cpp
│ │ │ ├── GeneralizedEigenSolver.cpp
│ │ │ ├── HessenbergDecomposition_compute.cpp
│ │ │ ├── HessenbergDecomposition_matrixH.cpp
│ │ │ ├── HessenbergDecomposition_packedMatrix.cpp
│ │ │ ├── HouseholderQR_householderQ.cpp
│ │ │ ├── HouseholderQR_solve.cpp
│ │ │ ├── HouseholderSequence_HouseholderSequence.cpp
│ │ │ ├── IOFormat.cpp
│ │ │ ├── JacobiSVD_basic.cpp
│ │ │ ├── Jacobi_makeGivens.cpp
│ │ │ ├── Jacobi_makeJacobi.cpp
│ │ │ ├── LLT_example.cpp
│ │ │ ├── LLT_solve.cpp
│ │ │ ├── LeastSquaresNormalEquations.cpp
│ │ │ ├── LeastSquaresQR.cpp
│ │ │ ├── Map_general_stride.cpp
│ │ │ ├── Map_inner_stride.cpp
│ │ │ ├── Map_outer_stride.cpp
│ │ │ ├── Map_placement_new.cpp
│ │ │ ├── Map_simple.cpp
│ │ │ ├── MatrixBase_adjoint.cpp
│ │ │ ├── MatrixBase_all.cpp
│ │ │ ├── MatrixBase_applyOnTheLeft.cpp
│ │ │ ├── MatrixBase_applyOnTheRight.cpp
│ │ │ ├── MatrixBase_array.cpp
│ │ │ ├── MatrixBase_array_const.cpp
│ │ │ ├── MatrixBase_asDiagonal.cpp
│ │ │ ├── MatrixBase_block_int_int.cpp
│ │ │ ├── MatrixBase_block_int_int_int_int.cpp
│ │ │ ├── MatrixBase_bottomLeftCorner_int_int.cpp
│ │ │ ├── MatrixBase_bottomRightCorner_int_int.cpp
│ │ │ ├── MatrixBase_bottomRows_int.cpp
│ │ │ ├── MatrixBase_cast.cpp
│ │ │ ├── MatrixBase_col.cpp
│ │ │ ├── MatrixBase_colwise.cpp
│ │ │ ├── MatrixBase_colwise_iterator_cxx11.cpp
│ │ │ ├── MatrixBase_computeInverseAndDetWithCheck.cpp
│ │ │ ├── MatrixBase_computeInverseWithCheck.cpp
│ │ │ ├── MatrixBase_cwiseAbs.cpp
│ │ │ ├── MatrixBase_cwiseAbs2.cpp
│ │ │ ├── MatrixBase_cwiseEqual.cpp
│ │ │ ├── MatrixBase_cwiseInverse.cpp
│ │ │ ├── MatrixBase_cwiseMax.cpp
│ │ │ ├── MatrixBase_cwiseMin.cpp
│ │ │ ├── MatrixBase_cwiseNotEqual.cpp
│ │ │ ├── MatrixBase_cwiseProduct.cpp
│ │ │ ├── MatrixBase_cwiseQuotient.cpp
│ │ │ ├── MatrixBase_cwiseSign.cpp
│ │ │ ├── MatrixBase_cwiseSqrt.cpp
│ │ │ ├── MatrixBase_diagonal.cpp
│ │ │ ├── MatrixBase_diagonal_int.cpp
│ │ │ ├── MatrixBase_diagonal_template_int.cpp
│ │ │ ├── MatrixBase_eigenvalues.cpp
│ │ │ ├── MatrixBase_end_int.cpp
│ │ │ ├── MatrixBase_eval.cpp
│ │ │ ├── MatrixBase_fixedBlock_int_int.cpp
│ │ │ ├── MatrixBase_hnormalized.cpp
│ │ │ ├── MatrixBase_homogeneous.cpp
│ │ │ ├── MatrixBase_identity.cpp
│ │ │ ├── MatrixBase_identity_int_int.cpp
│ │ │ ├── MatrixBase_inverse.cpp
│ │ │ ├── MatrixBase_isDiagonal.cpp
│ │ │ ├── MatrixBase_isIdentity.cpp
│ │ │ ├── MatrixBase_isOnes.cpp
│ │ │ ├── MatrixBase_isOrthogonal.cpp
│ │ │ ├── MatrixBase_isUnitary.cpp
│ │ │ ├── MatrixBase_isZero.cpp
│ │ │ ├── MatrixBase_leftCols_int.cpp
│ │ │ ├── MatrixBase_noalias.cpp
│ │ │ ├── MatrixBase_ones.cpp
│ │ │ ├── MatrixBase_ones_int.cpp
│ │ │ ├── MatrixBase_ones_int_int.cpp
│ │ │ ├── MatrixBase_operatorNorm.cpp
│ │ │ ├── MatrixBase_prod.cpp
│ │ │ ├── MatrixBase_random.cpp
│ │ │ ├── MatrixBase_random_int.cpp
│ │ │ ├── MatrixBase_random_int_int.cpp
│ │ │ ├── MatrixBase_replicate.cpp
│ │ │ ├── MatrixBase_replicate_int_int.cpp
│ │ │ ├── MatrixBase_reshaped_auto.cpp
│ │ │ ├── MatrixBase_reshaped_fixed.cpp
│ │ │ ├── MatrixBase_reshaped_int_int.cpp
│ │ │ ├── MatrixBase_reshaped_to_vector.cpp
│ │ │ ├── MatrixBase_reverse.cpp
│ │ │ ├── MatrixBase_rightCols_int.cpp
│ │ │ ├── MatrixBase_row.cpp
│ │ │ ├── MatrixBase_rowwise.cpp
│ │ │ ├── MatrixBase_segment_int_int.cpp
│ │ │ ├── MatrixBase_select.cpp
│ │ │ ├── MatrixBase_selfadjointView.cpp
│ │ │ ├── MatrixBase_set.cpp
│ │ │ ├── MatrixBase_setIdentity.cpp
│ │ │ ├── MatrixBase_setOnes.cpp
│ │ │ ├── MatrixBase_setRandom.cpp
│ │ │ ├── MatrixBase_setZero.cpp
│ │ │ ├── MatrixBase_start_int.cpp
│ │ │ ├── MatrixBase_template_int_bottomRows.cpp
│ │ │ ├── MatrixBase_template_int_end.cpp
│ │ │ ├── MatrixBase_template_int_int_block_int_int_int_int.cpp
│ │ │ ├── MatrixBase_template_int_int_bottomLeftCorner.cpp
│ │ │ ├── MatrixBase_template_int_int_bottomLeftCorner_int_int.cpp
│ │ │ ├── MatrixBase_template_int_int_bottomRightCorner.cpp
│ │ │ ├── MatrixBase_template_int_int_bottomRightCorner_int_int.cpp
│ │ │ ├── MatrixBase_template_int_int_topLeftCorner.cpp
│ │ │ ├── MatrixBase_template_int_int_topLeftCorner_int_int.cpp
│ │ │ ├── MatrixBase_template_int_int_topRightCorner.cpp
│ │ │ ├── MatrixBase_template_int_int_topRightCorner_int_int.cpp
│ │ │ ├── MatrixBase_template_int_leftCols.cpp
│ │ │ ├── MatrixBase_template_int_rightCols.cpp
│ │ │ ├── MatrixBase_template_int_segment.cpp
│ │ │ ├── MatrixBase_template_int_start.cpp
│ │ │ ├── MatrixBase_template_int_topRows.cpp
│ │ │ ├── MatrixBase_topLeftCorner_int_int.cpp
│ │ │ ├── MatrixBase_topRightCorner_int_int.cpp
│ │ │ ├── MatrixBase_topRows_int.cpp
│ │ │ ├── MatrixBase_transpose.cpp
│ │ │ ├── MatrixBase_triangularView.cpp
│ │ │ ├── MatrixBase_zero.cpp
│ │ │ ├── MatrixBase_zero_int.cpp
│ │ │ ├── MatrixBase_zero_int_int.cpp
│ │ │ ├── Matrix_Map_stride.cpp
│ │ │ ├── Matrix_initializer_list_23_cxx11.cpp
│ │ │ ├── Matrix_initializer_list_vector_cxx11.cpp
│ │ │ ├── Matrix_resize_NoChange_int.cpp
│ │ │ ├── Matrix_resize_int.cpp
│ │ │ ├── Matrix_resize_int_NoChange.cpp
│ │ │ ├── Matrix_resize_int_int.cpp
│ │ │ ├── Matrix_setConstant_int.cpp
│ │ │ ├── Matrix_setConstant_int_int.cpp
│ │ │ ├── Matrix_setIdentity_int_int.cpp
│ │ │ ├── Matrix_setOnes_int.cpp
│ │ │ ├── Matrix_setOnes_int_int.cpp
│ │ │ ├── Matrix_setRandom_int.cpp
│ │ │ ├── Matrix_setRandom_int_int.cpp
│ │ │ ├── Matrix_setZero_int.cpp
│ │ │ ├── Matrix_setZero_int_int.cpp
│ │ │ ├── Matrix_variadic_ctor_cxx11.cpp
│ │ │ ├── PartialPivLU_solve.cpp
│ │ │ ├── PartialRedux_count.cpp
│ │ │ ├── PartialRedux_maxCoeff.cpp
│ │ │ ├── PartialRedux_minCoeff.cpp
│ │ │ ├── PartialRedux_norm.cpp
│ │ │ ├── PartialRedux_prod.cpp
│ │ │ ├── PartialRedux_squaredNorm.cpp
│ │ │ ├── PartialRedux_sum.cpp
│ │ │ ├── RealQZ_compute.cpp
│ │ │ ├── RealSchur_RealSchur_MatrixType.cpp
│ │ │ ├── RealSchur_compute.cpp
│ │ │ ├── SelfAdjointEigenSolver_SelfAdjointEigenSolver.cpp
│ │ │ ├── SelfAdjointEigenSolver_SelfAdjointEigenSolver_MatrixType.cpp
│ │ │ ├── SelfAdjointEigenSolver_SelfAdjointEigenSolver_MatrixType2.cpp
│ │ │ ├── SelfAdjointEigenSolver_compute_MatrixType.cpp
│ │ │ ├── SelfAdjointEigenSolver_compute_MatrixType2.cpp
│ │ │ ├── SelfAdjointEigenSolver_eigenvalues.cpp
│ │ │ ├── SelfAdjointEigenSolver_eigenvectors.cpp
│ │ │ ├── SelfAdjointEigenSolver_operatorInverseSqrt.cpp
│ │ │ ├── SelfAdjointEigenSolver_operatorSqrt.cpp
│ │ │ ├── SelfAdjointView_eigenvalues.cpp
│ │ │ ├── SelfAdjointView_operatorNorm.cpp
│ │ │ ├── Slicing_arrayexpr.cpp
│ │ │ ├── Slicing_custom_padding_cxx11.cpp
│ │ │ ├── Slicing_rawarray_cxx11.cpp
│ │ │ ├── Slicing_stdvector_cxx11.cpp
│ │ │ ├── SparseMatrix_coeffs.cpp
│ │ │ ├── TopicAliasing_block.cpp
│ │ │ ├── TopicAliasing_block_correct.cpp
│ │ │ ├── TopicAliasing_cwise.cpp
│ │ │ ├── TopicAliasing_mult1.cpp
│ │ │ ├── TopicAliasing_mult2.cpp
│ │ │ ├── TopicAliasing_mult3.cpp
│ │ │ ├── TopicAliasing_mult4.cpp
│ │ │ ├── TopicAliasing_mult5.cpp
│ │ │ ├── TopicStorageOrders_example.cpp
│ │ │ ├── Triangular_solve.cpp
│ │ │ ├── Tridiagonalization_Tridiagonalization_MatrixType.cpp
│ │ │ ├── Tridiagonalization_compute.cpp
│ │ │ ├── Tridiagonalization_decomposeInPlace.cpp
│ │ │ ├── Tridiagonalization_diagonal.cpp
│ │ │ ├── Tridiagonalization_householderCoefficients.cpp
│ │ │ ├── Tridiagonalization_packedMatrix.cpp
│ │ │ ├── Tutorial_AdvancedInitialization_Block.cpp
│ │ │ ├── Tutorial_AdvancedInitialization_CommaTemporary.cpp
│ │ │ ├── Tutorial_AdvancedInitialization_Join.cpp
│ │ │ ├── Tutorial_AdvancedInitialization_LinSpaced.cpp
│ │ │ ├── Tutorial_AdvancedInitialization_ThreeWays.cpp
│ │ │ ├── Tutorial_AdvancedInitialization_Zero.cpp
│ │ │ ├── Tutorial_Map_rowmajor.cpp
│ │ │ ├── Tutorial_Map_using.cpp
│ │ │ ├── Tutorial_ReshapeMat2Mat.cpp
│ │ │ ├── Tutorial_ReshapeMat2Vec.cpp
│ │ │ ├── Tutorial_SlicingCol.cpp
│ │ │ ├── Tutorial_SlicingVec.cpp
│ │ │ ├── Tutorial_commainit_01.cpp
│ │ │ ├── Tutorial_commainit_01b.cpp
│ │ │ ├── Tutorial_commainit_02.cpp
│ │ │ ├── Tutorial_range_for_loop_1d_cxx11.cpp
│ │ │ ├── Tutorial_range_for_loop_2d_cxx11.cpp
│ │ │ ├── Tutorial_reshaped_vs_resize_1.cpp
│ │ │ ├── Tutorial_reshaped_vs_resize_2.cpp
│ │ │ ├── Tutorial_solve_matrix_inverse.cpp
│ │ │ ├── Tutorial_solve_multiple_rhs.cpp
│ │ │ ├── Tutorial_solve_reuse_decomposition.cpp
│ │ │ ├── Tutorial_solve_singular.cpp
│ │ │ ├── Tutorial_solve_triangular.cpp
│ │ │ ├── Tutorial_solve_triangular_inplace.cpp
│ │ │ ├── Tutorial_std_sort.cpp
│ │ │ ├── Tutorial_std_sort_rows_cxx11.cpp
│ │ │ ├── VectorwiseOp_homogeneous.cpp
│ │ │ ├── Vectorwise_reverse.cpp
│ │ │ ├── class_FullPivLU.cpp
│ │ │ ├── compile_snippet.cpp.in
│ │ │ ├── tut_arithmetic_redux_minmax.cpp
│ │ │ ├── tut_arithmetic_transpose_aliasing.cpp
│ │ │ ├── tut_arithmetic_transpose_conjugate.cpp
│ │ │ ├── tut_arithmetic_transpose_inplace.cpp
│ │ │ └── tut_matrix_assignment_resizing.cpp
│ │ ├── special_examples/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── Tutorial_sparse_example.cpp
│ │ │ ├── Tutorial_sparse_example_details.cpp
│ │ │ └── random_cpp11.cpp
│ │ └── tutorial.cpp
│ ├── eigen3.pc.in
│ ├── failtest/
│ │ ├── CMakeLists.txt
│ │ ├── bdcsvd_int.cpp
│ │ ├── block_nonconst_ctor_on_const_xpr_0.cpp
│ │ ├── block_nonconst_ctor_on_const_xpr_1.cpp
│ │ ├── block_nonconst_ctor_on_const_xpr_2.cpp
│ │ ├── block_on_const_type_actually_const_0.cpp
│ │ ├── block_on_const_type_actually_const_1.cpp
│ │ ├── colpivqr_int.cpp
│ │ ├── const_qualified_block_method_retval_0.cpp
│ │ ├── const_qualified_block_method_retval_1.cpp
│ │ ├── const_qualified_diagonal_method_retval.cpp
│ │ ├── const_qualified_transpose_method_retval.cpp
│ │ ├── cwiseunaryview_nonconst_ctor_on_const_xpr.cpp
│ │ ├── cwiseunaryview_on_const_type_actually_const.cpp
│ │ ├── diagonal_nonconst_ctor_on_const_xpr.cpp
│ │ ├── diagonal_on_const_type_actually_const.cpp
│ │ ├── eigensolver_cplx.cpp
│ │ ├── eigensolver_int.cpp
│ │ ├── failtest_sanity_check.cpp
│ │ ├── fullpivlu_int.cpp
│ │ ├── fullpivqr_int.cpp
│ │ ├── initializer_list_1.cpp
│ │ ├── initializer_list_2.cpp
│ │ ├── jacobisvd_int.cpp
│ │ ├── ldlt_int.cpp
│ │ ├── llt_int.cpp
│ │ ├── map_nonconst_ctor_on_const_ptr_0.cpp
│ │ ├── map_nonconst_ctor_on_const_ptr_1.cpp
│ │ ├── map_nonconst_ctor_on_const_ptr_2.cpp
│ │ ├── map_nonconst_ctor_on_const_ptr_3.cpp
│ │ ├── map_nonconst_ctor_on_const_ptr_4.cpp
│ │ ├── map_on_const_type_actually_const_0.cpp
│ │ ├── map_on_const_type_actually_const_1.cpp
│ │ ├── partialpivlu_int.cpp
│ │ ├── qr_int.cpp
│ │ ├── ref_1.cpp
│ │ ├── ref_2.cpp
│ │ ├── ref_3.cpp
│ │ ├── ref_4.cpp
│ │ ├── ref_5.cpp
│ │ ├── selfadjointview_nonconst_ctor_on_const_xpr.cpp
│ │ ├── selfadjointview_on_const_type_actually_const.cpp
│ │ ├── sparse_ref_1.cpp
│ │ ├── sparse_ref_2.cpp
│ │ ├── sparse_ref_3.cpp
│ │ ├── sparse_ref_4.cpp
│ │ ├── sparse_ref_5.cpp
│ │ ├── sparse_storage_mismatch.cpp
│ │ ├── swap_1.cpp
│ │ ├── swap_2.cpp
│ │ ├── ternary_1.cpp
│ │ ├── ternary_2.cpp
│ │ ├── transpose_nonconst_ctor_on_const_xpr.cpp
│ │ ├── transpose_on_const_type_actually_const.cpp
│ │ ├── triangularview_nonconst_ctor_on_const_xpr.cpp
│ │ └── triangularview_on_const_type_actually_const.cpp
│ ├── lapack/
│ │ ├── CMakeLists.txt
│ │ ├── cholesky.cpp
│ │ ├── clacgv.f
│ │ ├── cladiv.f
│ │ ├── clarf.f
│ │ ├── clarfb.f
│ │ ├── clarfg.f
│ │ ├── clarft.f
│ │ ├── complex_double.cpp
│ │ ├── complex_single.cpp
│ │ ├── dladiv.f
│ │ ├── dlamch.f
│ │ ├── dlapy2.f
│ │ ├── dlapy3.f
│ │ ├── dlarf.f
│ │ ├── dlarfb.f
│ │ ├── dlarfg.f
│ │ ├── dlarft.f
│ │ ├── double.cpp
│ │ ├── dsecnd_NONE.f
│ │ ├── eigenvalues.cpp
│ │ ├── ilaclc.f
│ │ ├── ilaclr.f
│ │ ├── iladlc.f
│ │ ├── iladlr.f
│ │ ├── ilaslc.f
│ │ ├── ilaslr.f
│ │ ├── ilazlc.f
│ │ ├── ilazlr.f
│ │ ├── lapack_common.h
│ │ ├── lu.cpp
│ │ ├── second_NONE.f
│ │ ├── single.cpp
│ │ ├── sladiv.f
│ │ ├── slamch.f
│ │ ├── slapy2.f
│ │ ├── slapy3.f
│ │ ├── slarf.f
│ │ ├── slarfb.f
│ │ ├── slarfg.f
│ │ ├── slarft.f
│ │ ├── svd.cpp
│ │ ├── zlacgv.f
│ │ ├── zladiv.f
│ │ ├── zlarf.f
│ │ ├── zlarfb.f
│ │ ├── zlarfg.f
│ │ └── zlarft.f
│ ├── scripts/
│ │ ├── CMakeLists.txt
│ │ ├── buildtests.in
│ │ ├── cdashtesting.cmake.in
│ │ ├── check.in
│ │ ├── debug.in
│ │ ├── eigen_gen_credits.cpp
│ │ ├── eigen_gen_docs
│ │ ├── eigen_gen_split_test_help.cmake
│ │ ├── eigen_monitor_perf.sh
│ │ ├── release.in
│ │ └── relicense.py
│ ├── signature_of_eigen3_matrix_library
│ ├── test/
│ │ ├── AnnoyingScalar.h
│ │ ├── CMakeLists.txt
│ │ ├── adjoint.cpp
│ │ ├── array_cwise.cpp
│ │ ├── array_for_matrix.cpp
│ │ ├── array_of_string.cpp
│ │ ├── array_replicate.cpp
│ │ ├── array_reverse.cpp
│ │ ├── bandmatrix.cpp
│ │ ├── basicstuff.cpp
│ │ ├── bdcsvd.cpp
│ │ ├── bicgstab.cpp
│ │ ├── block.cpp
│ │ ├── boostmultiprec.cpp
│ │ ├── bug1213.cpp
│ │ ├── bug1213.h
│ │ ├── bug1213_main.cpp
│ │ ├── cholesky.cpp
│ │ ├── cholmod_support.cpp
│ │ ├── commainitializer.cpp
│ │ ├── conjugate_gradient.cpp
│ │ ├── conservative_resize.cpp
│ │ ├── constructor.cpp
│ │ ├── corners.cpp
│ │ ├── ctorleak.cpp
│ │ ├── denseLM.cpp
│ │ ├── dense_storage.cpp
│ │ ├── determinant.cpp
│ │ ├── diagonal.cpp
│ │ ├── diagonal_matrix_variadic_ctor.cpp
│ │ ├── diagonalmatrices.cpp
│ │ ├── dontalign.cpp
│ │ ├── dynalloc.cpp
│ │ ├── eigen2support.cpp
│ │ ├── eigensolver_complex.cpp
│ │ ├── eigensolver_generalized_real.cpp
│ │ ├── eigensolver_generic.cpp
│ │ ├── eigensolver_selfadjoint.cpp
│ │ ├── evaluator_common.h
│ │ ├── evaluators.cpp
│ │ ├── exceptions.cpp
│ │ ├── fastmath.cpp
│ │ ├── first_aligned.cpp
│ │ ├── geo_alignedbox.cpp
│ │ ├── geo_eulerangles.cpp
│ │ ├── geo_homogeneous.cpp
│ │ ├── geo_hyperplane.cpp
│ │ ├── geo_orthomethods.cpp
│ │ ├── geo_parametrizedline.cpp
│ │ ├── geo_quaternion.cpp
│ │ ├── geo_transformations.cpp
│ │ ├── gpu_basic.cu
│ │ ├── gpu_common.h
│ │ ├── half_float.cpp
│ │ ├── hessenberg.cpp
│ │ ├── householder.cpp
│ │ ├── incomplete_cholesky.cpp
│ │ ├── indexed_view.cpp
│ │ ├── initializer_list_construction.cpp
│ │ ├── inplace_decomposition.cpp
│ │ ├── integer_types.cpp
│ │ ├── inverse.cpp
│ │ ├── io.cpp
│ │ ├── is_same_dense.cpp
│ │ ├── jacobi.cpp
│ │ ├── jacobisvd.cpp
│ │ ├── klu_support.cpp
│ │ ├── linearstructure.cpp
│ │ ├── lscg.cpp
│ │ ├── lu.cpp
│ │ ├── main.h
│ │ ├── mapped_matrix.cpp
│ │ ├── mapstaticmethods.cpp
│ │ ├── mapstride.cpp
│ │ ├── meta.cpp
│ │ ├── metis_support.cpp
│ │ ├── miscmatrices.cpp
│ │ ├── mixingtypes.cpp
│ │ ├── mpl2only.cpp
│ │ ├── nestbyvalue.cpp
│ │ ├── nesting_ops.cpp
│ │ ├── nomalloc.cpp
│ │ ├── nullary.cpp
│ │ ├── num_dimensions.cpp
│ │ ├── numext.cpp
│ │ ├── packetmath.cpp
│ │ ├── packetmath_test_shared.h
│ │ ├── pardiso_support.cpp
│ │ ├── pastix_support.cpp
│ │ ├── permutationmatrices.cpp
│ │ ├── prec_inverse_4x4.cpp
│ │ ├── product.h
│ │ ├── product_extra.cpp
│ │ ├── product_large.cpp
│ │ ├── product_mmtr.cpp
│ │ ├── product_notemporary.cpp
│ │ ├── product_selfadjoint.cpp
│ │ ├── product_small.cpp
│ │ ├── product_symm.cpp
│ │ ├── product_syrk.cpp
│ │ ├── product_trmm.cpp
│ │ ├── product_trmv.cpp
│ │ ├── product_trsolve.cpp
│ │ ├── qr.cpp
│ │ ├── qr_colpivoting.cpp
│ │ ├── qr_fullpivoting.cpp
│ │ ├── qtvector.cpp
│ │ ├── rand.cpp
│ │ ├── real_qz.cpp
│ │ ├── redux.cpp
│ │ ├── ref.cpp
│ │ ├── reshape.cpp
│ │ ├── resize.cpp
│ │ ├── rvalue_types.cpp
│ │ ├── schur_complex.cpp
│ │ ├── schur_real.cpp
│ │ ├── selfadjoint.cpp
│ │ ├── simplicial_cholesky.cpp
│ │ ├── sizeof.cpp
│ │ ├── sizeoverflow.cpp
│ │ ├── smallvectors.cpp
│ │ ├── solverbase.h
│ │ ├── sparse.h
│ │ ├── sparseLM.cpp
│ │ ├── sparse_basic.cpp
│ │ ├── sparse_block.cpp
│ │ ├── sparse_permutations.cpp
│ │ ├── sparse_product.cpp
│ │ ├── sparse_ref.cpp
│ │ ├── sparse_solver.h
│ │ ├── sparse_solvers.cpp
│ │ ├── sparse_vector.cpp
│ │ ├── sparselu.cpp
│ │ ├── sparseqr.cpp
│ │ ├── special_numbers.cpp
│ │ ├── split_test_helper.h
│ │ ├── spqr_support.cpp
│ │ ├── stable_norm.cpp
│ │ ├── stddeque.cpp
│ │ ├── stddeque_overload.cpp
│ │ ├── stdlist.cpp
│ │ ├── stdlist_overload.cpp
│ │ ├── stdvector.cpp
│ │ ├── stdvector_overload.cpp
│ │ ├── stl_iterators.cpp
│ │ ├── superlu_support.cpp
│ │ ├── svd_common.h
│ │ ├── svd_fill.h
│ │ ├── swap.cpp
│ │ ├── symbolic_index.cpp
│ │ ├── triangular.cpp
│ │ ├── type_alias.cpp
│ │ ├── umeyama.cpp
│ │ ├── umfpack_support.cpp
│ │ ├── unalignedassert.cpp
│ │ ├── unalignedcount.cpp
│ │ ├── upperbidiagonalization.cpp
│ │ ├── vectorization_logic.cpp
│ │ ├── vectorwiseop.cpp
│ │ ├── visitor.cpp
│ │ └── zerosized.cpp
│ └── unsupported/
│ ├── CMakeLists.txt
│ ├── Eigen/
│ │ ├── AdolcForward
│ │ ├── AlignedVector3
│ │ ├── ArpackSupport
│ │ ├── AutoDiff
│ │ ├── BVH
│ │ ├── CMakeLists.txt
│ │ ├── CXX11/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── Tensor
│ │ │ ├── TensorSymmetry
│ │ │ ├── ThreadPool
│ │ │ └── src/
│ │ │ ├── Tensor/
│ │ │ │ ├── README.md
│ │ │ │ ├── Tensor.h
│ │ │ │ ├── TensorArgMax.h
│ │ │ │ ├── TensorAssign.h
│ │ │ │ ├── TensorBase.h
│ │ │ │ ├── TensorBlock.h
│ │ │ │ ├── TensorBroadcasting.h
│ │ │ │ ├── TensorChipping.h
│ │ │ │ ├── TensorConcatenation.h
│ │ │ │ ├── TensorContraction.h
│ │ │ │ ├── TensorContractionBlocking.h
│ │ │ │ ├── TensorContractionCuda.h
│ │ │ │ ├── TensorContractionGpu.h
│ │ │ │ ├── TensorContractionMapper.h
│ │ │ │ ├── TensorContractionSycl.h
│ │ │ │ ├── TensorContractionThreadPool.h
│ │ │ │ ├── TensorConversion.h
│ │ │ │ ├── TensorConvolution.h
│ │ │ │ ├── TensorConvolutionSycl.h
│ │ │ │ ├── TensorCostModel.h
│ │ │ │ ├── TensorCustomOp.h
│ │ │ │ ├── TensorDevice.h
│ │ │ │ ├── TensorDeviceCuda.h
│ │ │ │ ├── TensorDeviceDefault.h
│ │ │ │ ├── TensorDeviceGpu.h
│ │ │ │ ├── TensorDeviceSycl.h
│ │ │ │ ├── TensorDeviceThreadPool.h
│ │ │ │ ├── TensorDimensionList.h
│ │ │ │ ├── TensorDimensions.h
│ │ │ │ ├── TensorEvalTo.h
│ │ │ │ ├── TensorEvaluator.h
│ │ │ │ ├── TensorExecutor.h
│ │ │ │ ├── TensorExpr.h
│ │ │ │ ├── TensorFFT.h
│ │ │ │ ├── TensorFixedSize.h
│ │ │ │ ├── TensorForcedEval.h
│ │ │ │ ├── TensorForwardDeclarations.h
│ │ │ │ ├── TensorFunctors.h
│ │ │ │ ├── TensorGenerator.h
│ │ │ │ ├── TensorGlobalFunctions.h
│ │ │ │ ├── TensorGpuHipCudaDefines.h
│ │ │ │ ├── TensorGpuHipCudaUndefines.h
│ │ │ │ ├── TensorIO.h
│ │ │ │ ├── TensorImagePatch.h
│ │ │ │ ├── TensorIndexList.h
│ │ │ │ ├── TensorInflation.h
│ │ │ │ ├── TensorInitializer.h
│ │ │ │ ├── TensorIntDiv.h
│ │ │ │ ├── TensorLayoutSwap.h
│ │ │ │ ├── TensorMacros.h
│ │ │ │ ├── TensorMap.h
│ │ │ │ ├── TensorMeta.h
│ │ │ │ ├── TensorMorphing.h
│ │ │ │ ├── TensorPadding.h
│ │ │ │ ├── TensorPatch.h
│ │ │ │ ├── TensorRandom.h
│ │ │ │ ├── TensorReduction.h
│ │ │ │ ├── TensorReductionCuda.h
│ │ │ │ ├── TensorReductionGpu.h
│ │ │ │ ├── TensorReductionSycl.h
│ │ │ │ ├── TensorRef.h
│ │ │ │ ├── TensorReverse.h
│ │ │ │ ├── TensorScan.h
│ │ │ │ ├── TensorScanSycl.h
│ │ │ │ ├── TensorShuffling.h
│ │ │ │ ├── TensorStorage.h
│ │ │ │ ├── TensorStriding.h
│ │ │ │ ├── TensorTrace.h
│ │ │ │ ├── TensorTraits.h
│ │ │ │ ├── TensorUInt128.h
│ │ │ │ └── TensorVolumePatch.h
│ │ │ ├── TensorSymmetry/
│ │ │ │ ├── DynamicSymmetry.h
│ │ │ │ ├── StaticSymmetry.h
│ │ │ │ ├── Symmetry.h
│ │ │ │ └── util/
│ │ │ │ └── TemplateGroupTheory.h
│ │ │ ├── ThreadPool/
│ │ │ │ ├── Barrier.h
│ │ │ │ ├── EventCount.h
│ │ │ │ ├── NonBlockingThreadPool.h
│ │ │ │ ├── RunQueue.h
│ │ │ │ ├── ThreadCancel.h
│ │ │ │ ├── ThreadEnvironment.h
│ │ │ │ ├── ThreadLocal.h
│ │ │ │ ├── ThreadPoolInterface.h
│ │ │ │ └── ThreadYield.h
│ │ │ └── util/
│ │ │ ├── CXX11Meta.h
│ │ │ ├── CXX11Workarounds.h
│ │ │ ├── EmulateArray.h
│ │ │ └── MaxSizeVector.h
│ │ ├── EulerAngles
│ │ ├── FFT
│ │ ├── IterativeSolvers
│ │ ├── KroneckerProduct
│ │ ├── LevenbergMarquardt
│ │ ├── MPRealSupport
│ │ ├── MatrixFunctions
│ │ ├── MoreVectorization
│ │ ├── NonLinearOptimization
│ │ ├── NumericalDiff
│ │ ├── OpenGLSupport
│ │ ├── Polynomials
│ │ ├── Skyline
│ │ ├── SparseExtra
│ │ ├── SpecialFunctions
│ │ ├── Splines
│ │ └── src/
│ │ ├── AutoDiff/
│ │ │ ├── AutoDiffJacobian.h
│ │ │ ├── AutoDiffScalar.h
│ │ │ └── AutoDiffVector.h
│ │ ├── BVH/
│ │ │ ├── BVAlgorithms.h
│ │ │ └── KdBVH.h
│ │ ├── Eigenvalues/
│ │ │ └── ArpackSelfAdjointEigenSolver.h
│ │ ├── EulerAngles/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── EulerAngles.h
│ │ │ └── EulerSystem.h
│ │ ├── FFT/
│ │ │ ├── ei_fftw_impl.h
│ │ │ └── ei_kissfft_impl.h
│ │ ├── IterativeSolvers/
│ │ │ ├── ConstrainedConjGrad.h
│ │ │ ├── DGMRES.h
│ │ │ ├── GMRES.h
│ │ │ ├── IncompleteLU.h
│ │ │ ├── IterationController.h
│ │ │ ├── MINRES.h
│ │ │ └── Scaling.h
│ │ ├── KroneckerProduct/
│ │ │ └── KroneckerTensorProduct.h
│ │ ├── LevenbergMarquardt/
│ │ │ ├── CopyrightMINPACK.txt
│ │ │ ├── LMcovar.h
│ │ │ ├── LMonestep.h
│ │ │ ├── LMpar.h
│ │ │ ├── LMqrsolv.h
│ │ │ └── LevenbergMarquardt.h
│ │ ├── MatrixFunctions/
│ │ │ ├── MatrixExponential.h
│ │ │ ├── MatrixFunction.h
│ │ │ ├── MatrixLogarithm.h
│ │ │ ├── MatrixPower.h
│ │ │ ├── MatrixSquareRoot.h
│ │ │ └── StemFunction.h
│ │ ├── MoreVectorization/
│ │ │ └── MathFunctions.h
│ │ ├── NonLinearOptimization/
│ │ │ ├── HybridNonLinearSolver.h
│ │ │ ├── LevenbergMarquardt.h
│ │ │ ├── chkder.h
│ │ │ ├── covar.h
│ │ │ ├── dogleg.h
│ │ │ ├── fdjac1.h
│ │ │ ├── lmpar.h
│ │ │ ├── qrsolv.h
│ │ │ ├── r1mpyq.h
│ │ │ ├── r1updt.h
│ │ │ └── rwupdt.h
│ │ ├── NumericalDiff/
│ │ │ └── NumericalDiff.h
│ │ ├── Polynomials/
│ │ │ ├── Companion.h
│ │ │ ├── PolynomialSolver.h
│ │ │ └── PolynomialUtils.h
│ │ ├── Skyline/
│ │ │ ├── SkylineInplaceLU.h
│ │ │ ├── SkylineMatrix.h
│ │ │ ├── SkylineMatrixBase.h
│ │ │ ├── SkylineProduct.h
│ │ │ ├── SkylineStorage.h
│ │ │ └── SkylineUtil.h
│ │ ├── SparseExtra/
│ │ │ ├── BlockOfDynamicSparseMatrix.h
│ │ │ ├── BlockSparseMatrix.h
│ │ │ ├── DynamicSparseMatrix.h
│ │ │ ├── MarketIO.h
│ │ │ ├── MatrixMarketIterator.h
│ │ │ └── RandomSetter.h
│ │ ├── SpecialFunctions/
│ │ │ ├── BesselFunctionsArrayAPI.h
│ │ │ ├── BesselFunctionsFunctors.h
│ │ │ ├── BesselFunctionsHalf.h
│ │ │ ├── BesselFunctionsImpl.h
│ │ │ ├── BesselFunctionsPacketMath.h
│ │ │ ├── HipVectorCompatibility.h
│ │ │ ├── SpecialFunctionsArrayAPI.h
│ │ │ ├── SpecialFunctionsFunctors.h
│ │ │ ├── SpecialFunctionsHalf.h
│ │ │ ├── SpecialFunctionsImpl.h
│ │ │ ├── SpecialFunctionsPacketMath.h
│ │ │ └── arch/
│ │ │ └── GPU/
│ │ │ └── GpuSpecialFunctions.h
│ │ └── Splines/
│ │ ├── Spline.h
│ │ ├── SplineFitting.h
│ │ └── SplineFwd.h
│ ├── README.txt
│ ├── bench/
│ │ └── bench_svd.cpp
│ ├── doc/
│ │ ├── CMakeLists.txt
│ │ ├── Overview.dox
│ │ ├── SYCL.dox
│ │ ├── eigendoxy_layout.xml.in
│ │ ├── examples/
│ │ │ ├── BVH_Example.cpp
│ │ │ ├── CMakeLists.txt
│ │ │ ├── EulerAngles.cpp
│ │ │ ├── FFT.cpp
│ │ │ ├── MatrixExponential.cpp
│ │ │ ├── MatrixFunction.cpp
│ │ │ ├── MatrixLogarithm.cpp
│ │ │ ├── MatrixPower.cpp
│ │ │ ├── MatrixPower_optimal.cpp
│ │ │ ├── MatrixSine.cpp
│ │ │ ├── MatrixSinh.cpp
│ │ │ ├── MatrixSquareRoot.cpp
│ │ │ ├── PolynomialSolver1.cpp
│ │ │ ├── PolynomialUtils1.cpp
│ │ │ └── SYCL/
│ │ │ ├── CMakeLists.txt
│ │ │ └── CwiseMul.cpp
│ │ └── snippets/
│ │ └── CMakeLists.txt
│ └── test/
│ ├── BVH.cpp
│ ├── CMakeLists.txt
│ ├── EulerAngles.cpp
│ ├── FFT.cpp
│ ├── FFTW.cpp
│ ├── NonLinearOptimization.cpp
│ ├── NumericalDiff.cpp
│ ├── alignedvector3.cpp
│ ├── autodiff.cpp
│ ├── autodiff_scalar.cpp
│ ├── bessel_functions.cpp
│ ├── cxx11_eventcount.cpp
│ ├── cxx11_maxsizevector.cpp
│ ├── cxx11_meta.cpp
│ ├── cxx11_non_blocking_thread_pool.cpp
│ ├── cxx11_runqueue.cpp
│ ├── cxx11_tensor_argmax.cpp
│ ├── cxx11_tensor_argmax_gpu.cu
│ ├── cxx11_tensor_argmax_sycl.cpp
│ ├── cxx11_tensor_assign.cpp
│ ├── cxx11_tensor_block_access.cpp
│ ├── cxx11_tensor_block_eval.cpp
│ ├── cxx11_tensor_block_io.cpp
│ ├── cxx11_tensor_broadcast_sycl.cpp
│ ├── cxx11_tensor_broadcasting.cpp
│ ├── cxx11_tensor_builtins_sycl.cpp
│ ├── cxx11_tensor_cast_float16_gpu.cu
│ ├── cxx11_tensor_casts.cpp
│ ├── cxx11_tensor_chipping.cpp
│ ├── cxx11_tensor_chipping_sycl.cpp
│ ├── cxx11_tensor_comparisons.cpp
│ ├── cxx11_tensor_complex_cwise_ops_gpu.cu
│ ├── cxx11_tensor_complex_gpu.cu
│ ├── cxx11_tensor_concatenation.cpp
│ ├── cxx11_tensor_concatenation_sycl.cpp
│ ├── cxx11_tensor_const.cpp
│ ├── cxx11_tensor_contract_gpu.cu
│ ├── cxx11_tensor_contract_sycl.cpp
│ ├── cxx11_tensor_contraction.cpp
│ ├── cxx11_tensor_convolution.cpp
│ ├── cxx11_tensor_convolution_sycl.cpp
│ ├── cxx11_tensor_custom_index.cpp
│ ├── cxx11_tensor_custom_op.cpp
│ ├── cxx11_tensor_custom_op_sycl.cpp
│ ├── cxx11_tensor_device.cu
│ ├── cxx11_tensor_device_sycl.cpp
│ ├── cxx11_tensor_dimension.cpp
│ ├── cxx11_tensor_empty.cpp
│ ├── cxx11_tensor_executor.cpp
│ ├── cxx11_tensor_expr.cpp
│ ├── cxx11_tensor_fft.cpp
│ ├── cxx11_tensor_fixed_size.cpp
│ ├── cxx11_tensor_forced_eval.cpp
│ ├── cxx11_tensor_forced_eval_sycl.cpp
│ ├── cxx11_tensor_generator.cpp
│ ├── cxx11_tensor_generator_sycl.cpp
│ ├── cxx11_tensor_gpu.cu
│ ├── cxx11_tensor_ifft.cpp
│ ├── cxx11_tensor_image_op_sycl.cpp
│ ├── cxx11_tensor_image_patch.cpp
│ ├── cxx11_tensor_image_patch_sycl.cpp
│ ├── cxx11_tensor_index_list.cpp
│ ├── cxx11_tensor_inflation.cpp
│ ├── cxx11_tensor_inflation_sycl.cpp
│ ├── cxx11_tensor_intdiv.cpp
│ ├── cxx11_tensor_io.cpp
│ ├── cxx11_tensor_layout_swap.cpp
│ ├── cxx11_tensor_layout_swap_sycl.cpp
│ ├── cxx11_tensor_lvalue.cpp
│ ├── cxx11_tensor_map.cpp
│ ├── cxx11_tensor_math.cpp
│ ├── cxx11_tensor_math_sycl.cpp
│ ├── cxx11_tensor_mixed_indices.cpp
│ ├── cxx11_tensor_morphing.cpp
│ ├── cxx11_tensor_morphing_sycl.cpp
│ ├── cxx11_tensor_move.cpp
│ ├── cxx11_tensor_notification.cpp
│ ├── cxx11_tensor_of_complex.cpp
│ ├── cxx11_tensor_of_const_values.cpp
│ ├── cxx11_tensor_of_float16_gpu.cu
│ ├── cxx11_tensor_of_strings.cpp
│ ├── cxx11_tensor_padding.cpp
│ ├── cxx11_tensor_padding_sycl.cpp
│ ├── cxx11_tensor_patch.cpp
│ ├── cxx11_tensor_patch_sycl.cpp
│ ├── cxx11_tensor_random.cpp
│ ├── cxx11_tensor_random_gpu.cu
│ ├── cxx11_tensor_random_sycl.cpp
│ ├── cxx11_tensor_reduction.cpp
│ ├── cxx11_tensor_reduction_gpu.cu
│ ├── cxx11_tensor_reduction_sycl.cpp
│ ├── cxx11_tensor_ref.cpp
│ ├── cxx11_tensor_reverse.cpp
│ ├── cxx11_tensor_reverse_sycl.cpp
│ ├── cxx11_tensor_roundings.cpp
│ ├── cxx11_tensor_scan.cpp
│ ├── cxx11_tensor_scan_gpu.cu
│ ├── cxx11_tensor_scan_sycl.cpp
│ ├── cxx11_tensor_shuffling.cpp
│ ├── cxx11_tensor_shuffling_sycl.cpp
│ ├── cxx11_tensor_simple.cpp
│ ├── cxx11_tensor_striding.cpp
│ ├── cxx11_tensor_striding_sycl.cpp
│ ├── cxx11_tensor_sugar.cpp
│ ├── cxx11_tensor_sycl.cpp
│ ├── cxx11_tensor_symmetry.cpp
│ ├── cxx11_tensor_thread_local.cpp
│ ├── cxx11_tensor_thread_pool.cpp
│ ├── cxx11_tensor_trace.cpp
│ ├── cxx11_tensor_uint128.cpp
│ ├── cxx11_tensor_volume_patch.cpp
│ ├── cxx11_tensor_volume_patch_sycl.cpp
│ ├── dgmres.cpp
│ ├── forward_adolc.cpp
│ ├── gmres.cpp
│ ├── kronecker_product.cpp
│ ├── levenberg_marquardt.cpp
│ ├── matrix_exponential.cpp
│ ├── matrix_function.cpp
│ ├── matrix_functions.h
│ ├── matrix_power.cpp
│ ├── matrix_square_root.cpp
│ ├── minres.cpp
│ ├── mpreal/
│ │ └── mpreal.h
│ ├── mpreal_support.cpp
│ ├── openglsupport.cpp
│ ├── polynomialsolver.cpp
│ ├── polynomialutils.cpp
│ ├── sparse_extra.cpp
│ ├── special_functions.cpp
│ ├── special_packetmath.cpp
│ └── splines.cpp
├── CMakeLists.txt
├── README.md
├── data/
│ └── circle.csv
├── include/
│ ├── camera_calibrator.hpp
│ ├── logging.hpp
│ ├── nonlinear_optimizer.hpp
│ ├── params.hpp
│ ├── reprojection_error.hpp
│ └── termination_checking.hpp
├── src/
│ ├── camera_calibrator.cpp
│ ├── lidar2camera.cpp
│ └── nonlinear_optimizer.cpp
└── tool/
├── LidarCircleDetect/
│ ├── CMakeLists.txt
│ ├── data/
│ │ ├── 2022-01-18-15-25-03-449.pcd
│ │ ├── 2022-01-18-15-25-03-549.pcd
│ │ ├── 2022-01-18-15-25-03-649.pcd
│ │ ├── 2022-01-18-15-25-03-749.pcd
│ │ ├── 2022-01-18-15-25-03-849.pcd
│ │ ├── 2022-01-18-15-25-03-949.pcd
│ │ ├── 2022-01-18-15-25-04-049.pcd
│ │ ├── 2022-01-18-15-25-04-149.pcd
│ │ ├── 2022-01-18-15-25-04-249.pcd
│ │ └── 2022-01-18-15-25-04-349.pcd
│ ├── include/
│ │ ├── lidar_pattern.h
│ │ └── logging.hpp
│ └── src/
│ ├── lidar_pattern.cpp
│ └── run_lidar_detection.cpp
└── README.md
Showing preview only (8,554K chars total). Download the full file or copy to clipboard to get everything.
SYMBOL INDEX (13034 symbols across 1554 files)
FILE: 3rdparty/ceres/include/ceres/autodiff_cost_function.h
function namespace (line 135) | namespace ceres {
FILE: 3rdparty/ceres/include/ceres/autodiff_first_order_function.h
function namespace (line 42) | namespace ceres {
FILE: 3rdparty/ceres/include/ceres/autodiff_local_parameterization.h
function namespace (line 41) | namespace ceres {
FILE: 3rdparty/ceres/include/ceres/c_api.h
type ceres_problem_s (line 113) | struct ceres_problem_s
type ceres_problem_t (line 114) | typedef struct ceres_problem_s ceres_problem_t;
type ceres_residual_block_id_s (line 116) | struct ceres_residual_block_id_s
type ceres_residual_block_id_t (line 117) | typedef struct ceres_residual_block_id_s ceres_residual_block_id_t;
FILE: 3rdparty/ceres/include/ceres/conditioned_cost_function.h
function namespace (line 44) | namespace ceres {
FILE: 3rdparty/ceres/include/ceres/context.h
function namespace (line 34) | namespace ceres {
FILE: 3rdparty/ceres/include/ceres/cost_function.h
function namespace (line 53) | namespace ceres {
FILE: 3rdparty/ceres/include/ceres/covariance.h
function namespace (line 42) | namespace ceres {
FILE: 3rdparty/ceres/include/ceres/crs_matrix.h
function namespace (line 39) | namespace ceres {
FILE: 3rdparty/ceres/include/ceres/cubic_interpolation.h
function namespace (line 38) | namespace ceres {
function Evaluate (line 264) | void Evaluate(
function Evaluate (line 330) | void Evaluate(const double& r, const double& c, double* f) const {
function EIGEN_STRONG_INLINE (line 403) | EIGEN_STRONG_INLINE void GetValue(const int r, const int c, double* f) c...
FILE: 3rdparty/ceres/include/ceres/dynamic_autodiff_cost_function.h
function namespace (line 45) | namespace ceres {
FILE: 3rdparty/ceres/include/ceres/dynamic_cost_function.h
function namespace (line 36) | namespace ceres {
FILE: 3rdparty/ceres/include/ceres/dynamic_cost_function_to_functor.h
function namespace (line 43) | namespace ceres {
FILE: 3rdparty/ceres/include/ceres/dynamic_numeric_diff_cost_function.h
function namespace (line 49) | namespace ceres {
function Evaluate (line 93) | bool Evaluate(double const* const* parameters,
FILE: 3rdparty/ceres/include/ceres/evaluation_callback.h
function namespace (line 36) | namespace ceres {
FILE: 3rdparty/ceres/include/ceres/first_order_function.h
function namespace (line 36) | namespace ceres {
FILE: 3rdparty/ceres/include/ceres/gradient_checker.h
function namespace (line 48) | namespace ceres {
FILE: 3rdparty/ceres/include/ceres/gradient_problem.h
function namespace (line 40) | namespace ceres {
FILE: 3rdparty/ceres/include/ceres/gradient_problem_solver.h
function Options (line 56) | struct CERES_EXPORT Options {
type CERES_EXPORT (line 256) | struct CERES_EXPORT
FILE: 3rdparty/ceres/include/ceres/internal/algorithm.h
function namespace (line 29) | namespace ceres {
FILE: 3rdparty/ceres/include/ceres/internal/array_selector.h
function namespace (line 41) | namespace ceres {
FILE: 3rdparty/ceres/include/ceres/internal/autodiff.h
function namespace (line 167) | namespace ceres {
function Apply (line 233) | void Apply(T const* const* /* NOT USED */, JetT* /* NOT USED */) {}
function Take0thOrderPart (line 239) | void Take0thOrderPart(int M, const JetT* src, T dst) {
function Take1stOrderPart (line 249) | void Take1stOrderPart(const int M, const JetT* src, T* dst) {
function Apply (line 283) | void Apply(int num_outputs, JetT* output, T** jacobians) {
function Apply (line 297) | void Apply(int /* NOT USED*/,
function AutoDifferentiate (line 306) | bool AutoDifferentiate(const Functor& functor,
FILE: 3rdparty/ceres/include/ceres/internal/eigen.h
function namespace (line 36) | namespace ceres {
FILE: 3rdparty/ceres/include/ceres/internal/fixed_array.h
function namespace (line 46) | namespace ceres {
function size_type (line 430) | size_type size() const { return std::get<0>(size_alloc_); }
function StorageElement (line 432) | StorageElement* end() const { return begin() + size(); }
function StorageElement (line 440) | StorageElement* InitializeData() {
FILE: 3rdparty/ceres/include/ceres/internal/householder_vector.h
function namespace (line 37) | namespace ceres {
FILE: 3rdparty/ceres/include/ceres/internal/integer_sequence.h
function namespace (line 44) | namespace ceres {
function namespace (line 56) | namespace ceres {
FILE: 3rdparty/ceres/include/ceres/internal/integer_sequence_algorithm.h
function namespace (line 40) | namespace ceres {
FILE: 3rdparty/ceres/include/ceres/internal/line_parameterization.h
function namespace (line 37) | namespace ceres {
FILE: 3rdparty/ceres/include/ceres/internal/memory.h
function namespace (line 43) | namespace ceres {
FILE: 3rdparty/ceres/include/ceres/internal/numeric_diff.h
function namespace (line 50) | namespace ceres {
FILE: 3rdparty/ceres/include/ceres/internal/parameter_dims.h
function IsValidParameterDimensionSequence (line 44) | constexpr bool IsValidParameterDimensionSequence(integer_sequence<int>) {
function GetDim (line 87) | static constexpr int GetDim(int dim) { return params_[dim]; }
FILE: 3rdparty/ceres/include/ceres/internal/variadic_evaluate.h
function namespace (line 43) | namespace ceres {
FILE: 3rdparty/ceres/include/ceres/iteration_callback.h
function namespace (line 41) | namespace ceres {
FILE: 3rdparty/ceres/include/ceres/jet.h
function namespace (line 169) | namespace ceres {
function BesselJ0 (line 582) | inline double BesselJ0(double x) {
function BesselJ1 (line 589) | inline double BesselJ1(double x) {
function BesselJn (line 596) | inline double BesselJn(int n, double x) {
function isfinite (line 646) | bool isfinite(const Jet<T, N>& f) {
function isinf (line 658) | bool isinf(const Jet<T, N>& f) {
function isnan (line 668) | bool isnan(const Jet<T, N>& f) {
function isnormal (line 678) | bool isnormal(const Jet<T, N>& f) {
function IsFinite (line 688) | bool IsFinite(const Jet<T, N>& f) {
function IsNaN (line 693) | bool IsNaN(const Jet<T, N>& f) {
function IsNormal (line 698) | bool IsNormal(const Jet<T, N>& f) {
function IsInfinite (line 704) | bool IsInfinite(const Jet<T, N>& f) {
function namespace (line 858) | namespace std {
function namespace (line 922) | namespace Eigen {
type ceres (line 983) | typedef ceres::Jet<T, N> ReturnType;
type ceres (line 987) | typedef ceres::Jet<T, N> ReturnType;
FILE: 3rdparty/ceres/include/ceres/local_parameterization.h
function GlobalSize (line 146) | int GlobalSize() const = 0;
function virtual (line 179) | virtual ~SubsetParameterization() {}
function virtual (line 253) | virtual ~HomogeneousVectorParameterization() {}
function CERES_EXPORT (line 279) | CERES_EXPORT LineParameterization : public LocalParameterization {
FILE: 3rdparty/ceres/include/ceres/loss_function.h
function namespace (line 84) | namespace ceres {
FILE: 3rdparty/ceres/include/ceres/normal_prior.h
function namespace (line 41) | namespace ceres {
FILE: 3rdparty/ceres/include/ceres/numeric_diff_cost_function.h
function namespace (line 176) | namespace ceres {
FILE: 3rdparty/ceres/include/ceres/numeric_diff_options.h
function namespace (line 37) | namespace ceres {
FILE: 3rdparty/ceres/include/ceres/ordered_groups.h
function Clear (line 86) | void Clear() {
function Remove (line 93) | bool Remove(const T element) {
function Remove (line 112) | int Remove(const std::vector<T>& elements) {
function Reverse (line 125) | void Reverse() {
type OrderedGroups (line 193) | typedef OrderedGroups<double*> ParameterBlockOrdering;
FILE: 3rdparty/ceres/include/ceres/problem.h
type CRSMatrix (line 57) | struct CRSMatrix
function namespace (line 59) | namespace internal {
type internal (line 68) | typedef internal::ResidualBlock* ResidualBlockId;
type CERES_EXPORT (line 124) | struct CERES_EXPORT
type EvaluateOptions (line 405) | struct EvaluateOptions {
FILE: 3rdparty/ceres/include/ceres/rotation.h
function namespace (line 54) | namespace ceres {
function RotationMatrixToAngleAxis (line 367) | void RotationMatrixToAngleAxis(const T* R, T* angle_axis) {
function AngleAxisToRotationMatrix (line 381) | void AngleAxisToRotationMatrix(const T* angle_axis, T* R) {
function EulerAnglesToRotationMatrix (line 428) | void EulerAnglesToRotationMatrix(const T* euler,
function QuaternionToScaledRotation (line 465) | void QuaternionToScaledRotation(const T q[4], T R[3 * 3]) {
function QuaternionToScaledRotation (line 470) | void QuaternionToScaledRotation(
function QuaternionToRotation (line 498) | void QuaternionToRotation(const T q[4], T R[3 * 3]) {
function QuaternionToRotation (line 503) | void QuaternionToRotation(
function UnitQuaternionRotatePoint (line 518) | void UnitQuaternionRotatePoint(const T q[4],
function QuaternionRotatePoint (line 540) | void QuaternionRotatePoint(const T q[4], const T pt[3], T result[3]) {
function QuaternionProduct (line 559) | void QuaternionProduct(const T z[4], const T w[4], T zw[4]) {
function CrossProduct (line 573) | void CrossProduct(const T x[3], const T y[3], T x_cross_y[3]) {
function T (line 583) | T DotProduct(const T x[3], const T y[3]) {
function AngleAxisRotatePoint (line 588) | void AngleAxisRotatePoint(const T angle_axis[3],
FILE: 3rdparty/ceres/include/ceres/sized_cost_function.h
function namespace (line 46) | namespace ceres {
FILE: 3rdparty/ceres/include/ceres/solver.h
function Options (line 60) | struct CERES_EXPORT Options {
type CERES_EXPORT (line 756) | struct CERES_EXPORT
FILE: 3rdparty/ceres/include/ceres/tiny_solver.h
function namespace (line 59) | namespace ceres {
FILE: 3rdparty/ceres/include/ceres/tiny_solver_autodiff_function.h
function namespace (line 45) | namespace ceres {
FILE: 3rdparty/ceres/include/ceres/tiny_solver_cost_function_adapter.h
function namespace (line 38) | namespace ceres {
FILE: 3rdparty/ceres/include/ceres/types.h
function namespace (line 45) | namespace ceres {
FILE: 3rdparty/ceres/internal/ceres/accelerate_sparse.cc
type ceres (line 49) | namespace ceres {
type internal (line 50) | namespace internal {
class AccelerateSparse<double> (line 166) | class AccelerateSparse<double>
class AccelerateSparse<float> (line 167) | class AccelerateSparse<float>
function LinearSolverTerminationType (line 194) | LinearSolverTerminationType
function LinearSolverTerminationType (line 238) | LinearSolverTerminationType
class AppleAccelerateCholesky<double> (line 283) | class AppleAccelerateCholesky<double>
class AppleAccelerateCholesky<float> (line 284) | class AppleAccelerateCholesky<float>
FILE: 3rdparty/ceres/internal/ceres/accelerate_sparse.h
function namespace (line 47) | namespace ceres {
FILE: 3rdparty/ceres/internal/ceres/algorithm_test.cc
function TEST (line 26) | TEST(EqualTest, DefaultComparisonRandomAccess) {
function TEST (line 40) | TEST(EqualTest, DefaultComparison) {
function TEST (line 54) | TEST(EqualTest, EmptyRange) {
function TEST (line 67) | TEST(EqualTest, MixedIterTypes) {
function TEST (line 81) | TEST(EqualTest, MixedValueTypes) {
function TEST (line 95) | TEST(EqualTest, WeirdIterators) {
function TEST (line 109) | TEST(EqualTest, CustomComparison) {
function TEST (line 126) | TEST(EqualTest, MoveOnlyPredicate) {
type CountingTrivialPred (line 145) | struct CountingTrivialPred {
function TEST (line 153) | TEST(EqualTest, RandomAccessComplexity) {
FILE: 3rdparty/ceres/internal/ceres/array_selector_test.cc
type ceres (line 36) | namespace ceres {
type internal (line 37) | namespace internal {
function TEST (line 42) | TEST(ArraySelector, FixedArray) {
function TEST (line 56) | TEST(ArraySelector, Array) {
function TEST (line 68) | TEST(ArraySelector, Vector) {
FILE: 3rdparty/ceres/internal/ceres/array_utils.cc
type ceres (line 40) | namespace ceres {
type internal (line 41) | namespace internal {
function IsArrayValid (line 45) | bool IsArrayValid(const int size, const double* x) {
function FindInvalidValue (line 56) | int FindInvalidValue(const int size, const double* x) {
function InvalidateArray (line 70) | void InvalidateArray(const int size, double* x) {
function AppendArrayToString (line 78) | void AppendArrayToString(const int size, const double* x, string* re...
function MapValuesToContiguousRange (line 92) | void MapValuesToContiguousRange(const int size, int* array) {
FILE: 3rdparty/ceres/internal/ceres/array_utils.h
function namespace (line 49) | namespace ceres {
FILE: 3rdparty/ceres/internal/ceres/array_utils_test.cc
type ceres (line 38) | namespace ceres {
type internal (line 39) | namespace internal {
function TEST (line 43) | TEST(ArrayUtils, IsArrayValid) {
function TEST (line 60) | TEST(ArrayUtils, FindInvalidIndex) {
function TEST (line 77) | TEST(MapValuesToContiguousRange, ContiguousEntries) {
function TEST (line 93) | TEST(MapValuesToContiguousRange, NonContiguousEntries) {
function TEST (line 104) | TEST(MapValuesToContiguousRange, NonContiguousRepeatingEntries) {
FILE: 3rdparty/ceres/internal/ceres/autodiff_benchmarks/autodiff_benchmarks.cc
type ceres (line 43) | namespace ceres {
type internal (line 44) | namespace internal {
type CostFunctionToFunctor (line 54) | struct CostFunctionToFunctor {
method CostFunctionToFunctor (line 56) | explicit CostFunctionToFunctor(_Args&&... __args)
function BM_ConstantAnalytic (line 70) | static void BM_ConstantAnalytic(benchmark::State& state) {
function BM_ConstantAutodiff (line 90) | static void BM_ConstantAutodiff(benchmark::State& state) {
function BM_Linear1AutoDiff (line 127) | static void BM_Linear1AutoDiff(benchmark::State& state) {
function BM_Linear10AutoDiff (line 148) | static void BM_Linear10AutoDiff(benchmark::State& state) {
type Rat43CostFunctor (line 170) | struct Rat43CostFunctor {
method Rat43CostFunctor (line 171) | Rat43CostFunctor(const double x, const double y) : x_(x), y_(y) {}
function BM_Rat43AutoDiff (line 188) | static void BM_Rat43AutoDiff(benchmark::State& state) {
function BM_SnavelyReprojectionAutoDiff (line 208) | static void BM_SnavelyReprojectionAutoDiff(benchmark::State& state) {
function BM_PhotometricAutoDiff (line 235) | static void BM_PhotometricAutoDiff(benchmark::State& state) {
function BM_RelativePoseAutoDiff (line 299) | static void BM_RelativePoseAutoDiff(benchmark::State& state) {
function BM_BrdfAutoDiff (line 329) | static void BM_BrdfAutoDiff(benchmark::State& state) {
FILE: 3rdparty/ceres/internal/ceres/autodiff_benchmarks/brdf_cost_function.h
function namespace (line 38) | namespace ceres {
FILE: 3rdparty/ceres/internal/ceres/autodiff_benchmarks/constant_cost_function.h
function namespace (line 37) | namespace ceres {
function virtual (line 48) | virtual bool Evaluate(double const* const* parameters,
FILE: 3rdparty/ceres/internal/ceres/autodiff_benchmarks/linear_cost_functions.h
function namespace (line 37) | namespace ceres {
FILE: 3rdparty/ceres/internal/ceres/autodiff_benchmarks/photometric_error.h
function namespace (line 39) | namespace ceres {
FILE: 3rdparty/ceres/internal/ceres/autodiff_benchmarks/relative_pose_error.h
function namespace (line 39) | namespace ceres {
FILE: 3rdparty/ceres/internal/ceres/autodiff_benchmarks/snavely_reprojection_error.h
function namespace (line 37) | namespace ceres {
FILE: 3rdparty/ceres/internal/ceres/autodiff_cost_function_test.cc
type ceres (line 39) | namespace ceres {
type internal (line 40) | namespace internal {
class BinaryScalarCost (line 42) | class BinaryScalarCost {
method BinaryScalarCost (line 44) | explicit BinaryScalarCost(double a): a_(a) {}
function TEST (line 55) | TEST(AutodiffCostFunction, BilinearDifferentiationTest) {
type TenParameterCost (line 96) | struct TenParameterCost {
function TEST (line 114) | TEST(AutodiffCostFunction, ManyParameterAutodiffInstantiates) {
type OnlyFillsOneOutputFunctor (line 148) | struct OnlyFillsOneOutputFunctor {
function TEST (line 156) | TEST(AutoDiffCostFunction, PartiallyFilledResidualShouldFailEvaluati...
FILE: 3rdparty/ceres/internal/ceres/autodiff_first_order_function_test.cc
type ceres (line 39) | namespace ceres {
type internal (line 40) | namespace internal {
class QuadraticCostFunctor (line 42) | class QuadraticCostFunctor {
method QuadraticCostFunctor (line 44) | explicit QuadraticCostFunctor(double a) : a_(a) {}
function TEST (line 55) | TEST(AutoDiffFirstOrderFunction, BilinearDifferentiationTest) {
FILE: 3rdparty/ceres/internal/ceres/autodiff_local_parameterization_test.cc
type ceres (line 37) | namespace ceres {
type internal (line 38) | namespace internal {
type IdentityPlus (line 40) | struct IdentityPlus {
function TEST (line 50) | TEST(AutoDiffLocalParameterizationTest, IdentityParameterization) {
type ScaledPlus (line 73) | struct ScaledPlus {
method ScaledPlus (line 74) | explicit ScaledPlus(const double &scale_factor)
function TEST (line 89) | TEST(AutoDiffLocalParameterizationTest, ScaledParameterization) {
type QuaternionPlus (line 114) | struct QuaternionPlus {
function QuaternionParameterizationTestHelper (line 144) | static void QuaternionParameterizationTestHelper(const double* x,
function TEST (line 182) | TEST(AutoDiffLocalParameterization, QuaternionParameterizationZeroTe...
function TEST (line 189) | TEST(AutoDiffLocalParameterization, QuaternionParameterizationNearZe...
function TEST (line 207) | TEST(AutoDiffLocalParameterization, QuaternionParameterizationNonZer...
FILE: 3rdparty/ceres/internal/ceres/autodiff_test.cc
type ceres (line 36) | namespace ceres {
type internal (line 37) | namespace internal {
function T (line 40) | inline T& RowMajorAccess(T* base, int rows, int cols, int i, int j) {
function SymmetricDiff (line 53) | inline bool SymmetricDiff(const B& b,
function QuaternionToScaledRotation (line 101) | inline void QuaternionToScaledRotation(A const q[4], A R[3 * 3]) {
type Projective (line 134) | struct Projective {
function TEST (line 165) | TEST(AutoDiff, ProjectiveCameraModel) {
type Metric (line 242) | struct Metric {
function TEST (line 285) | TEST(AutoDiff, Metric) {
type VaryingResidualFunctor (line 344) | struct VaryingResidualFunctor {
function TEST (line 356) | TEST(AutoDiff, VaryingNumberOfResidualsForOneCostFunctorType) {
type Residual1Param (line 385) | struct Residual1Param {
type Residual2Param (line 393) | struct Residual2Param {
type Residual3Param (line 401) | struct Residual3Param {
type Residual4Param (line 409) | struct Residual4Param {
type Residual5Param (line 418) | struct Residual5Param {
type Residual6Param (line 431) | struct Residual6Param {
type Residual7Param (line 446) | struct Residual7Param {
type Residual8Param (line 462) | struct Residual8Param {
type Residual9Param (line 479) | struct Residual9Param {
type Residual10Param (line 497) | struct Residual10Param {
function TEST (line 516) | TEST(AutoDiff, VariadicAutoDiff) {
function TEST (line 652) | TEST(AutoDiff, AlignedAllocationTest) {
FILE: 3rdparty/ceres/internal/ceres/blas.cc
type ceres (line 48) | namespace ceres {
type internal (line 49) | namespace internal {
FILE: 3rdparty/ceres/internal/ceres/blas.h
function namespace (line 36) | namespace ceres {
FILE: 3rdparty/ceres/internal/ceres/block_evaluate_preparer.cc
type ceres (line 40) | namespace ceres {
type internal (line 41) | namespace internal {
FILE: 3rdparty/ceres/internal/ceres/block_evaluate_preparer.h
function namespace (line 41) | namespace ceres {
FILE: 3rdparty/ceres/internal/ceres/block_jacobi_preconditioner.cc
type ceres (line 39) | namespace ceres {
type internal (line 40) | namespace internal {
FILE: 3rdparty/ceres/internal/ceres/block_jacobi_preconditioner.h
function namespace (line 38) | namespace ceres {
FILE: 3rdparty/ceres/internal/ceres/block_jacobi_preconditioner_test.cc
type ceres (line 41) | namespace ceres {
type internal (line 42) | namespace internal {
class BlockJacobiPreconditionerTest (line 45) | class BlockJacobiPreconditionerTest : public ::testing::Test {
method SetUpFromProblemId (line 47) | void SetUpFromProblemId(int problem_id) {
method VerifyDiagonalBlocks (line 62) | void VerifyDiagonalBlocks(const int problem_id) {
function TEST_F (line 96) | TEST_F(BlockJacobiPreconditionerTest, SmallProblem) {
function TEST_F (line 100) | TEST_F(BlockJacobiPreconditionerTest, LargeProblem) {
FILE: 3rdparty/ceres/internal/ceres/block_jacobian_writer.cc
type ceres (line 41) | namespace ceres {
type internal (line 42) | namespace internal {
function BuildJacobianLayout (line 58) | void BuildJacobianLayout(const Program& program,
function BlockEvaluatePreparer (line 139) | BlockEvaluatePreparer* BlockJacobianWriter::CreateEvaluatePreparers(
function SparseMatrix (line 151) | SparseMatrix* BlockJacobianWriter::CreateJacobian() const {
FILE: 3rdparty/ceres/internal/ceres/block_jacobian_writer.h
function namespace (line 45) | namespace ceres {
FILE: 3rdparty/ceres/internal/ceres/block_random_access_dense_matrix.cc
type ceres (line 37) | namespace ceres {
type internal (line 38) | namespace internal {
function CellInfo (line 65) | CellInfo* BlockRandomAccessDenseMatrix::GetCell(const int row_block_id,
FILE: 3rdparty/ceres/internal/ceres/block_random_access_dense_matrix.h
function namespace (line 41) | namespace ceres {
FILE: 3rdparty/ceres/internal/ceres/block_random_access_dense_matrix_test.cc
type ceres (line 36) | namespace ceres {
type internal (line 37) | namespace internal {
function TEST (line 39) | TEST(BlockRandomAccessDenseMatrix, GetCell) {
function TEST (line 71) | TEST(BlockRandomAccessDenseMatrix, WriteCell) {
FILE: 3rdparty/ceres/internal/ceres/block_random_access_diagonal_matrix.cc
type ceres (line 45) | namespace ceres {
type internal (line 46) | namespace internal {
function CellInfo (line 96) | CellInfo* BlockRandomAccessDiagonalMatrix::GetCell(int row_block_id,
FILE: 3rdparty/ceres/internal/ceres/block_random_access_diagonal_matrix.h
function namespace (line 44) | namespace ceres {
FILE: 3rdparty/ceres/internal/ceres/block_random_access_diagonal_matrix_test.cc
type ceres (line 41) | namespace ceres {
type internal (line 42) | namespace internal {
class BlockRandomAccessDiagonalMatrixTest (line 44) | class BlockRandomAccessDiagonalMatrixTest : public ::testing::Test {
method SetUp (line 46) | void SetUp() {
function TEST_F (line 99) | TEST_F(BlockRandomAccessDiagonalMatrixTest, MatrixContents) {
function TEST_F (line 134) | TEST_F(BlockRandomAccessDiagonalMatrixTest, RightMultiply) {
function TEST_F (line 146) | TEST_F(BlockRandomAccessDiagonalMatrixTest, Invert) {
FILE: 3rdparty/ceres/internal/ceres/block_random_access_matrix.cc
type ceres (line 33) | namespace ceres {
type internal (line 34) | namespace internal {
FILE: 3rdparty/ceres/internal/ceres/block_random_access_matrix.h
function namespace (line 38) | namespace ceres {
FILE: 3rdparty/ceres/internal/ceres/block_random_access_sparse_matrix.cc
type ceres (line 44) | namespace ceres {
type internal (line 45) | namespace internal {
function CellInfo (line 126) | CellInfo* BlockRandomAccessSparseMatrix::GetCell(int row_block_id,
FILE: 3rdparty/ceres/internal/ceres/block_random_access_sparse_matrix.h
function namespace (line 47) | namespace ceres {
FILE: 3rdparty/ceres/internal/ceres/block_random_access_sparse_matrix_test.cc
type ceres (line 40) | namespace ceres {
type internal (line 41) | namespace internal {
function TEST (line 48) | TEST(BlockRandomAccessSparseMatrix, GetCell) {
class BlockRandomAccessSparseMatrixTest (line 140) | class BlockRandomAccessSparseMatrixTest : public ::testing::Test {
method SetUp (line 142) | void SetUp() final {
method CheckIntPairToLong (line 150) | void CheckIntPairToLong(int a, int b) {
method CheckLongToIntPair (line 157) | void CheckLongToIntPair() {
function TEST_F (line 176) | TEST_F(BlockRandomAccessSparseMatrixTest, IntPairToLongOverflow) {
function TEST_F (line 181) | TEST_F(BlockRandomAccessSparseMatrixTest, LongToIntPair) {
FILE: 3rdparty/ceres/internal/ceres/block_sparse_matrix.cc
type ceres (line 43) | namespace ceres {
type internal (line 44) | namespace internal {
function CompressedRowBlockStructure (line 218) | const CompressedRowBlockStructure* BlockSparseMatrix::block_structure()
function BlockSparseMatrix (line 246) | BlockSparseMatrix* BlockSparseMatrix::CreateDiagonalMatrix(
function BlockSparseMatrix (line 335) | BlockSparseMatrix* BlockSparseMatrix::CreateRandomMatrix(
FILE: 3rdparty/ceres/internal/ceres/block_sparse_matrix.h
function namespace (line 42) | namespace ceres {
FILE: 3rdparty/ceres/internal/ceres/block_sparse_matrix_test.cc
type ceres (line 42) | namespace ceres {
type internal (line 43) | namespace internal {
class BlockSparseMatrixTest (line 45) | class BlockSparseMatrixTest : public ::testing::Test {
method SetUp (line 47) | void SetUp() final {
function TEST_F (line 66) | TEST_F(BlockSparseMatrixTest, SetZeroTest) {
function TEST_F (line 71) | TEST_F(BlockSparseMatrixTest, RightMultiplyTest) {
function TEST_F (line 83) | TEST_F(BlockSparseMatrixTest, LeftMultiplyTest) {
function TEST_F (line 95) | TEST_F(BlockSparseMatrixTest, SquaredColumnNormTest) {
function TEST_F (line 103) | TEST_F(BlockSparseMatrixTest, ToDenseMatrixTest) {
function TEST_F (line 111) | TEST_F(BlockSparseMatrixTest, AppendRows) {
function TEST_F (line 139) | TEST_F(BlockSparseMatrixTest, AppendAndDeleteBlockDiagonalMatrix) {
function TEST (line 187) | TEST(BlockSparseMatrix, CreateDiagonalMatrix) {
FILE: 3rdparty/ceres/internal/ceres/block_structure.cc
type ceres (line 33) | namespace ceres {
type internal (line 34) | namespace internal {
function CellLessThan (line 36) | bool CellLessThan(const Cell& lhs, const Cell& rhs) {
FILE: 3rdparty/ceres/internal/ceres/block_structure.h
type BlockSize (line 48) | typedef int32_t BlockSize;
type CompressedList (line 72) | struct CompressedList {
type CompressedRowBlockStructure (line 85) | struct CompressedRowBlockStructure {
type CompressedColumnBlockStructure (line 90) | struct CompressedColumnBlockStructure {
FILE: 3rdparty/ceres/internal/ceres/c_api.cc
function ceres_init (line 49) | void ceres_init() {
function ceres_problem_t (line 56) | ceres_problem_t* ceres_create_problem() {
function ceres_free_problem (line 60) | void ceres_free_problem(ceres_problem_t* problem) {
class CallbackCostFunction (line 66) | class CallbackCostFunction : public ceres::CostFunction {
method CallbackCostFunction (line 68) | CallbackCostFunction(ceres_cost_function_t cost_function,
method Evaluate (line 83) | bool Evaluate(double const* const* parameters,
class CallbackLossFunction (line 99) | class CallbackLossFunction : public ceres::LossFunction {
method CallbackLossFunction (line 101) | explicit CallbackLossFunction(ceres_loss_function_t loss_function,
method Evaluate (line 104) | void Evaluate(double sq_norm, double* rho) const final {
function ceres_free_stock_loss_function_data (line 130) | void ceres_free_stock_loss_function_data(void* loss_function_data) {
function ceres_stock_loss_function (line 134) | void ceres_stock_loss_function(void* user_data,
function ceres_residual_block_id_t (line 141) | ceres_residual_block_id_t* ceres_problem_add_residual_block(
function ceres_solve (line 174) | void ceres_solve(ceres_problem_t* c_problem) {
FILE: 3rdparty/ceres/internal/ceres/c_api_test.cc
function exponential_residual (line 111) | static int exponential_residual(void* user_data,
type ceres (line 134) | namespace ceres {
type internal (line 135) | namespace internal {
function TEST (line 137) | TEST(C_API, SimpleEndToEndTest) {
class ScopedSetValue (line 166) | class ScopedSetValue {
method ScopedSetValue (line 168) | ScopedSetValue(T* variable, T new_value)
function TEST (line 181) | TEST(C_API, LossFunctions) {
FILE: 3rdparty/ceres/internal/ceres/callbacks.cc
type ceres (line 37) | namespace ceres {
type internal (line 38) | namespace internal {
function CallbackReturnType (line 48) | CallbackReturnType StateUpdatingCallback::operator()(
function CallbackReturnType (line 67) | CallbackReturnType GradientProblemSolverStateUpdatingCallback::opera...
function CallbackReturnType (line 84) | CallbackReturnType LoggingCallback::operator()(
FILE: 3rdparty/ceres/internal/ceres/callbacks.h
function namespace (line 38) | namespace ceres {
FILE: 3rdparty/ceres/internal/ceres/canonical_views_clustering.cc
type ceres (line 41) | namespace ceres {
type internal (line 42) | namespace internal {
class CanonicalViewsClustering (line 49) | class CanonicalViewsClustering {
method CanonicalViewsClustering (line 51) | CanonicalViewsClustering() {}
function ComputeCanonicalViewsClustering (line 83) | void ComputeCanonicalViewsClustering(
FILE: 3rdparty/ceres/internal/ceres/canonical_views_clustering.h
function namespace (line 49) | namespace ceres {
FILE: 3rdparty/ceres/internal/ceres/canonical_views_clustering_test.cc
type ceres (line 38) | namespace ceres {
type internal (line 39) | namespace internal {
class CanonicalViewsTest (line 42) | class CanonicalViewsTest : public ::testing::Test {
method SetUp (line 44) | void SetUp() final {
method ComputeClustering (line 69) | void ComputeClustering() {
function TEST_F (line 80) | TEST_F(CanonicalViewsTest, ComputeCanonicalViewsTest) {
function TEST_F (line 101) | TEST_F(CanonicalViewsTest, SizePenaltyTest) {
function TEST_F (line 115) | TEST_F(CanonicalViewsTest, ViewScoreTest) {
function TEST_F (line 130) | TEST_F(CanonicalViewsTest, SimilarityPenaltyTest) {
FILE: 3rdparty/ceres/internal/ceres/casts.h
function namespace (line 37) | namespace ceres {
FILE: 3rdparty/ceres/internal/ceres/cgnr_linear_operator.h
function namespace (line 39) | namespace ceres {
FILE: 3rdparty/ceres/internal/ceres/cgnr_solver.cc
type ceres (line 42) | namespace ceres {
type internal (line 43) | namespace internal {
FILE: 3rdparty/ceres/internal/ceres/cgnr_solver.h
function namespace (line 37) | namespace ceres {
FILE: 3rdparty/ceres/internal/ceres/compressed_col_sparse_matrix_utils.cc
type ceres (line 38) | namespace ceres {
type internal (line 39) | namespace internal {
function CompressedColumnScalarMatrixToBlockMatrix (line 43) | void CompressedColumnScalarMatrixToBlockMatrix(
function BlockOrderingToScalarOrdering (line 99) | void BlockOrderingToScalarOrdering(const vector<int>& blocks,
FILE: 3rdparty/ceres/internal/ceres/compressed_col_sparse_matrix_utils.h
function namespace (line 37) | namespace ceres {
FILE: 3rdparty/ceres/internal/ceres/compressed_col_sparse_matrix_utils_test.cc
type ceres (line 41) | namespace ceres {
type internal (line 42) | namespace internal {
function TEST (line 46) | TEST(_, BlockPermutationToScalarPermutation) {
function FillBlock (line 90) | static void FillBlock(const vector<int>& row_blocks,
function TEST (line 104) | TEST(_, ScalarMatrixToBlockMatrix) {
class SolveUpperTriangularTest (line 167) | class SolveUpperTriangularTest : public ::testing::Test {
method SetUp (line 169) | void SetUp() {
function TEST_F (line 204) | TEST_F(SolveUpperTriangularTest, SolveInPlace) {
function TEST_F (line 219) | TEST_F(SolveUpperTriangularTest, TransposeSolveInPlace) {
function TEST_F (line 234) | TEST_F(SolveUpperTriangularTest, RTRSolveWithSparseRHS) {
FILE: 3rdparty/ceres/internal/ceres/compressed_row_jacobian_writer.cc
type ceres (line 44) | namespace ceres {
type internal (line 45) | namespace internal {
function SparseMatrix (line 90) | SparseMatrix* CompressedRowJacobianWriter::CreateJacobian() const {
FILE: 3rdparty/ceres/internal/ceres/compressed_row_jacobian_writer.h
function namespace (line 42) | namespace ceres {
FILE: 3rdparty/ceres/internal/ceres/compressed_row_sparse_matrix.cc
type ceres (line 42) | namespace ceres {
type internal (line 43) | namespace internal {
type RowColLessThan (line 57) | struct RowColLessThan {
method RowColLessThan (line 58) | RowColLessThan(const int* rows, const int* cols) : rows(rows), col...
function TransposeForCompressedRowSparseStructure (line 71) | void TransposeForCompressedRowSparseStructure(const int num_rows,
function AddRandomBlock (line 120) | void AddRandomBlock(const int num_rows,
function AddSymmetricRandomBlock (line 136) | void AddSymmetricRandomBlock(const int num_rows,
function CompressedRowSparseMatrix (line 176) | CompressedRowSparseMatrix* CompressedRowSparseMatrix::FromTripletSpa...
function CompressedRowSparseMatrix (line 181) | CompressedRowSparseMatrix*
function CompressedRowSparseMatrix (line 187) | CompressedRowSparseMatrix* CompressedRowSparseMatrix::FromTripletSpa...
function CompressedRowSparseMatrix (line 535) | CompressedRowSparseMatrix* CompressedRowSparseMatrix::CreateBlockDia...
function CompressedRowSparseMatrix (line 575) | CompressedRowSparseMatrix* CompressedRowSparseMatrix::Transpose() co...
function CompressedRowSparseMatrix (line 614) | CompressedRowSparseMatrix* CompressedRowSparseMatrix::CreateRandomMa...
FILE: 3rdparty/ceres/internal/ceres/compressed_row_sparse_matrix.h
function namespace (line 40) | namespace ceres {
FILE: 3rdparty/ceres/internal/ceres/compressed_row_sparse_matrix_test.cc
type ceres (line 46) | namespace ceres {
type internal (line 47) | namespace internal {
function CompareMatrices (line 51) | static void CompareMatrices(const SparseMatrix* a, const SparseMatri...
class CompressedRowSparseMatrixTest (line 72) | class CompressedRowSparseMatrixTest : public ::testing::Test {
method SetUp (line 74) | void SetUp() final {
function TEST_F (line 102) | TEST_F(CompressedRowSparseMatrixTest, Scale) {
function TEST_F (line 113) | TEST_F(CompressedRowSparseMatrixTest, DeleteRows) {
function TEST_F (line 125) | TEST_F(CompressedRowSparseMatrixTest, AppendRows) {
function TEST_F (line 143) | TEST_F(CompressedRowSparseMatrixTest, AppendAndDeleteBlockDiagonalMa...
function TEST_F (line 183) | TEST_F(CompressedRowSparseMatrixTest, ToDenseMatrix) {
function TEST_F (line 193) | TEST_F(CompressedRowSparseMatrixTest, ToCRSMatrix) {
function TEST (line 212) | TEST(CompressedRowSparseMatrix, CreateBlockDiagonalMatrix) {
function TEST (line 254) | TEST(CompressedRowSparseMatrix, Transpose) {
function TEST (line 328) | TEST(CompressedRowSparseMatrix, FromTripletSparseMatrix) {
function TEST (line 354) | TEST(CompressedRowSparseMatrix, FromTripletSparseMatrixTransposed) {
function ParamInfoToString (line 383) | static std::string ParamInfoToString(testing::TestParamInfo<Param> i...
class RightMultiplyTest (line 397) | class RightMultiplyTest : public ::testing::TestWithParam<Param> {}
function TEST_P (line 399) | TEST_P(RightMultiplyTest, _) {
class LeftMultiplyTest (line 465) | class LeftMultiplyTest : public ::testing::TestWithParam<Param> {}
function TEST_P (line 467) | TEST_P(LeftMultiplyTest, _) {
class SquaredColumnNormTest (line 533) | class SquaredColumnNormTest : public ::testing::TestWithParam<Param> {}
function TEST_P (line 535) | TEST_P(SquaredColumnNormTest, _) {
FILE: 3rdparty/ceres/internal/ceres/concurrent_queue.h
function namespace (line 41) | namespace ceres {
FILE: 3rdparty/ceres/internal/ceres/concurrent_queue_test.cc
type ceres (line 44) | namespace ceres {
type internal (line 45) | namespace internal {
function TEST (line 48) | TEST(ConcurrentQueue, PushPop) {
function TEST (line 64) | TEST(ConcurrentQueue, PushPopAfterStopWaiters) {
function TEST (line 112) | TEST(ConcurrentQueue, PushPopStopAndStart) {
function TEST (line 145) | TEST(ConcurrentQueue, Wait) {
function TEST (line 182) | TEST(ConcurrentQueue, EnsureWaitBlocks) {
function TEST (line 227) | TEST(ConcurrentQueue, StopAndEnableWaiters) {
FILE: 3rdparty/ceres/internal/ceres/conditioned_cost_function.cc
type ceres (line 42) | namespace ceres {
FILE: 3rdparty/ceres/internal/ceres/conditioned_cost_function_test.cc
type ceres (line 40) | namespace ceres {
type internal (line 41) | namespace internal {
class LinearCostFunction (line 47) | class LinearCostFunction : public CostFunction {
method LinearCostFunction (line 49) | LinearCostFunction(double a, double b) : a_(a), b_(b) {
method Evaluate (line 54) | bool Evaluate(double const* const* parameters,
function TEST (line 70) | TEST(ConditionedCostFunction, NormalOperation) {
function TEST (line 124) | TEST(ConditionedCostFunction, SharedConditionersDoNotTriggerDoubleFr...
FILE: 3rdparty/ceres/internal/ceres/conjugate_gradients_solver.cc
type ceres (line 50) | namespace ceres {
type internal (line 51) | namespace internal {
function IsZeroOrInfinity (line 54) | bool IsZeroOrInfinity(double x) {
FILE: 3rdparty/ceres/internal/ceres/conjugate_gradients_solver.h
function namespace (line 39) | namespace ceres {
FILE: 3rdparty/ceres/internal/ceres/conjugate_gradients_solver_test.cc
type ceres (line 42) | namespace ceres {
type internal (line 43) | namespace internal {
function TEST (line 45) | TEST(ConjugateGradientTest, Solves3x3IdentitySystem) {
function TEST (line 79) | TEST(ConjuateGradientTest, Solves3x3SymmetricSystem) {
FILE: 3rdparty/ceres/internal/ceres/context.cc
type ceres (line 35) | namespace ceres {
function Context (line 37) | Context* Context::Create() {
FILE: 3rdparty/ceres/internal/ceres/context_impl.cc
type ceres (line 33) | namespace ceres {
type internal (line 34) | namespace internal {
FILE: 3rdparty/ceres/internal/ceres/context_impl.h
function namespace (line 43) | namespace ceres {
FILE: 3rdparty/ceres/internal/ceres/coordinate_descent_minimizer.cc
type ceres (line 52) | namespace ceres {
type internal (line 53) | namespace internal {
function ParameterBlockOrdering (line 268) | ParameterBlockOrdering* CoordinateDescentMinimizer::CreateOrdering(
FILE: 3rdparty/ceres/internal/ceres/coordinate_descent_minimizer.h
function namespace (line 43) | namespace ceres {
FILE: 3rdparty/ceres/internal/ceres/corrector.cc
type ceres (line 38) | namespace ceres {
type internal (line 39) | namespace internal {
FILE: 3rdparty/ceres/internal/ceres/corrector.h
function namespace (line 38) | namespace ceres {
FILE: 3rdparty/ceres/internal/ceres/corrector_test.cc
type ceres (line 41) | namespace ceres {
type internal (line 42) | namespace internal {
function TEST (line 45) | TEST(Corrector, ZeroGradientDeathTest) {
function TEST (line 52) | TEST(Corrector, NegativeGradientDeathTest) {
function TEST (line 58) | TEST(Corrector, ScalarCorrection) {
function TEST (line 86) | TEST(Corrector, ScalarCorrectionZeroResidual) {
function TEST (line 114) | TEST(Corrector, ScalarCorrectionAlphaClamped) {
function TEST (line 145) | TEST(Corrector, MultidimensionalGaussNewtonApproximation) {
function TEST (line 213) | TEST(Corrector, MultidimensionalGaussNewtonApproximationZeroResidual) {
FILE: 3rdparty/ceres/internal/ceres/cost_function_to_functor_test.cc
type ceres (line 40) | namespace ceres {
type internal (line 41) | namespace internal {
function ExpectCostFunctionsAreEqual (line 46) | static void ExpectCostFunctionsAreEqual(
type OneParameterBlockFunctor (line 121) | struct OneParameterBlockFunctor {
type TwoParameterBlockFunctor (line 131) | struct TwoParameterBlockFunctor {
type ThreeParameterBlockFunctor (line 141) | struct ThreeParameterBlockFunctor {
type FourParameterBlockFunctor (line 151) | struct FourParameterBlockFunctor {
type FiveParameterBlockFunctor (line 164) | struct FiveParameterBlockFunctor {
type SixParameterBlockFunctor (line 177) | struct SixParameterBlockFunctor {
type SevenParameterBlockFunctor (line 190) | struct SevenParameterBlockFunctor {
type EightParameterBlockFunctor (line 203) | struct EightParameterBlockFunctor {
type NineParameterBlockFunctor (line 219) | struct NineParameterBlockFunctor {
type TenParameterBlockFunctor (line 235) | struct TenParameterBlockFunctor {
class DynamicTwoParameterBlockFunctor (line 251) | class DynamicTwoParameterBlockFunctor {
function TEST (line 322) | TEST(CostFunctionToFunctor, DynamicNumberOfResiduals) {
function TEST (line 336) | TEST(CostFunctionToFunctor, DynamicCostFunctionToFunctor) {
FILE: 3rdparty/ceres/internal/ceres/covariance.cc
type ceres (line 39) | namespace ceres {
FILE: 3rdparty/ceres/internal/ceres/covariance_impl.cc
type ceres (line 61) | namespace ceres {
type internal (line 62) | namespace internal {
function CheckForDuplicates (line 94) | void CheckForDuplicates(vector<T> blocks) {
FILE: 3rdparty/ceres/internal/ceres/covariance_impl.h
function namespace (line 43) | namespace ceres {
FILE: 3rdparty/ceres/internal/ceres/covariance_test.cc
type ceres (line 49) | namespace ceres {
type internal (line 50) | namespace internal {
class UnaryCostFunction (line 57) | class UnaryCostFunction: public CostFunction {
method UnaryCostFunction (line 59) | UnaryCostFunction(const int num_residuals,
method Evaluate (line 67) | bool Evaluate(double const* const* parameters,
class BinaryCostFunction (line 90) | class BinaryCostFunction: public CostFunction {
method BinaryCostFunction (line 92) | BinaryCostFunction(const int num_residuals,
method Evaluate (line 106) | bool Evaluate(double const* const* parameters,
class PolynomialParameterization (line 134) | class PolynomialParameterization : public LocalParameterization {
method Plus (line 138) | bool Plus(const double* x,
method ComputeJacobian (line 146) | bool ComputeJacobian(const double* x, double* jacobian) const final {
method GlobalSize (line 152) | int GlobalSize() const final { return 2; }
method LocalSize (line 153) | int LocalSize() const final { return 1; }
function TEST (line 156) | TEST(CovarianceImpl, ComputeCovarianceSparsity) {
function TEST (line 245) | TEST(CovarianceImpl, ComputeCovarianceSparsityWithConstantParameterB...
function TEST (line 328) | TEST(CovarianceImpl, ComputeCovarianceSparsityWithFreeParameterBlock) {
class CovarianceTest (line 409) | class CovarianceTest : public ::testing::Test {
method SetUp (line 413) | void SetUp() override {
method ComputeAndCompareCovarianceBlocks (line 475) | void ComputeAndCompareCovarianceBlocks(const Covariance::Options& ...
method ComputeAndCompareCovarianceBlocksInTangentSpace (line 484) | void ComputeAndCompareCovarianceBlocksInTangentSpace(
method ComputeAndCompareCovarianceBlocksInTangentOrAmbientSpace (line 493) | void ComputeAndCompareCovarianceBlocksInTangentOrAmbientSpace(
method GetCovarianceBlockAndCompare (line 547) | void GetCovarianceBlockAndCompare(const double* block1,
function TEST_F (line 601) | TEST_F(CovarianceTest, NormalBehavior) {
function TEST_F (line 650) | TEST_F(CovarianceTest, ThreadedNormalBehavior) {
function TEST_F (line 700) | TEST_F(CovarianceTest, ConstantParameterBlock) {
function TEST_F (line 749) | TEST_F(CovarianceTest, LocalParameterization) {
function TEST_F (line 806) | TEST_F(CovarianceTest, LocalParameterizationInTangentSpace) {
function TEST_F (line 867) | TEST_F(CovarianceTest, LocalParameterizationInTangentSpaceWithConsta...
function TEST_F (line 930) | TEST_F(CovarianceTest, TruncatedRank) {
function TEST_F (line 983) | TEST_F(CovarianceTest, DenseCovarianceMatrixFromSetOfParameters) {
function TEST_F (line 1011) | TEST_F(CovarianceTest, DenseCovarianceMatrixFromSetOfParametersThrea...
function TEST_F (line 1040) | TEST_F(CovarianceTest, DenseCovarianceMatrixFromSetOfParametersInTan...
function TEST_F (line 1081) | TEST_F(CovarianceTest, ComputeCovarianceFailure) {
class RankDeficientCovarianceTest (line 1104) | class RankDeficientCovarianceTest : public CovarianceTest {
method SetUp (line 1106) | void SetUp() final {
function TEST_F (line 1161) | TEST_F(RankDeficientCovarianceTest, AutomaticTruncation) {
type LinearCostFunction (line 1198) | struct LinearCostFunction {
method CostFunction (line 1205) | static CostFunction* Create() {
function TEST (line 1211) | TEST(Covariance, ZeroSizedLocalParameterizationGetCovariance) {
function TEST (line 1246) | TEST(Covariance, ZeroSizedLocalParameterizationGetCovarianceInTangen...
class LargeScaleCovarianceTest (line 1279) | class LargeScaleCovarianceTest : public ::testing::Test {
method SetUp (line 1281) | void SetUp() final {
method ComputeAndCompare (line 1305) | void ComputeAndCompare(
function TEST_F (line 1354) | TEST_F(LargeScaleCovarianceTest, Parallel) {
FILE: 3rdparty/ceres/internal/ceres/cubic_interpolation_test.cc
type ceres (line 38) | namespace ceres {
type internal (line 39) | namespace internal {
function TEST (line 43) | TEST(Grid1D, OneDataDimension) {
function TEST (line 53) | TEST(Grid1D, OneDataDimensionOutOfBounds) {
function TEST (line 67) | TEST(Grid1D, TwoDataDimensionIntegerDataInterleaved) {
function TEST (line 82) | TEST(Grid1D, TwoDataDimensionIntegerDataStacked) {
function TEST (line 95) | TEST(Grid2D, OneDataDimensionRowMajor) {
function TEST (line 108) | TEST(Grid2D, OneDataDimensionRowMajorOutOfBounds) {
function TEST (line 143) | TEST(Grid2D, TwoDataDimensionRowMajorInterleaved) {
function TEST (line 157) | TEST(Grid2D, TwoDataDimensionRowMajorStacked) {
function TEST (line 173) | TEST(Grid2D, TwoDataDimensionColMajorInterleaved) {
function TEST (line 188) | TEST(Grid2D, TwoDataDimensionColMajorStacked) {
class CubicInterpolatorTest (line 206) | class CubicInterpolatorTest : public ::testing::Test {
method RunPolynomialInterpolationTest (line 209) | void RunPolynomialInterpolationTest(const double a,
function TEST_F (line 263) | TEST_F(CubicInterpolatorTest, ConstantFunction) {
function TEST_F (line 269) | TEST_F(CubicInterpolatorTest, LinearFunction) {
function TEST_F (line 275) | TEST_F(CubicInterpolatorTest, QuadraticFunction) {
function TEST (line 282) | TEST(CubicInterpolator, JetEvaluation) {
class BiCubicInterpolatorTest (line 314) | class BiCubicInterpolatorTest : public ::testing::Test {
method RunPolynomialInterpolationTest (line 321) | void RunPolynomialInterpolationTest(const Eigen::Matrix3d& coeff) {
method EvaluateF (line 352) | double EvaluateF(double r, double c) {
method EvaluatedFdr (line 360) | double EvaluatedFdr(double r, double c) {
method EvaluatedFdc (line 368) | double EvaluatedFdc(double r, double c) {
function TEST_F (line 385) | TEST_F(BiCubicInterpolatorTest, ZeroFunction) {
function TEST_F (line 392) | TEST_F(BiCubicInterpolatorTest, Degree00Function) {
function TEST_F (line 400) | TEST_F(BiCubicInterpolatorTest, Degree01Function) {
function TEST_F (line 410) | TEST_F(BiCubicInterpolatorTest, Degree10Function) {
function TEST_F (line 420) | TEST_F(BiCubicInterpolatorTest, Degree11Function) {
function TEST_F (line 432) | TEST_F(BiCubicInterpolatorTest, Degree12Function) {
function TEST_F (line 445) | TEST_F(BiCubicInterpolatorTest, Degree21Function) {
function TEST_F (line 458) | TEST_F(BiCubicInterpolatorTest, Degree22Function) {
function TEST (line 473) | TEST(BiCubicInterpolator, JetEvaluation) {
FILE: 3rdparty/ceres/internal/ceres/cxsparse.cc
type ceres (line 46) | namespace ceres {
type internal (line 47) | namespace internal {
function csn (line 59) | csn* CXSparse::Cholesky(cs_di* A, cs_dis* symbolic_factor) {
function cs_dis (line 93) | cs_dis* CXSparse::AnalyzeCholesky(cs_di* A) {
function cs_dis (line 98) | cs_dis* CXSparse::AnalyzeCholeskyWithNaturalOrdering(cs_di* A) {
function cs_dis (line 103) | cs_dis* CXSparse::BlockAnalyzeCholesky(cs_di* A,
function cs_di (line 156) | cs_di CXSparse::CreateSparseMatrixTransposeView(CompressedRowSparseM...
function cs_di (line 168) | cs_di* CXSparse::CreateSparseMatrix(TripletSparseMatrix* tsm) {
function cs_di (line 187) | cs_di* CXSparse::TransposeMatrix(cs_di* A) { return cs_di_transpose(...
function cs_di (line 189) | cs_di* CXSparse::MatrixMatrixMultiply(cs_di* A, cs_di* B) {
function LinearSolverTerminationType (line 218) | LinearSolverTerminationType CXSparseCholesky::Factorize(
function LinearSolverTerminationType (line 256) | LinearSolverTerminationType CXSparseCholesky::Solve(const double* rhs,
FILE: 3rdparty/ceres/internal/ceres/cxsparse.h
function namespace (line 47) | namespace ceres {
type cs_dis (line 171) | typedef void cs_dis;
function class (line 173) | class CXSparse {
FILE: 3rdparty/ceres/internal/ceres/dense_jacobian_writer.h
function namespace (line 44) | namespace ceres {
FILE: 3rdparty/ceres/internal/ceres/dense_linear_solver_test.cc
type ceres (line 41) | namespace ceres {
type internal (line 42) | namespace internal {
function ParamInfoToString (line 48) | static std::string ParamInfoToString(testing::TestParamInfo<Param> i...
class DenseLinearSolverTest (line 58) | class DenseLinearSolverTest : public ::testing::TestWithParam<Param> {}
function TEST_P (line 60) | TEST_P(DenseLinearSolverTest, _) {
FILE: 3rdparty/ceres/internal/ceres/dense_normal_cholesky_solver.cc
type ceres (line 44) | namespace ceres {
type internal (line 45) | namespace internal {
FILE: 3rdparty/ceres/internal/ceres/dense_normal_cholesky_solver.h
function namespace (line 39) | namespace ceres {
FILE: 3rdparty/ceres/internal/ceres/dense_qr_solver.cc
type ceres (line 42) | namespace ceres {
type internal (line 43) | namespace internal {
FILE: 3rdparty/ceres/internal/ceres/dense_qr_solver.h
function namespace (line 38) | namespace ceres {
FILE: 3rdparty/ceres/internal/ceres/dense_sparse_matrix.cc
type ceres (line 39) | namespace ceres {
type internal (line 40) | namespace internal {
function ConstColMajorMatrixRef (line 147) | ConstColMajorMatrixRef DenseSparseMatrix::matrix() const {
function ColMajorMatrixRef (line 157) | ColMajorMatrixRef DenseSparseMatrix::mutable_matrix() {
FILE: 3rdparty/ceres/internal/ceres/dense_sparse_matrix.h
function namespace (line 40) | namespace ceres {
FILE: 3rdparty/ceres/internal/ceres/dense_sparse_matrix_test.cc
type ceres (line 45) | namespace ceres {
type internal (line 46) | namespace internal {
function CompareMatrices (line 48) | static void CompareMatrices(const SparseMatrix* a, const SparseMatri...
class DenseSparseMatrixTest (line 69) | class DenseSparseMatrixTest : public ::testing::Test {
method SetUp (line 71) | void SetUp() final {
function TEST_F (line 91) | TEST_F(DenseSparseMatrixTest, RightMultiply) {
function TEST_F (line 109) | TEST_F(DenseSparseMatrixTest, LeftMultiply) {
function TEST_F (line 138) | TEST_F(DenseSparseMatrixTest, ColumnNorm) {
function TEST_F (line 148) | TEST_F(DenseSparseMatrixTest, Scale) {
function TEST_F (line 158) | TEST_F(DenseSparseMatrixTest, ToDenseMatrix) {
FILE: 3rdparty/ceres/internal/ceres/detect_structure.cc
type ceres (line 35) | namespace ceres {
type internal (line 36) | namespace internal {
function DetectStructure (line 38) | void DetectStructure(const CompressedRowBlockStructure& bs,
FILE: 3rdparty/ceres/internal/ceres/detect_structure.h
function namespace (line 36) | namespace ceres {
FILE: 3rdparty/ceres/internal/ceres/detect_structure_test.cc
type ceres (line 37) | namespace ceres {
type internal (line 38) | namespace internal {
function TEST (line 40) | TEST(DetectStructure, EverythingStatic) {
function TEST (line 92) | TEST(DetectStructure, DynamicRow) {
function TEST (line 144) | TEST(DetectStructure, DynamicFBlockDifferentRows) {
function TEST (line 197) | TEST(DetectStructure, DynamicEBlock) {
function TEST (line 249) | TEST(DetectStructure, DynamicFBlockSameRow) {
FILE: 3rdparty/ceres/internal/ceres/dogleg_strategy.cc
type ceres (line 47) | namespace ceres {
type internal (line 48) | namespace internal {
function Vector (line 421) | Vector DoglegStrategy::MakePolynomialForBoundaryConstrainedProblem()...
FILE: 3rdparty/ceres/internal/ceres/dogleg_strategy.h
function namespace (line 37) | namespace ceres {
FILE: 3rdparty/ceres/internal/ceres/dogleg_strategy_test.cc
type ceres (line 41) | namespace ceres {
type internal (line 42) | namespace internal {
class Fixture (line 45) | class Fixture : public testing::Test {
class DoglegStrategyFixtureEllipse (line 61) | class DoglegStrategyFixtureEllipse : public Fixture {
method SetUp (line 63) | void SetUp() final {
class DoglegStrategyFixtureValley (line 99) | class DoglegStrategyFixtureValley : public Fixture {
method SetUp (line 101) | void SetUp() final {
function TEST_F (line 128) | TEST_F(DoglegStrategyFixtureEllipse, TrustRegionObeyedTraditional) {
function TEST_F (line 151) | TEST_F(DoglegStrategyFixtureEllipse, TrustRegionObeyedSubspace) {
function TEST_F (line 171) | TEST_F(DoglegStrategyFixtureEllipse, CorrectGaussNewtonStep) {
function TEST_F (line 198) | TEST_F(DoglegStrategyFixtureEllipse, ValidSubspaceBasis) {
function TEST_F (line 233) | TEST_F(DoglegStrategyFixtureValley, CorrectStepLocalOptimumAlongGrad...
function TEST_F (line 261) | TEST_F(DoglegStrategyFixtureValley, CorrectStepGlobalOptimumAlongGra...
FILE: 3rdparty/ceres/internal/ceres/dynamic_autodiff_cost_function_test.cc
type ceres (line 39) | namespace ceres {
type internal (line 40) | namespace internal {
class MyCostFunctor (line 51) | class MyCostFunctor {
function TEST (line 76) | TEST(DynamicAutodiffCostFunctionTest, TestResiduals) {
function TEST (line 100) | TEST(DynamicAutodiffCostFunctionTest, TestJacobian) {
function TEST (line 167) | TEST(DynamicAutodiffCostFunctionTest, JacobianWithFirstParameterBloc...
function TEST (line 217) | TEST(DynamicAutodiffCostFunctionTest, JacobianWithSecondParameterBlo...
class MyThreeParameterCostFunctor (line 287) | class MyThreeParameterCostFunctor {
class ThreeParameterCostFunctorTest (line 310) | class ThreeParameterCostFunctorTest : public ::testing::Test {
method SetUp (line 312) | void SetUp() final {
function TEST_F (line 432) | TEST_F(ThreeParameterCostFunctorTest, TestThreeParameterResiduals) {
function TEST_F (line 442) | TEST_F(ThreeParameterCostFunctorTest, TestThreeParameterJacobian) {
function TEST_F (line 471) | TEST_F(ThreeParameterCostFunctorTest,
function TEST_F (line 493) | TEST_F(ThreeParameterCostFunctorTest,
class MySixParameterCostFunctor (line 523) | class MySixParameterCostFunctor {
class SixParameterCostFunctorTest (line 549) | class SixParameterCostFunctorTest : public ::testing::Test {
method SetUp (line 551) | void SetUp() final {
function TEST_F (line 676) | TEST_F(SixParameterCostFunctorTest, TestSixParameterResiduals) {
function TEST_F (line 686) | TEST_F(SixParameterCostFunctorTest, TestSixParameterJacobian) {
function TEST_F (line 712) | TEST_F(SixParameterCostFunctorTest, TestSixParameterJacobianVVCVVC) {
function TEST_F (line 743) | TEST_F(SixParameterCostFunctorTest, TestSixParameterJacobianVCCVCV) {
FILE: 3rdparty/ceres/internal/ceres/dynamic_compressed_row_finalizer.h
function namespace (line 37) | namespace ceres {
FILE: 3rdparty/ceres/internal/ceres/dynamic_compressed_row_jacobian_writer.cc
type ceres (line 39) | namespace ceres {
type internal (line 40) | namespace internal {
function ScratchEvaluatePreparer (line 45) | ScratchEvaluatePreparer*
function SparseMatrix (line 50) | SparseMatrix* DynamicCompressedRowJacobianWriter::CreateJacobian() c...
FILE: 3rdparty/ceres/internal/ceres/dynamic_compressed_row_jacobian_writer.h
function namespace (line 40) | namespace ceres {
FILE: 3rdparty/ceres/internal/ceres/dynamic_compressed_row_sparse_matrix.cc
type ceres (line 34) | namespace ceres {
type internal (line 35) | namespace internal {
FILE: 3rdparty/ceres/internal/ceres/dynamic_compressed_row_sparse_matrix.h
function namespace (line 48) | namespace ceres {
FILE: 3rdparty/ceres/internal/ceres/dynamic_compressed_row_sparse_matrix_test.cc
type ceres (line 41) | namespace ceres {
type internal (line 42) | namespace internal {
class DynamicCompressedRowSparseMatrixTest (line 47) | class DynamicCompressedRowSparseMatrixTest : public ::testing::Test {
method SetUp (line 49) | void SetUp() final {
method Finalize (line 68) | void Finalize() {
method InitialiseDenseReference (line 72) | void InitialiseDenseReference() {
method InitialiseSparseMatrixReferences (line 86) | void InitialiseSparseMatrixReferences() {
method InsertNonZeroEntriesFromDenseReference (line 117) | void InsertNonZeroEntriesFromDenseReference() {
method ExpectEmpty (line 128) | void ExpectEmpty() {
method ExpectEqualToDenseReference (line 140) | void ExpectEqualToDenseReference() {
method ExpectEqualToCompressedRowSparseMatrixReference (line 146) | void ExpectEqualToCompressedRowSparseMatrixReference() {
function TEST_F (line 176) | TEST_F(DynamicCompressedRowSparseMatrixTest, Initialization) {
function TEST_F (line 183) | TEST_F(DynamicCompressedRowSparseMatrixTest, InsertEntryAndFinalize) {
function TEST_F (line 192) | TEST_F(DynamicCompressedRowSparseMatrixTest, ClearRows) {
FILE: 3rdparty/ceres/internal/ceres/dynamic_numeric_diff_cost_function_test.cc
type ceres (line 38) | namespace ceres {
type internal (line 39) | namespace internal {
class MyCostFunctor (line 52) | class MyCostFunctor {
function TEST (line 76) | TEST(DynamicNumericdiffCostFunctionTest, TestResiduals) {
function TEST (line 101) | TEST(DynamicNumericdiffCostFunctionTest, TestJacobian) {
function TEST (line 168) | TEST(DynamicNumericdiffCostFunctionTest, JacobianWithFirstParameterB...
function TEST (line 218) | TEST(DynamicNumericdiffCostFunctionTest, JacobianWithSecondParameter...
class MyThreeParameterCostFunctor (line 288) | class MyThreeParameterCostFunctor {
class ThreeParameterCostFunctorTest (line 311) | class ThreeParameterCostFunctorTest : public ::testing::Test {
method SetUp (line 313) | void SetUp() final {
function TEST_F (line 433) | TEST_F(ThreeParameterCostFunctorTest, TestThreeParameterResiduals) {
function TEST_F (line 443) | TEST_F(ThreeParameterCostFunctorTest, TestThreeParameterJacobian) {
function TEST_F (line 472) | TEST_F(ThreeParameterCostFunctorTest,
function TEST_F (line 494) | TEST_F(ThreeParameterCostFunctorTest,
FILE: 3rdparty/ceres/internal/ceres/dynamic_sparse_normal_cholesky_solver.cc
type ceres (line 53) | namespace ceres {
type internal (line 54) | namespace internal {
FILE: 3rdparty/ceres/internal/ceres/dynamic_sparse_normal_cholesky_solver.h
function namespace (line 42) | namespace ceres {
FILE: 3rdparty/ceres/internal/ceres/dynamic_sparse_normal_cholesky_solver_test.cc
type ceres (line 44) | namespace ceres {
type internal (line 45) | namespace internal {
class DynamicSparseNormalCholeskySolverTest (line 50) | class DynamicSparseNormalCholeskySolverTest : public ::testing::Test {
method SetUp (line 52) | void SetUp() final {
method TestSolver (line 61) | void TestSolver(const LinearSolver::Options& options, double* D) {
method TestSolver (line 94) | void TestSolver(
function TEST_F (line 113) | TEST_F(DynamicSparseNormalCholeskySolverTest, SuiteSparse) {
function TEST_F (line 119) | TEST_F(DynamicSparseNormalCholeskySolverTest, CXSparse) {
function TEST_F (line 125) | TEST_F(DynamicSparseNormalCholeskySolverTest, Eigen) {
FILE: 3rdparty/ceres/internal/ceres/dynamic_sparsity_test.cc
type ceres (line 40) | namespace ceres {
type internal (line 41) | namespace internal {
class PointToLineSegmentContourCostFunction (line 273) | class PointToLineSegmentContourCostFunction : public CostFunction {
function Evaluate (line 291) | bool Evaluate(const double* const* x,
function CostFunction (line 330) | static CostFunction* Create(const int num_segments, const Eigen::Vecto...
class EuclideanDistanceFunctor (line 343) | class EuclideanDistanceFunctor {
method EuclideanDistanceFunctor (line 345) | explicit EuclideanDistanceFunctor(const double sqrt_weight)
method CostFunction (line 355) | static CostFunction* Create(const double sqrt_weight) {
function TEST (line 364) | TEST(DynamicSparsity, StaticAndDynamicSparsityProduceSameSolution) {
FILE: 3rdparty/ceres/internal/ceres/eigensparse.cc
type ceres (line 42) | namespace ceres {
type internal (line 43) | namespace internal {
class EigenSparseCholeskyTemplate (line 48) | class EigenSparseCholeskyTemplate : public SparseCholesky {
method EigenSparseCholeskyTemplate (line 50) | EigenSparseCholeskyTemplate() : analyzed_(false) {}
method StorageType (line 52) | CompressedRowSparseMatrix::StorageType StorageType() const final {
method LinearSolverTerminationType (line 56) | LinearSolverTerminationType Factorize(
method LinearSolverTerminationType (line 84) | LinearSolverTerminationType Solve(const double* rhs_ptr,
method LinearSolverTerminationType (line 108) | LinearSolverTerminationType Factorize(CompressedRowSparseMatrix* lhs,
FILE: 3rdparty/ceres/internal/ceres/eigensparse.h
function namespace (line 49) | namespace internal {
FILE: 3rdparty/ceres/internal/ceres/evaluation_callback_test.cc
type ceres (line 43) | namespace ceres {
type internal (line 44) | namespace internal {
function Djb2Hash (line 49) | uint64_t Djb2Hash(const T* data, const int size) {
type WigglyBowlCostFunctionAndEvaluationCallback (line 62) | struct WigglyBowlCostFunctionAndEvaluationCallback :
method WigglyBowlCostFunctionAndEvaluationCallback (line 66) | explicit WigglyBowlCostFunctionAndEvaluationCallback(double *param...
method PrepareForEvaluation (line 80) | void PrepareForEvaluation(bool evaluate_jacobians,
method Evaluate (line 114) | bool Evaluate(double const* const* parameters,
function TEST (line 191) | TEST(EvaluationCallback, WithTrustRegionMinimizer) {
function WithLineSearchMinimizerImpl (line 235) | static void WithLineSearchMinimizerImpl(
function TEST (line 284) | TEST(EvaluationCallback, WithLineSearchMinimizerWolfeLbfgsCubic) {
function TEST (line 287) | TEST(EvaluationCallback, WithLineSearchMinimizerWolfeLbfgsQuadratic) {
function TEST (line 292) | TEST(EvaluationCallback, WithLineSearchMinimizerWolfeBfgsCubic) {
function TEST (line 296) | TEST(EvaluationCallback, WithLineSearchMinimizerWolfeBfgsQuadratic) {
function TEST (line 301) | TEST(EvaluationCallback, WithLineSearchMinimizerArmijoCubic) {
function TEST (line 305) | TEST(EvaluationCallback, WithLineSearchMinimizerArmijoBisection) {
function TEST (line 309) | TEST(EvaluationCallback, WithLineSearchMinimizerArmijoQuadratic) {
FILE: 3rdparty/ceres/internal/ceres/evaluator.cc
type ceres (line 46) | namespace ceres {
type internal (line 47) | namespace internal {
function Evaluator (line 51) | Evaluator* Evaluator::Create(const Evaluator::Options& options,
FILE: 3rdparty/ceres/internal/ceres/evaluator.h
function namespace (line 44) | namespace ceres {
FILE: 3rdparty/ceres/internal/ceres/evaluator_test.cc
type ceres (line 51) | namespace ceres {
type internal (line 52) | namespace internal {
class ParameterIgnoringCostFunction (line 59) | class ParameterIgnoringCostFunction
method ParameterIgnoringCostFunction (line 64) | explicit ParameterIgnoringCostFunction(bool succeeds = true)
method Evaluate (line 67) | bool Evaluate(double const* const* parameters,
type EvaluatorTestOptions (line 104) | struct EvaluatorTestOptions {
method EvaluatorTestOptions (line 105) | EvaluatorTestOptions(LinearSolverType linear_solver_type,
type EvaluatorTest (line 117) | struct EvaluatorTest
method Evaluator (line 119) | Evaluator* CreateEvaluator(Program* program) {
method EvaluateAndCompare (line 145) | void EvaluateAndCompare(ProblemImpl *problem,
method CheckAllEvaluationCombinations (line 199) | void CheckAllEvaluationCombinations(const ExpectedEvaluation &expe...
function SetSparseMatrixConstant (line 219) | static void SetSparseMatrixConstant(SparseMatrix* sparse_matrix, dou...
function TEST_P (line 224) | TEST_P(EvaluatorTest, SingleResidualProblem) {
function TEST_P (line 251) | TEST_P(EvaluatorTest, SingleResidualProblemWithPermutedParameters) {
function TEST_P (line 289) | TEST_P(EvaluatorTest, SingleResidualProblemWithNuisanceParameters) {
function TEST_P (line 336) | TEST_P(EvaluatorTest, MultipleResidualProblem) {
function TEST_P (line 391) | TEST_P(EvaluatorTest, MultipleResidualsWithLocalParameterizations) {
function TEST_P (line 454) | TEST_P(EvaluatorTest, MultipleResidualProblemWithSomeConstantParamet...
function TEST_P (line 532) | TEST_P(EvaluatorTest, EvaluatorAbortsForResidualsThatFailToEvaluate) {
class ParameterSensitiveCostFunction (line 581) | class ParameterSensitiveCostFunction : public SizedCostFunction<2, 2> {
method Evaluate (line 583) | bool Evaluate(double const* const* parameters,
function TEST (line 604) | TEST(Evaluator, EvaluatorRespectsParameterChanges) {
FILE: 3rdparty/ceres/internal/ceres/evaluator_test_utils.cc
type ceres (line 36) | namespace ceres {
type internal (line 37) | namespace internal {
function CompareEvaluations (line 39) | void CompareEvaluations(int expected_num_rows,
FILE: 3rdparty/ceres/internal/ceres/evaluator_test_utils.h
function namespace (line 34) | namespace ceres {
FILE: 3rdparty/ceres/internal/ceres/execution_summary.h
function namespace (line 41) | namespace ceres {
FILE: 3rdparty/ceres/internal/ceres/file.cc
type ceres (line 38) | namespace ceres {
type internal (line 39) | namespace internal {
function WriteStringToFileOrDie (line 43) | void WriteStringToFileOrDie(const string &data, const string &filena...
function ReadFileToStringOrDie (line 52) | void ReadFileToStringOrDie(const string &filename, string *data) {
function string (line 78) | string JoinPath(const string& dirname, const string& basename) {
FILE: 3rdparty/ceres/internal/ceres/file.h
function namespace (line 39) | namespace ceres {
FILE: 3rdparty/ceres/internal/ceres/fixed_array_test.cc
function IsOnStack (line 50) | static bool IsOnStack(const ArrayType& a) {
class ConstructionTester (line 54) | class ConstructionTester {
method ConstructionTester (line 56) | ConstructionTester() : self_ptr_(this), value_(0) { constructions++; }
method CheckConstructed (line 68) | void CheckConstructed() { assert(self_ptr_ == this); }
method set (line 70) | void set(int value) { value_ = value; }
method get (line 71) | int get() { return value_; }
class ThreeInts (line 86) | class ThreeInts {
method ThreeInts (line 88) | ThreeInts() {
function TEST (line 102) | TEST(FixedArrayTest, CopyCtor) {
function TEST (line 116) | TEST(FixedArrayTest, MoveCtor) {
function TEST (line 138) | TEST(FixedArrayTest, SmallObjects) {
function TEST (line 195) | TEST(FixedArrayRelationalsTest, EqualArrays) {
function TEST (line 216) | TEST(FixedArrayRelationalsTest, UnequalArrays) {
function TestArray (line 239) | static void TestArray(int n) {
function TestArrayOfArrays (line 283) | static void TestArrayOfArrays(int n) {
function TEST (line 344) | TEST(IteratorConstructorTest, NonInline) {
function TEST (line 354) | TEST(IteratorConstructorTest, Inline) {
function TEST (line 364) | TEST(IteratorConstructorTest, NonPod) {
function TEST (line 375) | TEST(IteratorConstructorTest, FromEmptyVector) {
function TEST (line 382) | TEST(IteratorConstructorTest, FromNonEmptyVector) {
function TEST (line 393) | TEST(IteratorConstructorTest, FromBidirectionalIteratorRange) {
function TEST (line 400) | TEST(InitListConstructorTest, InitListConstruction) {
function TEST (line 405) | TEST(FillConstructorTest, NonEmptyArrays) {
function TEST (line 413) | TEST(FillConstructorTest, EmptyArray) {
function TEST (line 419) | TEST(FillConstructorTest, NotTriviallyCopyable) {
function TEST (line 427) | TEST(FillConstructorTest, Disambiguation) {
function TEST (line 432) | TEST(FixedArrayTest, ManySizedArrays) {
function TEST (line 444) | TEST(FixedArrayTest, ManySizedArraysOfArraysOf1) {
function TEST (line 453) | TEST(FixedArrayTest, ManySizedArraysOfArraysOf2) {
function TEST (line 467) | TEST(FixedArrayTest, AvoidParanoidDiagnostics) {
function TEST (line 472) | TEST(FixedArrayTest, TooBigInlinedSpace) {
type PickyDelete (line 501) | struct PickyDelete {
method PickyDelete (line 502) | PickyDelete() {}
function TEST (line 514) | TEST(FixedArrayTest, UsesGlobalAlloc) {
function TEST (line 518) | TEST(FixedArrayTest, Data) {
function TEST (line 529) | TEST(FixedArrayTest, Empty) {
function TEST (line 538) | TEST(FixedArrayTest, FrontAndBack) {
function TEST (line 551) | TEST(FixedArrayTest, ReverseIteratorInlined) {
function TEST (line 581) | TEST(FixedArrayTest, ReverseIteratorAllocated) {
function TEST (line 611) | TEST(FixedArrayTest, Fill) {
function TEST (line 628) | TEST(FixedArrayTest, DefaultCtorDoesNotValueInit) {
class CountingAllocator (line 654) | class CountingAllocator : public std::allocator<T> {
method CountingAllocator (line 660) | CountingAllocator() : bytes_used_(nullptr), instance_count_(nullptr) {}
method CountingAllocator (line 661) | explicit CountingAllocator(int64_t* b)
method CountingAllocator (line 663) | CountingAllocator(int64_t* b, int64_t* a)
method CountingAllocator (line 667) | explicit CountingAllocator(const CountingAllocator<U>& x)
method pointer (line 672) | pointer allocate(size_type n, const void* const hint = nullptr) {
method deallocate (line 678) | void deallocate(pointer p, size_type n) {
method construct (line 685) | void construct(pointer p, Args&&... args) {
method destroy (line 692) | void destroy(pointer p) {
class rebind (line 700) | class rebind {
function TEST (line 709) | TEST(AllocatorSupportTest, CountInlineAllocations) {
function TEST (line 730) | TEST(AllocatorSupportTest, CountOutoflineAllocations) {
function TEST (line 751) | TEST(AllocatorSupportTest, CountCopyInlineAllocations) {
function TEST (line 779) | TEST(AllocatorSupportTest, CountCopyOutoflineAllocations) {
function TEST (line 807) | TEST(AllocatorSupportTest, SizeValAllocConstructor) {
type EigenStruct (line 837) | struct EigenStruct {
FILE: 3rdparty/ceres/internal/ceres/float_cxsparse.cc
type ceres (line 35) | namespace ceres {
type internal (line 36) | namespace internal {
FILE: 3rdparty/ceres/internal/ceres/float_cxsparse.h
function namespace (line 42) | namespace ceres {
FILE: 3rdparty/ceres/internal/ceres/float_suitesparse.cc
type ceres (line 35) | namespace ceres {
type internal (line 36) | namespace internal {
FILE: 3rdparty/ceres/internal/ceres/float_suitesparse.h
function namespace (line 42) | namespace ceres {
FILE: 3rdparty/ceres/internal/ceres/function_sample.cc
type ceres (line 34) | namespace ceres {
type internal (line 35) | namespace internal {
FILE: 3rdparty/ceres/internal/ceres/function_sample.h
function namespace (line 37) | namespace ceres {
FILE: 3rdparty/ceres/internal/ceres/generate_bundle_adjustment_tests.py
function camelcasify (line 152) | def camelcasify(token):
function generate_bundle_test (line 157) | def generate_bundle_test(linear_solver,
FILE: 3rdparty/ceres/internal/ceres/generate_template_specializations.py
function SuffixForSize (line 82) | def SuffixForSize(size):
function SpecializationFilename (line 87) | def SpecializationFilename(prefix, row_block_size, e_block_size, f_block...
function GenerateFactoryConditional (line 92) | def GenerateFactoryConditional(row_block_size, e_block_size, f_block_size):
function Specialize (line 108) | def Specialize(name, data):
function GenerateQueryFile (line 222) | def GenerateQueryFile():
FILE: 3rdparty/ceres/internal/ceres/generated/partitioned_matrix_view_2_2_2.cc
type ceres (line 50) | namespace ceres {
type internal (line 51) | namespace internal {
class PartitionedMatrixView<2, 2, 2> (line 53) | class PartitionedMatrixView<2, 2, 2>
FILE: 3rdparty/ceres/internal/ceres/generated/partitioned_matrix_view_2_2_3.cc
type ceres (line 50) | namespace ceres {
type internal (line 51) | namespace internal {
class PartitionedMatrixView<2, 2, 3> (line 53) | class PartitionedMatrixView<2, 2, 3>
FILE: 3rdparty/ceres/internal/ceres/generated/partitioned_matrix_view_2_2_4.cc
type ceres (line 50) | namespace ceres {
type internal (line 51) | namespace internal {
class PartitionedMatrixView<2, 2, 4> (line 53) | class PartitionedMatrixView<2, 2, 4>
FILE: 3rdparty/ceres/internal/ceres/generated/partitioned_matrix_view_2_2_d.cc
type ceres (line 50) | namespace ceres {
type internal (line 51) | namespace internal {
class PartitionedMatrixView<2, 2, Eigen::Dynamic> (line 53) | class PartitionedMatrixView<2, 2, Eigen::Dynamic>
FILE: 3rdparty/ceres/internal/ceres/generated/partitioned_matrix_view_2_3_3.cc
type ceres (line 50) | namespace ceres {
type internal (line 51) | namespace internal {
class PartitionedMatrixView<2, 3, 3> (line 53) | class PartitionedMatrixView<2, 3, 3>
FILE: 3rdparty/ceres/internal/ceres/generated/partitioned_matrix_view_2_3_4.cc
type ceres (line 50) | namespace ceres {
type internal (line 51) | namespace internal {
class PartitionedMatrixView<2, 3, 4> (line 53) | class PartitionedMatrixView<2, 3, 4>
FILE: 3rdparty/ceres/internal/ceres/generated/partitioned_matrix_view_2_3_6.cc
type ceres (line 50) | namespace ceres {
type internal (line 51) | namespace internal {
class PartitionedMatrixView<2, 3, 6> (line 53) | class PartitionedMatrixView<2, 3, 6>
FILE: 3rdparty/ceres/internal/ceres/generated/partitioned_matrix_view_2_3_9.cc
type ceres (line 50) | namespace ceres {
type internal (line 51) | namespace internal {
class PartitionedMatrixView<2, 3, 9> (line 53) | class PartitionedMatrixView<2, 3, 9>
FILE: 3rdparty/ceres/internal/ceres/generated/partitioned_matrix_view_2_3_d.cc
type ceres (line 50) | namespace ceres {
type internal (line 51) | namespace internal {
class PartitionedMatrixView<2, 3, Eigen::Dynamic> (line 53) | class PartitionedMatrixView<2, 3, Eigen::Dynamic>
FILE: 3rdparty/ceres/internal/ceres/generated/partitioned_matrix_view_2_4_3.cc
type ceres (line 50) | namespace ceres {
type internal (line 51) | namespace internal {
class PartitionedMatrixView<2, 4, 3> (line 53) | class PartitionedMatrixView<2, 4, 3>
FILE: 3rdparty/ceres/internal/ceres/generated/partitioned_matrix_view_2_4_4.cc
type ceres (line 50) | namespace ceres {
type internal (line 51) | namespace internal {
class PartitionedMatrixView<2, 4, 4> (line 53) | class PartitionedMatrixView<2, 4, 4>
FILE: 3rdparty/ceres/internal/ceres/generated/partitioned_matrix_view_2_4_6.cc
type ceres (line 50) | namespace ceres {
type internal (line 51) | namespace internal {
class PartitionedMatrixView<2, 4, 6> (line 53) | class PartitionedMatrixView<2, 4, 6>
FILE: 3rdparty/ceres/internal/ceres/generated/partitioned_matrix_view_2_4_8.cc
type ceres (line 50) | namespace ceres {
type internal (line 51) | namespace internal {
class PartitionedMatrixView<2, 4, 8> (line 53) | class PartitionedMatrixView<2, 4, 8>
FILE: 3rdparty/ceres/internal/ceres/generated/partitioned_matrix_view_2_4_9.cc
type ceres (line 50) | namespace ceres {
type internal (line 51) | namespace internal {
class PartitionedMatrixView<2, 4, 9> (line 53) | class PartitionedMatrixView<2, 4, 9>
FILE: 3rdparty/ceres/internal/ceres/generated/partitioned_matrix_view_2_4_d.cc
type ceres (line 50) | namespace ceres {
type internal (line 51) | namespace internal {
class PartitionedMatrixView<2, 4, Eigen::Dynamic> (line 53) | class PartitionedMatrixView<2, 4, Eigen::Dynamic>
FILE: 3rdparty/ceres/internal/ceres/generated/partitioned_matrix_view_2_d_d.cc
type ceres (line 50) | namespace ceres {
type internal (line 51) | namespace internal {
class PartitionedMatrixView<2, Eigen::Dynamic, Eigen::Dynamic> (line 53) | class PartitionedMatrixView<2, Eigen::Dynamic, Eigen::Dynamic>
FILE: 3rdparty/ceres/internal/ceres/generated/partitioned_matrix_view_3_3_3.cc
type ceres (line 50) | namespace ceres {
type internal (line 51) | namespace internal {
class PartitionedMatrixView<3, 3, 3> (line 53) | class PartitionedMatrixView<3, 3, 3>
FILE: 3rdparty/ceres/internal/ceres/generated/partitioned_matrix_view_4_4_2.cc
type ceres (line 50) | namespace ceres {
type internal (line 51) | namespace internal {
class PartitionedMatrixView<4, 4, 2> (line 53) | class PartitionedMatrixView<4, 4, 2>
FILE: 3rdparty/ceres/internal/ceres/generated/partitioned_matrix_view_4_4_3.cc
type ceres (line 50) | namespace ceres {
type internal (line 51) | namespace internal {
class PartitionedMatrixView<4, 4, 3> (line 53) | class PartitionedMatrixView<4, 4, 3>
FILE: 3rdparty/ceres/internal/ceres/generated/partitioned_matrix_view_4_4_4.cc
type ceres (line 50) | namespace ceres {
type internal (line 51) | namespace internal {
class PartitionedMatrixView<4, 4, 4> (line 53) | class PartitionedMatrixView<4, 4, 4>
FILE: 3rdparty/ceres/internal/ceres/generated/partitioned_matrix_view_4_4_d.cc
type ceres (line 50) | namespace ceres {
type internal (line 51) | namespace internal {
class PartitionedMatrixView<4, 4, Eigen::Dynamic> (line 53) | class PartitionedMatrixView<4, 4, Eigen::Dynamic>
FILE: 3rdparty/ceres/internal/ceres/generated/partitioned_matrix_view_d_d_d.cc
type ceres (line 46) | namespace ceres {
type internal (line 47) | namespace internal {
class PartitionedMatrixView<Eigen::Dynamic, Eigen::Dynamic, Eigen::Dynamic> (line 49) | class PartitionedMatrixView<Eigen::Dynamic, Eigen::Dynamic, Eigen::D...
FILE: 3rdparty/ceres/internal/ceres/generated/schur_eliminator_2_2_2.cc
type ceres (line 50) | namespace ceres {
type internal (line 51) | namespace internal {
class SchurEliminator<2, 2, 2> (line 53) | class SchurEliminator<2, 2, 2>
FILE: 3rdparty/ceres/internal/ceres/generated/schur_eliminator_2_2_3.cc
type ceres (line 50) | namespace ceres {
type internal (line 51) | namespace internal {
class SchurEliminator<2, 2, 3> (line 53) | class SchurEliminator<2, 2, 3>
FILE: 3rdparty/ceres/internal/ceres/generated/schur_eliminator_2_2_4.cc
type ceres (line 50) | namespace ceres {
type internal (line 51) | namespace internal {
class SchurEliminator<2, 2, 4> (line 53) | class SchurEliminator<2, 2, 4>
FILE: 3rdparty/ceres/internal/ceres/generated/schur_eliminator_2_2_d.cc
type ceres (line 50) | namespace ceres {
type internal (line 51) | namespace internal {
class SchurEliminator<2, 2, Eigen::Dynamic> (line 53) | class SchurEliminator<2, 2, Eigen::Dynamic>
FILE: 3rdparty/ceres/internal/ceres/generated/schur_eliminator_2_3_3.cc
type ceres (line 50) | namespace ceres {
type internal (line 51) | namespace internal {
class SchurEliminator<2, 3, 3> (line 53) | class SchurEliminator<2, 3, 3>
FILE: 3rdparty/ceres/internal/ceres/generated/schur_eliminator_2_3_4.cc
type ceres (line 50) | namespace ceres {
type internal (line 51) | namespace internal {
class SchurEliminator<2, 3, 4> (line 53) | class SchurEliminator<2, 3, 4>
FILE: 3rdparty/ceres/internal/ceres/generated/schur_eliminator_2_3_6.cc
type ceres (line 50) | namespace ceres {
type internal (line 51) | namespace internal {
class SchurEliminator<2, 3, 6> (line 53) | class SchurEliminator<2, 3, 6>
FILE: 3rdparty/ceres/internal/ceres/generated/schur_eliminator_2_3_9.cc
type ceres (line 50) | namespace ceres {
type internal (line 51) | namespace internal {
class SchurEliminator<2, 3, 9> (line 53) | class SchurEliminator<2, 3, 9>
FILE: 3rdparty/ceres/internal/ceres/generated/schur_eliminator_2_3_d.cc
type ceres (line 50) | namespace ceres {
type internal (line 51) | namespace internal {
class SchurEliminator<2, 3, Eigen::Dynamic> (line 53) | class SchurEliminator<2, 3, Eigen::Dynamic>
FILE: 3rdparty/ceres/internal/ceres/generated/schur_eliminator_2_4_3.cc
type ceres (line 50) | namespace ceres {
type internal (line 51) | namespace internal {
class SchurEliminator<2, 4, 3> (line 53) | class SchurEliminator<2, 4, 3>
FILE: 3rdparty/ceres/internal/ceres/generated/schur_eliminator_2_4_4.cc
type ceres (line 50) | namespace ceres {
type internal (line 51) | namespace internal {
class SchurEliminator<2, 4, 4> (line 53) | class SchurEliminator<2, 4, 4>
FILE: 3rdparty/ceres/internal/ceres/generated/schur_eliminator_2_4_6.cc
type ceres (line 50) | namespace ceres {
type internal (line 51) | namespace internal {
class SchurEliminator<2, 4, 6> (line 53) | class SchurEliminator<2, 4, 6>
FILE: 3rdparty/ceres/internal/ceres/generated/schur_eliminator_2_4_8.cc
type ceres (line 50) | namespace ceres {
type internal (line 51) | namespace internal {
class SchurEliminator<2, 4, 8> (line 53) | class SchurEliminator<2, 4, 8>
FILE: 3rdparty/ceres/internal/ceres/generated/schur_eliminator_2_4_9.cc
type ceres (line 50) | namespace ceres {
type internal (line 51) | namespace internal {
class SchurEliminator<2, 4, 9> (line 53) | class SchurEliminator<2, 4, 9>
FILE: 3rdparty/ceres/internal/ceres/generated/schur_eliminator_2_4_d.cc
type ceres (line 50) | namespace ceres {
type internal (line 51) | namespace internal {
class SchurEliminator<2, 4, Eigen::Dynamic> (line 53) | class SchurEliminator<2, 4, Eigen::Dynamic>
FILE: 3rdparty/ceres/internal/ceres/generated/schur_eliminator_2_d_d.cc
type ceres (line 50) | namespace ceres {
type internal (line 51) | namespace internal {
class SchurEliminator<2, Eigen::Dynamic, Eigen::Dynamic> (line 53) | class SchurEliminator<2, Eigen::Dynamic, Eigen::Dynamic>
FILE: 3rdparty/ceres/internal/ceres/generated/schur_eliminator_3_3_3.cc
type ceres (line 50) | namespace ceres {
type internal (line 51) | namespace internal {
class SchurEliminator<3, 3, 3> (line 53) | class SchurEliminator<3, 3, 3>
FILE: 3rdparty/ceres/internal/ceres/generated/schur_eliminator_4_4_2.cc
type ceres (line 50) | namespace ceres {
type internal (line 51) | namespace internal {
class SchurEliminator<4, 4, 2> (line 53) | class SchurEliminator<4, 4, 2>
FILE: 3rdparty/ceres/internal/ceres/generated/schur_eliminator_4_4_3.cc
type ceres (line 50) | namespace ceres {
type internal (line 51) | namespace internal {
class SchurEliminator<4, 4, 3> (line 53) | class SchurEliminator<4, 4, 3>
FILE: 3rdparty/ceres/internal/ceres/generated/schur_eliminator_4_4_4.cc
type ceres (line 50) | namespace ceres {
type internal (line 51) | namespace internal {
class SchurEliminator<4, 4, 4> (line 53) | class SchurEliminator<4, 4, 4>
FILE: 3rdparty/ceres/internal/ceres/generated/schur_eliminator_4_4_d.cc
type ceres (line 50) | namespace ceres {
type internal (line 51) | namespace internal {
class SchurEliminator<4, 4, Eigen::Dynamic> (line 53) | class SchurEliminator<4, 4, Eigen::Dynamic>
FILE: 3rdparty/ceres/internal/ceres/generated/schur_eliminator_d_d_d.cc
type ceres (line 46) | namespace ceres {
type internal (line 47) | namespace internal {
class SchurEliminator<Eigen::Dynamic, Eigen::Dynamic, Eigen::Dynamic> (line 49) | class SchurEliminator<Eigen::Dynamic, Eigen::Dynamic, Eigen::Dynamic>
FILE: 3rdparty/ceres/internal/ceres/generated_bundle_adjustment_tests/ba_denseschur_auto_test.cc
type ceres (line 40) | namespace ceres {
type internal (line 41) | namespace internal {
function TEST_F (line 43) | TEST_F(BundleAdjustmentTest,
FILE: 3rdparty/ceres/internal/ceres/generated_bundle_adjustment_tests/ba_denseschur_auto_threads_test.cc
type ceres (line 42) | namespace ceres {
type internal (line 43) | namespace internal {
function TEST_F (line 45) | TEST_F(BundleAdjustmentTest,
FILE: 3rdparty/ceres/internal/ceres/generated_bundle_adjustment_tests/ba_denseschur_user_test.cc
type ceres (line 40) | namespace ceres {
type internal (line 41) | namespace internal {
function TEST_F (line 43) | TEST_F(BundleAdjustmentTest,
FILE: 3rdparty/ceres/internal/ceres/generated_bundle_adjustment_tests/ba_denseschur_user_threads_test.cc
type ceres (line 42) | namespace ceres {
type internal (line 43) | namespace internal {
function TEST_F (line 45) | TEST_F(BundleAdjustmentTest,
FILE: 3rdparty/ceres/internal/ceres/generated_bundle_adjustment_tests/ba_iterschur_acceleratesparse_clustjacobi_auto_test.cc
type ceres (line 42) | namespace ceres {
type internal (line 43) | namespace internal {
function TEST_F (line 45) | TEST_F(BundleAdjustmentTest,
FILE: 3rdparty/ceres/internal/ceres/generated_bundle_adjustment_tests/ba_iterschur_acceleratesparse_clustjacobi_auto_threads_test.cc
type ceres (line 43) | namespace ceres {
type internal (line 44) | namespace internal {
function TEST_F (line 46) | TEST_F(BundleAdjustmentTest,
FILE: 3rdparty/ceres/internal/ceres/generated_bundle_adjustment_tests/ba_iterschur_acceleratesparse_clustjacobi_user_test.cc
type ceres (line 42) | namespace ceres {
type internal (line 43) | namespace internal {
function TEST_F (line 45) | TEST_F(BundleAdjustmentTest,
FILE: 3rdparty/ceres/internal/ceres/generated_bundle_adjustment_tests/ba_iterschur_acceleratesparse_clustjacobi_user_threads_test.cc
type ceres (line 43) | namespace ceres {
type internal (line 44) | namespace internal {
function TEST_F (line 46) | TEST_F(BundleAdjustmentTest,
FILE: 3rdparty/ceres/internal/ceres/generated_bundle_adjustment_tests/ba_iterschur_acceleratesparse_clusttri_auto_test.cc
type ceres (line 42) | namespace ceres {
type internal (line 43) | namespace internal {
function TEST_F (line 45) | TEST_F(BundleAdjustmentTest,
FILE: 3rdparty/ceres/internal/ceres/generated_bundle_adjustment_tests/ba_iterschur_acceleratesparse_clusttri_auto_threads_test.cc
type ceres (line 43) | namespace ceres {
type internal (line 44) | namespace internal {
function TEST_F (line 46) | TEST_F(BundleAdjustmentTest,
FILE: 3rdparty/ceres/internal/ceres/generated_bundle_adjustment_tests/ba_iterschur_acceleratesparse_clusttri_user_test.cc
type ceres (line 42) | namespace ceres {
type internal (line 43) | namespace internal {
function TEST_F (line 45) | TEST_F(BundleAdjustmentTest,
FILE: 3rdparty/ceres/internal/ceres/generated_bundle_adjustment_tests/ba_iterschur_acceleratesparse_clusttri_user_threads_test.cc
type ceres (line 43) | namespace ceres {
type internal (line 44) | namespace internal {
function TEST_F (line 46) | TEST_F(BundleAdjustmentTest,
FILE: 3rdparty/ceres/internal/ceres/generated_bundle_adjustment_tests/ba_iterschur_cxsparse_clustjacobi_auto_test.cc
type ceres (line 42) | namespace ceres {
type internal (line 43) | namespace internal {
function TEST_F (line 45) | TEST_F(BundleAdjustmentTest,
FILE: 3rdparty/ceres/internal/ceres/generated_bundle_adjustment_tests/ba_iterschur_cxsparse_clustjacobi_auto_threads_test.cc
type ceres (line 43) | namespace ceres {
type internal (line 44) | namespace internal {
function TEST_F (line 46) | TEST_F(BundleAdjustmentTest,
FILE: 3rdparty/ceres/internal/ceres/generated_bundle_adjustment_tests/ba_iterschur_cxsparse_clustjacobi_user_test.cc
type ceres (line 42) | namespace ceres {
type internal (line 43) | namespace internal {
function TEST_F (line 45) | TEST_F(BundleAdjustmentTest,
FILE: 3rdparty/ceres/internal/ceres/generated_bundle_adjustment_tests/ba_iterschur_cxsparse_clustjacobi_user_threads_test.cc
type ceres (line 43) | namespace ceres {
type internal (line 44) | namespace internal {
function TEST_F (line 46) | TEST_F(BundleAdjustmentTest,
FILE: 3rdparty/ceres/internal/ceres/generated_bundle_adjustment_tests/ba_iterschur_cxsparse_clusttri_auto_test.cc
type ceres (line 42) | namespace ceres {
type internal (line 43) | namespace internal {
function TEST_F (line 45) | TEST_F(BundleAdjustmentTest,
FILE: 3rdparty/ceres/internal/ceres/generated_bundle_adjustment_tests/ba_iterschur_cxsparse_clusttri_auto_threads_test.cc
type ceres (line 43) | namespace ceres {
type internal (line 44) | namespace internal {
function TEST_F (line 46) | TEST_F(BundleAdjustmentTest,
FILE: 3rdparty/ceres/internal/ceres/generated_bundle_adjustment_tests/ba_iterschur_cxsparse_clusttri_user_test.cc
type ceres (line 42) | namespace ceres {
type internal (line 43) | namespace internal {
function TEST_F (line 45) | TEST_F(BundleAdjustmentTest,
FILE: 3rdparty/ceres/internal/ceres/generated_bundle_adjustment_tests/ba_iterschur_cxsparse_clusttri_user_threads_test.cc
type ceres (line 43) | namespace ceres {
type internal (line 44) | namespace internal {
function TEST_F (line 46) | TEST_F(BundleAdjustmentTest,
FILE: 3rdparty/ceres/internal/ceres/generated_bundle_adjustment_tests/ba_iterschur_eigensparse_clustjacobi_auto_test.cc
type ceres (line 42) | namespace ceres {
type internal (line 43) | namespace internal {
function TEST_F (line 45) | TEST_F(BundleAdjustmentTest,
FILE: 3rdparty/ceres/internal/ceres/generated_bundle_adjustment_tests/ba_iterschur_eigensparse_clustjacobi_auto_threads_test.cc
type ceres (line 43) | namespace ceres {
type internal (line 44) | namespace internal {
function TEST_F (line 46) | TEST_F(BundleAdjustmentTest,
FILE: 3rdparty/ceres/internal/ceres/generated_bundle_adjustment_tests/ba_iterschur_eigensparse_clustjacobi_user_test.cc
type ceres (line 42) | namespace ceres {
type internal (line 43) | namespace internal {
function TEST_F (line 45) | TEST_F(BundleAdjustmentTest,
FILE: 3rdparty/ceres/internal/ceres/generated_bundle_adjustment_tests/ba_iterschur_eigensparse_clustjacobi_user_threads_test.cc
type ceres (line 43) | namespace ceres {
type internal (line 44) | namespace internal {
function TEST_F (line 46) | TEST_F(BundleAdjustmentTest,
FILE: 3rdparty/ceres/internal/ceres/generated_bundle_adjustment_tests/ba_iterschur_eigensparse_clusttri_auto_test.cc
type ceres (line 42) | namespace ceres {
type internal (line 43) | namespace internal {
function TEST_F (line 45) | TEST_F(BundleAdjustmentTest,
FILE: 3rdparty/ceres/internal/ceres/generated_bundle_adjustment_tests/ba_iterschur_eigensparse_clusttri_auto_threads_test.cc
type ceres (line 43) | namespace ceres {
type internal (line 44) | namespace internal {
function TEST_F (line 46) | TEST_F(BundleAdjustmentTest,
FILE: 3rdparty/ceres/internal/ceres/generated_bundle_adjustment_tests/ba_iterschur_eigensparse_clusttri_user_test.cc
type ceres (line 42) | namespace ceres {
type internal (line 43) | namespace internal {
function TEST_F (line 45) | TEST_F(BundleAdjustmentTest,
FILE: 3rdparty/ceres/internal/ceres/generated_bundle_adjustment_tests/ba_iterschur_eigensparse_clusttri_user_threads_test.cc
type ceres (line 43) | namespace ceres {
type internal (line 44) | namespace internal {
function TEST_F (line 46) | TEST_F(BundleAdjustmentTest,
FILE: 3rdparty/ceres/internal/ceres/generated_bundle_adjustment_tests/ba_iterschur_jacobi_auto_test.cc
type ceres (line 40) | namespace ceres {
type internal (line 41) | namespace internal {
function TEST_F (line 43) | TEST_F(BundleAdjustmentTest,
FILE: 3rdparty/ceres/internal/ceres/generated_bundle_adjustment_tests/ba_iterschur_jacobi_auto_threads_test.cc
type ceres (line 42) | namespace ceres {
type internal (line 43) | namespace internal {
function TEST_F (line 45) | TEST_F(BundleAdjustmentTest,
FILE: 3rdparty/ceres/internal/ceres/generated_bundle_adjustment_tests/ba_iterschur_jacobi_user_test.cc
type ceres (line 40) | namespace ceres {
type internal (line 41) | namespace internal {
function TEST_F (line 43) | TEST_F(BundleAdjustmentTest,
FILE: 3rdparty/ceres/internal/ceres/generated_bundle_adjustment_tests/ba_iterschur_jacobi_user_threads_test.cc
type ceres (line 42) | namespace ceres {
type internal (line 43) | namespace internal {
function TEST_F (line 45) | TEST_F(BundleAdjustmentTest,
FILE: 3rdparty/ceres/internal/ceres/generated_bundle_adjustment_tests/ba_iterschur_schurjacobi_auto_test.cc
type ceres (line 40) | namespace ceres {
type internal (line 41) | namespace internal {
function TEST_F (line 43) | TEST_F(BundleAdjustmentTest,
FILE: 3rdparty/ceres/internal/ceres/generated_bundle_adjustment_tests/ba_iterschur_schurjacobi_auto_threads_test.cc
type ceres (line 42) | namespace ceres {
type internal (line 43) | namespace internal {
function TEST_F (line 45) | TEST_F(BundleAdjustmentTest,
FILE: 3rdparty/ceres/internal/ceres/generated_bundle_adjustment_tests/ba_iterschur_schurjacobi_user_test.cc
type ceres (line 40) | namespace ceres {
type internal (line 41) | namespace internal {
function TEST_F (line 43) | TEST_F(BundleAdjustmentTest,
FILE: 3rdparty/ceres/internal/ceres/generated_bundle_adjustment_tests/ba_iterschur_schurjacobi_user_threads_test.cc
type ceres (line 42) | namespace ceres {
type internal (line 43) | namespace internal {
function TEST_F (line 45) | TEST_F(BundleAdjustmentTest,
FILE: 3rdparty/ceres/internal/ceres/generated_bundle_adjustment_tests/ba_iterschur_suitesparse_clustjacobi_auto_test.cc
type ceres (line 42) | namespace ceres {
type internal (line 43) | namespace internal {
function TEST_F (line 45) | TEST_F(BundleAdjustmentTest,
FILE: 3rdparty/ceres/internal/ceres/generated_bundle_adjustment_tests/ba_iterschur_suitesparse_clustjacobi_auto_threads_test.cc
type ceres (line 43) | namespace ceres {
type internal (line 44) | namespace internal {
function TEST_F (line 46) | TEST_F(BundleAdjustmentTest,
FILE: 3rdparty/ceres/internal/ceres/generated_bundle_adjustment_tests/ba_iterschur_suitesparse_clustjacobi_user_test.cc
type ceres (line 42) | namespace ceres {
type internal (line 43) | namespace internal {
function TEST_F (line 45) | TEST_F(BundleAdjustmentTest,
FILE: 3rdparty/ceres/internal/ceres/generated_bundle_adjustment_tests/ba_iterschur_suitesparse_clustjacobi_user_threads_test.cc
type ceres (line 43) | namespace ceres {
type internal (line 44) | namespace internal {
function TEST_F (line 46) | TEST_F(BundleAdjustmentTest,
FILE: 3rdparty/ceres/internal/ceres/generated_bundle_adjustment_tests/ba_iterschur_suitesparse_clusttri_auto_test.cc
type ceres (line 42) | namespace ceres {
type internal (line 43) | namespace internal {
function TEST_F (line 45) | TEST_F(BundleAdjustmentTest,
FILE: 3rdparty/ceres/internal/ceres/generated_bundle_adjustment_tests/ba_iterschur_suitesparse_clusttri_auto_threads_test.cc
type ceres (line 43) | namespace ceres {
type internal (line 44) | namespace internal {
function TEST_F (line 46) | TEST_F(BundleAdjustmentTest,
FILE: 3rdparty/ceres/internal/ceres/generated_bundle_adjustment_tests/ba_iterschur_suitesparse_clusttri_user_test.cc
type ceres (line 42) | namespace ceres {
type internal (line 43) | namespace internal {
function TEST_F (line 45) | TEST_F(BundleAdjustmentTest,
FILE: 3rdparty/ceres/internal/ceres/generated_bundle_adjustment_tests/ba_iterschur_suitesparse_clusttri_user_threads_test.cc
type ceres (line 43) | namespace ceres {
type internal (line 44) | namespace internal {
function TEST_F (line 46) | TEST_F(BundleAdjustmentTest,
FILE: 3rdparty/ceres/internal/ceres/generated_bundle_adjustment_tests/ba_sparsecholesky_acceleratesparse_auto_test.cc
type ceres (line 42) | namespace ceres {
type internal (line 43) | namespace internal {
function TEST_F (line 45) | TEST_F(BundleAdjustmentTest,
FILE: 3rdparty/ceres/internal/ceres/generated_bundle_adjustment_tests/ba_sparsecholesky_acceleratesparse_auto_threads_test.cc
type ceres (line 43) | namespace ceres {
type internal (line 44) | namespace internal {
function TEST_F (line 46) | TEST_F(BundleAdjustmentTest,
FILE: 3rdparty/ceres/internal/ceres/generated_bundle_adjustment_tests/ba_sparsecholesky_acceleratesparse_user_test.cc
type ceres (line 42) | namespace ceres {
type internal (line 43) | namespace internal {
function TEST_F (line 45) | TEST_F(BundleAdjustmentTest,
FILE: 3rdparty/ceres/internal/ceres/generated_bundle_adjustment_tests/ba_sparsecholesky_acceleratesparse_user_threads_test.cc
type ceres (line 43) | namespace ceres {
type internal (line 44) | namespace internal {
function TEST_F (line 46) | TEST_F(BundleAdjustmentTest,
FILE: 3rdparty/ceres/internal/ceres/generated_bundle_adjustment_tests/ba_sparsecholesky_cxsparse_auto_test.cc
type ceres (line 42) | namespace ceres {
type internal (line 43) | namespace internal {
function TEST_F (line 45) | TEST_F(BundleAdjustmentTest,
FILE: 3rdparty/ceres/internal/ceres/generated_bundle_adjustment_tests/ba_sparsecholesky_cxsparse_auto_threads_test.cc
type ceres (line 43) | namespace ceres {
type internal (line 44) | namespace internal {
function TEST_F (line 46) | TEST_F(BundleAdjustmentTest,
FILE: 3rdparty/ceres/internal/ceres/generated_bundle_adjustment_tests/ba_sparsecholesky_cxsparse_user_test.cc
type ceres (line 42) | namespace ceres {
type internal (line 43) | namespace internal {
function TEST_F (line 45) | TEST_F(BundleAdjustmentTest,
FILE: 3rdparty/ceres/internal/ceres/generated_bundle_adjustment_tests/ba_sparsecholesky_cxsparse_user_threads_test.cc
type ceres (line 43) | namespace ceres {
type internal (line 44) | namespace internal {
function TEST_F (line 46) | TEST_F(BundleAdjustmentTest,
FILE: 3rdparty/ceres/internal/ceres/generated_bundle_adjustment_tests/ba_sparsecholesky_eigensparse_auto_test.cc
type ceres (line 42) | namespace ceres {
type internal (line 43) | namespace internal {
function TEST_F (line 45) | TEST_F(BundleAdjustmentTest,
FILE: 3rdparty/ceres/internal/ceres/generated_bundle_adjustment_tests/ba_sparsecholesky_eigensparse_auto_threads_test.cc
type ceres (line 43) | namespace ceres {
type internal (line 44) | namespace internal {
function TEST_F (line 46) | TEST_F(BundleAdjustmentTest,
FILE: 3rdparty/ceres/internal/ceres/generated_bundle_adjustment_tests/ba_sparsecholesky_eigensparse_user_test.cc
type ceres (line 42) | namespace ceres {
type internal (line 43) | namespace internal {
function TEST_F (line 45) | TEST_F(BundleAdjustmentTest,
FILE: 3rdparty/ceres/internal/ceres/generated_bundle_adjustment_tests/ba_sparsecholesky_eigensparse_user_threads_test.cc
type ceres (line 43) | namespace ceres {
type internal (line 44) | namespace internal {
function TEST_F (line 46) | TEST_F(BundleAdjustmentTest,
FILE: 3rdparty/ceres/internal/ceres/generated_bundle_adjustment_tests/ba_sparsecholesky_suitesparse_auto_test.cc
type ceres (line 42) | namespace ceres {
type internal (line 43) | namespace internal {
function TEST_F (line 45) | TEST_F(BundleAdjustmentTest,
FILE: 3rdparty/ceres/internal/ceres/generated_bundle_adjustment_tests/ba_sparsecholesky_suitesparse_auto_threads_test.cc
type ceres (line 43) | namespace ceres {
type internal (line 44) | namespace internal {
function TEST_F (line 46) | TEST_F(BundleAdjustmentTest,
FILE: 3rdparty/ceres/internal/ceres/generated_bundle_adjustment_tests/ba_sparsecholesky_suitesparse_user_test.cc
type ceres (line 42) | namespace ceres {
type internal (line 43) | namespace internal {
function TEST_F (line 45) | TEST_F(BundleAdjustmentTest,
FILE: 3rdparty/ceres/internal/ceres/generated_bundle_adjustment_tests/ba_sparsecholesky_suitesparse_user_threads_test.cc
type ceres (line 43) | namespace ceres {
type internal (line 44) | namespace internal {
function TEST_F (line 46) | TEST_F(BundleAdjustmentTest,
FILE: 3rdparty/ceres/internal/ceres/generated_bundle_adjustment_tests/ba_sparseschur_acceleratesparse_auto_test.cc
type ceres (line 42) | namespace ceres {
type internal (line 43) | namespace internal {
function TEST_F (line 45) | TEST_F(BundleAdjustmentTest,
FILE: 3rdparty/ceres/internal/ceres/generated_bundle_adjustment_tests/ba_sparseschur_acceleratesparse_auto_threads_test.cc
type ceres (line 43) | namespace ceres {
type internal (line 44) | namespace internal {
function TEST_F (line 46) | TEST_F(BundleAdjustmentTest,
FILE: 3rdparty/ceres/internal/ceres/generated_bundle_adjustment_tests/ba_sparseschur_acceleratesparse_user_test.cc
type ceres (line 42) | namespace ceres {
type internal (line 43) | namespace internal {
function TEST_F (line 45) | TEST_F(BundleAdjustmentTest,
FILE: 3rdparty/ceres/internal/ceres/generated_bundle_adjustment_tests/ba_sparseschur_acceleratesparse_user_threads_test.cc
type ceres (line 43) | namespace ceres {
type internal (line 44) | namespace internal {
function TEST_F (line 46) | TEST_F(BundleAdjustmentTest,
FILE: 3rdparty/ceres/internal/ceres/generated_bundle_adjustment_tests/ba_sparseschur_cxsparse_auto_test.cc
type ceres (line 42) | namespace ceres {
type internal (line 43) | namespace internal {
function TEST_F (line 45) | TEST_F(BundleAdjustmentTest,
FILE: 3rdparty/ceres/internal/ceres/generated_bundle_adjustment_tests/ba_sparseschur_cxsparse_auto_threads_test.cc
type ceres (line 43) | namespace ceres {
type internal (line 44) | namespace internal {
function TEST_F (line 46) | TEST_F(BundleAdjustmentTest,
FILE: 3rdparty/ceres/internal/ceres/generated_bundle_adjustment_tests/ba_sparseschur_cxsparse_user_test.cc
type ceres (line 42) | namespace ceres {
type internal (line 43) | namespace internal {
function TEST_F (line 45) | TEST_F(BundleAdjustmentTest,
FILE: 3rdparty/ceres/internal/ceres/generated_bundle_adjustment_tests/ba_sparseschur_cxsparse_user_threads_test.cc
type ceres (line 43) | namespace ceres {
type internal (line 44) | namespace internal {
function TEST_F (line 46) | TEST_F(BundleAdjustmentTest,
FILE: 3rdparty/ceres/internal/ceres/generated_bundle_adjustment_tests/ba_sparseschur_eigensparse_auto_test.cc
type ceres (line 42) | namespace ceres {
type internal (line 43) | namespace internal {
function TEST_F (line 45) | TEST_F(BundleAdjustmentTest,
FILE: 3rdparty/ceres/internal/ceres/generated_bundle_adjustment_tests/ba_sparseschur_eigensparse_auto_threads_test.cc
type ceres (line 43) | namespace ceres {
type internal (line 44) | namespace internal {
function TEST_F (line 46) | TEST_F(BundleAdjustmentTest,
FILE: 3rdparty/ceres/internal/ceres/generated_bundle_adjustment_tests/ba_sparseschur_eigensparse_user_test.cc
type ceres (line 42) | namespace ceres {
type internal (line 43) | namespace internal {
function TEST_F (line 45) | TEST_F(BundleAdjustmentTest,
FILE: 3rdparty/ceres/internal/ceres/generated_bundle_adjustment_tests/ba_sparseschur_eigensparse_user_threads_test.cc
type ceres (line 43) | namespace ceres {
type internal (line 44) | namespace internal {
function TEST_F (line 46) | TEST_F(BundleAdjustmentTest,
FILE: 3rdparty/ceres/internal/ceres/generated_bundle_adjustment_tests/ba_sparseschur_suitesparse_auto_test.cc
type ceres (line 42) | namespace ceres {
type internal (line 43) | namespace internal {
function TEST_F (line 45) | TEST_F(BundleAdjustmentTest,
FILE: 3rdparty/ceres/internal/ceres/generated_bundle_adjustment_tests/ba_sparseschur_suitesparse_auto_threads_test.cc
type ceres (line 43) | namespace ceres {
type internal (line 44) | namespace internal {
function TEST_F (line 46) | TEST_F(BundleAdjustmentTest,
FILE: 3rdparty/ceres/internal/ceres/generated_bundle_adjustment_tests/ba_sparseschur_suitesparse_user_test.cc
type ceres (line 42) | namespace ceres {
type internal (line 43) | namespace internal {
function TEST_F (line 45) | TEST_F(BundleAdjustmentTest,
FILE: 3rdparty/ceres/internal/ceres/generated_bundle_adjustment_tests/ba_sparseschur_suitesparse_user_threads_test.cc
type ceres (line 43) | namespace ceres {
type internal (line 44) | namespace internal {
function TEST_F (line 46) | TEST_F(BundleAdjustmentTest,
FILE: 3rdparty/ceres/internal/ceres/glog/logging.cc
type google (line 33) | namespace google {
FILE: 3rdparty/ceres/internal/ceres/glog/logging.h
function namespace (line 120) | namespace google {
function class (line 171) | class CERES_EXPORT MessageLogger {
type tm (line 232) | struct tm
function WaitForSinks (line 250) | void WaitForSinks() {
function StripBasename (line 261) | void StripBasename(const std::string &full_path, std::string *filename) {
function class (line 285) | class CERES_EXPORT LoggerVoidify {
FILE: 3rdparty/ceres/internal/ceres/gmock/gmock.h
function namespace (line 280) | namespace testing {
function namespace (line 809) | namespace testing {
type T (line 952) | typedef T (*FactoryFunction)();
function SetFactory (line 953) | static void SetFactory(FactoryFunction factory) {
function Clear (line 959) | static void Clear() {
function IsSet (line 965) | static bool IsSet() { return producer_ != nullptr; }
function Exists (line 969) | static bool Exists() {
function T (line 976) | static T Get() {
function class (line 988) | class FixedValueProducer : public ValueProducer {
function class (line 998) | class FactoryValueProducer : public ValueProducer {
function Clear (line 1023) | static void Clear() { address_ = nullptr; }
function IsSet (line 1026) | static bool IsSet() { return address_ != nullptr; }
function Exists (line 1030) | static bool Exists() {
function T (line 1037) | static T& Get() {
function Get (line 1052) | static void Get() {}
type typename (line 1068) | typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
function virtual (line 1071) | virtual ~ActionInterface() {}
type ActionAdapter (line 1094) | struct ActionAdapter {
type typename (line 1107) | typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
function explicit (line 1122) | explicit Action(ActionInterface<F>* impl)
function Result (line 1140) | Result Perform(ArgumentTuple args) const {
type typename (line 1191) | typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
function explicit (line 1193) | explicit MonomorphicImpl(const Impl& impl) : impl_(impl) {}
function Result (line 1195) | Result Perform(const ArgumentTuple& args) override {
function namespace (line 1229) | namespace internal {
function class (line 1358) | class ReturnNullAction {
function class (line 1370) | class ReturnVoidAction {
type typename (line 1392) | typedef typename Function<F>::Result Result;
type typename (line 1407) | typedef typename Function<F>::ArgumentTuple ArgumentTuple;
function explicit (line 1409) | explicit Impl(T& ref) : ref_(ref) {}
function Result (line 1411) | Result Perform(const ArgumentTuple&) override { return ref_; }
type typename (line 1438) | typedef typename Function<F>::Result Result;
type typename (line 1454) | typedef typename Function<F>::ArgumentTuple ArgumentTuple;
function explicit (line 1456) | explicit Impl(const T& value) : value_(value) {}
function Result (line 1458) | Result Perform(const ArgumentTuple&) override { return value_; }
function class (line 1472) | class DoDefaultAction {
type typename (line 1629) | typedef typename internal::Function<F>::Result Result;
type Op (line 1698) | struct Op {
type internal (line 1746) | typedef internal::IgnoredValue Unused;
function PolymorphicAction (line 1796) | inline PolymorphicAction<internal::ReturnNullAction> ReturnNull() {
function PolymorphicAction (line 1801) | inline PolymorphicAction<internal::ReturnVoidAction> Return() {
function internal (line 1829) | inline internal::DoDefaultAction DoDefault() {
function namespace (line 2001) | namespace testing {
function namespace (line 2285) | namespace testing {
type RawT (line 2499) | typedef GTEST_REMOVE_REFERENCE_AND_CONST_(T) RawT;
type RawU (line 2500) | typedef GTEST_REMOVE_REFERENCE_AND_CONST_(U) RawU;
function namespace (line 2522) | namespace internal {
function MatchAndExplain (line 3006) | bool MatchAndExplain(const absl::string_view& s,
function DescribeTo (line 3037) | void DescribeTo(::std::ostream* os) const {
function DescribeNegationTo (line 3042) | void DescribeNegationTo(::std::ostream* os) const {
function MatchAndExplain (line 3062) | bool MatchAndExplain(const absl::string_view& s,
function DescribeTo (line 3093) | void DescribeTo(::std::ostream* os) const {
function DescribeNegationTo (line 3098) | void DescribeNegationTo(::std::ostream* os) const {
function DescribeTo (line 3141) | void DescribeTo(::std::ostream* os) const override {
function DescribeNegationTo (line 3144) | void DescribeNegationTo(::std::ostream* os) const override {
function matcher_ (line 3183) | matcher_(matcher) {}
function MatchAndExplain (line 3185) | bool MatchAndExplain(const T& x,
function DescribeTo (line 3190) | void DescribeTo(::std::ostream* os) const override {
function DescribeNegationTo (line 3194) | void DescribeNegationTo(::std::ostream* os) const override {
function DescribeTo (line 3234) | void DescribeTo(::std::ostream* os) const override {
function DescribeNegationTo (line 3243) | void DescribeNegationTo(::std::ostream* os) const override {
function MatchAndExplain (line 3252) | bool MatchAndExplain(const T& x,
function DescribeTo (line 3340) | void DescribeTo(::std::ostream* os) const override {
function DescribeNegationTo (line 3349) | void DescribeNegationTo(::std::ostream* os) const override {
function MatchAndExplain (line 3358) | bool MatchAndExplain(const T& x,
function DescribeTo (line 3640) | void DescribeTo(::std::ostream* os) const override {
function DescribeNegationTo (line 3661) | void DescribeNegationTo(::std::ostream* os) const override {
function operator (line 3700) | operator Matcher<FloatType>() const {
function operator (line 3705) | operator Matcher<const FloatType&>() const {
function operator (line 3710) | operator Matcher<FloatType&>() const {
function explicit (line 3734) | explicit FloatingEq2Matcher(bool nan_eq_nan) { Init(-1, nan_eq_nan); }
function explicit (line 3736) | explicit FloatingEq2Matcher(FloatType max_abs_error) {
function explicit (line 3828) | explicit Impl(const InnerMatcher& matcher)
function DescribeTo (line 3831) | void DescribeTo(::std::ostream* os) const override {
function DescribeNegationTo (line 3836) | void DescribeNegationTo(::std::ostream* os) const override {
function MatchAndExplain (line 3841) | bool MatchAndExplain(Pointer pointer,
function DescribeTo (line 3873) | void DescribeTo(::std::ostream* os) const {
function DescribeNegationTo (line 3878) | void DescribeNegationTo(::std::ostream* os) const {
function std (line 3886) | static std::string GetToName() {
function DescribeTo (line 3949) | void DescribeTo(::std::ostream* os) const {
function DescribeNegationTo (line 3954) | void DescribeNegationTo(::std::ostream* os) const {
function MatchAndExplainImpl (line 3976) | bool MatchAndExplainImpl(std::true_type /* is_pointer */, const Class* p,
function DescribeTo (line 4018) | void DescribeTo(::std::ostream* os) const {
function DescribeNegationTo (line 4023) | void DescribeNegationTo(::std::ostream* os) const {
function MatchAndExplainImpl (line 4046) | bool MatchAndExplainImpl(std::true_type /* is_pointer */, const Class* p,
type Functor (line 4071) | typedef Functor StorageType;
function CheckIsValid (line 4073) | static void CheckIsValid(Functor /* functor */) {}
type ResType (line 4082) | typedef ResType ResultType;
type ResType (line 4083) | typedef ResType(*StorageType)(ArgType);
function CheckIsValid (line 4085) | static void CheckIsValid(ResType(*f)(ArgType)) {
function ResType (line 4090) | ResType Invoke(ResType(*f)(ArgType), T arg) {
function DescribeTo (line 4123) | void DescribeTo(::std::ostream* os) const override {
function DescribeNegationTo (line 4128) | void DescribeNegationTo(::std::ostream* os) const override {
function MatchAndExplain (line 4133) | bool MatchAndExplain(T obj, MatchResultListener* listener) const override {
function explicit (line 4179) | explicit Impl(const SizeMatcher& size_matcher)
function DescribeTo (line 4182) | void DescribeTo(::std::ostream* os) const override {
function DescribeNegationTo (line 4186) | void DescribeNegationTo(::std::ostream* os) const override {
function MatchAndExplain (line 4191) | bool MatchAndExplain(Container container,
type typename (line 4230) | typedef typename std::iterator_traits<
function explicit (line 4233) | explicit Impl(const DistanceMatcher& distance_matcher)
function DescribeTo (line 4236) | void DescribeTo(::std::ostream* os) const override {
function DescribeNegationTo (line 4240) | void DescribeNegationTo(::std::ostream* os) const override {
function MatchAndExplain (line 4245) | bool MatchAndExplain(Container container,
type typename (line 4283) | typedef typename View::type StlContainer;
type typename (line 4284) | typedef typename View::const_reference StlContainerReference;
function explicit (line 4288) | explicit ContainerEqMatcher(const Container& expected)
function DescribeTo (line 4296) | void DescribeTo(::std::ostream* os) const {
function DescribeNegationTo (line 4300) | void DescribeNegationTo(::std::ostream* os) const {
type internal (line 4310) | typedef internal::StlContainerView<GTEST_REMOVE_CONST_(LhsContainer)>
type typename (line 4312) | typedef typename LhsView::type LhsStlContainer;
type LessComparator (line 4365) | struct LessComparator {
type typename (line 4388) | typedef typename LhsView::type LhsStlContainer;
type typename (line 4389) | typedef typename LhsView::const_reference LhsStlContainerReference;
type typename (line 4392) | typedef typename RemoveConstFromKey<
function DescribeTo (line 4398) | void DescribeTo(::std::ostream* os) const override {
function DescribeNegationTo (line 4403) | void DescribeNegationTo(::std::ostream* os) const override {
function MatchAndExplain (line 4408) | bool MatchAndExplain(LhsContainer lhs,
type typename (line 4459) | typedef typename RhsView::type RhsStlContainer;
type typename (line 4460) | typedef typename RhsStlContainer::value_type RhsValue;
type typename (line 4487) | typedef typename LhsView::type LhsStlContainer;
type typename (line 4488) | typedef typename LhsView::const_reference LhsStlContainerReference;
type typename (line 4489) | typedef typename LhsStlContainer::value_type LhsValue;
type LhsValue (line 4494) | typedef ::std::tuple<const LhsValue&, const RhsValue&> InnerMatcherArg;
function DescribeTo (line 4501) | void DescribeTo(::std::ostream* os) const override {
function DescribeNegationTo (line 4508) | void DescribeNegationTo(::std::ostream* os) const override {
function MatchAndExplain (line 4517) | bool MatchAndExplain(LhsContainer lhs,
type StlContainerView (line 4576) | typedef StlContainerView<RawContainer> View;
type typename (line 4577) | typedef typename View::type StlContainer;
type typename (line 4578) | typedef typename View::const_reference StlContainerReference;
type typename (line 4579) | typedef typename StlContainer::value_type Element;
function MatchAndExplainImpl (line 4589) | bool MatchAndExplainImpl(bool all_elements_should_match,
function DescribeTo (line 4625) | void DescribeTo(::std::ostream* os) const override {
function DescribeNegationTo (line 4630) | void DescribeNegationTo(::std::ostream* os) const override {
function MatchAndExplain (line 4635) | bool MatchAndExplain(Container container,
function DescribeTo (line 4654) | void DescribeTo(::std::ostream* os) const override {
function DescribeNegationTo (line 4659) | void DescribeNegationTo(::std::ostream* os) const override {
function MatchAndExplain (line 4664) | bool MatchAndExplain(Container container,
type Rank1 (line 4709) | struct Rank1 {}
type Rank0 (line 4710) | struct Rank0
function namespace (line 4712) | namespace pair_getters {
type typename (line 4741) | typedef typename RawPairType::first_type KeyType;
function MatchAndExplain (line 4750) | bool MatchAndExplain(PairType key_value,
function DescribeTo (line 4763) | void DescribeTo(::std::ostream* os) const override {
function DescribeNegationTo (line 4769) | void DescribeNegationTo(::std::ostream* os) const override {
type typename (line 4804) | typedef typename RawPairType::first_type FirstType;
type typename (line 4805) | typedef typename RawPairType::second_type SecondType;
function DescribeTo (line 4816) | void DescribeTo(::std::ostream* os) const override {
function DescribeNegationTo (line 4824) | void DescribeNegationTo(::std::ostream* os) const override {
function MatchAndExplain (line 4833) | bool MatchAndExplain(PairType a_pair,
type internal (line 4910) | typedef internal::StlContainerView<RawContainer> View;
type typename (line 4911) | typedef typename View::type StlContainer;
type typename (line 4912) | typedef typename View::const_reference StlContainerReference;
type typename (line 4913) | typedef typename StlContainer::value_type Element;
function DescribeTo (line 4925) | void DescribeTo(::std::ostream* os) const override {
function DescribeNegationTo (line 4944) | void DescribeNegationTo(::std::ostream* os) const override {
function MatchAndExplain (line 4960) | bool MatchAndExplain(Container container,
function class (line 5056) | class GTEST_API_ MatchMatrix {
type std (line 5096) | typedef ::std::pair<size_t, size_t> ElementMatcherPair;
type std (line 5097) | typedef ::std::vector<ElementMatcherPair> ElementMatcherPairs;
type UnorderedMatcherRequire (line 5104) | struct UnorderedMatcherRequire {
function class (line 5115) | class GTEST_API_ UnorderedElementsAreMatcherImplBase {
type internal (line 5164) | typedef internal::StlContainerView<RawContainer> View;
type typename (line 5165) | typedef typename View::type StlContainer;
type typename (line 5166) | typedef typename View::const_reference StlContainerReference;
type typename (line 5167) | typedef typename StlContainer::const_iterator StlContainerConstIterator;
type typename (line 5168) | typedef typename StlContainer::value_type Element;
function UnorderedElementsAreMatcherImplBase (line 5173) | UnorderedElementsAreMatcherImplBase(matcher_flags) {
function DescribeTo (line 5181) | void DescribeTo(::std::ostream* os) const override {
function DescribeNegationTo (line 5186) | void DescribeNegationTo(::std::ostream* os) const override {
function MatchAndExplain (line 5190) | bool MatchAndExplain(Container container,
type RawContainer (line 5270) | typedef GTEST_REMOVE_REFERENCE_AND_CONST_(Container) RawContainer;
type typename (line 5271) | typedef typename internal::StlContainerView<RawContainer>::type View;
type typename (line 5272) | typedef typename View::value_type Element;
type Element (line 5273) | typedef ::std::vector<Matcher<const Element&> > MatcherVec;
type RawContainer (line 5302) | typedef GTEST_REMOVE_REFERENCE_AND_CONST_(Container) RawContainer;
type typename (line 5303) | typedef typename internal::StlContainerView<RawContainer>::type View;
type typename (line 5304) | typedef typename View::value_type Element;
type Element (line 5305) | typedef ::std::vector<Matcher<const Element&> > MatcherVec;
function DescribeTo (line 5407) | void DescribeTo(::std::ostream* os) const override {
function MatchAndExplain (line 5414) | bool MatchAndExplain(T x, MatchResultListener* listener) const override {
type typename (line 5465) | typedef typename OptionalView::value_type ValueType;
function explicit (line 5466) | explicit Impl(const ValueMatcher& value_matcher)
function DescribeTo (line 5469) | void DescribeTo(::std::ostream* os) const override {
function DescribeNegationTo (line 5474) | void DescribeNegationTo(::std::ostream* os) const override {
function MatchAndExplain (line 5479) | bool MatchAndExplain(Optional optional,
function namespace (line 5504) | namespace variant_matcher {
function namespace (line 5566) | namespace any_cast_matcher {
function inner_matcher_ (line 5637) | ArgsMatcherImpl(const InnerMatcher& inner_matcher)
function MatchAndExplain (line 5640) | bool MatchAndExplain(ArgsTuple args,
function DescribeTo (line 5658) | void DescribeTo(::std::ostream* os) const override {
function DescribeNegationTo (line 5664) | void DescribeNegationTo(::std::ostream* os) const override {
type typename (line 5721) | typedef typename ::std::iterator_traits<Iter>::value_type T;
type typename (line 5766) | typedef typename ::std::iterator_traits<Iter>::value_type T;
function PolymorphicMatcher (line 5832) | inline PolymorphicMatcher<internal::NotNullMatcher > NotNull() {
function internal (line 5845) | inline internal::FloatingEqMatcher<double> DoubleEq(double rhs) {
function internal (line 5851) | inline internal::FloatingEqMatcher<double> NanSensitiveDoubleEq(double r...
function internal (line 5858) | inline internal::FloatingEqMatcher<double> DoubleNear(
function internal (line 5866) | inline internal::FloatingEqMatcher<double> NanSensitiveDoubleNear(
function internal (line 5873) | inline internal::FloatingEqMatcher<float> FloatEq(float rhs) {
function internal (line 5879) | inline internal::FloatingEqMatcher<float> NanSensitiveFloatEq(float rhs) {
function internal (line 5886) | inline internal::FloatingEqMatcher<float> FloatNear(
function internal (line 5894) | inline internal::FloatingEqMatcher<float> NanSensitiveFloatNear(
function PolymorphicMatcher (line 6026) | inline PolymorphicMatcher<internal::StrEqualityMatcher<std::string> > St...
function PolymorphicMatcher (line 6033) | inline PolymorphicMatcher<internal::StrEqualityMatcher<std::string> > St...
function PolymorphicMatcher (line 6040) | inline PolymorphicMatcher<internal::StrEqualityMatcher<std::string> > St...
function PolymorphicMatcher (line 6047) | inline PolymorphicMatcher<internal::StrEqualityMatcher<std::string> > St...
function PolymorphicMatcher (line 6055) | inline PolymorphicMatcher<internal::HasSubstrMatcher<std::string> > HasS...
function PolymorphicMatcher (line 6062) | inline PolymorphicMatcher<internal::StartsWithMatcher<std::string> > Sta...
function PolymorphicMatcher (line 6069) | inline PolymorphicMatcher<internal::EndsWithMatcher<std::string> > EndsW...
function PolymorphicMatcher (line 6078) | inline PolymorphicMatcher<internal::StrEqualityMatcher<std::wstring> > S...
function PolymorphicMatcher (line 6085) | inline PolymorphicMatcher<internal::StrEqualityMatcher<std::wstring> > S...
function PolymorphicMatcher (line 6092) | inline PolymorphicMatcher<internal::StrEqualityMatcher<std::wstring> >
function PolymorphicMatcher (line 6099) | inline PolymorphicMatcher<internal::StrEqualityMatcher<std::wstring> >
function PolymorphicMatcher (line 6107) | inline PolymorphicMatcher<internal::HasSubstrMatcher<std::wstring> > Has...
function PolymorphicMatcher (line 6114) | inline PolymorphicMatcher<internal::StartsWithMatcher<std::wstring> >
function PolymorphicMatcher (line 6121) | inline PolymorphicMatcher<internal::EndsWithMatcher<std::wstring> > Ends...
function internal (line 6131) | inline internal::Eq2Matcher Eq() { return internal::Eq2Matcher(); }
function internal (line 6135) | inline internal::Ge2Matcher Ge() { return internal::Ge2Matcher(); }
function internal (line 6139) | inline internal::Gt2Matcher Gt() { return internal::Gt2Matcher(); }
function internal (line 6143) | inline internal::Le2Matcher Le() { return internal::Le2Matcher(); }
function internal (line 6147) | inline internal::Lt2Matcher Lt() { return internal::Lt2Matcher(); }
function internal (line 6151) | inline internal::Ne2Matcher Ne() { return internal::Ne2Matcher(); }
function internal (line 6155) | inline internal::FloatingEq2Matcher<float> FloatEq() {
function internal (line 6161) | inline internal::FloatingEq2Matcher<double> DoubleEq() {
function internal (line 6167) | inline internal::FloatingEq2Matcher<float> NanSensitiveFloatEq() {
function internal (line 6173) | inline internal::FloatingEq2Matcher<double> NanSensitiveDoubleEq() {
function internal (line 6179) | inline internal::FloatingEq2Matcher<float> FloatNear(float max_abs_error) {
function internal (line 6185) | inline internal::FloatingEq2Matcher<double> DoubleNear(double max_abs_er...
function internal (line 6192) | inline internal::FloatingEq2Matcher<float> NanSensitiveFloatNear(
function internal (line 6200) | inline internal::FloatingEq2Matcher<double> NanSensitiveDoubleNear(
type RawContainer (line 6254) | typedef GTEST_REMOVE_CONST_(Container) RawContainer;
type RawContainer (line 6292) | typedef GTEST_REMOVE_CONST_(Container) RawContainer;
type RawRhsContainer (line 6327) | typedef GTEST_REMOVE_CONST_(RhsContainer) RawRhsContainer;
type typename (line 6331) | typedef typename internal::StlContainerView<RawRhsContainer> RhsView;
type typename (line 6332) | typedef typename RhsView::type RhsStlContainer;
type typename (line 6333) | typedef typename RhsStlContainer::value_type Second;
type typename (line 6414) | typedef typename ::std::iterator_traits<Iter>::value_type T;
type typename (line 6471) | typedef typename ::std::iterator_traits<Iter>::value_type T;
function Value (line 6562) | bool Value(const T& value, M matcher) {
function ExplainMatchResult (line 6569) | bool ExplainMatchResult(
function InnerMatcher (line 6729) | InnerMatcher AllArgs(const InnerMatcher& matcher) { return matcher; }
function namespace (line 6826) | namespace testing {
type CallReaction (line 7107) | enum CallReaction {
function class (line 7116) | class GTEST_API_ Mock {
function class (line 7237) | class GTEST_API_ Expectation {
function class (line 7312) | class ExpectationSet {
function class (line 7368) | class GTEST_API_ Sequence {
function class (line 7406) | class GTEST_API_ InSequence {
function namespace (line 7416) | namespace internal {
type typename (line 7990) | typedef typename internal::Function<F>::ArgumentMatcherTuple
function T (line 8058) | T Unwrap() { return std::move(value_); }
function explicit (line 8080) | explicit ReferenceOrValueWrapper(reference ref)
function class (line 8104) | class UntypedActionResultHolderBase {
function PrintAsActionResult (line 8122) | void PrintAsActionResult(::std::ostream* os) const override {
function ActionResultHolder (line 8131) | ActionResultHolder* PerformDefaultAction(
function ActionResultHolder (line 8142) | ActionResultHolder* PerformAction(
function explicit (line 8151) | explicit ActionResultHolder(Wrapper result)
function PrintAsActionResult (line 8166) | void PrintAsActionResult(::std::ostream* /* os */) const override {}
function ActionResultHolder (line 8171) | ActionResultHolder* PerformDefaultAction(
function ActionResultHolder (line 8182) | ActionResultHolder* PerformAction(
function public (line 8197) | public UntypedFunctionMockerBase {
function R (line 8597) | R Call(Args... args) {
function Expectation (line 8642) | inline Expectation::Expectation(internal::ExpectationBase& exp) // NOLINT
function namespace (line 8724) | namespace testing {
function namespace (line 10004) | namespace testing {
function namespace (line 11519) | namespace testing {
function namespace (line 12967) | namespace testing {
type typename (line 13026) | typedef typename ::std::tuple_element<k, args_type>::type argk_type;
function namespace (line 13128) | namespace testing {
function namespace (line 13242) | namespace testing {
FILE: 3rdparty/ceres/internal/ceres/gmock/mock-log.h
function namespace (line 47) | namespace testing {
FILE: 3rdparty/ceres/internal/ceres/gmock_gtest_all.cc
type testing (line 115) | namespace testing {
function ScopedFakeTestPartResultReporter (line 126) | class GTEST_API_ ScopedFakeTestPartResultReporter
type internal (line 165) | namespace internal {
function SingleFailureChecker (line 172) | class GTEST_API_ SingleFailureChecker {
function GetRandomSeedFromFlag (line 522) | inline int GetRandomSeedFromFlag(Int32 random_seed_flag) {
function GetNextRandomSeed (line 538) | inline int GetNextRandomSeed(int seed) {
class GTestFlagSaver (line 548) | class GTestFlagSaver {
method GTestFlagSaver (line 551) | GTestFlagSaver() {
function CountIf (line 672) | inline int CountIf(const Container& c, Predicate predicate) {
function ForEach (line 685) | void ForEach(const Container& c, Functor functor) {
function E (line 692) | inline E GetElementOr(const std::vector<E>& v, int i, E default_valu...
function ShuffleRange (line 701) | void ShuffleRange(internal::Random* random, int begin, int end,
function Shuffle (line 722) | inline void Shuffle(internal::Random* random, std::vector<E>* v) {
function Delete (line 729) | static void Delete(T* x) {
class TestPropertyKeyIs (line 736) | class TestPropertyKeyIs {
method TestPropertyKeyIs (line 741) | explicit TestPropertyKeyIs(const std::string& key) : key_(key) {}
function UnitTestOptions (line 762) | class GTEST_API_ UnitTestOptions {
class OsStackTraceGetterInterface (line 807) | class OsStackTraceGetterInterface {
method OsStackTraceGetterInterface (line 809) | OsStackTraceGetterInterface() {}
class OsStackTraceGetter (line 834) | class OsStackTraceGetter : public OsStackTraceGetterInterface {
method OsStackTraceGetter (line 836) | OsStackTraceGetter() {}
type TraceInfo (line 856) | struct TraceInfo {
class DefaultGlobalTestPartResultReporter (line 864) | class DefaultGlobalTestPartResultReporter
class DefaultPerThreadTestPartResultReporter (line 880) | class DefaultPerThreadTestPartResultReporter
function UnitTestImpl (line 898) | class GTEST_API_ UnitTestImpl {
function UnitTestImpl (line 1337) | inline UnitTestImpl* GetUnitTestImpl() {
function ParseNaturalNumber (line 1377) | bool ParseNaturalNumber(const ::std::string& str, Integer* number) {
class TestResultAccessor (line 1422) | class TestResultAccessor {
method RecordProperty (line 1424) | static void RecordProperty(TestResult* test_result,
method ClearTestPartResults (line 1430) | static void ClearTestPartResults(TestResult* test_result) {
class StreamingListener (line 1443) | class StreamingListener : public EmptyTestEventListener {
class AbstractSocketWriter (line 1446) | class AbstractSocketWriter {
method CloseConnection (line 1454) | virtual void CloseConnection() {}
method SendLn (line 1457) | void SendLn(const std::string& message) { Send(message + "\n"); }
class SocketWriter (line 1461) | class SocketWriter : public AbstractSocketWriter {
method SocketWriter (line 1463) | SocketWriter(const std::string& host, const std::string& port)
method Send (line 1474) | void Send(const std::string& message) override {
method CloseConnection (line 1491) | void CloseConnection() override {
method StreamingListener (line 1509) | StreamingListener(const std::string& host, const std::string& port)
method StreamingListener (line 1514) | explicit StreamingListener(AbstractSocketWriter* socket_writer)
method OnTestProgramStart (line 1517) | void OnTestProgramStart(const UnitTest& /* unit_test */) override {
method OnTestProgramEnd (line 1521) | void OnTestProgramEnd(const UnitTest& unit_test) override {
method OnTestIterationStart (line 1530) | void OnTestIterationStart(const UnitTest& /* unit_test */,
method OnTestIterationEnd (line 1536) | void OnTestIterationEnd(const UnitTest& unit_test,
method OnTestCaseStart (line 1545) | void OnTestCaseStart(const TestCase& test_case) override {
method OnTestCaseEnd (line 1551) | void OnTestCaseEnd(const TestCase& test_case) override {
method OnTestStart (line 1557) | void OnTestStart(const TestInfo& test_info) override {
method OnTestEnd (line 1561) | void OnTestEnd(const TestInfo& test_info) override {
method OnTestPartResult (line 1568) | void OnTestPartResult(const TestPartResult& test_part_result) over...
method SendLn (line 1578) | void SendLn(const std::string& message) { socket_writer_->SendLn(m...
method Start (line 1582) | void Start() { SendLn("gtest_streaming_protocol_version=1.0"); }
method FormatBool (line 1584) | std::string FormatBool(bool value) { return value ? "1" : "0"; }
function FILE (line 1661) | static FILE* OpenFileForWriting(const std::string& output_file) {
function UInt32 (line 1816) | UInt32 Random::Generate(UInt32 range) {
function GTestIsInitialized (line 1836) | static bool GTestIsInitialized() { return GetArgvs().size() > 0; }
function SumOverTestSuiteList (line 1841) | static int SumOverTestSuiteList(const std::vector<TestSuite*>& case_...
function TestSuitePassed (line 1851) | static bool TestSuitePassed(const TestSuite* test_suite) {
function TestSuiteFailed (line 1856) | static bool TestSuiteFailed(const TestSuite* test_suite) {
function ShouldRunTestSuite (line 1862) | static bool ShouldRunTestSuite(const TestSuite* test_suite) {
function GetArgvs (line 1892) | ::std::vector<std::string> GetArgvs() {
function FilePath (line 1905) | FilePath GetCurrentExecutableName() {
function TypeId (line 2123) | TypeId GetTestTypeId() {
function AssertionResult (line 2134) | static AssertionResult HasOneFailure(const char* /* results_expr */,
function TestPartResultReporterInterface (line 2204) | TestPartResultReporterInterface*
function TestPartResultReporterInterface (line 2218) | TestPartResultReporterInterface*
function TimeInMillis (line 2311) | TimeInMillis GetTimeInMillis() {
function LPCWSTR (line 2359) | LPCWSTR String::AnsiToUtf16(const char* ansi) {
function StreamWideCharsToMessage (line 2405) | static void StreamWideCharsToMessage(const wchar_t* wstr, size_t len...
function SplitString (line 2421) | void SplitString(const ::std::string& str, char delimiter,
type edit_distance (line 2524) | namespace edit_distance {
function CalculateOptimalEdits (line 2525) | std::vector<EditType> CalculateOptimalEdits(const std::vector<size...
class InternalStrings (line 2585) | class InternalStrings {
method GetId (line 2587) | size_t GetId(const std::string& str) {
function CalculateOptimalEdits (line 2601) | std::vector<EditType> CalculateOptimalEdits(
class Hunk (line 2623) | class Hunk {
method Hunk (line 2625) | Hunk(size_t left_start, size_t right_start)
method PushLine (line 2632) | void PushLine(char edit, const char* line) {
method PrintTo (line 2650) | void PrintTo(std::ostream* os) {
method has_edits (line 2660) | bool has_edits() const { return adds_ || removes_; }
method FlushEdits (line 2663) | void FlushEdits() {
method PrintHeader (line 2672) | void PrintHeader(std::ostream* ss) const {
function CreateUnifiedDiff (line 2700) | std::string CreateUnifiedDiff(const std::vector<std::string>& left,
function SplitEscapedString (line 2769) | std::vector<std::string> SplitEscapedString(const std::string& str) {
function AssertionResult (line 2809) | AssertionResult EqFailure(const char* lhs_expression,
function GetBoolAssertionFailureMessage (line 2844) | std::string GetBoolAssertionFailureMessage(
function AssertionResult (line 2860) | AssertionResult DoubleNearPredFormat(const char* expr1,
function AssertionResult (line 2880) | AssertionResult FloatingPointLE(const char* expr1,
function AssertionResult (line 2933) | AssertionResult CmpHelperEQ(const char* lhs_expression,
function InDeathTestChild (line 7696) | bool InDeathTestChild() {
function ExitSummary (line 7756) | static std::string ExitSummary(int exit_code) {
function ExitedUnsuccessfully (line 7782) | bool ExitedUnsuccessfully(int exit_status) {
function DeathTestThreadWarning (line 7791) | static std::string DeathTestThreadWarning(size_t thread_count) {
type DeathTestOutcome (line 7829) | enum DeathTestOutcome { IN_PROGRESS, DIED, LIVED, RETURNED, THREW }
function DeathTestAbort (line 7836) | static void DeathTestAbort(const std::string& message) {
function GetLastErrnoDescription (line 7889) | std::string GetLastErrnoDescription() {
function FailFromInternalError (line 7897) | static void FailFromInternalError(int fd) {
class DeathTestImpl (line 7948) | class DeathTestImpl : public DeathTest {
method DeathTestImpl (line 7950) | DeathTestImpl(const char* a_statement, Matcher<const std::string&>...
method spawned (line 7966) | bool spawned() const { return spawned_; }
method set_spawned (line 7967) | void set_spawned(bool is_spawned) { spawned_ = is_spawned; }
method status (line 7968) | int status() const { return status_; }
method set_status (line 7969) | void set_status(int a_status) { status_ = a_status; }
method DeathTestOutcome (line 7970) | DeathTestOutcome outcome() const { return outcome_; }
method set_outcome (line 7971) | void set_outcome(DeathTestOutcome an_outcome) { outcome_ = an_outc...
method read_fd (line 7972) | int read_fd() const { return read_fd_; }
method set_read_fd (line 7973) | void set_read_fd(int fd) { read_fd_ = fd; }
method write_fd (line 7974) | int write_fd() const { return write_fd_; }
method set_write_fd (line 7975) | void set_write_fd(int fd) { write_fd_ = fd; }
function FormatDeathTestOutput (line 8084) | static ::std::string FormatDeathTestOutput(const ::std::string& outp...
class WindowsDeathTest (line 8200) | class WindowsDeathTest : public DeathTestImpl {
method WindowsDeathTest (line 8202) | WindowsDeathTest(const char* a_statement, Matcher<const std::strin...
class FuchsiaDeathTest (line 8364) | class FuchsiaDeathTest : public DeathTestImpl {
method FuchsiaDeathTest (line 8366) | FuchsiaDeathTest(const char* a_statement, Matcher<const std::strin...
class Arguments (line 8391) | class Arguments {
method Arguments (line 8393) | Arguments() { args_.push_back(nullptr); }
method AddArgument (line 8401) | void AddArgument(const char* argument) {
method AddArguments (line 8406) | void AddArguments(const ::std::vector<Str>& arguments) {
method size (line 8417) | int size() {
method Arguments (line 8731) | Arguments() { args_.push_back(nullptr); }
method AddArgument (line 8739) | void AddArgument(const char* argument) {
method AddArguments (line 8744) | void AddArguments(const ::std::vector<Str>& arguments) {
class ForkingDeathTest (line 8611) | class ForkingDeathTest : public DeathTestImpl {
method set_child_pid (line 8619) | void set_child_pid(pid_t child_pid) { child_pid_ = child_pid; }
class NoExecDeathTest (line 8648) | class NoExecDeathTest : public ForkingDeathTest {
method NoExecDeathTest (line 8650) | NoExecDeathTest(const char* a_statement, Matcher<const std::string...
class ExecDeathTest (line 8703) | class ExecDeathTest : public ForkingDeathTest {
method ExecDeathTest (line 8705) | ExecDeathTest(const char* a_statement, Matcher<const std::string&>...
method GetArgvsForDeathTestChildProcess (line 8713) | static ::std::vector<std::string> GetArgvsForDeathTestChildProcess...
class Arguments (line 8729) | class Arguments {
method Arguments (line 8393) | Arguments() { args_.push_back(nullptr); }
method AddArgument (line 8401) | void AddArgument(const char* argument) {
method AddArguments (line 8406) | void AddArguments(const ::std::vector<Str>& arguments) {
method size (line 8417) | int size() {
method Arguments (line 8731) | Arguments() { args_.push_back(nullptr); }
method AddArgument (line 8739) | void AddArgument(const char* argument) {
method AddArguments (line 8744) | void AddArguments(const ::std::vector<Str>& arguments) {
type ExecDeathTestArgs (line 8761) | struct ExecDeathTestArgs {
function ExecDeathTestChildMain (line 8784) | static int ExecDeathTestChildMain(void* child_arg) {
function StackLowerThanAddress (line 8825) | static void StackLowerThanAddress(const void* ptr, bool* result) {
function GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_ (line 8831) | GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_
function pid_t (line 8847) | static pid_t ExecDeathTestSpawnChild(char* const* argv, int close_fd) {
function IsPathSeparator (line 9267) | static bool IsPathSeparator(char c) {
function FilePath (line 9276) | FilePath FilePath::GetCurrentDir() {
function FilePath (line 9302) | FilePath FilePath::RemoveExtension(const char* extension) const {
function FilePath (line 9333) | FilePath FilePath::RemoveDirectoryName() const {
function FilePath (line 9344) | FilePath FilePath::RemoveFileName() const {
function FilePath (line 9361) | FilePath FilePath::MakeFileName(const FilePath& directory,
function FilePath (line 9377) | FilePath FilePath::ConcatPaths(const FilePath& directory,
function FilePath (line 9461) | FilePath FilePath::GenerateUniqueFileName(const FilePath& directory,
function FilePath (line 9521) | FilePath FilePath::RemoveTrailingPathSeparator() const {
function T (line 9808) | T ReadProcFileField(const std::string& filename, int field) {
function GetThreadCount (line 9821) | size_t GetThreadCount() {
function GetThreadCount (line 9829) | size_t GetThreadCount() {
function GetThreadCount (line 9865) | size_t GetThreadCount() {
function GetThreadCount (line 9888) | size_t GetThreadCount() {
function GetThreadCount (line 9925) | size_t GetThreadCount() {
function GetThreadCount (line 9943) | size_t GetThreadCount() {
function GetThreadCount (line 9956) | size_t GetThreadCount() {
function GetThreadCount (line 9975) | size_t GetThreadCount() {
function SleepMilliseconds (line 9985) | void SleepMilliseconds(int n) {
class MemoryIsNotDeallocated (line 10095) | class MemoryIsNotDeallocated
method MemoryIsNotDeallocated (line 10098) | MemoryIsNotDeallocated() : old_crtdbg_flag_(0) {
class ThreadWithParamSupport (line 10169) | class ThreadWithParamSupport : public ThreadWithParamBase {
method HANDLE (line 10171) | static HANDLE CreateThread(Runnable* runnable,
type ThreadMainParam (line 10191) | struct ThreadMainParam {
method ThreadMainParam (line 10192) | ThreadMainParam(Runnable* runnable, Notification* thread_can_start)
method DWORD (line 10201) | static DWORD WINAPI ThreadMain(void* ptr) {
class ThreadLocalRegistryImpl (line 10237) | class ThreadLocalRegistryImpl {
method ThreadLocalValueHolderBase (line 10241) | static ThreadLocalValueHolderBase* GetValueOnCurrentThread(
method OnThreadLocalDestroyed (line 10269) | static void OnThreadLocalDestroyed(
method OnThreadExit (line 10297) | static void OnThreadExit(DWORD thread_id) {
method StartWatcherThreadFor (line 10336) | static void StartWatcherThreadFor(DWORD thread_id) {
method DWORD (line 10363) | static DWORD WINAPI WatcherThreadFunc(LPVOID param) {
method ThreadIdToThreadLocals (line 10375) | static ThreadIdToThreadLocals* GetThreadLocalsMapLocked() {
function ThreadLocalValueHolderBase (line 10391) | ThreadLocalValueHolderBase* ThreadLocalRegistry::GetValueOnCurrentTh...
function IsInSet (line 10471) | bool IsInSet(char ch, const char* str) {
function IsAsciiDigit (line 10478) | bool IsAsciiDigit(char ch) { return '0' <= ch && ch <= '9'; }
function IsAsciiPunct (line 10479) | bool IsAsciiPunct(char ch) {
function IsRepeat (line 10482) | bool IsRepeat(char ch) { return IsInSet(ch, "?*+"); }
function IsAsciiWhiteSpace (line 10483) | bool IsAsciiWhiteSpace(char ch) { return IsInSet(ch, " \f\n\r\t\v"); }
function IsAsciiWordChar (line 10484) | bool IsAsciiWordChar(char ch) {
function IsValidEscape (line 10490) | bool IsValidEscape(char c) {
function AtomMatchesChar (line 10496) | bool AtomMatchesChar(bool escaped, char pattern_char, char ch) {
function FormatRegexSyntaxError (line 10518) | static std::string FormatRegexSyntaxError(const char* regex, int ind...
function ValidateRegex (line 10525) | bool ValidateRegex(const char* regex) {
function MatchRepetitionAndRegexAtHead (line 10585) | bool MatchRepetitionAndRegexAtHead(
function MatchRegexAtHead (line 10612) | bool MatchRegexAtHead(const char* regex, const char* str) {
function MatchRegexAnywhere (line 10648) | bool MatchRegexAnywhere(const char* regex, const char* str) {
function FormatFileLocation (line 10720) | GTEST_API_ ::std::string FormatFileLocation(const char* file, int li...
function FormatCompilerIndependentFileLocation (line 10738) | GTEST_API_ ::std::string FormatCompilerIndependentFileLocation(
class CapturedStream (line 10774) | class CapturedStream {
method CapturedStream (line 10777) | explicit CapturedStream(int fd) : fd_(fd), uncaptured_fd_(dup(fd)) {
method GetCapturedString (line 10829) | std::string GetCapturedString() {
function CaptureStream (line 10859) | static void CaptureStream(int fd, const char* stream_name,
function GetCapturedStream (line 10869) | static std::string GetCapturedStream(CapturedStream** captured_strea...
function CaptureStdout (line 10879) | void CaptureStdout() {
function CaptureStderr (line 10884) | void CaptureStderr() {
function GetCapturedStdout (line 10889) | std::string GetCapturedStdout() {
function GetCapturedStderr (line 10894) | std::string GetCapturedStderr() {
function GetFileSize (line 10904) | size_t GetFileSize(FILE* file) {
function ReadEntireFile (line 10909) | std::string ReadEntireFile(FILE* file) {
function GetInjectableArgvs (line 10935) | std::vector<std::string> GetInjectableArgvs() {
function SetInjectableArgvs (line 10942) | void SetInjectableArgvs(const std::vector<std::string>* new_argvs) {
function SetInjectableArgvs (line 10947) | void SetInjectableArgvs(const std::vector<std::string>& new_argvs) {
function SetInjectableArgvs (line 10953) | void SetInjectableArgvs(const std::vector< ::string>& new_argvs) {
function ClearInjectableArgvs (line 10959) | void ClearInjectableArgvs() {
type posix (line 10966) | namespace posix {
function Abort (line 10967) | void Abort() {
function FlagToEnvVar (line 10977) | static std::string FlagToEnvVar(const char* flag) {
function ParseInt32 (line 10992) | bool ParseInt32(const Message& src_text, const char* str, Int32* val...
function BoolFromGTestEnv (line 11034) | bool BoolFromGTestEnv(const char* flag, bool default_value) {
function Int32 (line 11048) | Int32 Int32FromGTestEnv(const char* flag, Int32 default_value) {
function OutputFlagAlsoCheckEnvVar (line 11080) | std::string OutputFlagAlsoCheckEnvVar(){
type CharFormat (line 11226) | enum CharFormat {
function IsPrintableAscii (line 11235) | inline bool IsPrintableAscii(wchar_t c) {
function CharFormat (line 11244) | static CharFormat PrintAsCharLiteralTo(Char c, ostream* os) {
function CharFormat (line 11293) | static CharFormat PrintAsStringLiteralTo(wchar_t c, ostream* os) {
function CharFormat (line 11308) | static CharFormat PrintAsStringLiteralTo(char c, ostream* os) {
function PrintCharAndCodeTo (line 11318) | void PrintCharAndCodeTo(Char c, ostream* os) {
function PrintTo (line 11342) | void PrintTo(unsigned char c, ::std::ostream* os) {
function PrintTo (line 11345) | void PrintTo(signed char c, ::std::ostream* os) {
function PrintTo (line 11351) | void PrintTo(wchar_t wc, ostream* os) {
function CharFormat (line 11363) | static CharFormat PrintCharsAsStringTo(
function UniversalPrintCharArray (line 11393) | static void UniversalPrintCharArray(
function UniversalPrintArray (line 11416) | void UniversalPrintArray(const char* begin, size_t len, ostream* os) {
function UniversalPrintArray (line 11422) | void UniversalPrintArray(const wchar_t* begin, size_t len, ostream* ...
function PrintTo (line 11427) | void PrintTo(const char* s, ostream* os) {
function PrintTo (line 11444) | void PrintTo(const wchar_t* s, ostream* os) {
function ContainsUnprintableControlCodes (line 11456) | bool ContainsUnprintableControlCodes(const char* str, size_t length) {
function IsUTF8TrailByte (line 11475) | bool IsUTF8TrailByte(unsigned char t) { return 0x80 <= t && t<= 0xbf; }
function IsValidUTF8 (line 11477) | bool IsValidUTF8(const char* str, size_t length) {
function ConditionalPrintAsText (line 11512) | void ConditionalPrintAsText(const char* str, size_t length, ostream*...
function PrintStringTo (line 11523) | void PrintStringTo(const ::string& s, ostream* os) {
function PrintStringTo (line 11532) | void PrintStringTo(const ::std::string& s, ostream* os) {
function PrintWideStringTo (line 11542) | void PrintWideStringTo(const ::wstring& s, ostream* os) {
function PrintWideStringTo (line 11548) | void PrintWideStringTo(const ::std::wstring& s, ostream* os) {
function SplitIntoTestNames (line 11703) | static std::vector<std::string> SplitIntoTestNames(const char* src) {
function GTEST_API_ (line 12013) | GTEST_API_ std::string JoinAsTuple(const Strings& fields) {
function GTEST_API_ (line 12034) | GTEST_API_ std::string ConvertIdentifierNameToWords(const char* id_n...
class GoogleTestFailureReporter (line 12056) | class GoogleTestFailureReporter : public FailureReporterInterface {
method ReportFailure (line 12058) | void ReportFailure(FailureType type, const char* file, int line,
function GTEST_API_ (line 12074) | GTEST_API_ FailureReporterInterface* GetFailureReporter() {
function GTEST_API_ (line 12090) | GTEST_API_ bool LogIsVisible(LogSeverity severity) {
function GTEST_API_ (line 12111) | GTEST_API_ void Log(LogSeverity severity, const std::string& message,
function GTEST_API_ (line 12149) | GTEST_API_ WithoutMatchers GetWithoutMatchers() { return WithoutMatc...
function GTEST_API_ (line 12151) | GTEST_API_ void IllegalDoDefault(const char* file, int line) {
function GTEST_API_ (line 12212) | GTEST_API_ std::string FormatMatcherDescription(bool negation,
class MaxBipartiteMatchState (line 12282) | class MaxBipartiteMatchState {
method MaxBipartiteMatchState (line 12284) | explicit MaxBipartiteMatchState(const MatchMatrix& graph)
method ElementMatcherPairs (line 12290) | ElementMatcherPairs Compute() {
method TryAugment (line 12342) | bool TryAugment(size_t ilhs, ::std::vector<char>* seen) {
function GTEST_API_ (line 12388) | GTEST_API_ ElementMatcherPairs FindMaxBipartiteMatching(const MatchM...
function LogElementMatcherPairVec (line 12392) | static void LogElementMatcherPairVec(const ElementMatcherPairs& pairs,
function GTEST_API_ (line 12688) | GTEST_API_ void LogWithLocation(testing::internal::LogSeverity sever...
function GTEST_EXCLUSIVE_LOCK_REQUIRED_ (line 12724) | GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
function GTEST_EXCLUSIVE_LOCK_REQUIRED_ (line 12751) | GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
function GTEST_EXCLUSIVE_LOCK_REQUIRED_ (line 12771) | GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
function GTEST_EXCLUSIVE_LOCK_REQUIRED_ (line 12802) | GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
function GTEST_LOCK_EXCLUDED_ (line 12825) | GTEST_LOCK_EXCLUDED_(mutex_) {
function ReportUninterestingCall (line 12898) | void ReportUninterestingCall(CallReaction reaction, const std::strin...
function GTEST_LOCK_EXCLUDED_ (line 12933) | GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
function GTEST_LOCK_EXCLUDED_ (line 12946) | GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
function GTEST_LOCK_EXCLUDED_ (line 12957) | GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
function GTEST_LOCK_EXCLUDED_ (line 12974) | GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
function GTEST_LOCK_EXCLUDED_ (line 12992) | GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
function Expectation (line 13103) | Expectation UntypedFunctionMockerBase::GetHandleOf(ExpectationBase* ...
function GTEST_EXCLUSIVE_LOCK_REQUIRED_ (line 13124) | GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
function CallReaction (line 13168) | CallReaction intToCallReaction(int mock_behavior) {
function ParseGoogleMockBoolFlag (line 13598) | static bool ParseGoogleMockBoolFlag(const char* str, const char* flag,
function ParseGoogleMockStringFlag (line 13617) | static bool ParseGoogleMockStringFlag(const char* str, const char* f...
function ParseGoogleMockIntFlag (line 13630) | static bool ParseGoogleMockIntFlag(const char* str, const char* flag,
function InitGoogleMockImpl (line 13648) | void InitGoogleMockImpl(int* argc, CharType** argv) {
type internal (line 467) | namespace internal {
function SingleFailureChecker (line 172) | class GTEST_API_ SingleFailureChecker {
function GetRandomSeedFromFlag (line 522) | inline int GetRandomSeedFromFlag(Int32 random_seed_flag) {
function GetNextRandomSeed (line 538) | inline int GetNextRandomSeed(int seed) {
class GTestFlagSaver (line 548) | class GTestFlagSaver {
method GTestFlagSaver (line 551) | GTestFlagSaver() {
function CountIf (line 672) | inline int CountIf(const Container& c, Predicate predicate) {
function ForEach (line 685) | void ForEach(const Container& c, Functor functor) {
function E (line 692) | inline E GetElementOr(const std::vector<E>& v, int i, E default_valu...
function ShuffleRange (line 701) | void ShuffleRange(internal::Random* random, int begin, int end,
function Shuffle (line 722) | inline void Shuffle(internal::Random* random, std::vector<E>* v) {
function Delete (line 729) | static void Delete(T* x) {
class TestPropertyKeyIs (line 736) | class TestPropertyKeyIs {
method TestPropertyKeyIs (line 741) | explicit TestPropertyKeyIs(const std::string& key) : key_(key) {}
function UnitTestOptions (line 762) | class GTEST_API_ UnitTestOptions {
class OsStackTraceGetterInterface (line 807) | class OsStackTraceGetterInterface {
method OsStackTraceGetterInterface (line 809) | OsStackTraceGetterInterface() {}
class OsStackTraceGetter (line 834) | class OsStackTraceGetter : public OsStackTraceGetterInterface {
method OsStackTraceGetter (line 836) | OsStackTraceGetter() {}
type TraceInfo (line 856) | struct TraceInfo {
class DefaultGlobalTestPartResultReporter (line 864) | class DefaultGlobalTestPartResultReporter
class DefaultPerThreadTestPartResultReporter (line 880) | class DefaultPerThreadTestPartResultReporter
function UnitTestImpl (line 898) | class GTEST_API_ UnitTestImpl {
function UnitTestImpl (line 1337) | inline UnitTestImpl* GetUnitTestImpl() {
function ParseNaturalNumber (line 1377) | bool ParseNaturalNumber(const ::std::string& str, Integer* number) {
class TestResultAccessor (line 1422) | class TestResultAccessor {
method RecordProperty (line 1424) | static void RecordProperty(TestResult* test_result,
method ClearTestPartResults (line 1430) | static void ClearTestPartResults(TestResult* test_result) {
class StreamingListener (line 1443) | class StreamingListener : public EmptyTestEventListener {
class AbstractSocketWriter (line 1446) | class AbstractSocketWriter {
method CloseConnection (line 1454) | virtual void CloseConnection() {}
method SendLn (line 1457) | void SendLn(const std::string& message) { Send(message + "\n"); }
class SocketWriter (line 1461) | class SocketWriter : public AbstractSocketWriter {
method SocketWriter (line 1463) | SocketWriter(const std::string& host, const std::string& port)
method Send (line 1474) | void Send(const std::string& message) override {
method CloseConnection (line 1491) | void CloseConnection() override {
method StreamingListener (line 1509) | StreamingListener(const std::string& host, const std::string& port)
method StreamingListener (line 1514) | explicit StreamingListener(AbstractSocketWriter* socket_writer)
method OnTestProgramStart (line 1517) | void OnTestProgramStart(const UnitTest& /* unit_test */) override {
method OnTestProgramEnd (line 1521) | void OnTestProgramEnd(const UnitTest& unit_test) override {
method OnTestIterationStart (line 1530) | void OnTestIterationStart(const UnitTest& /* unit_test */,
method OnTestIterationEnd (line 1536) | void OnTestIterationEnd(const UnitTest& unit_test,
method OnTestCaseStart (line 1545) | void OnTestCaseStart(const TestCase& test_case) override {
method OnTestCaseEnd (line 1551) | void OnTestCaseEnd(const TestCase& test_case) override {
method OnTestStart (line 1557) | void OnTestStart(const TestInfo& test_info) override {
method OnTestEnd (line 1561) | void OnTestEnd(const TestInfo& test_info) override {
method OnTestPartResult (line 1568) | void OnTestPartResult(const TestPartResult& test_part_result) over...
method SendLn (line 1578) | void SendLn(const std::string& message) { socket_writer_->SendLn(m...
method Start (line 1582) | void Start() { SendLn("gtest_streaming_protocol_version=1.0"); }
method FormatBool (line 1584) | std::string FormatBool(bool value) { return value ? "1" : "0"; }
function FILE (line 1661) | static FILE* OpenFileForWriting(const std::string& output_file) {
function UInt32 (line 1816) | UInt32 Random::Generate(UInt32 range) {
function GTestIsInitialized (line 1836) | static bool GTestIsInitialized() { return GetArgvs().size() > 0; }
function SumOverTestSuiteList (line 1841) | static int SumOverTestSuiteList(const std::vector<TestSuite*>& case_...
function TestSuitePassed (line 1851) | static bool TestSuitePassed(const TestSuite* test_suite) {
function TestSuiteFailed (line 1856) | static bool TestSuiteFailed(const TestSuite* test_suite) {
function ShouldRunTestSuite (line 1862) | static bool ShouldRunTestSuite(const TestSuite* test_suite) {
function GetArgvs (line 1892) | ::std::vector<std::string> GetArgvs() {
function FilePath (line 1905) | FilePath GetCurrentExecutableName() {
function TypeId (line 2123) | TypeId GetTestTypeId() {
function AssertionResult (line 2134) | static AssertionResult HasOneFailure(const char* /* results_expr */,
function TestPartResultReporterInterface (line 2204) | TestPartResultReporterInterface*
function TestPartResultReporterInterface (line 2218) | TestPartResultReporterInterface*
function TimeInMillis (line 2311) | TimeInMillis GetTimeInMillis() {
function LPCWSTR (line 2359) | LPCWSTR String::AnsiToUtf16(const char* ansi) {
function StreamWideCharsToMessage (line 2405) | static void StreamWideCharsToMessage(const wchar_t* wstr, size_t len...
function SplitString (line 2421) | void SplitString(const ::std::string& str, char delimiter,
type edit_distance (line 2524) | namespace edit_distance {
function CalculateOptimalEdits (line 2525) | std::vector<EditType> CalculateOptimalEdits(const std::vector<size...
class InternalStrings (line 2585) | class InternalStrings {
method GetId (line 2587) | size_t GetId(const std::string& str) {
function CalculateOptimalEdits (line 2601) | std::vector<EditType> CalculateOptimalEdits(
class Hunk (line 2623) | class Hunk {
method Hunk (line 2625) | Hunk(size_t left_start, size_t right_start)
method PushLine (line 2632) | void PushLine(char edit, const char* line) {
method PrintTo (line 2650) | void PrintTo(std::ostream* os) {
method has_edits (line 2660) | bool has_edits() const { return adds_ || removes_; }
method FlushEdits (line 2663) | void FlushEdits() {
method PrintHeader (line 2672) | void PrintHeader(std::ostream* ss) const {
function CreateUnifiedDiff (line 2700) | std::string CreateUnifiedDiff(const std::vector<std::string>& left,
function SplitEscapedString (line 2769) | std::vector<std::string> SplitEscapedString(const std::string& str) {
function AssertionResult (line 2809) | AssertionResult EqFailure(const char* lhs_expression,
function GetBoolAssertionFailureMessage (line 2844) | std::string GetBoolAssertionFailureMessage(
function AssertionResult (line 2860) | AssertionResult DoubleNearPredFormat(const char* expr1,
function AssertionResult (line 2880) | AssertionResult FloatingPointLE(const char* expr1,
function AssertionResult (line 2933) | AssertionResult CmpHelperEQ(const char* lhs_expression,
function InDeathTestChild (line 7696) | bool InDeathTestChild() {
function ExitSummary (line 7756) | static std::string ExitSummary(int exit_code) {
function ExitedUnsuccessfully (line 7782) | bool ExitedUnsuccessfully(int exit_status) {
function DeathTestThreadWarning (line 7791) | static std::string DeathTestThreadWarning(size_t thread_count) {
type DeathTestOutcome (line 7829) | enum DeathTestOutcome { IN_PROGRESS, DIED, LIVED, RETURNED, THREW }
function DeathTestAbort (line 7836) | static void DeathTestAbort(const std::string& message) {
function GetLastErrnoDescription (line 7889) | std::string GetLastErrnoDescription() {
function FailFromInternalError (line 7897) | static void FailFromInternalError(int fd) {
class DeathTestImpl (line 7948) | class DeathTestImpl : public DeathTest {
method DeathTestImpl (line 7950) | DeathTestImpl(const char* a_statement, Matcher<const std::string&>...
method spawned (line 7966) | bool spawned() const { return spawned_; }
method set_spawned (line 7967) | void set_spawned(bool is_spawned) { spawned_ = is_spawned; }
method status (line 7968) | int status() const { return status_; }
method set_status (line 7969) | void set_status(int a_status) { status_ = a_status; }
method DeathTestOutcome (line 7970) | DeathTestOutcome outcome() const { return outcome_; }
method set_outcome (line 7971) | void set_outcome(DeathTestOutcome an_outcome) { outcome_ = an_outc...
method read_fd (line 7972) | int read_fd() const { return read_fd_; }
method set_read_fd (line 7973) | void set_read_fd(int fd) { read_fd_ = fd; }
method write_fd (line 7974) | int write_fd() const { return write_fd_; }
method set_write_fd (line 7975) | void set_write_fd(int fd) { write_fd_ = fd; }
function FormatDeathTestOutput (line 8084) | static ::std::string FormatDeathTestOutput(const ::std::string& outp...
class WindowsDeathTest (line 8200) | class WindowsDeathTest : public DeathTestImpl {
method WindowsDeathTest (line 8202) | WindowsDeathTest(const char* a_statement, Matcher<const std::strin...
class FuchsiaDeathTest (line 8364) | class FuchsiaDeathTest : public DeathTestImpl {
method FuchsiaDeathTest (line 8366) | FuchsiaDeathTest(const char* a_statement, Matcher<const std::strin...
class Arguments (line 8391) | class Arguments {
method Arguments (line 8393) | Arguments() { args_.push_back(nullptr); }
method AddArgument (line 8401) | void AddArgument(const char* argument) {
method AddArguments (line 8406) | void AddArguments(const ::std::vector<Str>& arguments) {
method size (line 8417) | int size() {
method Arguments (line 8731) | Arguments() { args_.push_back(nullptr); }
method AddArgument (line 8739) | void AddArgument(const char* argument) {
method AddArguments (line 8744) | void AddArguments(const ::std::vector<Str>& arguments) {
class ForkingDeathTest (line 8611) | class ForkingDeathTest : public DeathTestImpl {
method set_child_pid (line 8619) | void set_child_pid(pid_t child_pid) { child_pid_ = child_pid; }
class NoExecDeathTest (line 8648) | class NoExecDeathTest : public ForkingDeathTest {
method NoExecDeathTest (line 8650) | NoExecDeathTest(const char* a_statement, Matcher<const std::string...
class ExecDeathTest (line 8703) | class ExecDeathTest : public ForkingDeathTest {
method ExecDeathTest (line 8705) | ExecDeathTest(const char* a_statement, Matcher<const std::string&>...
method GetArgvsForDeathTestChildProcess (line 8713) | static ::std::vector<std::string> GetArgvsForDeathTestChildProcess...
class Arguments (line 8729) | class Arguments {
method Arguments (line 8393) | Arguments() { args_.push_back(nullptr); }
method AddArgument (line 8401) | void AddArgument(const char* argument) {
method AddArguments (line 8406) | void AddArguments(const ::std::vector<Str>& arguments) {
method size (line 8417) | int size() {
method Arguments (line 8731) | Arguments() { args_.push_back(nullptr); }
method AddArgument (line 8739) | void AddArgument(const char* argument) {
method AddArguments (line 8744) | void AddArguments(const ::std::vector<Str>& arguments) {
type ExecDeathTestArgs (line 8761) | struct ExecDeathTestArgs {
function ExecDeathTestChildMain (line 8784) | static int ExecDeathTestChildMain(void* child_arg) {
function StackLowerThanAddress (line 8825) | static void StackLowerThanAddress(const void* ptr, bool* result) {
function GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_ (line 8831) | GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_
function pid_t (line 8847) | static pid_t ExecDeathTestSpawnChild(char* const* argv, int close_fd) {
function IsPathSeparator (line 9267) | static bool IsPathSeparator(char c) {
function FilePath (line 9276) | FilePath FilePath::GetCurrentDir() {
function FilePath (line 9302) | FilePath FilePath::RemoveExtension(const char* extension) const {
function FilePath (line 9333) | FilePath FilePath::RemoveDirectoryName() const {
function FilePath (line 9344) | FilePath FilePath::RemoveFileName() const {
function FilePath (line 9361) | FilePath FilePath::MakeFileName(const FilePath& directory,
function FilePath (line 9377) | FilePath FilePath::ConcatPaths(const FilePath& directory,
function FilePath (line 9461) | FilePath FilePath::GenerateUniqueFileName(const FilePath& directory,
function FilePath (line 9521) | FilePath FilePath::RemoveTrailingPathSeparator() const {
function T (line 9808) | T ReadProcFileField(const std::string& filename, int field) {
function GetThreadCount (line 9821) | size_t GetThreadCount() {
function GetThreadCount (line 9829) | size_t GetThreadCount() {
function GetThreadCount (line 9865) | size_t GetThreadCount() {
function GetThreadCount (line 9888) | size_t GetThreadCount() {
function GetThreadCount (line 9925) | size_t GetThreadCount() {
function GetThreadCount (line 9943) | size_t GetThreadCount() {
function GetThreadCount (line 9956) | size_t GetThreadCount() {
function GetThreadCount (line 9975) | size_t GetThreadCount() {
function SleepMilliseconds (line 9985) | void SleepMilliseconds(int n) {
class MemoryIsNotDeallocated (line 10095) | class MemoryIsNotDeallocated
method MemoryIsNotDeallocated (line 10098) | MemoryIsNotDeallocated() : old_crtdbg_flag_(0) {
class ThreadWithParamSupport (line 10169) | class ThreadWithParamSupport : public ThreadWithParamBase {
method HANDLE (line 10171) | static HANDLE CreateThread(Runnable* runnable,
type ThreadMainParam (line 10191) | struct ThreadMainParam {
method ThreadMainParam (line 10192) | ThreadMainParam(Runnable* runnable, Notification* thread_can_start)
method DWORD (line 10201) | static DWORD WINAPI ThreadMain(void* ptr) {
class ThreadLocalRegistryImpl (line 10237) | class ThreadLocalRegistryImpl {
method ThreadLocalValueHolderBase (line 10241) | static ThreadLocalValueHolderBase* GetValueOnCurrentThread(
method OnThreadLocalDestroyed (line 10269) | static void OnThreadLocalDestroyed(
method OnThreadExit (line 10297) | static void OnThreadExit(DWORD thread_id) {
method StartWatcherThreadFor (line 10336) | static void StartWatcherThreadFor(DWORD thread_id) {
method DWORD (line 10363) | static DWORD WINAPI WatcherThreadFunc(LPVOID param) {
method ThreadIdToThreadLocals (line 10375) | static ThreadIdToThreadLocals* GetThreadLocalsMapLocked() {
function ThreadLocalValueHolderBase (line 10391) | ThreadLocalValueHolderBase* ThreadLocalRegistry::GetValueOnCurrentTh...
function IsInSet (line 10471) | bool IsInSet(char ch, const char* str) {
function IsAsciiDigit (line 10478) | bool IsAsciiDigit(char ch) { return '0' <= ch && ch <= '9'; }
function IsAsciiPunct (line 10479) | bool IsAsciiPunct(char ch) {
function IsRepeat (line 10482) | bool IsRepeat(char ch) { return IsInSet(ch, "?*+"); }
function IsAsciiWhiteSpace (line 10483) | bool IsAsciiWhiteSpace(char ch) { return IsInSet(ch, " \f\n\r\t\v"); }
function IsAsciiWordChar (line 10484) | bool IsAsciiWordChar(char ch) {
function IsValidEscape (line 10490) | bool IsValidEscape(char c) {
function AtomMatchesChar (line 10496) | bool AtomMatchesChar(bool escaped, char pattern_char, char ch) {
function FormatRegexSyntaxError (line 10518) | static std::string FormatRegexSyntaxError(const char* regex, int ind...
function ValidateRegex (line 10525) | bool ValidateRegex(const char* regex) {
function MatchRepetitionAndRegexAtHead (line 10585) | bool MatchRepetitionAndRegexAtHead(
function MatchRegexAtHead (line 10612) | bool MatchRegexAtHead(const char* regex, const char* str) {
function MatchRegexAnywhere (line 10648) | bool MatchRegexAnywhere(const char* regex, const char* str) {
function FormatFileLocation (line 10720) | GTEST_API_ ::std::string FormatFileLocation(const char* file, int li...
function FormatCompilerIndependentFileLocation (line 10738) | GTEST_API_ ::std::string FormatCompilerIndependentFileLocation(
class CapturedStream (line 10774) | class CapturedStream {
method CapturedStream (line 10777) | explicit CapturedStream(int fd) : fd_(fd), uncaptured_fd_(dup(fd)) {
method GetCapturedString (line 10829) | std::string GetCapturedString() {
function CaptureStream (line 10859) | static void CaptureStream(int fd, const char* stream_name,
function GetCapturedStream (line 10869) | static std::string GetCapturedStream(CapturedStream** captured_strea...
function CaptureStdout (line 10879) | void CaptureStdout() {
function CaptureStderr (line 10884) | void CaptureStderr() {
function GetCapturedStdout (line 10889) | std::string GetCapturedStdout() {
function GetCapturedStderr (line 10894) | std::string GetCapturedStderr() {
function GetFileSize (line 10904) | size_t GetFileSize(FILE* file) {
function ReadEntireFile (line 10909) | std::string ReadEntireFile(FILE* file) {
function GetInjectableArgvs (line 10935) | std::vector<std::string> GetInjectableArgvs() {
function SetInjectableArgvs (line 10942) | void SetInjectableArgvs(const std::vector<std::string>* new_argvs) {
function SetInjectableArgvs (line 10947) | void SetInjectableArgvs(const std::vector<std::string>& new_argvs) {
function SetInjectableArgvs (line 10953) | void SetInjectableArgvs(const std::vector< ::string>& new_argvs) {
function ClearInjectableArgvs (line 10959) | void ClearInjectableArgvs() {
type posix (line 10966) | namespace posix {
function Abort (line 10967) | void Abort() {
function FlagToEnvVar (line 10977) | static std::string FlagToEnvVar(const char* flag) {
function ParseInt32 (line 10992) | bool ParseInt32(const Message& src_text, const char* str, Int32* val...
function BoolFromGTestEnv (line 11034) | bool BoolFromGTestEnv(const char* flag, bool default_value) {
function Int32 (line 11048) | Int32 Int32FromGTestEnv(const char* flag, Int32 default_value) {
function OutputFlagAlsoCheckEnvVar (line 11080) | std::string OutputFlagAlsoCheckEnvVar(){
type CharFormat (line 11226) | enum CharFormat {
function IsPrintableAscii (line 11235) | inline bool IsPrintableAscii(wchar_t c) {
function CharFormat (line 11244) | static CharFormat PrintAsCharLiteralTo(Char c, ostream* os) {
function CharFormat (line 11293) | static CharFormat PrintAsStringLiteralTo(wchar_t c, ostream* os) {
function CharFormat (line 11308) | static CharFormat PrintAsStringLiteralTo(char c, ostream* os) {
function PrintCharAndCodeTo (line 11318) | void PrintCharAndCodeTo(Char c, ostream* os) {
function PrintTo (line 11342) | void PrintTo(unsigned char c, ::std::ostream* os) {
function PrintTo (line 11345) | void PrintTo(signed char c, ::std::ostream* os) {
function PrintTo (line 11351) | void PrintTo(wchar_t wc, ostream* os) {
function CharFormat (line 11363) | static CharFormat PrintCharsAsStringTo(
function UniversalPrintCharArray (line 11393) | static void UniversalPrintCharArray(
function UniversalPrintArray (line 11416) | void UniversalPrintArray(const char* begin, size_t len, ostream* os) {
function UniversalPrintArray (line 11422) | void UniversalPrintArray(const wchar_t* begin, size_t len, ostream* ...
function PrintTo (line 11427) | void PrintTo(const char* s, ostream* os) {
function PrintTo (line 11444) | void PrintTo(const wchar_t* s, ostream* os) {
function ContainsUnprintableControlCodes (line 11456) | bool ContainsUnprintableControlCodes(const char* str, size_t length) {
function IsUTF8TrailByte (line 11475) | bool IsUTF8TrailByte(unsigned char t) { return 0x80 <= t && t<= 0xbf; }
function IsValidUTF8 (line 11477) | bool IsValidUTF8(const char* str, size_t length) {
function ConditionalPrintAsText (line 11512) | void ConditionalPrintAsText(const char* str, size_t length, ostream*...
function PrintStringTo (line 11523) | void PrintStringTo(const ::string& s, ostream* os) {
function PrintStringTo (line 11532) | void PrintStringTo(const ::std::string& s, ostream* os) {
function PrintWideStringTo (line 11542) | void PrintWideStringTo(const ::wstring& s, ostream* os) {
function PrintWideStringTo (line 11548) | void PrintWideStringTo(const ::std::wstring& s, ostream* os) {
function SplitIntoTestNames (line 11703) | static std::vector<std::string> SplitIntoTestNames(const char* src) {
function GTEST_API_ (line 12013) | GTEST_API_ std::string JoinAsTuple(const Strings& fields) {
function GTEST_API_ (line 12034) | GTEST_API_ std::string ConvertIdentifierNameToWords(const char* id_n...
class GoogleTestFailureReporter (line 12056) | class GoogleTestFailureReporter : public FailureReporterInterface {
method ReportFailure (line 12058) | void ReportFailure(FailureType type, const char* file, int line,
function GTEST_API_ (line 12074) | GTEST_API_ FailureReporterInterface* GetFailureReporter() {
function GTEST_API_ (line 12090) | GTEST_API_ bool LogIsVisible(LogSeverity severity) {
function GTEST_API_ (line 12111) | GTEST_API_ void Log(LogSeverity severity, const std::string& message,
function GTEST_API_ (line 12149) | GTEST_API_ WithoutMatchers GetWithoutMatchers() { return WithoutMatc...
function GTEST_API_ (line 12151) | GTEST_API_ void IllegalDoDefault(const char* file, int line) {
function GTEST_API_ (line 12212) | GTEST_API_ std::string FormatMatcherDescription(bool negation,
class MaxBipartiteMatchState (line 12282) | class MaxBipartiteMatchState {
method MaxBipartiteMatchState (line 12284) | explicit MaxBipartiteMatchState(const MatchMatrix& graph)
method ElementMatcherPairs (line 12290) | ElementMatcherPairs Compute() {
method TryAugment (line 12342) | bool TryAugment(size_t ilhs, ::std::vector<char>* seen) {
function GTEST_API_ (line 12388) | GTEST_API_ ElementMatcherPairs FindMaxBipartiteMatching(const MatchM...
function LogElementMatcherPairVec (line 12392) | static void LogElementMatcherPairVec(const ElementMatcherPairs& pairs,
function GTEST_API_ (line 12688) | GTEST_API_ void LogWithLocation(testing::internal::LogSeverity sever...
function GTEST_EXCLUSIVE_LOCK_REQUIRED_ (line 12724) | GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
function GTEST_EXCLUSIVE_LOCK_REQUIRED_ (line 12751) | GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
function GTEST_EXCLUSIVE_LOCK_REQUIRED_ (line 12771) | GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
function GTEST_EXCLUSIVE_LOCK_REQUIRED_ (line 12802) | GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
function GTEST_LOCK_EXCLUDED_ (line 12825) | GTEST_LOCK_EXCLUDED_(mutex_) {
function ReportUninterestingCall (line 12898) | void ReportUninterestingCall(CallReaction reaction, const std::strin...
function GTEST_LOCK_EXCLUDED_ (line 12933) | GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
function GTEST_LOCK_EXCLUDED_ (line 12946) | GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
function GTEST_LOCK_EXCLUDED_ (line 12957) | GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
function GTEST_LOCK_EXCLUDED_ (line 12974) | GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
function GTEST_LOCK_EXCLUDED_ (line 12992) | GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
function Expectation (line 13103) | Expectation UntypedFunctionMockerBase::GetHandleOf(ExpectationBase* ...
function GTEST_EXCLUSIVE_LOCK_REQUIRED_ (line 13124) | GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
function CallReaction (line 13168) | CallReaction intToCallReaction(int mock_behavior) {
function ParseGoogleMockBoolFlag (line 13598) | static bool ParseGoogleMockBoolFlag(const char* str, const char* flag,
function ParseGoogleMockStringFlag (line 13617) | static bool ParseGoogleMockStringFlag(const char* str, const char* f...
function ParseGoogleMockIntFlag (line 13630) | static bool ParseGoogleMockIntFlag(const char* str, const char* flag,
function InitGoogleMockImpl (line 13648) | void InitGoogleMockImpl(int* argc, CharType** argv) {
type internal (line 1650) | namespace internal {
function SingleFailureChecker (line 172) | class GTEST_API_ SingleFailureChecker {
function GetRandomSeedFromFlag (line 522) | inline int GetRandomSeedFromFlag(Int32 random_seed_flag) {
function GetNextRandomSeed (line 538) | inline int GetNextRandomSeed(int seed) {
class GTestFlagSaver (line 548) | class GTestFlagSaver {
method GTestFlagSaver (line 551) | GTestFlagSaver() {
function CountIf (line 672) | inline int CountIf(const Container& c, Predicate predicate) {
function ForEach (line 685) | void ForEach(const Container& c, Functor functor) {
function E (line 692) | inline E GetElementOr(const std::vector<E>& v, int i, E default_valu...
function ShuffleRange (line 701) | void ShuffleRange(internal::Random* random, int begin, int end,
function Shuffle (line 722) | inline void Shuffle(internal::Random* random, std::vector<E>* v) {
function Delete (line 729) | static void Delete(T* x) {
class TestPropertyKeyIs (line 736) | class TestPropertyKeyIs {
method TestPropertyKeyIs (line 741) | explicit TestPropertyKeyIs(const std::string& key) : key_(key) {}
function UnitTestOptions (line 762) | class GTEST_API_ UnitTestOptions {
class OsStackTraceGetterInterface (line 807) | class OsStackTraceGetterInterface {
method OsStackTraceGetterInterface (line 809) | OsStackTraceGetterInterface() {}
class OsStackTraceGetter (line 834) | class OsStackTraceGetter : public OsStackTraceGetterInterface {
method OsStackTraceGetter (line 836) | OsStackTraceGetter() {}
type TraceInfo (line 856) | struct TraceInfo {
class DefaultGlobalTestPartResultReporter (line 864) | class DefaultGlobalTestPartResultReporter
class DefaultPerThreadTestPartResultReporter (line 880) | class DefaultPerThreadTestPartResultReporter
function UnitTestImpl (line 898) | class GTEST_API_ UnitTestImpl {
function UnitTestImpl (line 1337) | inline UnitTestImpl* GetUnitTestImpl() {
function ParseNaturalNumber (line 1377) | bool ParseNaturalNumber(const ::std::string& str, Integer* number) {
class TestResultAccessor (line 1422) | class TestResultAccessor {
method RecordProperty (line 1424) | static void RecordProperty(TestResult* test_result,
method ClearTestPartResults (line 1430) | static void ClearTestPartResults(TestResult* test_result) {
class StreamingListener (line 1443) | class StreamingListener : public EmptyTestEventListener {
class AbstractSocketWriter (line 1446) | class AbstractSocketWriter {
method CloseConnection (line 1454) | virtual void CloseConnection() {}
method SendLn (line 1457) | void SendLn(const std::string& message) { Send(message + "\n"); }
class SocketWriter (line 1461) | class SocketWriter : public AbstractSocketWriter {
method SocketWriter (line 1463) | SocketWriter(const std::string& host, const std::string& port)
method Send (line 1474) | void Send(const std::string& message) override {
method CloseConnection (line 1491) | void CloseConnection() override {
method StreamingListener (line 1509) | StreamingListener(const std::string& host, const std::string& port)
method StreamingListener (line 1514) | explicit StreamingListener(AbstractSocketWriter* socket_writer)
method OnTestProgramStart (line 1517) | void OnTestProgramStart(const UnitTest& /* unit_test */) override {
method OnTestProgramEnd (line 1521) | void OnTestProgramEnd(const UnitTest& unit_test) override {
method OnTestIterationStart (line 1530) | void OnTestIterationStart(const UnitTest& /* unit_test */,
method OnTestIterationEnd (line 1536) | void OnTestIterationEnd(const UnitTest& unit_test,
method OnTestCaseStart (line 1545) | void OnTestCaseStart(const TestCase& test_case) override {
method OnTestCaseEnd (line 1551) | void OnTestCaseEnd(const TestCase& test_case) override {
method OnTestStart (line 1557) | void OnTestStart(const TestInfo& test_info) override {
method OnTestEnd (line 1561) | void OnTestEnd(const TestInfo& test_info) override {
method OnTestPartResult (line 1568) | void OnTestPartResult(const TestPartResult& test_part_result) over...
method SendLn (line 1578) | void SendLn(const std::string& message) { socket_writer_->SendLn(m...
method Start (line 1582) | void Start() { SendLn("gtest_streaming_protocol_version=1.0"); }
method FormatBool (line 1584) | std::string FormatBool(bool value) { return value ? "1" : "0"; }
function FILE (line 1661) | static FILE* OpenFileForWriting(const std::string& output_file) {
function UInt32 (line 1816) | UInt32 Random::Generate(UInt32 range) {
function GTestIsInitialized (line 1836) | static bool GTestIsInitialized() { return GetArgvs().size() > 0; }
function SumOverTestSuiteList (line 1841) | static int SumOverTestSuiteList(const std::vector<TestSuite*>& case_...
function TestSuitePassed (line 1851) | static bool TestSuitePassed(const TestSuite* test_suite) {
function TestSuiteFailed (line 1856) | static bool TestSuiteFailed(const TestSuite* test_suite) {
function ShouldRunTestSuite (line 1862) | static bool ShouldRunTestSuite(const TestSuite* test_suite) {
function GetArgvs (line 1892) | ::std::vector<std::string> GetArgvs() {
function FilePath (line 1905) | FilePath GetCurrentExecutableName() {
function TypeId (line 2123) | TypeId GetTestTypeId() {
function AssertionResult (line 2134) | static AssertionResult HasOneFailure(const char* /* results_expr */,
function TestPartResultReporterInterface (line 2204) | TestPartResultReporterInterface*
function TestPartResultReporterInterface (line 2218) | TestPartResultReporterInterface*
function TimeInMillis (line 2311) | TimeInMillis GetTimeInMillis() {
function LPCWSTR (line 2359) | LPCWSTR String::AnsiToUtf16(const char* ansi) {
function StreamWideCharsToMessage (line 2405) | static void StreamWideCharsToMessage(const wchar_t* wstr, size_t len...
function SplitString (line 2421) | void SplitString(const ::std::string& str, char delimiter,
type edit_distance (line 2524) | namespace edit_distance {
function CalculateOptimalEdits (line 2525) | std::vector<EditType> CalculateOptimalEdits(const std::vector<size...
class InternalStrings (line 2585) | class InternalStrings {
method GetId (line 2587) | size_t GetId(const std::string& str) {
function CalculateOptimalEdits (line 2601) | std::vector<EditType> CalculateOptimalEdits(
class Hunk (line 2623) | class Hunk {
method Hunk (line 2625) | Hunk(size_t left_start, size_t right_start)
method PushLine (line 2632) | void PushLine(char edit, const char* line) {
method PrintTo (line 2650) | void PrintTo(std::ostream* os) {
method has_edits (line 2660) | bool has_edits() const { return adds_ || removes_; }
method FlushEdits (line 2663) | void FlushEdits() {
method PrintHeader (line 2672) | void PrintHeader(std::ostream* ss) const {
function CreateUnifiedDiff (line 2700) | std::string CreateUnifiedDiff(const std::vector<std::string>& left,
function SplitEscapedString (line 2769) | std::vector<std::string> SplitEscapedString(const std::string& str) {
function AssertionResult (line 2809) | AssertionResult EqFailure(const char* lhs_expression,
function GetBoolAssertionFailureMessage (line 2844) | std::string GetBoolAssertionFailureMessage(
function AssertionResult (line 2860) | AssertionResult DoubleNearPredFormat(const char* expr1,
function AssertionResult (line 2880) | AssertionResult FloatingPointLE(const char* expr1,
function AssertionResult (line 2933) | AssertionResult CmpHelperEQ(const char* lhs_expression,
function InDeathTestChild (line 7696) | bool InDeathTestChild() {
function ExitSummary (line 7756) | static std::string ExitSummary(int exit_code) {
function ExitedUnsuccessfully (line 7782) | bool ExitedUnsuccessfully(int exit_status) {
function DeathTestThreadWarning (line 7791) | static std::string DeathTestThreadWarning(size_t thread_count) {
type DeathTestOutcome (line 7829) | enum DeathTestOutcome { IN_PROGRESS, DIED, LIVED, RETURNED, THREW }
function DeathTestAbort (line 7836) | static void DeathTestAbort(const std::string& message) {
function GetLastErrnoDescription (line 7889) | std::string GetLastErrnoDescription() {
function FailFromInternalError (line 7897) | static void FailFromInternalError(int fd) {
class DeathTestImpl (line 7948) | class DeathTestImpl : public DeathTest {
method DeathTestImpl (line 7950) | DeathTestImpl(const char* a_statement, Matcher<const std::string&>...
method spawned (line 7966) | bool spawned() const { return spawned_; }
method set_spawned (line 7967) | void set_spawned(bool is_spawned) { spawned_ = is_spawned; }
method status (line 7968) | int status() const { return status_; }
method set_status (line 7969) | void set_status(int a_status) { status_ = a_status; }
method DeathTestOutcome (line 7970) | DeathTestOutcome outcome() const { return outcome_; }
method set_outcome (line 7971) | void set_outcome(DeathTestOutcome an_outcome) { outcome_ = an_outc...
method read_fd (line 7972) | int read_fd() const { return read_fd_; }
method set_read_fd (line 7973) | void set_read_fd(int fd) { read_fd_ = fd; }
method write_fd (line 7974) | int write_fd() const { return write_fd_; }
method set_write_fd (line 7975) | void set_write_fd(int fd) { write_fd_ = fd; }
function FormatDeathTestOutput (line 8084) | static ::std::string FormatDeathTestOutput(const ::std::string& outp...
class WindowsDeathTest (line 8200) | class WindowsDeathTest : public DeathTestImpl {
method WindowsDeathTest (line 8202) | WindowsDeathTest(const char* a_statement, Matcher<const std::strin...
class FuchsiaDeathTest (line 8364) | class FuchsiaDeathTest : public DeathTestImpl {
method FuchsiaDeathTest (line 8366) | FuchsiaDeathTest(const char* a_statement, Matcher<const std::strin...
class Arguments (line 8391) | class Arguments {
method Arguments (line 8393) | Arguments() { args_.push_back(nullptr); }
method AddArgument (line 8401) | void AddArgument(const char* argument) {
method AddArguments (line 8406) | void AddArguments(const ::std::vector<Str>& arguments) {
method size (line 8417) | int size() {
method Arguments (line 8731) | Arguments() { args_.push_back(nullptr); }
method AddArgument (line 8739) | void AddArgument(const char* argument) {
method AddArguments (line 8744) | void AddArguments(const ::std::vector<Str>& arguments) {
class ForkingDeathTest (line 8611) | class ForkingDeathTest : public DeathTestImpl {
method set_child_pid (line 8619) | void set_child_pid(pid_t child_pid) { child_pid_ = child_pid; }
class NoExecDeathTest (line 8648) | class NoExecDeathTest : public ForkingDeathTest {
method NoExecDeathTest (line 8650) | NoExecDeathTest(const char* a_statement, Matcher<const std::string...
class ExecDeathTest (line 8703) | class ExecDeathTest : public ForkingDeathTest {
method ExecDeathTest (line 8705) | ExecDeathTest(const char* a_statement, Matcher<const std::string&>...
method GetArgvsForDeathTestChildProcess (line 8713) | static ::std::vector<std::string> GetArgvsForDeathTestChildProcess...
class Arguments (line 8729) | class Arguments {
method Arguments (line 8393) | Arguments() { args_.push_back(nullptr); }
method AddArgument (line 8401) | void AddArgument(const char* argument) {
method AddArguments (line 8406) | void AddArguments(const ::std::vector<Str>& arguments) {
method size (line 8417) | int size() {
method Arguments (line 8731) | Arguments() { args_.push_back(nullptr); }
method AddArgument (line 8739) | void AddArgument(const char* argument) {
method AddArguments (line 8744) | void AddArguments(const ::std::vector<Str>& arguments) {
type ExecDeathTestArgs (line 8761) | struct ExecDeathTestArgs {
function ExecDeathTestChildMain (line 8784) | static int ExecDeathTestChildMain(void* child_arg) {
function StackLowerThanAddress (line 8825) | static void StackLowerThanAddress(const void* ptr, bool* result) {
function GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_ (line 8831) | GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_
function pid_t (line 8847) | static pid_t ExecDeathTestSpawnChild(char* const* argv, int close_fd) {
function IsPathSeparator (line 9267) | static bool IsPathSeparator(char c) {
function FilePath (line 9276) | FilePath FilePath::GetCurrentDir() {
function FilePath (line 9302) | FilePath FilePath::RemoveExtension(const char* extension) const {
function FilePath (line 9333) | FilePath FilePath::RemoveDirectoryName() const {
function FilePath (line 9344) | FilePath FilePath::RemoveFileName() const {
function FilePath (line 9361) | FilePath FilePath::MakeFileName(const FilePath& directory,
function FilePath (line 9377) | FilePath FilePath::ConcatPaths(const FilePath& directory,
function FilePath (line 9461) | FilePath FilePath::GenerateUniqueFileName(const FilePath& directory,
function FilePath (line 9521) | FilePath FilePath::RemoveTrailingPathSeparator() const {
function T (line 9808) | T ReadProcFileField(const std::string& filename, int field) {
function GetThreadCount (line 9821) | size_t GetThreadCount() {
function GetThreadCount (line 9829) | size_t GetThreadCount() {
function GetThreadCount (line 9865) | size_t GetThreadCount() {
function GetThreadCount (line 9888) | size_t GetThreadCount() {
function GetThreadCount (line 9925) | size_t GetThreadCount() {
function GetThreadCount (line 9943) | size_t GetThreadCount() {
function GetThreadCount (line 9956) | size_t GetThreadCount() {
function GetThreadCount (line 9975) | size_t GetThreadCount() {
function SleepMilliseconds (line 9985) | void SleepMilliseconds(int n) {
class MemoryIsNotDeallocated (line 10095) | class MemoryIsNotDeallocated
method MemoryIsNotDeallocated (line 10098) | MemoryIsNotDeallocated() : old_crtdbg_flag_(0) {
class ThreadWithParamSupport (line 10169) | class ThreadWithParamSupport : public ThreadWithParamBase {
method HANDLE (line 10171) | static HANDLE CreateThread(Runnable* runnable,
type ThreadMainParam (line 10191) | struct ThreadMainParam {
method ThreadMainParam (line 10192) | ThreadMainParam(Runnable* runnable, Notification* thread_can_start)
method DWORD (line 10201) | static DWORD WINAPI ThreadMain(void* ptr) {
class ThreadLocalRegistryImpl (line 10237) | class ThreadLocalRegistryImpl {
method ThreadLocalValueHolderBase (line 10241) | static ThreadLocalValueHolderBase* GetValueOnCurrentThread(
method OnThreadLocalDestroyed (line 10269) | static void OnThreadLocalDestroyed(
method OnThreadExit (line 10297) | static void OnThreadExit(DWORD thread_id) {
method StartWatcherThreadFor (line 10336) | static void StartWatcherThreadFor(DWORD thread_id) {
method DWORD (line 10363) | static DWORD WINAPI WatcherThreadFunc(LPVOID param) {
method ThreadIdToThreadLocals (line 10375) | static ThreadIdToThreadLocals* GetThreadLocalsMapLocked() {
function ThreadLocalValueHolderBase (line 10391) | ThreadLocalValueHolderBase* ThreadLocalRegistry::GetValueOnCurrentTh...
function IsInSet (line 10471) | bool IsInSet(char ch, const char* str) {
function IsAsciiDigit (line 10478) | bool IsAsciiDigit(char ch) { return '0' <= ch && ch <= '9'; }
function IsAsciiPunct (line 10479) | bool IsAsciiPunct(char ch) {
function IsRepeat (line 10482) | bool IsRepeat(char ch) { return IsInSet(ch, "?*+"); }
function IsAsciiWhiteSpace (line 10483) | bool IsAsciiWhiteSpace(char ch) { return IsInSet(ch, " \f\n\r\t\v"); }
function IsAsciiWordChar (line 10484) | bool IsAsciiWordChar(char ch) {
function IsValidEscape (line 10490) | bool IsValidEscape(char c) {
function AtomMatchesChar (line 10496) | bool AtomMatchesChar(bool escaped, char pattern_char, char ch) {
function FormatRegexSyntaxError (line 10518) | static std::string FormatRegexSyntaxError(const char* regex, int ind...
function ValidateRegex (line 10525) | bool ValidateRegex(const char* regex) {
function MatchRepetitionAndRegexAtHead (line 10585) | bool MatchRepetitionAndRegexAtHead(
function MatchRegexAtHead (line 10612) | bool MatchRegexAtHead(const char* regex, const char* str) {
function MatchRegexAnywhere (line 10648) | bool MatchRegexAnywhere(const char* regex, const char* str) {
function FormatFileLocation (line 10720) | GTEST_API_ ::std::string FormatFileLocation(const char* file, int li...
function FormatCompilerIndependentFileLocation (line 10738) | GTEST_API_ ::std::string FormatCompilerIndependentFileLocation(
class CapturedStream (line 10774) | class CapturedStream {
method CapturedStream (line 10777) | explicit CapturedStream(int fd) : fd_(fd), uncaptured_fd_(dup(fd)) {
method GetCapturedString (line 10829) | std::string GetCapturedString() {
function CaptureStream (line 10859) | static void CaptureStream(int fd, const char* stream_name,
function GetCapturedStream (line 10869) | static std::string GetCapturedStream(CapturedStream** captured_strea...
function CaptureStdout (line 10879) | void CaptureStdout() {
function CaptureStderr (line 10884) | void CaptureStderr() {
function GetCapturedStdout (line 10889) | std::string GetCapturedStdout() {
function GetCapturedStderr (line 10894) | std::string GetCapturedStderr(
Copy disabled (too large)
Download .json
Condensed preview — 2358 files, each showing path, character count, and a content snippet. Download the .json file for the full structured content (26,862K chars).
[
{
"path": ".gitignore",
"chars": 106,
"preview": "lib/\nbin/\nbuild/\ncmake-build-debug/\ncmake-build-release/\n.idea\n.vscode\n__pycache__/\n*.py[cod]\n*$py.class\n\n"
},
{
"path": "3rdparty/CMakeLists.txt",
"chars": 67,
"preview": "project(3rdparty)\nadd_subdirectory(eigen3)\nadd_subdirectory(ceres)\n"
},
{
"path": "3rdparty/ceres/.clang-format",
"chars": 123,
"preview": "BasedOnStyle: Google\nBinPackArguments: false\nBinPackParameters: false\nPointerAlignment: Left\nDerivePointerAlignment: fal"
},
{
"path": "3rdparty/ceres/.travis.yml",
"chars": 2155,
"preview": "language: cpp\n\nmatrix:\n fast_finish: true\n include:\n - os: linux\n dist: bionic\n sudo: required\n compiler: gc"
},
{
"path": "3rdparty/ceres/BUILD",
"chars": 6848,
"preview": "# Ceres Solver - A fast non-linear least squares minimizer\n# Copyright 2018 Google Inc. All rights reserved.\n# http://ce"
},
{
"path": "3rdparty/ceres/CMakeLists.txt",
"chars": 36520,
"preview": "## Modified by WANG JIADONG <wangjiadong@sensetime.com> for adas sdk\nmessage(STATUS \"${BoldGreen}[3RDPARTY : Ceres]${Col"
},
{
"path": "3rdparty/ceres/CONTRIBUTING.md",
"chars": 443,
"preview": "---------------------------------\nDo not make GitHub pull requests!\n---------------------------------\n\nCeres development"
},
{
"path": "3rdparty/ceres/LICENSE",
"chars": 1554,
"preview": "Ceres Solver - A fast non-linear least squares minimizer\nCopyright 2015 Google Inc. All rights reserved.\nhttp://ceres-so"
},
{
"path": "3rdparty/ceres/README.md",
"chars": 616,
"preview": "[](https://travis-ci.org/ceres-solver/"
},
{
"path": "3rdparty/ceres/WORKSPACE",
"chars": 4033,
"preview": "# Ceres Solver - A fast non-linear least squares minimizer\n# Copyright 2018 Google Inc. All rights reserved.\n# http://ce"
},
{
"path": "3rdparty/ceres/bazel/ceres.bzl",
"chars": 7674,
"preview": "# Ceres Solver - A fast non-linear least squares minimizer\n# Copyright 2018 Google Inc. All rights reserved.\n# http://ce"
},
{
"path": "3rdparty/ceres/cmake/AddCompileFlagsIfSupported.cmake",
"chars": 2586,
"preview": "# Ceres Solver - A fast non-linear least squares minimizer\n# Copyright 2017 Google Inc. All rights reserved.\n# http://ce"
},
{
"path": "3rdparty/ceres/cmake/AddGerritCommitHook.cmake",
"chars": 4370,
"preview": "# Ceres Solver - A fast non-linear least squares minimizer\n# Copyright 2015 Google Inc. All rights reserved.\n# http://ce"
},
{
"path": "3rdparty/ceres/cmake/AppendTargetProperty.cmake",
"chars": 3057,
"preview": "# Ceres Solver - A fast non-linear least squares minimizer\n# Copyright 2015 Google Inc. All rights reserved.\n# http://ce"
},
{
"path": "3rdparty/ceres/cmake/CeresCompileOptionsToComponents.cmake",
"chars": 4871,
"preview": "# Ceres Solver - A fast non-linear least squares minimizer\n# Copyright 2016 Google Inc. All rights reserved.\n# http://ce"
},
{
"path": "3rdparty/ceres/cmake/CeresConfig.cmake.in",
"chars": 14528,
"preview": "# Ceres Solver - A fast non-linear least squares minimizer\n# Copyright 2015 Google Inc. All rights reserved.\n# http://ce"
},
{
"path": "3rdparty/ceres/cmake/CeresThreadingModels.cmake",
"chars": 3870,
"preview": "# Ceres Solver - A fast non-linear least squares minimizer\n# Copyright 2018 Google Inc. All rights reserved.\n# http://ce"
},
{
"path": "3rdparty/ceres/cmake/CheckIfUnderscorePrefixedBesselFunctionsExist.cmake",
"chars": 2599,
"preview": "# Ceres Solver - A fast non-linear least squares minimizer\n# Copyright 2017 Google Inc. All rights reserved.\n# http://ce"
},
{
"path": "3rdparty/ceres/cmake/CreateCeresConfig.cmake",
"chars": 5975,
"preview": "# Ceres Solver - A fast non-linear least squares minimizer\n# Copyright 2015 Google Inc. All rights reserved.\n# http://ce"
},
{
"path": "3rdparty/ceres/cmake/DetectBrokenStackCheckMacOSXcodePairing.cmake",
"chars": 3905,
"preview": "# Ceres Solver - A fast non-linear least squares minimizer\n# Copyright 2019 Google Inc. All rights reserved.\n# http://ce"
},
{
"path": "3rdparty/ceres/cmake/EnableSanitizer.cmake",
"chars": 5109,
"preview": "# Ceres Solver - A fast non-linear least squares minimizer\n# Copyright 2019 Google Inc. All rights reserved.\n# http://ce"
},
{
"path": "3rdparty/ceres/cmake/FindAccelerateSparse.cmake",
"chars": 6885,
"preview": "# Ceres Solver - A fast non-linear least squares minimizer\n# Copyright 2018 Google Inc. All rights reserved.\n# http://ce"
},
{
"path": "3rdparty/ceres/cmake/FindCXSparse.cmake",
"chars": 11885,
"preview": "# Ceres Solver - A fast non-linear least squares minimizer\n# Copyright 2015 Google Inc. All rights reserved.\n# http://ce"
},
{
"path": "3rdparty/ceres/cmake/FindGlog.cmake",
"chars": 17150,
"preview": "# Ceres Solver - A fast non-linear least squares minimizer\n# Copyright 2015 Google Inc. All rights reserved.\n# http://ce"
},
{
"path": "3rdparty/ceres/cmake/FindSphinx.cmake",
"chars": 2591,
"preview": "# Ceres Solver - A fast non-linear least squares minimizer\n# Copyright 2015 Google Inc. All rights reserved.\n# http://ce"
},
{
"path": "3rdparty/ceres/cmake/FindSuiteSparse.cmake",
"chars": 22929,
"preview": "# Ceres Solver - A fast non-linear least squares minimizer\n# Copyright 2015 Google Inc. All rights reserved.\n# http://ce"
},
{
"path": "3rdparty/ceres/cmake/FindTBB.cmake",
"chars": 9298,
"preview": "# The MIT License (MIT)\n#\n# Copyright (c) 2015 Justus Calvin\n#\n# Permission is hereby granted, free of charge, to any pe"
},
{
"path": "3rdparty/ceres/cmake/PrettyPrintCMakeList.cmake",
"chars": 2068,
"preview": "# Ceres Solver - A fast non-linear least squares minimizer\n# Copyright 2018 Google Inc. All rights reserved.\n# http://ce"
},
{
"path": "3rdparty/ceres/cmake/ReadCeresVersionFromSource.cmake",
"chars": 4026,
"preview": "# Ceres Solver - A fast non-linear least squares minimizer\n# Copyright 2015 Google Inc. All rights reserved.\n# http://ce"
},
{
"path": "3rdparty/ceres/cmake/UpdateCacheVariable.cmake",
"chars": 2591,
"preview": "# Ceres Solver - A fast non-linear least squares minimizer\n# Copyright 2015 Google Inc. All rights reserved.\n# http://ce"
},
{
"path": "3rdparty/ceres/cmake/config.h.in",
"chars": 3762,
"preview": "// Ceres Solver - A fast non-linear least squares minimizer\n// Copyright 2015 Google Inc. All rights reserved.\n// http:/"
},
{
"path": "3rdparty/ceres/cmake/iOS.cmake",
"chars": 14362,
"preview": "# This file is part of the ios-cmake project. It was retrieved from\n# https://github.com/cristeab/ios-cmake.git, which i"
},
{
"path": "3rdparty/ceres/cmake/uninstall.cmake.in",
"chars": 4724,
"preview": "# Ceres Solver - A fast non-linear least squares minimizer\n# Copyright 2015 Google Inc. All rights reserved.\n# http://ce"
},
{
"path": "3rdparty/ceres/config/ceres/internal/config.h",
"chars": 2520,
"preview": "// Ceres Solver - A fast non-linear least squares minimizer\n// Copyright 2015 Google Inc. All rights reserved.\n// http:/"
},
{
"path": "3rdparty/ceres/data/2x2.foe",
"chars": 307,
"preview": "2 3\n0 1 0 1\n0 0 1 1\n0.586612685392731 1.157638405566669 0.846059486257292\n-0.0582774013402734 0.0339010363051084 -0.0501"
},
{
"path": "3rdparty/ceres/data/3x3.foe",
"chars": 755,
"preview": "3 8\n0 1 2 0 1 2 0 1 2\n0 0 0 1 1 1 2 2 2\n1.201143e-01 7.520515e-02 9.078330e-02 1.280545e-01 6.276734e-02 1.201840e-01 1."
},
{
"path": "3rdparty/ceres/data/5x5.foe",
"chars": 5611,
"preview": "5 24\n0 1 2 3 4 0 1 2 3 4 0 1 2 3 4 0 1 2 3 4 0 1 2 3 4\n0 0 0 0 0 1 1 1 1 1 2 2 2 2 2 3 3 3 3 3 4 4 4 4 4\n\n5.472286e-02 6"
},
{
"path": "3rdparty/ceres/data/README.foe",
"chars": 508,
"preview": "The *.foe files contain coefficients provided by Stefan Roth, who agreed to\nrelease them under a BSD license. See his ho"
},
{
"path": "3rdparty/ceres/data/ceres_noisy.pgm",
"chars": 125081,
"preview": "P2\n# PGM format\n # <width> <height> <levels> \n # <data> ... \n177 213 255 \n86 74 90 29 80 63 76 62 83 97 64 102 86 67 103"
},
{
"path": "3rdparty/ceres/data/libmv-ba-problems/Readme.txt",
"chars": 287,
"preview": "Problem files are created from Tears of Steel production files.\n\n- problem_01.bin is a final camera motion refinement st"
},
{
"path": "3rdparty/ceres/data/problem-16-22106-pre.txt",
"chars": 4783974,
"preview": "16 22106 83718\n0 0 -3.859900e+02 3.871200e+02\n1 0 -3.844000e+01 4.921200e+02\n2 0 -6.679200e+02 1.231100e+02\n"
},
{
"path": "3rdparty/ceres/docs/CMakeLists.txt",
"chars": 1631,
"preview": "# Ceres Solver - A fast non-linear least squares minimizer\n# Copyright 2015 Google Inc. All rights reserved.\n# http://ce"
},
{
"path": "3rdparty/ceres/docs/source/CMakeLists.txt",
"chars": 649,
"preview": "find_package(Sphinx REQUIRED)\n\n# HTML output directory\nset(SPHINX_HTML_DIR \"${Ceres_BINARY_DIR}/docs/html\")\n\n# Install d"
},
{
"path": "3rdparty/ceres/docs/source/_templates/layout.html",
"chars": 497,
"preview": "{% extends \"!layout.html\" %}\n\n{% block footer %}\n{{ super() }}\n<script>\n (function(i,s,o,g,r,a,m){i['GoogleAnalyticsObj"
},
{
"path": "3rdparty/ceres/docs/source/analytical_derivatives.rst",
"chars": 6896,
"preview": ".. default-domain:: cpp\n\n.. cpp:namespace:: ceres\n\n.. _chapter-analytical_derivatives:\n\n====================\nAnalytic De"
},
{
"path": "3rdparty/ceres/docs/source/automatic_derivatives.rst",
"chars": 9852,
"preview": ".. default-domain:: cpp\n\n.. cpp:namespace:: ceres\n\n.. _chapter-automatic_derivatives:\n\n=====================\nAutomatic D"
},
{
"path": "3rdparty/ceres/docs/source/bibliography.rst",
"chars": 5359,
"preview": ".. _sec-bibliography:\n\n============\nBibliography\n============\n\n.. [Agarwal] S. Agarwal, N. Snavely, S. M. Seitz and R. S"
},
{
"path": "3rdparty/ceres/docs/source/conf.py",
"chars": 7957,
"preview": "# -*- coding: utf-8 -*-\n#\n# Ceres Solver documentation build configuration file, created by\n# sphinx-quickstart on Sun J"
},
{
"path": "3rdparty/ceres/docs/source/contributing.rst",
"chars": 5027,
"preview": ".. _chapter-contributing:\n\n============\nContributing\n============\n\nWe welcome contributions to Ceres, whether they are n"
},
{
"path": "3rdparty/ceres/docs/source/derivatives.rst",
"chars": 2247,
"preview": ".. default-domain:: cpp\n\n.. cpp:namespace:: ceres\n\n.. _chapter-on_derivatives:\n\n==============\nOn Derivatives\n=========="
},
{
"path": "3rdparty/ceres/docs/source/faqs.rst",
"chars": 716,
"preview": ".. _chapter-tricks:\n\n.. default-domain:: cpp\n\n.. cpp:namespace:: ceres\n\n===================\nFAQS, Tips & Tricks\n========"
},
{
"path": "3rdparty/ceres/docs/source/features.rst",
"chars": 4263,
"preview": "====\nWhy?\n====\n.. _chapter-features:\n\n* **Code Quality** - Ceres Solver has been used in production at\n Google for more"
},
{
"path": "3rdparty/ceres/docs/source/gradient_solver.rst",
"chars": 19069,
"preview": ".. highlight:: c++\n\n.. default-domain:: cpp\n\n.. _chapter-gradient_problem_solver:\n\n==================================\nGe"
},
{
"path": "3rdparty/ceres/docs/source/gradient_tutorial.rst",
"chars": 6871,
"preview": ".. highlight:: c++\n\n.. default-domain:: cpp\n\n.. _chapter-gradient_tutorial:\n\n==================================\nGeneral "
},
{
"path": "3rdparty/ceres/docs/source/index.rst",
"chars": 2106,
"preview": "============\nCeres Solver\n============\n\nCeres Solver [#f1]_ is an open source C++ library for modeling and\nsolving large"
},
{
"path": "3rdparty/ceres/docs/source/installation.rst",
"chars": 46705,
"preview": ".. _chapter-installation:\n\n============\nInstallation\n============\n\nGetting the source code\n=======================\n.. _s"
},
{
"path": "3rdparty/ceres/docs/source/interfacing_with_autodiff.rst",
"chars": 10249,
"preview": ".. default-domain:: cpp\n\n.. cpp:namespace:: ceres\n\n.. _chapter-interfacing_with_automatic_differentiation:\n\nInterfacing "
},
{
"path": "3rdparty/ceres/docs/source/license.rst",
"chars": 1912,
"preview": "=======\nLicense\n=======\n\n.. NOTE::\n\n This page refers only to the license for Ceres itself, independent of its\n opti"
},
{
"path": "3rdparty/ceres/docs/source/modeling_faqs.rst",
"chars": 5679,
"preview": ".. _chapter-modeling_faqs:\n\n.. default-domain:: cpp\n\n.. cpp:namespace:: ceres\n\n========\nModeling\n========\n\n#. Use analyt"
},
{
"path": "3rdparty/ceres/docs/source/nnls_covariance.rst",
"chars": 14050,
"preview": "\n.. default-domain:: cpp\n\n.. cpp:namespace:: ceres\n\n.. _chapter-nnls_covariance:\n\n=====================\nCovariance Estim"
},
{
"path": "3rdparty/ceres/docs/source/nnls_modeling.rst",
"chars": 93818,
"preview": ".. default-domain:: cpp\n\n.. cpp:namespace:: ceres\n\n.. _`chapter-nnls_modeling`:\n\n=================================\nModel"
},
{
"path": "3rdparty/ceres/docs/source/nnls_solving.rst",
"chars": 89236,
"preview": "\n.. default-domain:: cpp\n\n.. cpp:namespace:: ceres\n\n.. _chapter-nnls_solving:\n\n================================\nSolving "
},
{
"path": "3rdparty/ceres/docs/source/nnls_tutorial.rst",
"chars": 43626,
"preview": ".. highlight:: c++\n\n.. default-domain:: cpp\n\n.. _chapter-nnls_tutorial:\n\n========================\nNon-linear Least Squar"
},
{
"path": "3rdparty/ceres/docs/source/numerical_derivatives.rst",
"chars": 14427,
"preview": ".. default-domain:: cpp\n\n.. cpp:namespace:: ceres\n\n.. _chapter-numerical_derivatives:\n\n===================\nNumeric deriv"
},
{
"path": "3rdparty/ceres/docs/source/solving_faqs.rst",
"chars": 6836,
"preview": ".. _chapter-solving_faqs:\n\n.. default-domain:: cpp\n\n.. cpp:namespace:: ceres\n\n=======\nSolving\n=======\n\n#. How do I evalu"
},
{
"path": "3rdparty/ceres/docs/source/spivak_notation.rst",
"chars": 1780,
"preview": ".. default-domain:: cpp\n\n.. cpp:namespace:: ceres\n\n.. _chapter-spivak_notation:\n\n===============\nSpivak Notation\n======="
},
{
"path": "3rdparty/ceres/docs/source/tutorial.rst",
"chars": 119,
"preview": ".. _chapter-tutorial:\n\n========\nTutorial\n========\n\n.. toctree::\n :maxdepth: 3\n\n nnls_tutorial\n gradient_tutorial\n"
},
{
"path": "3rdparty/ceres/docs/source/users.rst",
"chars": 3472,
"preview": ".. _chapter-users:\n\n=====\nUsers\n=====\n\n* At `Google <http://www.google.com>`_, Ceres is used to:\n\n * Estimate the pose "
},
{
"path": "3rdparty/ceres/docs/source/version_history.rst",
"chars": 59646,
"preview": ".. _chapter-version-history:\n\n===============\nVersion History\n===============\n\n1.14.0\n======\n\nNew Features\n------------\n"
},
{
"path": "3rdparty/ceres/include/ceres/autodiff_cost_function.h",
"chars": 9844,
"preview": "// Ceres Solver - A fast non-linear least squares minimizer\n// Copyright 2019 Google Inc. All rights reserved.\n// http:/"
},
{
"path": "3rdparty/ceres/include/ceres/autodiff_first_order_function.h",
"chars": 5778,
"preview": "// Ceres Solver - A fast non-linear least squares minimizer\n// Copyright 2019 Google Inc. All rights reserved.\n// http:/"
},
{
"path": "3rdparty/ceres/include/ceres/autodiff_local_parameterization.h",
"chars": 6294,
"preview": "// Ceres Solver - A fast non-linear least squares minimizer\n// Copyright 2019 Google Inc. All rights reserved.\n// http:/"
},
{
"path": "3rdparty/ceres/include/ceres/c_api.h",
"chars": 5937,
"preview": "/* Ceres Solver - A fast non-linear least squares minimizer\n * Copyright 2019 Google Inc. All rights reserved.\n * http:/"
},
{
"path": "3rdparty/ceres/include/ceres/ceres.h",
"chars": 2969,
"preview": "// Ceres Solver - A fast non-linear least squares minimizer\n// Copyright 2019 Google Inc. All rights reserved.\n// http:/"
},
{
"path": "3rdparty/ceres/include/ceres/conditioned_cost_function.h",
"chars": 4219,
"preview": "// Ceres Solver - A fast non-linear least squares minimizer\n// Copyright 2019 Google Inc. All rights reserved.\n// http:/"
},
{
"path": "3rdparty/ceres/include/ceres/context.h",
"chars": 2482,
"preview": "// Ceres Solver - A fast non-linear least squares minimizer\n// Copyright 2019 Google Inc. All rights reserved.\n// http:/"
},
{
"path": "3rdparty/ceres/include/ceres/cost_function.h",
"chars": 6361,
"preview": "// Ceres Solver - A fast non-linear least squares minimizer\n// Copyright 2019 Google Inc. All rights reserved.\n// http:/"
},
{
"path": "3rdparty/ceres/include/ceres/cost_function_to_functor.h",
"chars": 6902,
"preview": "// Ceres Solver - A fast non-linear least squares minimizer\n// Copyright 2019 Google Inc. All rights reserved.\n// http:/"
},
{
"path": "3rdparty/ceres/include/ceres/covariance.h",
"chars": 18731,
"preview": "// Ceres Solver - A fast non-linear least squares minimizer\n// Copyright 2019 Google Inc. All rights reserved.\n// http:/"
},
{
"path": "3rdparty/ceres/include/ceres/crs_matrix.h",
"chars": 3126,
"preview": "// Ceres Solver - A fast non-linear least squares minimizer\n// Copyright 2019 Google Inc. All rights reserved.\n// http:/"
},
{
"path": "3rdparty/ceres/include/ceres/cubic_interpolation.h",
"chars": 15722,
"preview": "// Ceres Solver - A fast non-linear least squares minimizer\n// Copyright 2019 Google Inc. All rights reserved.\n// http:/"
},
{
"path": "3rdparty/ceres/include/ceres/dynamic_autodiff_cost_function.h",
"chars": 10570,
"preview": "// Ceres Solver - A fast non-linear least squares minimizer\n// Copyright 2019 Google Inc. All rights reserved.\n// http:/"
},
{
"path": "3rdparty/ceres/include/ceres/dynamic_cost_function.h",
"chars": 2405,
"preview": "// Ceres Solver - A fast non-linear least squares minimizer\n// Copyright 2019 Google Inc. All rights reserved.\n// http:/"
},
{
"path": "3rdparty/ceres/include/ceres/dynamic_cost_function_to_functor.h",
"chars": 7661,
"preview": "// Ceres Solver - A fast non-linear least squares minimizer\n// Copyright 2019 Google Inc. All rights reserved.\n// http:/"
},
{
"path": "3rdparty/ceres/include/ceres/dynamic_numeric_diff_cost_function.h",
"chars": 6640,
"preview": "// Ceres Solver - A fast non-linear least squares minimizer\n// Copyright 2019 Google Inc. All rights reserved.\n// http:/"
},
{
"path": "3rdparty/ceres/include/ceres/evaluation_callback.h",
"chars": 4005,
"preview": "// Ceres Solver - A fast non-linear least squares minimizer\n// Copyright 2019 Google Inc. All rights reserved.\n// http:/"
},
{
"path": "3rdparty/ceres/include/ceres/first_order_function.h",
"chars": 2398,
"preview": "// Ceres Solver - A fast non-linear least squares minimizer\n// Copyright 2019 Google Inc. All rights reserved.\n// http:/"
},
{
"path": "3rdparty/ceres/include/ceres/gradient_checker.h",
"chars": 6491,
"preview": "// Ceres Solver - A fast non-linear least squares minimizer\n// Copyright 2019 Google Inc. All rights reserved.\n// http:/"
},
{
"path": "3rdparty/ceres/include/ceres/gradient_problem.h",
"chars": 4556,
"preview": "// Ceres Solver - A fast non-linear least squares minimizer\n// Copyright 2019 Google Inc. All rights reserved.\n// http:/"
},
{
"path": "3rdparty/ceres/include/ceres/gradient_problem_solver.h",
"chars": 14870,
"preview": "// Ceres Solver - A fast non-linear least squares minimizer\n// Copyright 2019 Google Inc. All rights reserved.\n// http:/"
},
{
"path": "3rdparty/ceres/include/ceres/internal/algorithm.h",
"chars": 4484,
"preview": "// Copyright 2017 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
},
{
"path": "3rdparty/ceres/include/ceres/internal/array_selector.h",
"chars": 3788,
"preview": "// Ceres Solver - A fast non-linear least squares minimizer\n// Copyright 2020 Google Inc. All rights reserved.\n// http:/"
},
{
"path": "3rdparty/ceres/include/ceres/internal/autodiff.h",
"chars": 14676,
"preview": "// Ceres Solver - A fast non-linear least squares minimizer\n// Copyright 2019 Google Inc. All rights reserved.\n// http:/"
},
{
"path": "3rdparty/ceres/include/ceres/internal/config.h",
"chars": 3855,
"preview": "// Ceres Solver - A fast non-linear least squares minimizer\n// Copyright 2015 Google Inc. All rights reserved.\n// http:/"
},
{
"path": "3rdparty/ceres/include/ceres/internal/disable_warnings.h",
"chars": 2208,
"preview": "// Ceres Solver - A fast non-linear least squares minimizer\n// Copyright 2015 Google Inc. All rights reserved.\n// http:/"
},
{
"path": "3rdparty/ceres/include/ceres/internal/eigen.h",
"chars": 3425,
"preview": "// Ceres Solver - A fast non-linear least squares minimizer\n// Copyright 2015 Google Inc. All rights reserved.\n// http:/"
},
{
"path": "3rdparty/ceres/include/ceres/internal/fixed_array.h",
"chars": 17340,
"preview": "// Copyright 2018 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
},
{
"path": "3rdparty/ceres/include/ceres/internal/householder_vector.h",
"chars": 3400,
"preview": "// Ceres Solver - A fast non-linear least squares minimizer\n// Copyright 2015 Google Inc. All rights reserved.\n// http:/"
},
{
"path": "3rdparty/ceres/include/ceres/internal/integer_sequence.h",
"chars": 4368,
"preview": "// Ceres Solver - A fast non-linear least squares minimizer\n// Copyright 2018 Google Inc. All rights reserved.\n// http:/"
},
{
"path": "3rdparty/ceres/include/ceres/internal/integer_sequence_algorithm.h",
"chars": 6382,
"preview": "// Ceres Solver - A fast non-linear least squares minimizer\n// Copyright 2018 Google Inc. All rights reserved.\n// http:/"
},
{
"path": "3rdparty/ceres/include/ceres/internal/line_parameterization.h",
"chars": 7044,
"preview": "// Ceres Solver - A fast non-linear least squares minimizer\n// Copyright 2020 Google Inc. All rights reserved.\n// http:/"
},
{
"path": "3rdparty/ceres/include/ceres/internal/memory.h",
"chars": 2941,
"preview": "// Copyright 2017 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
},
{
"path": "3rdparty/ceres/include/ceres/internal/numeric_diff.h",
"chars": 20890,
"preview": "// Ceres Solver - A fast non-linear least squares minimizer\n// Copyright 2015 Google Inc. All rights reserved.\n// http:/"
},
{
"path": "3rdparty/ceres/include/ceres/internal/parameter_dims.h",
"chars": 5136,
"preview": "// Ceres Solver - A fast non-linear least squares minimizer\n// Copyright 2018 Google Inc. All rights reserved.\n// http:/"
},
{
"path": "3rdparty/ceres/include/ceres/internal/port.h",
"chars": 4147,
"preview": "// Ceres Solver - A fast non-linear least squares minimizer\n// Copyright 2015 Google Inc. All rights reserved.\n// http:/"
},
{
"path": "3rdparty/ceres/include/ceres/internal/reenable_warnings.h",
"chars": 1844,
"preview": "// Ceres Solver - A fast non-linear least squares minimizer\n// Copyright 2015 Google Inc. All rights reserved.\n// http:/"
},
{
"path": "3rdparty/ceres/include/ceres/internal/variadic_evaluate.h",
"chars": 4946,
"preview": "// Ceres Solver - A fast non-linear least squares minimizer\n// Copyright 2015 Google Inc. All rights reserved.\n// http:/"
},
{
"path": "3rdparty/ceres/include/ceres/iteration_callback.h",
"chars": 8118,
"preview": "// Ceres Solver - A fast non-linear least squares minimizer\n// Copyright 2019 Google Inc. All rights reserved.\n// http:/"
},
{
"path": "3rdparty/ceres/include/ceres/jet.h",
"chars": 33099,
"preview": "// Ceres Solver - A fast non-linear least squares minimizer\n// Copyright 2019 Google Inc. All rights reserved.\n// http:/"
},
{
"path": "3rdparty/ceres/include/ceres/local_parameterization.h",
"chars": 14698,
"preview": "// Ceres Solver - A fast non-linear least squares minimizer\n// Copyright 2019 Google Inc. All rights reserved.\n// http:/"
},
{
"path": "3rdparty/ceres/include/ceres/loss_function.h",
"chars": 14713,
"preview": "// Ceres Solver - A fast non-linear least squares minimizer\n// Copyright 2019 Google Inc. All rights reserved.\n// http:/"
},
{
"path": "3rdparty/ceres/include/ceres/normal_prior.h",
"chars": 3147,
"preview": "// Ceres Solver - A fast non-linear least squares minimizer\n// Copyright 2019 Google Inc. All rights reserved.\n// http:/"
},
{
"path": "3rdparty/ceres/include/ceres/numeric_diff_cost_function.h",
"chars": 11123,
"preview": "// Ceres Solver - A fast non-linear least squares minimizer\n// Copyright 2019 Google Inc. All rights reserved.\n// http:/"
},
{
"path": "3rdparty/ceres/include/ceres/numeric_diff_options.h",
"chars": 3388,
"preview": "// Ceres Solver - A fast non-linear least squares minimizer\n// Copyright 2019 Google Inc. All rights reserved.\n// http:/"
},
{
"path": "3rdparty/ceres/include/ceres/ordered_groups.h",
"chars": 6450,
"preview": "// Ceres Solver - A fast non-linear least squares minimizer\n// Copyright 2019 Google Inc. All rights reserved.\n// http:/"
},
{
"path": "3rdparty/ceres/include/ceres/problem.h",
"chars": 24386,
"preview": "// Ceres Solver - A fast non-linear least squares minimizer\n// Copyright 2015 Google Inc. All rights reserved.\n// http:/"
},
{
"path": "3rdparty/ceres/include/ceres/rotation.h",
"chars": 23862,
"preview": "// Ceres Solver - A fast non-linear least squares minimizer\n// Copyright 2019 Google Inc. All rights reserved.\n// http:/"
},
{
"path": "3rdparty/ceres/include/ceres/sized_cost_function.h",
"chars": 3068,
"preview": "// Ceres Solver - A fast non-linear least squares minimizer\n// Copyright 2019 Google Inc. All rights reserved.\n// http:/"
},
{
"path": "3rdparty/ceres/include/ceres/solver.h",
"chars": 46604,
"preview": "// Ceres Solver - A fast non-linear least squares minimizer\n// Copyright 2019 Google Inc. All rights reserved.\n// http:/"
},
{
"path": "3rdparty/ceres/include/ceres/tiny_solver.h",
"chars": 13430,
"preview": "// Ceres Solver - A fast non-linear least squares minimizer\n// Copyright 2019 Google Inc. All rights reserved.\n// http:/"
},
{
"path": "3rdparty/ceres/include/ceres/tiny_solver_autodiff_function.h",
"chars": 7866,
"preview": "// Ceres Solver - A fast non-linear least squares minimizer\n// Copyright 2019 Google Inc. All rights reserved.\n// http:/"
},
{
"path": "3rdparty/ceres/include/ceres/tiny_solver_cost_function_adapter.h",
"chars": 5537,
"preview": "// Ceres Solver - A fast non-linear least squares minimizer\n// Copyright 2019 Google Inc. All rights reserved.\n// http:/"
},
{
"path": "3rdparty/ceres/include/ceres/types.h",
"chars": 20555,
"preview": "// Ceres Solver - A fast non-linear least squares minimizer\n// Copyright 2019 Google Inc. All rights reserved.\n// http:/"
},
{
"path": "3rdparty/ceres/include/ceres/version.h",
"chars": 2377,
"preview": "// Ceres Solver - A fast non-linear least squares minimizer\n// Copyright 2019 Google Inc. All rights reserved.\n// http:/"
},
{
"path": "3rdparty/ceres/internal/ceres/CMakeLists.txt",
"chars": 19874,
"preview": "# Ceres Solver - A fast non-linear least squares minimizer\n# Copyright 2015 Google Inc. All rights reserved.\n# http://ce"
},
{
"path": "3rdparty/ceres/internal/ceres/accelerate_sparse.cc",
"chars": 11151,
"preview": "// Ceres Solver - A fast non-linear least squares minimizer\n// Copyright 2018 Google Inc. All rights reserved.\n// http:/"
},
{
"path": "3rdparty/ceres/internal/ceres/accelerate_sparse.h",
"chars": 5969,
"preview": "// Ceres Solver - A fast non-linear least squares minimizer\n// Copyright 2018 Google Inc. All rights reserved.\n// http:/"
},
{
"path": "3rdparty/ceres/internal/ceres/algorithm_test.cc",
"chars": 5268,
"preview": "// Copyright 2017 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
},
{
"path": "3rdparty/ceres/internal/ceres/array_selector_test.cc",
"chars": 3185,
"preview": "// Ceres Solver - A fast non-linear least squares minimizer\n// Copyright 2020 Google Inc. All rights reserved.\n// http:/"
},
{
"path": "3rdparty/ceres/internal/ceres/array_utils.cc",
"chars": 3510,
"preview": "// Ceres Solver - A fast non-linear least squares minimizer\n// Copyright 2015 Google Inc. All rights reserved.\n// http:/"
},
{
"path": "3rdparty/ceres/internal/ceres/array_utils.h",
"chars": 3664,
"preview": "// Ceres Solver - A fast non-linear least squares minimizer\n// Copyright 2015 Google Inc. All rights reserved.\n// http:/"
},
{
"path": "3rdparty/ceres/internal/ceres/array_utils_test.cc",
"chars": 4090,
"preview": "// Ceres Solver - A fast non-linear least squares minimizer\n// Copyright 2015 Google Inc. All rights reserved.\n// http:/"
},
{
"path": "3rdparty/ceres/internal/ceres/autodiff_benchmarks/CMakeLists.txt",
"chars": 694,
"preview": "# TODO: Add support for other compilers\nif(CMAKE_CXX_COMPILER_ID MATCHES \"Clang\")\n list(APPEND CERES_BENCHMARK_FLAGS \"-"
},
{
"path": "3rdparty/ceres/internal/ceres/autodiff_benchmarks/autodiff_benchmarks.cc",
"chars": 13497,
"preview": "// Ceres Solver - A fast non-linear least squares minimizer\n// Copyright 2020 Google Inc. All rights reserved.\n// http:/"
},
{
"path": "3rdparty/ceres/internal/ceres/autodiff_benchmarks/brdf_cost_function.h",
"chars": 7802,
"preview": "// Ceres Solver - A fast non-linear least squares minimizer\n// Copyright 2020 Google Inc. All rights reserved.\n// http:/"
},
{
"path": "3rdparty/ceres/internal/ceres/autodiff_benchmarks/constant_cost_function.h",
"chars": 2578,
"preview": "// Ceres Solver - A fast non-linear least squares minimizer\n// Copyright 2020 Google Inc. All rights reserved.\n// http:/"
},
{
"path": "3rdparty/ceres/internal/ceres/autodiff_benchmarks/linear_cost_functions.h",
"chars": 2352,
"preview": "// Ceres Solver - A fast non-linear least squares minimizer\n// Copyright 2020 Google Inc. All rights reserved.\n// http:/"
},
{
"path": "3rdparty/ceres/internal/ceres/autodiff_benchmarks/photometric_error.h",
"chars": 8064,
"preview": "// Ceres Solver - A fast non-linear least squares minimizer\n// Copyright 2020 Google Inc. All rights reserved.\n// http:/"
},
{
"path": "3rdparty/ceres/internal/ceres/autodiff_benchmarks/relative_pose_error.h",
"chars": 3843,
"preview": "// Ceres Solver - A fast non-linear least squares minimizer\n// Copyright 2020 Google Inc. All rights reserved.\n// http:/"
},
{
"path": "3rdparty/ceres/internal/ceres/autodiff_benchmarks/snavely_reprojection_error.h",
"chars": 3473,
"preview": "// Ceres Solver - A fast non-linear least squares minimizer\n// Copyright 2020 Google Inc. All rights reserved.\n// http:/"
},
{
"path": "3rdparty/ceres/internal/ceres/autodiff_cost_function_test.cc",
"chars": 5438,
"preview": "// Ceres Solver - A fast non-linear least squares minimizer\n// Copyright 2019 Google Inc. All rights reserved.\n// http:/"
},
{
"path": "3rdparty/ceres/internal/ceres/autodiff_first_order_function_test.cc",
"chars": 2846,
"preview": "// Ceres Solver - A fast non-linear least squares minimizer\n// Copyright 2019 Google Inc. All rights reserved.\n// http:/"
},
{
"path": "3rdparty/ceres/internal/ceres/autodiff_local_parameterization_test.cc",
"chars": 7432,
"preview": "// Ceres Solver - A fast non-linear least squares minimizer\n// Copyright 2015 Google Inc. All rights reserved.\n// http:/"
},
{
"path": "3rdparty/ceres/internal/ceres/autodiff_test.cc",
"chars": 19672,
"preview": "// Ceres Solver - A fast non-linear least squares minimizer\n// Copyright 2015 Google Inc. All rights reserved.\n// http:/"
},
{
"path": "3rdparty/ceres/internal/ceres/benchmarks/macbook-pro-2014-small_blas_gemm_benchmark.json",
"chars": 114882,
"preview": "{\n \"context\": {\n \"date\": \"2018-03-23 13:15:00\",\n \"num_cpus\": 8,\n \"mhz_per_cpu\": 2200,\n \"cpu_scaling_enabled"
},
{
"path": "3rdparty/ceres/internal/ceres/benchmarks/macbook-pro-2014-small_blas_gemv_benchmark.json",
"chars": 17141,
"preview": "{\n \"context\": {\n \"date\": \"2018-03-23 13:34:44\",\n \"num_cpus\": 8,\n \"mhz_per_cpu\": 2200,\n \"cpu_scaling_enabled"
},
{
"path": "3rdparty/ceres/internal/ceres/blas.cc",
"chars": 2999,
"preview": "// Ceres Solver - A fast non-linear least squares minimizer\n// Copyright 2015 Google Inc. All rights reserved.\n// http:/"
},
{
"path": "3rdparty/ceres/internal/ceres/blas.h",
"chars": 2439,
"preview": "// Ceres Solver - A fast non-linear least squares minimizer\n// Copyright 2015 Google Inc. All rights reserved.\n// http:/"
},
{
"path": "3rdparty/ceres/internal/ceres/block_evaluate_preparer.cc",
"chars": 3624,
"preview": "// Ceres Solver - A fast non-linear least squares minimizer\n// Copyright 2015 Google Inc. All rights reserved.\n// http:/"
},
{
"path": "3rdparty/ceres/internal/ceres/block_evaluate_preparer.h",
"chars": 3262,
"preview": "// Ceres Solver - A fast non-linear least squares minimizer\n// Copyright 2015 Google Inc. All rights reserved.\n// http:/"
},
{
"path": "3rdparty/ceres/internal/ceres/block_jacobi_preconditioner.cc",
"chars": 4241,
"preview": "// Ceres Solver - A fast non-linear least squares minimizer\n// Copyright 2015 Google Inc. All rights reserved.\n// http:/"
},
{
"path": "3rdparty/ceres/internal/ceres/block_jacobi_preconditioner.h",
"chars": 3461,
"preview": "// Ceres Solver - A fast non-linear least squares minimizer\n// Copyright 2015 Google Inc. All rights reserved.\n// http:/"
},
{
"path": "3rdparty/ceres/internal/ceres/block_jacobi_preconditioner_test.cc",
"chars": 4218,
"preview": "// Ceres Solver - A fast non-linear least squares minimizer\n// Copyright 2015 Google Inc. All rights reserved.\n// http:/"
},
{
"path": "3rdparty/ceres/internal/ceres/block_jacobian_writer.cc",
"chars": 8546,
"preview": "// Ceres Solver - A fast non-linear least squares minimizer\n// Copyright 2015 Google Inc. All rights reserved.\n// http:/"
},
{
"path": "3rdparty/ceres/internal/ceres/block_jacobian_writer.h",
"chars": 5282,
"preview": "// Ceres Solver - A fast non-linear least squares minimizer\n// Copyright 2015 Google Inc. All rights reserved.\n// http:/"
},
{
"path": "3rdparty/ceres/internal/ceres/block_random_access_dense_matrix.cc",
"chars": 3446,
"preview": "// Ceres Solver - A fast non-linear least squares minimizer\n// Copyright 2015 Google Inc. All rights reserved.\n// http:/"
},
{
"path": "3rdparty/ceres/internal/ceres/block_random_access_dense_matrix.h",
"chars": 3916,
"preview": "// Ceres Solver - A fast non-linear least squares minimizer\n// Copyright 2015 Google Inc. All rights reserved.\n// http:/"
},
{
"path": "3rdparty/ceres/internal/ceres/block_random_access_dense_matrix_test.cc",
"chars": 3990,
"preview": "// Ceres Solver - A fast non-linear least squares minimizer\n// Copyright 2015 Google Inc. All rights reserved.\n// http:/"
},
{
"path": "3rdparty/ceres/internal/ceres/block_random_access_diagonal_matrix.cc",
"chars": 5486,
"preview": "// Ceres Solver - A fast non-linear least squares minimizer\n// Copyright 2015 Google Inc. All rights reserved.\n// http:/"
},
{
"path": "3rdparty/ceres/internal/ceres/block_random_access_diagonal_matrix.h",
"chars": 3900,
"preview": "// Ceres Solver - A fast non-linear least squares minimizer\n// Copyright 2015 Google Inc. All rights reserved.\n// http:/"
},
{
"path": "3rdparty/ceres/internal/ceres/block_random_access_diagonal_matrix_test.cc",
"chars": 5526,
"preview": "// Ceres Solver - A fast non-linear least squares minimizer\n// Copyright 2015 Google Inc. All rights reserved.\n// http:/"
},
{
"path": "3rdparty/ceres/internal/ceres/block_random_access_matrix.cc",
"chars": 1880,
"preview": "// Ceres Solver - A fast non-linear least squares minimizer\n// Copyright 2015 Google Inc. All rights reserved.\n// http:/"
},
{
"path": "3rdparty/ceres/internal/ceres/block_random_access_matrix.h",
"chars": 5185,
"preview": "// Ceres Solver - A fast non-linear least squares minimizer\n// Copyright 2015 Google Inc. All rights reserved.\n// http:/"
},
{
"path": "3rdparty/ceres/internal/ceres/block_random_access_sparse_matrix.cc",
"chars": 6961,
"preview": "// Ceres Solver - A fast non-linear least squares minimizer\n// Copyright 2015 Google Inc. All rights reserved.\n// http:/"
},
{
"path": "3rdparty/ceres/internal/ceres/block_random_access_sparse_matrix.h",
"chars": 5075,
"preview": "// Ceres Solver - A fast non-linear least squares minimizer\n// Copyright 2015 Google Inc. All rights reserved.\n// http:/"
},
{
"path": "3rdparty/ceres/internal/ceres/block_random_access_sparse_matrix_test.cc",
"chars": 6402,
"preview": "// Ceres Solver - A fast non-linear least squares minimizer\n// Copyright 2015 Google Inc. All rights reserved.\n// http:/"
},
{
"path": "3rdparty/ceres/internal/ceres/block_sparse_matrix.cc",
"chars": 15526,
"preview": "// Ceres Solver - A fast non-linear least squares minimizer\n// Copyright 2015 Google Inc. All rights reserved.\n// http:/"
},
{
"path": "3rdparty/ceres/internal/ceres/block_sparse_matrix.h",
"chars": 6303,
"preview": "// Ceres Solver - A fast non-linear least squares minimizer\n// Copyright 2015 Google Inc. All rights reserved.\n// http:/"
},
{
"path": "3rdparty/ceres/internal/ceres/block_sparse_matrix_test.cc",
"chars": 7616,
"preview": "// Ceres Solver - A fast non-linear least squares minimizer\n// Copyright 2015 Google Inc. All rights reserved.\n// http:/"
},
{
"path": "3rdparty/ceres/internal/ceres/block_structure.cc",
"chars": 1994,
"preview": "// Ceres Solver - A fast non-linear least squares minimizer\n// Copyright 2015 Google Inc. All rights reserved.\n// http:/"
},
{
"path": "3rdparty/ceres/internal/ceres/block_structure.h",
"chars": 3506,
"preview": "// Ceres Solver - A fast non-linear least squares minimizer\n// Copyright 2015 Google Inc. All rights reserved.\n// http:/"
},
{
"path": "3rdparty/ceres/internal/ceres/bundle_adjustment_test_util.h",
"chars": 8506,
"preview": "// Ceres Solver - A fast non-linear least squares minimizer\n// Copyright 2018 Google Inc. All rights reserved.\n// http:/"
},
{
"path": "3rdparty/ceres/internal/ceres/c_api.cc",
"chars": 6932,
"preview": "// Ceres Solver - A fast non-linear least squares minimizer\n// Copyright 2015 Google Inc. All rights reserved.\n// http:/"
},
{
"path": "3rdparty/ceres/internal/ceres/c_api_test.cc",
"chars": 7046,
"preview": "// Ceres Solver - A fast non-linear least squares minimizer\n// Copyright 2015 Google Inc. All rights reserved.\n// http:/"
},
{
"path": "3rdparty/ceres/internal/ceres/callbacks.cc",
"chars": 5298,
"preview": "// Ceres Solver - A fast non-linear least squares minimizer\n// Copyright 2015 Google Inc. All rights reserved.\n// http:/"
},
{
"path": "3rdparty/ceres/internal/ceres/callbacks.h",
"chars": 3454,
"preview": "// Ceres Solver - A fast non-linear least squares minimizer\n// Copyright 2015 Google Inc. All rights reserved.\n// http:/"
},
{
"path": "3rdparty/ceres/internal/ceres/canonical_views_clustering.cc",
"chars": 8404,
"preview": "// Ceres Solver - A fast non-linear least squares minimizer\n// Copyright 2015 Google Inc. All rights reserved.\n// http:/"
},
{
"path": "3rdparty/ceres/internal/ceres/canonical_views_clustering.h",
"chars": 5207,
"preview": "// Ceres Solver - A fast non-linear least squares minimizer\n// Copyright 2015 Google Inc. All rights reserved.\n// http:/"
},
{
"path": "3rdparty/ceres/internal/ceres/canonical_views_clustering_test.cc",
"chars": 4945,
"preview": "// Ceres Solver - A fast non-linear least squares minimizer\n// Copyright 2015 Google Inc. All rights reserved.\n// http:/"
},
{
"path": "3rdparty/ceres/internal/ceres/casts.h",
"chars": 4582,
"preview": "// Ceres Solver - A fast non-linear least squares minimizer\n// Copyright 2015 Google Inc. All rights reserved.\n// http:/"
},
{
"path": "3rdparty/ceres/internal/ceres/cgnr_linear_operator.h",
"chars": 3920,
"preview": "// Ceres Solver - A fast non-linear least squares minimizer\n// Copyright 2015 Google Inc. All rights reserved.\n// http:/"
},
{
"path": "3rdparty/ceres/internal/ceres/cgnr_solver.cc",
"chars": 4337,
"preview": "// Ceres Solver - A fast non-linear least squares minimizer\n// Copyright 2015 Google Inc. All rights reserved.\n// http:/"
},
{
"path": "3rdparty/ceres/internal/ceres/cgnr_solver.h",
"chars": 2753,
"preview": "// Ceres Solver - A fast non-linear least squares minimizer\n// Copyright 2015 Google Inc. All rights reserved.\n// http:/"
},
{
"path": "3rdparty/ceres/internal/ceres/compressed_col_sparse_matrix_utils.cc",
"chars": 5017,
"preview": "// Ceres Solver - A fast non-linear least squares minimizer\n// Copyright 2015 Google Inc. All rights reserved.\n// http:/"
},
{
"path": "3rdparty/ceres/internal/ceres/compressed_col_sparse_matrix_utils.h",
"chars": 5924,
"preview": "// Ceres Solver - A fast non-linear least squares minimizer\n// Copyright 2015 Google Inc. All rights reserved.\n// http:/"
},
{
"path": "3rdparty/ceres/internal/ceres/compressed_col_sparse_matrix_utils_test.cc",
"chars": 8688,
"preview": "// Ceres Solver - A fast non-linear least squares minimizer\n// Copyright 2015 Google Inc. All rights reserved.\n// http:/"
},
{
"path": "3rdparty/ceres/internal/ceres/compressed_row_jacobian_writer.cc",
"chars": 10068,
"preview": "// Ceres Solver - A fast non-linear least squares minimizer\n// Copyright 2015 Google Inc. All rights reserved.\n// http:/"
},
{
"path": "3rdparty/ceres/internal/ceres/compressed_row_jacobian_writer.h",
"chars": 4628,
"preview": "// Ceres Solver - A fast non-linear least squares minimizer\n// Copyright 2015 Google Inc. All rights reserved.\n// http:/"
},
{
"path": "3rdparty/ceres/internal/ceres/compressed_row_sparse_matrix.cc",
"chars": 25006,
"preview": "// Ceres Solver - A fast non-linear least squares minimizer\n// Copyright 2017 Google Inc. All rights reserved.\n// http:/"
},
{
"path": "3rdparty/ceres/internal/ceres/compressed_row_sparse_matrix.h",
"chars": 8925,
"preview": "// Ceres Solver - A fast non-linear least squares minimizer\n// Copyright 2015 Google Inc. All rights reserved.\n// http:/"
},
{
"path": "3rdparty/ceres/internal/ceres/compressed_row_sparse_matrix_test.cc",
"chars": 19371,
"preview": "// Ceres Solver - A fast non-linear least squares minimizer\n// Copyright 2015 Google Inc. All rights reserved.\n// http:/"
},
{
"path": "3rdparty/ceres/internal/ceres/concurrent_queue.h",
"chars": 5573,
"preview": "// Ceres Solver - A fast non-linear least squares minimizer\n// Copyright 2018 Google Inc. All rights reserved.\n// http:/"
},
{
"path": "3rdparty/ceres/internal/ceres/concurrent_queue_test.cc",
"chars": 7791,
"preview": "// Ceres Solver - A fast non-linear least squares minimizer\n// Copyright 2018 Google Inc. All rights reserved.\n// http:/"
},
{
"path": "3rdparty/ceres/internal/ceres/conditioned_cost_function.cc",
"chars": 5179,
"preview": "// Ceres Solver - A fast non-linear least squares minimizer\n// Copyright 2015 Google Inc. All rights reserved.\n// http:/"
},
{
"path": "3rdparty/ceres/internal/ceres/conditioned_cost_function_test.cc",
"chars": 5190,
"preview": "// Ceres Solver - A fast non-linear least squares minimizer\n// Copyright 2015 Google Inc. All rights reserved.\n// http:/"
},
{
"path": "3rdparty/ceres/internal/ceres/conjugate_gradients_solver.cc",
"chars": 8311,
"preview": "// Ceres Solver - A fast non-linear least squares minimizer\n// Copyright 2015 Google Inc. All rights reserved.\n// http:/"
},
{
"path": "3rdparty/ceres/internal/ceres/conjugate_gradients_solver.h",
"chars": 3190,
"preview": "// Ceres Solver - A fast non-linear least squares minimizer\n// Copyright 2015 Google Inc. All rights reserved.\n// http:/"
},
{
"path": "3rdparty/ceres/internal/ceres/conjugate_gradients_solver_test.cc",
"chars": 4115,
"preview": "// Ceres Solver - A fast non-linear least squares minimizer\n// Copyright 2017 Google Inc. All rights reserved.\n// http:/"
},
{
"path": "3rdparty/ceres/internal/ceres/context.cc",
"chars": 1852,
"preview": "// Ceres Solver - A fast non-linear least squares minimizer\n// Copyright 2018 Google Inc. All rights reserved.\n// http:/"
},
{
"path": "3rdparty/ceres/internal/ceres/context_impl.cc",
"chars": 1962,
"preview": "// Ceres Solver - A fast non-linear least squares minimizer\n// Copyright 2018 Google Inc. All rights reserved.\n// http:/"
}
]
// ... and 2158 more files (download for full content)
About this extraction
This page contains the full source code of the OpenCalib/JointCalib GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 2358 files (24.7 MB), approximately 6.6M tokens, and a symbol index with 13034 extracted functions, classes, methods, constants, and types. Use this with OpenClaw, Claude, ChatGPT, Cursor, Windsurf, or any other AI tool that accepts text input. You can copy the full output to your clipboard or download it as a .txt file.
Extracted by GitExtract — free GitHub repo to text converter for AI. Built by Nikandr Surkov.