Copy disabled (too large)
Download .txt
Showing preview only (106,565K chars total). Download the full file to get everything.
Repository: jchengai/gpir
Branch: main
Commit: 1bed4d500a5d
Files: 5806
Total size: 136.6 MB
Directory structure:
gitextract_p9zhc6xs/
├── .gitmodules
├── LICENSE
├── README.md
├── common/
│ ├── .gitignore
│ ├── CMakeLists.txt
│ ├── base/
│ │ ├── state.h
│ │ ├── trajectory.h
│ │ └── type.h
│ ├── cmake/
│ │ └── FindGlog.cmake
│ ├── frenet/
│ │ ├── CMakeLists.txt
│ │ ├── frenet_state.h
│ │ ├── frenet_transform.cc
│ │ └── frenet_transform.h
│ ├── geometry/
│ │ ├── CMakeLists.txt
│ │ ├── box2d.cc
│ │ └── box2d.h
│ ├── graph/
│ │ └── dijkstra.hpp
│ ├── package.xml
│ ├── smoothing/
│ │ ├── CMakeLists.txt
│ │ ├── LICENSE
│ │ ├── README.md
│ │ ├── affine_constraint.cc
│ │ ├── affine_constraint.h
│ │ ├── discrete_points_math.cc
│ │ ├── discrete_points_math.h
│ │ ├── osqp_spline1d_solver.cc
│ │ ├── osqp_spline1d_solver.h
│ │ ├── osqp_spline2d_solver.cc
│ │ ├── osqp_spline2d_solver.h
│ │ ├── polynomialxd.cc
│ │ ├── polynomialxd.h
│ │ ├── spline1d.cc
│ │ ├── spline1d.h
│ │ ├── spline1d_constraint.cc
│ │ ├── spline1d_constraint.h
│ │ ├── spline1d_kernel.cc
│ │ ├── spline1d_kernel.h
│ │ ├── spline1d_kernel_helper.cc
│ │ ├── spline1d_kernel_helper.h
│ │ ├── spline1d_seg.cc
│ │ ├── spline1d_seg.h
│ │ ├── spline1d_solver.h
│ │ ├── spline2d.cc
│ │ ├── spline2d.h
│ │ ├── spline2d_constraint.cc
│ │ ├── spline2d_constraint.h
│ │ ├── spline2d_kernel.cc
│ │ ├── spline2d_kernel.h
│ │ ├── spline2d_seg.cc
│ │ ├── spline2d_seg.h
│ │ └── spline2d_solver.h
│ ├── solver/
│ │ ├── CMakeLists.txt
│ │ └── osqp/
│ │ ├── osqp_interface.cc
│ │ ├── osqp_interface.h
│ │ └── osqp_sparse_matrix.h
│ ├── thirdparty/
│ │ └── osqp/
│ │ ├── .bumpversion.cfg
│ │ ├── .editorconfig
│ │ ├── .gitattributes
│ │ ├── .gitignore
│ │ ├── .gitmodules
│ │ ├── .travis.yml
│ │ ├── .valgrind-suppress.supp
│ │ ├── CHANGELOG.md
│ │ ├── CMakeLists.txt
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── README.md
│ │ ├── ROADMAP.md
│ │ ├── appveyor.yml
│ │ ├── ci/
│ │ │ ├── appveyor/
│ │ │ │ ├── deploy.cmd
│ │ │ │ ├── install.cmd
│ │ │ │ └── script.cmd
│ │ │ └── travis/
│ │ │ ├── deploy.sh
│ │ │ ├── docs.sh
│ │ │ ├── install.sh
│ │ │ └── script.sh
│ │ ├── configure/
│ │ │ ├── cmake/
│ │ │ │ ├── FindPythonModule.cmake
│ │ │ │ ├── FindR.cmake
│ │ │ │ ├── Utils.cmake
│ │ │ │ └── cmake_uninstall.cmake.in
│ │ │ └── osqp_configure.h.in
│ │ ├── docs/
│ │ │ ├── Makefile
│ │ │ ├── _static/
│ │ │ │ └── css/
│ │ │ │ └── osqp_theme.css
│ │ │ ├── _templates/
│ │ │ │ └── layout.html
│ │ │ ├── citing/
│ │ │ │ └── index.rst
│ │ │ ├── codegen/
│ │ │ │ ├── index.rst
│ │ │ │ ├── matlab.rst
│ │ │ │ └── python.rst
│ │ │ ├── conf.py
│ │ │ ├── contributing/
│ │ │ │ └── index.rst
│ │ │ ├── doxygen.conf
│ │ │ ├── examples/
│ │ │ │ ├── huber.rst
│ │ │ │ ├── index.rst
│ │ │ │ ├── lasso.rst
│ │ │ │ ├── least-squares.rst
│ │ │ │ ├── mpc.rst
│ │ │ │ ├── portfolio.rst
│ │ │ │ ├── setup-and-solve.rst
│ │ │ │ ├── svm.rst
│ │ │ │ ├── update-matrices.rst
│ │ │ │ └── update-vectors.rst
│ │ │ ├── get_started/
│ │ │ │ ├── CC++.rst
│ │ │ │ ├── cutest.rst
│ │ │ │ ├── index.rst
│ │ │ │ ├── julia.rst
│ │ │ │ ├── linear_system_solvers.rst
│ │ │ │ ├── matlab.rst
│ │ │ │ ├── python.rst
│ │ │ │ ├── r.rst
│ │ │ │ └── sources.rst
│ │ │ ├── index.rst
│ │ │ ├── interfaces/
│ │ │ │ ├── CC++.rst
│ │ │ │ ├── cutest.rst
│ │ │ │ ├── eigen_google.rst
│ │ │ │ ├── eigen_robotology.rst
│ │ │ │ ├── fortran.rst
│ │ │ │ ├── index.rst
│ │ │ │ ├── julia.rst
│ │ │ │ ├── linear_systems_solvers.rst
│ │ │ │ ├── matlab.rst
│ │ │ │ ├── python.rst
│ │ │ │ ├── rlang.rst
│ │ │ │ ├── ruby.rst
│ │ │ │ ├── rust.rst
│ │ │ │ ├── solver_settings.rst
│ │ │ │ └── status_values.rst
│ │ │ ├── make.bat
│ │ │ ├── parsers/
│ │ │ │ ├── cvxpy.rst
│ │ │ │ ├── index.rst
│ │ │ │ ├── jump.rst
│ │ │ │ └── yalmip.rst
│ │ │ ├── requirements.txt
│ │ │ └── solver/
│ │ │ └── index.rst
│ │ ├── examples/
│ │ │ └── osqp_demo.c
│ │ ├── include/
│ │ │ ├── .gitignore
│ │ │ ├── CMakeLists.txt
│ │ │ ├── auxil.h
│ │ │ ├── constants.h
│ │ │ ├── cs.h
│ │ │ ├── ctrlc.h
│ │ │ ├── error.h
│ │ │ ├── glob_opts.h
│ │ │ ├── kkt.h
│ │ │ ├── lin_alg.h
│ │ │ ├── lin_sys.h
│ │ │ ├── osqp.h
│ │ │ ├── polish.h
│ │ │ ├── proj.h
│ │ │ ├── scaling.h
│ │ │ ├── types.h
│ │ │ └── util.h
│ │ ├── lin_sys/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── direct/
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── pardiso/
│ │ │ │ │ ├── CMakeLists.txt
│ │ │ │ │ ├── pardiso_interface.c
│ │ │ │ │ ├── pardiso_interface.h
│ │ │ │ │ ├── pardiso_loader.c
│ │ │ │ │ └── pardiso_loader.h
│ │ │ │ └── qdldl/
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── amd/
│ │ │ │ │ ├── LICENSE
│ │ │ │ │ ├── include/
│ │ │ │ │ │ ├── SuiteSparse_config.h
│ │ │ │ │ │ ├── amd.h
│ │ │ │ │ │ └── amd_internal.h
│ │ │ │ │ └── src/
│ │ │ │ │ ├── SuiteSparse_config.c
│ │ │ │ │ ├── amd_1.c
│ │ │ │ │ ├── amd_2.c
│ │ │ │ │ ├── amd_aat.c
│ │ │ │ │ ├── amd_control.c
│ │ │ │ │ ├── amd_defaults.c
│ │ │ │ │ ├── amd_info.c
│ │ │ │ │ ├── amd_order.c
│ │ │ │ │ ├── amd_post_tree.c
│ │ │ │ │ ├── amd_postorder.c
│ │ │ │ │ ├── amd_preprocess.c
│ │ │ │ │ └── amd_valid.c
│ │ │ │ ├── qdldl_interface.c
│ │ │ │ ├── qdldl_interface.h
│ │ │ │ └── qdldl_sources/
│ │ │ │ ├── .editorconfig
│ │ │ │ ├── .gitignore
│ │ │ │ ├── .travis.yml
│ │ │ │ ├── CHANGELOG.md
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── LICENSE
│ │ │ │ ├── README.md
│ │ │ │ ├── appveyor.yml
│ │ │ │ ├── configure/
│ │ │ │ │ ├── cmake/
│ │ │ │ │ │ └── cmake_uninstall.cmake.in
│ │ │ │ │ └── qdldl_types.h.in
│ │ │ │ ├── examples/
│ │ │ │ │ └── example.c
│ │ │ │ ├── include/
│ │ │ │ │ ├── .gitignore
│ │ │ │ │ └── qdldl.h
│ │ │ │ ├── src/
│ │ │ │ │ └── qdldl.c
│ │ │ │ └── tests/
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── minunit.h
│ │ │ │ ├── qdldl_tester.c
│ │ │ │ ├── test_basic.h
│ │ │ │ ├── test_identity.h
│ │ │ │ ├── test_osqp_kkt.h
│ │ │ │ ├── test_rank_deficient.h
│ │ │ │ ├── test_singleton.h
│ │ │ │ ├── test_sym_structure.h
│ │ │ │ ├── test_tril_structure.h
│ │ │ │ ├── test_two_by_two.h
│ │ │ │ └── test_zero_on_diag.h
│ │ │ ├── lib_handler.c
│ │ │ └── lib_handler.h
│ │ ├── src/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── auxil.c
│ │ │ ├── cs.c
│ │ │ ├── ctrlc.c
│ │ │ ├── error.c
│ │ │ ├── kkt.c
│ │ │ ├── lin_alg.c
│ │ │ ├── lin_sys.c
│ │ │ ├── osqp.c
│ │ │ ├── polish.c
│ │ │ ├── proj.c
│ │ │ ├── scaling.c
│ │ │ └── util.c
│ │ └── tests/
│ │ ├── .gitignore
│ │ ├── CMakeLists.txt
│ │ ├── README.md
│ │ ├── __init__.py
│ │ ├── basic_qp/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── __init__.py
│ │ │ ├── generate_problem.py
│ │ │ └── test_basic_qp.h
│ │ ├── basic_qp2/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── __init__.py
│ │ │ ├── generate_problem.py
│ │ │ └── test_basic_qp2.h
│ │ ├── custom_memory/
│ │ │ ├── custom_memory.c
│ │ │ └── custom_memory.h
│ │ ├── demo/
│ │ │ ├── CMakeLists.txt
│ │ │ └── test_demo.h
│ │ ├── generate_tests_data.py
│ │ ├── lin_alg/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── __init__.py
│ │ │ ├── generate_problem.py
│ │ │ └── test_lin_alg.h
│ │ ├── minunit.h
│ │ ├── non_cvx/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── __init__.py
│ │ │ ├── generate_problem.py
│ │ │ └── test_non_cvx.h
│ │ ├── osqp_tester.c
│ │ ├── osqp_tester.h
│ │ ├── primal_dual_infeasibility/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── __init__.py
│ │ │ ├── generate_problem.py
│ │ │ └── test_primal_dual_infeasibility.h
│ │ ├── primal_infeasibility/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── __init__.py
│ │ │ ├── generate_problem.py
│ │ │ └── test_primal_infeasibility.h
│ │ ├── solve_linsys/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── __init__.py
│ │ │ ├── generate_problem.py
│ │ │ └── test_solve_linsys.h
│ │ ├── unconstrained/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── __init__.py
│ │ │ ├── generate_problem.py
│ │ │ └── test_unconstrained.h
│ │ ├── update_matrices/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── __init__.py
│ │ │ ├── generate_problem.py
│ │ │ └── test_update_matrices.h
│ │ └── utils/
│ │ ├── __init__.py
│ │ └── codegen_utils.py
│ └── utils/
│ ├── CMakeLists.txt
│ ├── boxcar_filter.h
│ ├── color_map.cc
│ ├── color_map.h
│ ├── common_visual.cc
│ ├── common_visual.h
│ ├── contains.hpp
│ ├── io_utils.cc
│ ├── io_utils.h
│ ├── math.cc
│ ├── math.h
│ ├── stdout_color.h
│ ├── str_utils.h
│ └── timer.h
├── gp_planner/
│ ├── CMakeLists.txt
│ ├── gp/
│ │ ├── CMakeLists.txt
│ │ ├── factors/
│ │ │ ├── gp_interpolate_kappa_limit_factor.cc
│ │ │ ├── gp_interpolate_kappa_limit_factor.h
│ │ │ ├── gp_interpolate_obstacle_factor.cc
│ │ │ ├── gp_interpolate_obstacle_factor.h
│ │ │ ├── gp_kappa_limit_factor.cc
│ │ │ ├── gp_kappa_limit_factor.h
│ │ │ ├── gp_lat_acc_limit_factor.cc
│ │ │ ├── gp_lat_acc_limit_factor.h
│ │ │ ├── gp_obstacle_factor.cc
│ │ │ ├── gp_obstacle_factor.h
│ │ │ ├── gp_prior_factor.cc
│ │ │ └── gp_prior_factor.h
│ │ ├── gp_incremental_path_planner.cc
│ │ ├── gp_incremental_path_planner.h
│ │ ├── interpolator/
│ │ │ └── gp_interpolator.h
│ │ ├── model/
│ │ │ ├── white_noise_on_acceleration_model_1d.h
│ │ │ └── white_noise_on_jerk_model_1d.h
│ │ └── utils/
│ │ ├── bounded_penalty_function.h
│ │ ├── curvature_utils.h
│ │ ├── gp_path.cc
│ │ ├── gp_path.h
│ │ ├── gp_utils.cc
│ │ ├── gp_utils.h
│ │ └── penalty_function.h
│ ├── gp_planner.cc
│ ├── gp_planner.h
│ ├── initializer/
│ │ ├── CMakeLists.txt
│ │ ├── gp_initializer.cc
│ │ └── gp_initializer.h
│ ├── package.xml
│ ├── sdf/
│ │ ├── CMakeLists.txt
│ │ ├── grid_map_2d.cc
│ │ ├── grid_map_2d.h
│ │ ├── signed_distance_field_2d.cc
│ │ └── signed_distance_field_2d.h
│ ├── st_plan/
│ │ ├── CMakeLists.txt
│ │ ├── st_graph.cc
│ │ ├── st_graph.h
│ │ ├── st_node.cc
│ │ └── st_node.h
│ └── thirdparty/
│ └── gtsam-4.1rc/
│ ├── .cproject
│ ├── .gitignore
│ ├── .project
│ ├── .settings/
│ │ ├── .gitignore
│ │ └── org.eclipse.cdt.core.prefs
│ ├── CMakeLists.txt
│ ├── CppUnitLite/
│ │ ├── CMakeLists.txt
│ │ ├── Failure.h
│ │ ├── Test.cpp
│ │ ├── Test.h
│ │ ├── TestHarness.h
│ │ ├── TestRegistry.cpp
│ │ ├── TestRegistry.h
│ │ ├── TestResult.cpp
│ │ └── TestResult.h
│ ├── DEVELOP.md
│ ├── GTSAM-Concepts.md
│ ├── INSTALL.md
│ ├── LICENSE
│ ├── LICENSE.BSD
│ ├── README.md
│ ├── THANKS.md
│ ├── USAGE.md
│ ├── Using-GTSAM-EXPORT.md
│ ├── cmake/
│ │ ├── CMakeLists.txt
│ │ ├── Config.cmake.in
│ │ ├── FindBoost.cmake
│ │ ├── FindCython.cmake
│ │ ├── FindEigen3.cmake
│ │ ├── FindGooglePerfTools.cmake
│ │ ├── FindMKL.cmake
│ │ ├── FindNumPy.cmake
│ │ ├── FindTBB.cmake
│ │ ├── GTSAMCMakeToolsConfig.cmake
│ │ ├── GtsamAddPch.cmake
│ │ ├── GtsamBuildTypes.cmake
│ │ ├── GtsamMakeConfigFile.cmake
│ │ ├── GtsamMatlabWrap.cmake
│ │ ├── GtsamPrinting.cmake
│ │ ├── GtsamTesting.cmake
│ │ ├── README.html
│ │ ├── README.md
│ │ ├── cmake_uninstall.cmake.in
│ │ ├── dllexport.h.in
│ │ ├── example_cmake_find_gtsam/
│ │ │ ├── CMakeLists.txt
│ │ │ └── main.cpp
│ │ ├── example_project/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── README.md
│ │ │ ├── SayGoodbye.cpp
│ │ │ ├── SayHello.cpp
│ │ │ ├── example/
│ │ │ │ ├── PrintExamples.cpp
│ │ │ │ └── PrintExamples.h
│ │ │ ├── example.h
│ │ │ └── tests/
│ │ │ └── testExample.cpp
│ │ └── obsolete/
│ │ ├── FindCppUnitLite.cmake
│ │ ├── FindWrap.cmake
│ │ └── GtsamTestingObsolete.cmake
│ ├── gtsam/
│ │ ├── 3rdparty/
│ │ │ ├── CCOLAMD/
│ │ │ │ ├── Demo/
│ │ │ │ │ ├── Makefile
│ │ │ │ │ ├── ccolamd_example.c
│ │ │ │ │ ├── ccolamd_example.out
│ │ │ │ │ ├── ccolamd_l_example.c
│ │ │ │ │ └── ccolamd_l_example.out
│ │ │ │ ├── Doc/
│ │ │ │ │ ├── ChangeLog
│ │ │ │ │ ├── License.txt
│ │ │ │ │ └── lesser.txt
│ │ │ │ ├── Include/
│ │ │ │ │ └── ccolamd.h
│ │ │ │ ├── Lib/
│ │ │ │ │ └── Makefile
│ │ │ │ ├── MATLAB/
│ │ │ │ │ ├── Contents.m
│ │ │ │ │ ├── ccolamd.m
│ │ │ │ │ ├── ccolamd_demo.m
│ │ │ │ │ ├── ccolamd_install.m
│ │ │ │ │ ├── ccolamd_make.m
│ │ │ │ │ ├── ccolamd_test.m
│ │ │ │ │ ├── ccolamdmex.c
│ │ │ │ │ ├── ccolamdtestmex.c
│ │ │ │ │ ├── ccolamdtestmex.m
│ │ │ │ │ ├── csymamd.m
│ │ │ │ │ ├── csymamdmex.c
│ │ │ │ │ ├── csymamdtestmex.c
│ │ │ │ │ ├── csymamdtestmex.m
│ │ │ │ │ └── luflops.m
│ │ │ │ ├── Makefile
│ │ │ │ ├── README.txt
│ │ │ │ └── Source/
│ │ │ │ └── ccolamd.c
│ │ │ ├── CMakeLists.txt
│ │ │ ├── Eigen/
│ │ │ │ ├── .hgeol
│ │ │ │ ├── .hgignore
│ │ │ │ ├── .hgtags
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── COPYING.BSD
│ │ │ │ ├── COPYING.GPL
│ │ │ │ ├── COPYING.LGPL
│ │ │ │ ├── COPYING.MINPACK
│ │ │ │ ├── COPYING.MPL2
│ │ │ │ ├── COPYING.README
│ │ │ │ ├── CTestConfig.cmake
│ │ │ │ ├── CTestCustom.cmake.in
│ │ │ │ ├── Eigen/
│ │ │ │ │ ├── CMakeLists.txt
│ │ │ │ │ ├── Cholesky
│ │ │ │ │ ├── CholmodSupport
│ │ │ │ │ ├── Core
│ │ │ │ │ ├── Dense
│ │ │ │ │ ├── Eigen
│ │ │ │ │ ├── Eigenvalues
│ │ │ │ │ ├── Geometry
│ │ │ │ │ ├── Householder
│ │ │ │ │ ├── IterativeLinearSolvers
│ │ │ │ │ ├── Jacobi
│ │ │ │ │ ├── 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/
│ │ │ │ │ │ ├── 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
│ │ │ │ │ │ ├── Inverse.h
│ │ │ │ │ │ ├── Map.h
│ │ │ │ │ │ ├── MapBase.h
│ │ │ │ │ │ ├── MathFunctions.h
│ │ │ │ │ │ ├── MathFunctionsImpl.h
│ │ │ │ │ │ ├── Matrix.h
│ │ │ │ │ │ ├── MatrixBase.h
│ │ │ │ │ │ ├── NestByValue.h
│ │ │ │ │ │ ├── NoAlias.h
│ │ │ │ │ │ ├── NumTraits.h
│ │ │ │ │ │ ├── PermutationMatrix.h
│ │ │ │ │ │ ├── PlainObjectBase.h
│ │ │ │ │ │ ├── Product.h
│ │ │ │ │ │ ├── ProductEvaluators.h
│ │ │ │ │ │ ├── Random.h
│ │ │ │ │ │ ├── Redux.h
│ │ │ │ │ │ ├── Ref.h
│ │ │ │ │ │ ├── Replicate.h
│ │ │ │ │ │ ├── ReturnByValue.h
│ │ │ │ │ │ ├── Reverse.h
│ │ │ │ │ │ ├── Select.h
│ │ │ │ │ │ ├── SelfAdjointView.h
│ │ │ │ │ │ ├── SelfCwiseBinaryOp.h
│ │ │ │ │ │ ├── Solve.h
│ │ │ │ │ │ ├── SolveTriangular.h
│ │ │ │ │ │ ├── SolverBase.h
│ │ │ │ │ │ ├── StableNorm.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/
│ │ │ │ │ │ │ │ ├── MathFunctions.h
│ │ │ │ │ │ │ │ └── PacketMath.h
│ │ │ │ │ │ │ ├── AltiVec/
│ │ │ │ │ │ │ │ ├── Complex.h
│ │ │ │ │ │ │ │ ├── MathFunctions.h
│ │ │ │ │ │ │ │ └── PacketMath.h
│ │ │ │ │ │ │ ├── CUDA/
│ │ │ │ │ │ │ │ ├── Complex.h
│ │ │ │ │ │ │ │ ├── Half.h
│ │ │ │ │ │ │ │ ├── MathFunctions.h
│ │ │ │ │ │ │ │ ├── PacketMath.h
│ │ │ │ │ │ │ │ ├── PacketMathHalf.h
│ │ │ │ │ │ │ │ └── TypeCasting.h
│ │ │ │ │ │ │ ├── Default/
│ │ │ │ │ │ │ │ ├── ConjHelper.h
│ │ │ │ │ │ │ │ └── Settings.h
│ │ │ │ │ │ │ ├── NEON/
│ │ │ │ │ │ │ │ ├── Complex.h
│ │ │ │ │ │ │ │ ├── MathFunctions.h
│ │ │ │ │ │ │ │ └── PacketMath.h
│ │ │ │ │ │ │ ├── SSE/
│ │ │ │ │ │ │ │ ├── Complex.h
│ │ │ │ │ │ │ │ ├── MathFunctions.h
│ │ │ │ │ │ │ │ ├── PacketMath.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
│ │ │ │ │ │ ├── Constants.h
│ │ │ │ │ │ ├── DisableStupidWarnings.h
│ │ │ │ │ │ ├── ForwardDeclarations.h
│ │ │ │ │ │ ├── MKL_support.h
│ │ │ │ │ │ ├── Macros.h
│ │ │ │ │ │ ├── Memory.h
│ │ │ │ │ │ ├── Meta.h
│ │ │ │ │ │ ├── NonMPL2.h
│ │ │ │ │ │ ├── ReenableStupidWarnings.h
│ │ │ │ │ │ ├── StaticAssert.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
│ │ │ │ │ ├── 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
│ │ │ │ │ ├── MatrixCwiseBinaryOps.h
│ │ │ │ │ └── MatrixCwiseUnaryOps.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/
│ │ │ │ │ │ └── gemm/
│ │ │ │ │ │ ├── changesets.txt
│ │ │ │ │ │ ├── gemm.cpp
│ │ │ │ │ │ ├── gemm_settings.txt
│ │ │ │ │ │ ├── lazy_gemm.cpp
│ │ │ │ │ │ ├── lazy_gemm_settings.txt
│ │ │ │ │ │ ├── make_plot.sh
│ │ │ │ │ │ └── run.sh
│ │ │ │ │ ├── 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
│ │ │ │ │ │ ├── tensor_benchmarks.h
│ │ │ │ │ │ ├── tensor_benchmarks_cpu.cc
│ │ │ │ │ │ ├── tensor_benchmarks_fp16_gpu.cu
│ │ │ │ │ │ ├── tensor_benchmarks_gpu.cu
│ │ │ │ │ │ └── tensor_benchmarks_sycl.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
│ │ │ │ │ ├── FindLAPACK.cmake
│ │ │ │ │ ├── FindMPFR.cmake
│ │ │ │ │ ├── FindMetis.cmake
│ │ │ │ │ ├── FindPTSCOTCH.cmake
│ │ │ │ │ ├── FindPastix.cmake
│ │ │ │ │ ├── FindSPQR.cmake
│ │ │ │ │ ├── FindScotch.cmake
│ │ │ │ │ ├── FindStandardMathLibrary.cmake
│ │ │ │ │ ├── FindSuperLU.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/
│ │ │ │ │ ├── A05_PortingFrom2To3.dox
│ │ │ │ │ ├── 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
│ │ │ │ │ ├── TutorialReshapeSlicing.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_FixedVectorBlock.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
│ │ │ │ │ │ ├── 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_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.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_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_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_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
│ │ │ │ │ │ ├── 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
│ │ │ │ │ │ ├── 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_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
│ │ │ │ │ │ ├── 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
│ │ │ │ │ ├── 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
│ │ │ │ │ ├── release.in
│ │ │ │ │ └── relicense.py
│ │ │ │ ├── signature_of_eigen3_matrix_library
│ │ │ │ ├── test/
│ │ │ │ │ ├── CMakeLists.txt
│ │ │ │ │ ├── adjoint.cpp
│ │ │ │ │ ├── array.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
│ │ │ │ │ ├── cuda_basic.cu
│ │ │ │ │ ├── cuda_common.h
│ │ │ │ │ ├── denseLM.cpp
│ │ │ │ │ ├── dense_storage.cpp
│ │ │ │ │ ├── determinant.cpp
│ │ │ │ │ ├── diagonal.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
│ │ │ │ │ ├── half_float.cpp
│ │ │ │ │ ├── hessenberg.cpp
│ │ │ │ │ ├── householder.cpp
│ │ │ │ │ ├── incomplete_cholesky.cpp
│ │ │ │ │ ├── inplace_decomposition.cpp
│ │ │ │ │ ├── integer_types.cpp
│ │ │ │ │ ├── inverse.cpp
│ │ │ │ │ ├── is_same_dense.cpp
│ │ │ │ │ ├── jacobi.cpp
│ │ │ │ │ ├── jacobisvd.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
│ │ │ │ │ ├── nesting_ops.cpp
│ │ │ │ │ ├── nomalloc.cpp
│ │ │ │ │ ├── nullary.cpp
│ │ │ │ │ ├── numext.cpp
│ │ │ │ │ ├── packetmath.cpp
│ │ │ │ │ ├── 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
│ │ │ │ │ ├── resize.cpp
│ │ │ │ │ ├── rvalue_types.cpp
│ │ │ │ │ ├── schur_complex.cpp
│ │ │ │ │ ├── schur_real.cpp
│ │ │ │ │ ├── selfadjoint.cpp
│ │ │ │ │ ├── simplicial_cholesky.cpp
│ │ │ │ │ ├── sizeof.cpp
│ │ │ │ │ ├── sizeoverflow.cpp
│ │ │ │ │ ├── smallvectors.cpp
│ │ │ │ │ ├── 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
│ │ │ │ │ ├── spqr_support.cpp
│ │ │ │ │ ├── stable_norm.cpp
│ │ │ │ │ ├── stddeque.cpp
│ │ │ │ │ ├── stddeque_overload.cpp
│ │ │ │ │ ├── stdlist.cpp
│ │ │ │ │ ├── stdlist_overload.cpp
│ │ │ │ │ ├── stdvector.cpp
│ │ │ │ │ ├── stdvector_overload.cpp
│ │ │ │ │ ├── superlu_support.cpp
│ │ │ │ │ ├── svd_common.h
│ │ │ │ │ ├── svd_fill.h
│ │ │ │ │ ├── swap.cpp
│ │ │ │ │ ├── triangular.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
│ │ │ │ │ │ │ ├── TensorBroadcasting.h
│ │ │ │ │ │ │ ├── TensorChipping.h
│ │ │ │ │ │ │ ├── TensorConcatenation.h
│ │ │ │ │ │ │ ├── TensorContraction.h
│ │ │ │ │ │ │ ├── TensorContractionBlocking.h
│ │ │ │ │ │ │ ├── TensorContractionCuda.h
│ │ │ │ │ │ │ ├── TensorContractionMapper.h
│ │ │ │ │ │ │ ├── TensorContractionThreadPool.h
│ │ │ │ │ │ │ ├── TensorConversion.h
│ │ │ │ │ │ │ ├── TensorConvolution.h
│ │ │ │ │ │ │ ├── TensorCostModel.h
│ │ │ │ │ │ │ ├── TensorCustomOp.h
│ │ │ │ │ │ │ ├── TensorDevice.h
│ │ │ │ │ │ │ ├── TensorDeviceCuda.h
│ │ │ │ │ │ │ ├── TensorDeviceDefault.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
│ │ │ │ │ │ │ ├── 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
│ │ │ │ │ │ │ ├── TensorReductionSycl.h
│ │ │ │ │ │ │ ├── TensorRef.h
│ │ │ │ │ │ │ ├── TensorReverse.h
│ │ │ │ │ │ │ ├── TensorScan.h
│ │ │ │ │ │ │ ├── TensorShuffling.h
│ │ │ │ │ │ │ ├── TensorStorage.h
│ │ │ │ │ │ │ ├── TensorStriding.h
│ │ │ │ │ │ │ ├── TensorSycl.h
│ │ │ │ │ │ │ ├── TensorSyclConvertToDeviceExpression.h
│ │ │ │ │ │ │ ├── TensorSyclExprConstructor.h
│ │ │ │ │ │ │ ├── TensorSyclExtractAccessor.h
│ │ │ │ │ │ │ ├── TensorSyclExtractFunctors.h
│ │ │ │ │ │ │ ├── TensorSyclLeafCount.h
│ │ │ │ │ │ │ ├── TensorSyclPlaceHolderExpr.h
│ │ │ │ │ │ │ ├── TensorSyclRun.h
│ │ │ │ │ │ │ ├── TensorSyclTuple.h
│ │ │ │ │ │ │ ├── TensorTraits.h
│ │ │ │ │ │ │ ├── TensorUInt128.h
│ │ │ │ │ │ │ └── TensorVolumePatch.h
│ │ │ │ │ │ ├── TensorSymmetry/
│ │ │ │ │ │ │ ├── DynamicSymmetry.h
│ │ │ │ │ │ │ ├── StaticSymmetry.h
│ │ │ │ │ │ │ ├── Symmetry.h
│ │ │ │ │ │ │ └── util/
│ │ │ │ │ │ │ └── TemplateGroupTheory.h
│ │ │ │ │ │ ├── ThreadPool/
│ │ │ │ │ │ │ ├── EventCount.h
│ │ │ │ │ │ │ ├── NonBlockingThreadPool.h
│ │ │ │ │ │ │ ├── RunQueue.h
│ │ │ │ │ │ │ ├── SimpleThreadPool.h
│ │ │ │ │ │ │ ├── ThreadEnvironment.h
│ │ │ │ │ │ │ ├── ThreadLocal.h
│ │ │ │ │ │ │ ├── ThreadPoolInterface.h
│ │ │ │ │ │ │ └── ThreadYield.h
│ │ │ │ │ │ └── util/
│ │ │ │ │ │ ├── CXX11Meta.h
│ │ │ │ │ │ ├── CXX11Workarounds.h
│ │ │ │ │ │ ├── EmulateArray.h
│ │ │ │ │ │ ├── EmulateCXX11Meta.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/
│ │ │ │ │ │ ├── SpecialFunctionsArrayAPI.h
│ │ │ │ │ │ ├── SpecialFunctionsFunctors.h
│ │ │ │ │ │ ├── SpecialFunctionsHalf.h
│ │ │ │ │ │ ├── SpecialFunctionsImpl.h
│ │ │ │ │ │ ├── SpecialFunctionsPacketMath.h
│ │ │ │ │ │ └── arch/
│ │ │ │ │ │ └── CUDA/
│ │ │ │ │ │ └── CudaSpecialFunctions.h
│ │ │ │ │ └── Splines/
│ │ │ │ │ ├── Spline.h
│ │ │ │ │ ├── SplineFitting.h
│ │ │ │ │ └── SplineFwd.h
│ │ │ │ ├── README.txt
│ │ │ │ ├── bench/
│ │ │ │ │ └── bench_svd.cpp
│ │ │ │ ├── doc/
│ │ │ │ │ ├── CMakeLists.txt
│ │ │ │ │ ├── Overview.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
│ │ │ │ │ └── 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
│ │ │ │ ├── cxx11_eventcount.cpp
│ │ │ │ ├── cxx11_meta.cpp
│ │ │ │ ├── cxx11_non_blocking_thread_pool.cpp
│ │ │ │ ├── cxx11_runqueue.cpp
│ │ │ │ ├── cxx11_tensor_argmax.cpp
│ │ │ │ ├── cxx11_tensor_argmax_cuda.cu
│ │ │ │ ├── cxx11_tensor_assign.cpp
│ │ │ │ ├── cxx11_tensor_broadcast_sycl.cpp
│ │ │ │ ├── cxx11_tensor_broadcasting.cpp
│ │ │ │ ├── cxx11_tensor_cast_float16_cuda.cu
│ │ │ │ ├── cxx11_tensor_casts.cpp
│ │ │ │ ├── cxx11_tensor_chipping.cpp
│ │ │ │ ├── cxx11_tensor_comparisons.cpp
│ │ │ │ ├── cxx11_tensor_complex_cuda.cu
│ │ │ │ ├── cxx11_tensor_complex_cwise_ops_cuda.cu
│ │ │ │ ├── cxx11_tensor_concatenation.cpp
│ │ │ │ ├── cxx11_tensor_const.cpp
│ │ │ │ ├── cxx11_tensor_contract_cuda.cu
│ │ │ │ ├── cxx11_tensor_contraction.cpp
│ │ │ │ ├── cxx11_tensor_convolution.cpp
│ │ │ │ ├── cxx11_tensor_cuda.cu
│ │ │ │ ├── cxx11_tensor_custom_index.cpp
│ │ │ │ ├── cxx11_tensor_custom_op.cpp
│ │ │ │ ├── cxx11_tensor_device.cu
│ │ │ │ ├── cxx11_tensor_device_sycl.cpp
│ │ │ │ ├── cxx11_tensor_dimension.cpp
│ │ │ │ ├── cxx11_tensor_empty.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_ifft.cpp
│ │ │ │ ├── cxx11_tensor_image_patch.cpp
│ │ │ │ ├── cxx11_tensor_index_list.cpp
│ │ │ │ ├── cxx11_tensor_inflation.cpp
│ │ │ │ ├── cxx11_tensor_intdiv.cpp
│ │ │ │ ├── cxx11_tensor_io.cpp
│ │ │ │ ├── cxx11_tensor_layout_swap.cpp
│ │ │ │ ├── cxx11_tensor_lvalue.cpp
│ │ │ │ ├── cxx11_tensor_map.cpp
│ │ │ │ ├── cxx11_tensor_math.cpp
│ │ │ │ ├── cxx11_tensor_mixed_indices.cpp
│ │ │ │ ├── cxx11_tensor_morphing.cpp
│ │ │ │ ├── cxx11_tensor_notification.cpp
│ │ │ │ ├── cxx11_tensor_of_complex.cpp
│ │ │ │ ├── cxx11_tensor_of_const_values.cpp
│ │ │ │ ├── cxx11_tensor_of_float16_cuda.cu
│ │ │ │ ├── cxx11_tensor_of_strings.cpp
│ │ │ │ ├── cxx11_tensor_padding.cpp
│ │ │ │ ├── cxx11_tensor_patch.cpp
│ │ │ │ ├── cxx11_tensor_random.cpp
│ │ │ │ ├── cxx11_tensor_random_cuda.cu
│ │ │ │ ├── cxx11_tensor_reduction.cpp
│ │ │ │ ├── cxx11_tensor_reduction_cuda.cu
│ │ │ │ ├── cxx11_tensor_reduction_sycl.cpp
│ │ │ │ ├── cxx11_tensor_ref.cpp
│ │ │ │ ├── cxx11_tensor_reverse.cpp
│ │ │ │ ├── cxx11_tensor_roundings.cpp
│ │ │ │ ├── cxx11_tensor_scan.cpp
│ │ │ │ ├── cxx11_tensor_scan_cuda.cu
│ │ │ │ ├── cxx11_tensor_shuffling.cpp
│ │ │ │ ├── cxx11_tensor_simple.cpp
│ │ │ │ ├── cxx11_tensor_striding.cpp
│ │ │ │ ├── cxx11_tensor_sugar.cpp
│ │ │ │ ├── cxx11_tensor_sycl.cpp
│ │ │ │ ├── cxx11_tensor_symmetry.cpp
│ │ │ │ ├── cxx11_tensor_thread_pool.cpp
│ │ │ │ ├── cxx11_tensor_uint128.cpp
│ │ │ │ ├── cxx11_tensor_volume_patch.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
│ │ │ │ └── splines.cpp
│ │ │ ├── GeographicLib/
│ │ │ │ ├── 00README.txt
│ │ │ │ ├── AUTHORS
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── INSTALL
│ │ │ │ ├── LICENSE.txt
│ │ │ │ ├── Makefile
│ │ │ │ ├── Makefile.am
│ │ │ │ ├── Makefile.in
│ │ │ │ ├── Makefile.mk
│ │ │ │ ├── NEWS
│ │ │ │ ├── README.md
│ │ │ │ ├── aclocal.m4
│ │ │ │ ├── cmake/
│ │ │ │ │ ├── CMakeLists.txt
│ │ │ │ │ ├── FindGeographicLib.cmake
│ │ │ │ │ ├── Makefile.am
│ │ │ │ │ ├── Makefile.in
│ │ │ │ │ ├── Makefile.mk
│ │ │ │ │ ├── project-config-version.cmake.in
│ │ │ │ │ ├── project-config.cmake.in
│ │ │ │ │ └── project.pc.in
│ │ │ │ ├── compile
│ │ │ │ ├── config.guess
│ │ │ │ ├── config.sub
│ │ │ │ ├── configure
│ │ │ │ ├── configure.ac
│ │ │ │ ├── depcomp
│ │ │ │ ├── doc/
│ │ │ │ │ ├── CMakeLists.txt
│ │ │ │ │ ├── GeographicLib.dox.in
│ │ │ │ │ ├── Makefile.am
│ │ │ │ │ ├── Makefile.in
│ │ │ │ │ ├── Makefile.mk
│ │ │ │ │ ├── NETGeographicLib.dox
│ │ │ │ │ ├── doxyfile-c.in
│ │ │ │ │ ├── doxyfile-for.in
│ │ │ │ │ ├── doxyfile-net.in
│ │ │ │ │ ├── doxyfile.in
│ │ │ │ │ ├── geodesic-c.dox
│ │ │ │ │ ├── geodesic-for.dox
│ │ │ │ │ ├── geodseries30.html
│ │ │ │ │ ├── index.html.in
│ │ │ │ │ ├── tmseries30.html
│ │ │ │ │ └── utilities.html.in
│ │ │ │ ├── dotnet/
│ │ │ │ │ ├── NETGeographicLib/
│ │ │ │ │ │ ├── Accumulator.cpp
│ │ │ │ │ │ ├── Accumulator.h
│ │ │ │ │ │ ├── AlbersEqualArea.cpp
│ │ │ │ │ │ ├── AlbersEqualArea.h
│ │ │ │ │ │ ├── AssemblyInfo.cpp
│ │ │ │ │ │ ├── AzimuthalEquidistant.cpp
│ │ │ │ │ │ ├── AzimuthalEquidistant.h
│ │ │ │ │ │ ├── CMakeLists.txt
│ │ │ │ │ │ ├── CassiniSoldner.cpp
│ │ │ │ │ │ ├── CassiniSoldner.h
│ │ │ │ │ │ ├── CircularEngine.cpp
│ │ │ │ │ │ ├── CircularEngine.h
│ │ │ │ │ │ ├── DMS.cpp
│ │ │ │ │ │ ├── DMS.h
│ │ │ │ │ │ ├── Ellipsoid.cpp
│ │ │ │ │ │ ├── Ellipsoid.h
│ │ │ │ │ │ ├── EllipticFunction.cpp
│ │ │ │ │ │ ├── EllipticFunction.h
│ │ │ │ │ │ ├── GARS.cpp
│ │ │ │ │ │ ├── GARS.h
│ │ │ │ │ │ ├── GeoCoords.cpp
│ │ │ │ │ │ ├── GeoCoords.h
│ │ │ │ │ │ ├── Geocentric.cpp
│ │ │ │ │ │ ├── Geocentric.h
│ │ │ │ │ │ ├── Geodesic.cpp
│ │ │ │ │ │ ├── Geodesic.h
│ │ │ │ │ │ ├── GeodesicExact.cpp
│ │ │ │ │ │ ├── GeodesicExact.h
│ │ │ │ │ │ ├── GeodesicLine.cpp
│ │ │ │ │ │ ├── GeodesicLine.h
│ │ │ │ │ │ ├── GeodesicLineExact.cpp
│ │ │ │ │ │ ├── GeodesicLineExact.h
│ │ │ │ │ │ ├── Geohash.cpp
│ │ │ │ │ │ ├── Geohash.h
│ │ │ │ │ │ ├── Geoid.cpp
│ │ │ │ │ │ ├── Geoid.h
│ │ │ │ │ │ ├── Georef.cpp
│ │ │ │ │ │ ├── Georef.h
│ │ │ │ │ │ ├── Gnomonic.cpp
│ │ │ │ │ │ ├── Gnomonic.h
│ │ │ │ │ │ ├── GravityCircle.cpp
│ │ │ │ │ │ ├── GravityCircle.h
│ │ │ │ │ │ ├── GravityModel.cpp
│ │ │ │ │ │ ├── GravityModel.h
│ │ │ │ │ │ ├── LambertConformalConic.cpp
│ │ │ │ │ │ ├── LambertConformalConic.h
│ │ │ │ │ │ ├── LocalCartesian.cpp
│ │ │ │ │ │ ├── LocalCartesian.h
│ │ │ │ │ │ ├── MGRS.cpp
│ │ │ │ │ │ ├── MGRS.h
│ │ │ │ │ │ ├── MagneticCircle.cpp
│ │ │ │ │ │ ├── MagneticCircle.h
│ │ │ │ │ │ ├── MagneticModel.cpp
│ │ │ │ │ │ ├── MagneticModel.h
│ │ │ │ │ │ ├── NETGeographicLib.cpp
│ │ │ │ │ │ ├── NETGeographicLib.h
│ │ │ │ │ │ ├── NormalGravity.cpp
│ │ │ │ │ │ ├── NormalGravity.h
│ │ │ │ │ │ ├── OSGB.cpp
│ │ │ │ │ │ ├── OSGB.h
│ │ │ │ │ │ ├── PolarStereographic.cpp
│ │ │ │ │ │ ├── PolarStereographic.h
│ │ │ │ │ │ ├── PolygonArea.cpp
│ │ │ │ │ │ ├── PolygonArea.h
│ │ │ │ │ │ ├── ReadMe.txt
│ │ │ │ │ │ ├── Rhumb.cpp
│ │ │ │ │ │ ├── Rhumb.h
│ │ │ │ │ │ ├── SphericalCoefficients.cpp
│ │ │ │ │ │ ├── SphericalCoefficients.h
│ │ │ │ │ │ ├── SphericalHarmonic.cpp
│ │ │ │ │ │ ├── SphericalHarmonic.h
│ │ │ │ │ │ ├── SphericalHarmonic1.cpp
│ │ │ │ │ │ ├── SphericalHarmonic1.h
│ │ │ │ │ │ ├── SphericalHarmonic2.cpp
│ │ │ │ │ │ ├── SphericalHarmonic2.h
│ │ │ │ │ │ ├── TransverseMercator.cpp
│ │ │ │ │ │ ├── TransverseMercator.h
│ │ │ │ │ │ ├── TransverseMercatorExact.cpp
│ │ │ │ │ │ ├── TransverseMercatorExact.h
│ │ │ │ │ │ ├── UTMUPS.cpp
│ │ │ │ │ │ ├── UTMUPS.h
│ │ │ │ │ │ ├── stdafx.cpp
│ │ │ │ │ │ └── stdafx.h
│ │ │ │ │ ├── Projections/
│ │ │ │ │ │ ├── AccumPanel.Designer.cs
│ │ │ │ │ │ ├── AccumPanel.cs
│ │ │ │ │ │ ├── AccumPanel.resx
│ │ │ │ │ │ ├── AlbersPanel.Designer.cs
│ │ │ │ │ │ ├── AlbersPanel.cs
│ │ │ │ │ │ ├── AlbersPanel.resx
│ │ │ │ │ │ ├── EllipsoidPanel.Designer.cs
│ │ │ │ │ │ ├── EllipsoidPanel.cs
│ │ │ │ │ │ ├── EllipsoidPanel.resx
│ │ │ │ │ │ ├── EllipticPanel.Designer.cs
│ │ │ │ │ │ ├── EllipticPanel.cs
│ │ │ │ │ │ ├── EllipticPanel.resx
│ │ │ │ │ │ ├── Form1.Designer.cs
│ │ │ │ │ │ ├── Form1.cs
│ │ │ │ │ │ ├── Form1.resx
│ │ │ │ │ │ ├── GeocentricPanel.Designer.cs
│ │ │ │ │ │ ├── GeocentricPanel.cs
│ │ │ │ │ │ ├── GeocentricPanel.resx
│ │ │ │ │ │ ├── GeodesicPanel.Designer.cs
│ │ │ │ │ │ ├── GeodesicPanel.cs
│ │ │ │ │ │ ├── GeodesicPanel.resx
│ │ │ │ │ │ ├── GeoidPanel.Designer.cs
│ │ │ │ │ │ ├── GeoidPanel.cs
│ │ │ │ │ │ ├── GeoidPanel.resx
│ │ │ │ │ │ ├── GravityPanel.Designer.cs
│ │ │ │ │ │ ├── GravityPanel.cs
│ │ │ │ │ │ ├── GravityPanel.resx
│ │ │ │ │ │ ├── LocalCartesianPanel.Designer.cs
│ │ │ │ │ │ ├── LocalCartesianPanel.cs
│ │ │ │ │ │ ├── LocalCartesianPanel.resx
│ │ │ │ │ │ ├── MagneticPanel.Designer.cs
│ │ │ │ │ │ ├── MagneticPanel.cs
│ │ │ │ │ │ ├── MagneticPanel.resx
│ │ │ │ │ │ ├── MiscPanel.Designer.cs
│ │ │ │ │ │ ├── MiscPanel.cs
│ │ │ │ │ │ ├── MiscPanel.resx
│ │ │ │ │ │ ├── PolarStereoPanel.Designer.cs
│ │ │ │ │ │ ├── PolarStereoPanel.cs
│ │ │ │ │ │ ├── PolarStereoPanel.resx
│ │ │ │ │ │ ├── PolyPanel.Designer.cs
│ │ │ │ │ │ ├── PolyPanel.cs
│ │ │ │ │ │ ├── PolyPanel.resx
│ │ │ │ │ │ ├── Program.cs
│ │ │ │ │ │ ├── Projections-vs13.csproj
│ │ │ │ │ │ ├── Projections.csproj
│ │ │ │ │ │ ├── ProjectionsPanel.Designer.cs
│ │ │ │ │ │ ├── ProjectionsPanel.cs
│ │ │ │ │ │ ├── ProjectionsPanel.resx
│ │ │ │ │ │ ├── Properties/
│ │ │ │ │ │ │ ├── AssemblyInfo.cs
│ │ │ │ │ │ │ ├── Resources.Designer.cs
│ │ │ │ │ │ │ ├── Resources.resx
│ │ │ │ │ │ │ ├── Settings.Designer.cs
│ │ │ │ │ │ │ └── Settings.settings
│ │ │ │ │ │ ├── RhumbPanel.Designer.cs
│ │ │ │ │ │ ├── RhumbPanel.cs
│ │ │ │ │ │ ├── RhumbPanel.resx
│ │ │ │ │ │ ├── SphericalHarmonicsPanel.Designer.cs
│ │ │ │ │ │ ├── SphericalHarmonicsPanel.cs
│ │ │ │ │ │ ├── SphericalHarmonicsPanel.resx
│ │ │ │ │ │ ├── TypeIIIProjPanel.Designer.cs
│ │ │ │ │ │ ├── TypeIIIProjPanel.cs
│ │ │ │ │ │ └── TypeIIIProjPanel.resx
│ │ │ │ │ └── examples/
│ │ │ │ │ ├── CS/
│ │ │ │ │ │ ├── example-Accumulator.cs
│ │ │ │ │ │ ├── example-AlbersEqualArea.cs
│ │ │ │ │ │ ├── example-AzimuthalEquidistant.cs
│ │ │ │ │ │ ├── example-CassiniSoldner.cs
│ │ │ │ │ │ ├── example-CircularEngine.cs
│ │ │ │ │ │ ├── example-DMS.cs
│ │ │ │ │ │ ├── example-Ellipsoid.cs
│ │ │ │ │ │ ├── example-EllipticFunction.cs
│ │ │ │ │ │ ├── example-GARS.cs
│ │ │ │ │ │ ├── example-GeoCoords.cs
│ │ │ │ │ │ ├── example-Geocentric.cs
│ │ │ │ │ │ ├── example-Geodesic.cs
│ │ │ │ │ │ ├── example-GeodesicExact.cs
│ │ │ │ │ │ ├── example-GeodesicLine.cs
│ │ │ │ │ │ ├── example-GeodesicLineExact.cs
│ │ │ │ │ │ ├── example-Geohash.cs
│ │ │ │ │ │ ├── example-Geoid.cs
│ │ │ │ │ │ ├── example-Georef.cs
│ │ │ │ │ │ ├── example-Gnomonic.cs
│ │ │ │ │ │ ├── example-GravityCircle.cs
│ │ │ │ │ │ ├── example-GravityModel.cs
│ │ │ │ │ │ ├── example-LambertConformalConic.cs
│ │ │ │ │ │ ├── example-LocalCartesian.cs
│ │ │ │ │ │ ├── example-MGRS.cs
│ │ │ │ │ │ ├── example-MagneticCircle.cs
│ │ │ │ │ │ ├── example-MagneticModel.cs
│ │ │ │ │ │ ├── example-NormalGravity.cs
│ │ │ │ │ │ ├── example-OSGB.cs
│ │ │ │ │ │ ├── example-PolarStereographic.cs
│ │ │ │ │ │ ├── example-PolygonArea.cs
│ │ │ │ │ │ ├── example-Rhumb.cs
│ │ │ │ │ │ ├── example-RhumbLine.cs
│ │ │ │ │ │ ├── example-SphericalHarmonic.cs
│ │ │ │ │ │ ├── example-SphericalHarmonic1.cs
│ │ │ │ │ │ ├── example-SphericalHarmonic2.cs
│ │ │ │ │ │ ├── example-TransverseMercator.cs
│ │ │ │ │ │ ├── example-TransverseMercatorExact.cs
│ │ │ │ │ │ └── example-UTMUPS.cs
│ │ │ │ │ ├── ManagedCPP/
│ │ │ │ │ │ ├── CMakeLists.txt
│ │ │ │ │ │ ├── example-Accumulator.cpp
│ │ │ │ │ │ ├── example-AlbersEqualArea.cpp
│ │ │ │ │ │ ├── example-AzimuthalEquidistant.cpp
│ │ │ │ │ │ ├── example-CassiniSoldner.cpp
│ │ │ │ │ │ ├── example-CircularEngine.cpp
│ │ │ │ │ │ ├── example-DMS.cpp
│ │ │ │ │ │ ├── example-Ellipsoid.cpp
│ │ │ │ │ │ ├── example-EllipticFunction.cpp
│ │ │ │ │ │ ├── example-GARS.cpp
│ │ │ │ │ │ ├── example-GeoCoords.cpp
│ │ │ │ │ │ ├── example-Geocentric.cpp
│ │ │ │ │ │ ├── example-Geodesic-small.cpp
│ │ │ │ │ │ ├── example-Geodesic.cpp
│ │ │ │ │ │ ├── example-GeodesicExact.cpp
│ │ │ │ │ │ ├── example-GeodesicLine.cpp
│ │ │ │ │ │ ├── example-GeodesicLineExact.cpp
│ │ │ │ │ │ ├── example-Geohash.cpp
│ │ │ │ │ │ ├── example-Geoid.cpp
│ │ │ │ │ │ ├── example-Georef.cpp
│ │ │ │ │ │ ├── example-Gnomonic.cpp
│ │ │ │ │ │ ├── example-GravityCircle.cpp
│ │ │ │ │ │ ├── example-GravityModel.cpp
│ │ │ │ │ │ ├── example-LambertConformalConic.cpp
│ │ │ │ │ │ ├── example-LocalCartesian.cpp
│ │ │ │ │ │ ├── example-MGRS.cpp
│ │ │ │ │ │ ├── example-MagneticCircle.cpp
│ │ │ │ │ │ ├── example-MagneticModel.cpp
│ │ │ │ │ │ ├── example-NormalGravity.cpp
│ │ │ │ │ │ ├── example-OSGB.cpp
│ │ │ │ │ │ ├── example-PolarStereographic.cpp
│ │ │ │ │ │ ├── example-PolygonArea.cpp
│ │ │ │ │ │ ├── example-Rhumb.cpp
│ │ │ │ │ │ ├── example-RhumbLine.cpp
│ │ │ │ │ │ ├── example-SphericalHarmonic.cpp
│ │ │ │ │ │ ├── example-SphericalHarmonic1.cpp
│ │ │ │ │ │ ├── example-SphericalHarmonic2.cpp
│ │ │ │ │ │ ├── example-TransverseMercator.cpp
│ │ │ │ │ │ ├── example-TransverseMercatorExact.cpp
│ │ │ │ │ │ └── example-UTMUPS.cpp
│ │ │ │ │ └── VB/
│ │ │ │ │ ├── example-Accumulator.vb
│ │ │ │ │ ├── example-AlbersEqualArea.vb
│ │ │ │ │ ├── example-AzimuthalEquidistant.vb
│ │ │ │ │ ├── example-CassiniSoldner.vb
│ │ │ │ │ ├── example-CircularEngine.vb
│ │ │ │ │ ├── example-DMS.vb
│ │ │ │ │ ├── example-Ellipsoid.vb
│ │ │ │ │ ├── example-EllipticFunction.vb
│ │ │ │ │ ├── example-GARS.vb
│ │ │ │ │ ├── example-GeoCoords.vb
│ │ │ │ │ ├── example-Geocentric.vb
│ │ │ │ │ ├── example-Geodesic.vb
│ │ │ │ │ ├── example-GeodesicExact.vb
│ │ │ │ │ ├── example-GeodesicLine.vb
│ │ │ │ │ ├── example-GeodesicLineExact.vb
│ │ │ │ │ ├── example-Geohash.vb
│ │ │ │ │ ├── example-Geoid.vb
│ │ │ │ │ ├── example-Georef.vb
│ │ │ │ │ ├── example-Gnomonic.vb
│ │ │ │ │ ├── example-GravityCircle.vb
│ │ │ │ │ ├── example-GravityModel.vb
│ │ │ │ │ ├── example-LambertConformalConic.vb
│ │ │ │ │ ├── example-LocalCartesian.vb
│ │ │ │ │ ├── example-MGRS.vb
│ │ │ │ │ ├── example-MagneticCircle.vb
│ │ │ │ │ ├── example-MagneticModel.vb
│ │ │ │ │ ├── example-NormalGravity.vb
│ │ │ │ │ ├── example-OSGB.vb
│ │ │ │ │ ├── example-PolarStereographic.vb
│ │ │ │ │ ├── example-PolygonArea.vb
│ │ │ │ │ ├── example-Rhumb.vb
│ │ │ │ │ ├── example-RhumbLine.vb
│ │ │ │ │ ├── example-SphericalHarmonic.vb
│ │ │ │ │ ├── example-SphericalHarmonic1.vb
│ │ │ │ │ ├── example-SphericalHarmonic2.vb
│ │ │ │ │ ├── example-TransverseMercator.vb
│ │ │ │ │ ├── example-TransverseMercatorExact.vb
│ │ │ │ │ └── example-UTMUPS.vb
│ │ │ │ ├── examples/
│ │ │ │ │ ├── CMakeLists.txt
│ │ │ │ │ ├── GeoidToGTX.cpp
│ │ │ │ │ ├── JacobiConformal.cpp
│ │ │ │ │ ├── JacobiConformal.hpp
│ │ │ │ │ ├── Makefile.am
│ │ │ │ │ ├── Makefile.in
│ │ │ │ │ ├── example-Accumulator.cpp
│ │ │ │ │ ├── example-AlbersEqualArea.cpp
│ │ │ │ │ ├── example-AzimuthalEquidistant.cpp
│ │ │ │ │ ├── example-CassiniSoldner.cpp
│ │ │ │ │ ├── example-CircularEngine.cpp
│ │ │ │ │ ├── example-Constants.cpp
│ │ │ │ │ ├── example-DMS.cpp
│ │ │ │ │ ├── example-Ellipsoid.cpp
│ │ │ │ │ ├── example-EllipticFunction.cpp
│ │ │ │ │ ├── example-GARS.cpp
│ │ │ │ │ ├── example-GeoCoords.cpp
│ │ │ │ │ ├── example-Geocentric.cpp
│ │ │ │ │ ├── example-Geodesic-small.cpp
│ │ │ │ │ ├── example-Geodesic.cpp
│ │ │ │ │ ├── example-GeodesicExact.cpp
│ │ │ │ │ ├── example-GeodesicLine.cpp
│ │ │ │ │ ├── example-GeodesicLineExact.cpp
│ │ │ │ │ ├── example-GeographicErr.cpp
│ │ │ │ │ ├── example-Geohash.cpp
│ │ │ │ │ ├── example-Geoid.cpp
│ │ │ │ │ ├── example-Georef.cpp
│ │ │ │ │ ├── example-Gnomonic.cpp
│ │ │ │ │ ├── example-GravityCircle.cpp
│ │ │ │ │ ├── example-GravityModel.cpp
│ │ │ │ │ ├── example-LambertConformalConic.cpp
│ │ │ │ │ ├── example-LocalCartesian.cpp
│ │ │ │ │ ├── example-MGRS.cpp
│ │ │ │ │ ├── example-MagneticCircle.cpp
│ │ │ │ │ ├── example-MagneticModel.cpp
│ │ │ │ │ ├── example-Math.cpp
│ │ │ │ │ ├── example-NearestNeighbor.cpp
│ │ │ │ │ ├── example-NormalGravity.cpp
│ │ │ │ │ ├── example-OSGB.cpp
│ │ │ │ │ ├── example-PolarStereographic.cpp
│ │ │ │ │ ├── example-PolygonArea.cpp
│ │ │ │ │ ├── example-Rhumb.cpp
│ │ │ │ │ ├── example-RhumbLine.cpp
│ │ │ │ │ ├── example-SphericalEngine.cpp
│ │ │ │ │ ├── example-SphericalHarmonic.cpp
│ │ │ │ │ ├── example-SphericalHarmonic1.cpp
│ │ │ │ │ ├── example-SphericalHarmonic2.cpp
│ │ │ │ │ ├── example-TransverseMercator.cpp
│ │ │ │ │ ├── example-TransverseMercatorExact.cpp
│ │ │ │ │ ├── example-UTMUPS.cpp
│ │ │ │ │ ├── example-Utility.cpp
│ │ │ │ │ └── make-egmcof.cpp
│ │ │ │ ├── include/
│ │ │ │ │ ├── GeographicLib/
│ │ │ │ │ │ ├── Accumulator.hpp
│ │ │ │ │ │ ├── AlbersEqualArea.hpp
│ │ │ │ │ │ ├── AzimuthalEquidistant.hpp
│ │ │ │ │ │ ├── CMakeLists.txt
│ │ │ │ │ │ ├── CassiniSoldner.hpp
│ │ │ │ │ │ ├── CircularEngine.hpp
│ │ │ │ │ │ ├── Config-ac.h.in
│ │ │ │ │ │ ├── Config.h
│ │ │ │ │ │ ├── Config.h.in
│ │ │ │ │ │ ├── Constants.hpp
│ │ │ │ │ │ ├── DMS.hpp
│ │ │ │ │ │ ├── Ellipsoid.hpp
│ │ │ │ │ │ ├── EllipticFunction.hpp
│ │ │ │ │ │ ├── GARS.hpp
│ │ │ │ │ │ ├── GeoCoords.hpp
│ │ │ │ │ │ ├── Geocentric.hpp
│ │ │ │ │ │ ├── Geodesic.hpp
│ │ │ │ │ │ ├── GeodesicExact.hpp
│ │ │ │ │ │ ├── GeodesicLine.hpp
│ │ │ │ │ │ ├── GeodesicLineExact.hpp
│ │ │ │ │ │ ├── Geohash.hpp
│ │ │ │ │ │ ├── Geoid.hpp
│ │ │ │ │ │ ├── Georef.hpp
│ │ │ │ │ │ ├── Gnomonic.hpp
│ │ │ │ │ │ ├── GravityCircle.hpp
│ │ │ │ │ │ ├── GravityModel.hpp
│ │ │ │ │ │ ├── LambertConformalConic.hpp
│ │ │ │ │ │ ├── LocalCartesian.hpp
│ │ │ │ │ │ ├── MGRS.hpp
│ │ │ │ │ │ ├── MagneticCircle.hpp
│ │ │ │ │ │ ├── MagneticModel.hpp
│ │ │ │ │ │ ├── Math.hpp
│ │ │ │ │ │ ├── NearestNeighbor.hpp
│ │ │ │ │ │ ├── NormalGravity.hpp
│ │ │ │ │ │ ├── OSGB.hpp
│ │ │ │ │ │ ├── PolarStereographic.hpp
│ │ │ │ │ │ ├── PolygonArea.hpp
│ │ │ │ │ │ ├── Rhumb.hpp
│ │ │ │ │ │ ├── SphericalEngine.hpp
│ │ │ │ │ │ ├── SphericalHarmonic.hpp
│ │ │ │ │ │ ├── SphericalHarmonic1.hpp
│ │ │ │ │ │ ├── SphericalHarmonic2.hpp
│ │ │ │ │ │ ├── TransverseMercator.hpp
│ │ │ │ │ │ ├── TransverseMercatorExact.hpp
│ │ │ │ │ │ ├── UTMUPS.hpp
│ │ │ │ │ │ └── Utility.hpp
│ │ │ │ │ ├── Makefile.am
│ │ │ │ │ ├── Makefile.in
│ │ │ │ │ └── Makefile.mk
│ │ │ │ ├── install-sh
│ │ │ │ ├── java/
│ │ │ │ │ ├── README.txt
│ │ │ │ │ ├── direct/
│ │ │ │ │ │ ├── pom.xml
│ │ │ │ │ │ └── src/
│ │ │ │ │ │ └── main/
│ │ │ │ │ │ └── java/
│ │ │ │ │ │ └── Direct.java
│ │ │ │ │ ├── inverse/
│ │ │ │ │ │ ├── pom.xml
│ │ │ │ │ │ └── src/
│ │ │ │ │ │ └── main/
│ │ │ │ │ │ └── java/
│ │ │ │ │ │ └── Inverse.java
│ │ │ │ │ ├── planimeter/
│ │ │ │ │ │ ├── pom.xml
│ │ │ │ │ │ └── src/
│ │ │ │ │ │ └── main/
│ │ │ │ │ │ └── java/
│ │ │ │ │ │ └── Planimeter.java
│ │ │ │ │ ├── pom.xml
│ │ │ │ │ └── src/
│ │ │ │ │ ├── main/
│ │ │ │ │ │ └── java/
│ │ │ │ │ │ └── net/
│ │ │ │ │ │ └── sf/
│ │ │ │ │ │ └── geographiclib/
│ │ │ │ │ │ ├── Accumulator.java
│ │ │ │ │ │ ├── Constants.java
│ │ │ │ │ │ ├── GeoMath.java
│ │ │ │ │ │ ├── Geodesic.java
│ │ │ │ │ │ ├── GeodesicData.java
│ │ │ │ │ │ ├── GeodesicLine.java
│ │ │ │ │ │ ├── GeodesicMask.java
│ │ │ │ │ │ ├── GeographicErr.java
│ │ │ │ │ │ ├── Gnomonic.java
│ │ │ │ │ │ ├── GnomonicData.java
│ │ │ │ │ │ ├── Pair.java
│ │ │ │ │ │ ├── PolygonArea.java
│ │ │ │ │ │ ├── PolygonResult.java
│ │ │ │ │ │ └── package-info.java
│ │ │ │ │ └── test/
│ │ │ │ │ └── java/
│ │ │ │ │ └── net/
│ │ │ │ │ └── sf/
│ │ │ │ │ └── geographiclib/
│ │ │ │ │ └── GeodesicTest.java
│ │ │ │ ├── js/
│ │ │ │ │ ├── CMakeLists.txt
│ │ │ │ │ ├── GeographicLib.md
│ │ │ │ │ ├── HEADER.js
│ │ │ │ │ ├── Makefile.am
│ │ │ │ │ ├── Makefile.in
│ │ │ │ │ ├── Makefile.mk
│ │ │ │ │ ├── README.md
│ │ │ │ │ ├── conf.json
│ │ │ │ │ ├── doc/
│ │ │ │ │ │ ├── 1-geodesics.md
│ │ │ │ │ │ ├── 2-interface.md
│ │ │ │ │ │ ├── 3-examples.md
│ │ │ │ │ │ └── tutorials.json
│ │ │ │ │ ├── js-cat.sh
│ │ │ │ │ ├── js-compress.sh
│ │ │ │ │ ├── package.json
│ │ │ │ │ ├── samples/
│ │ │ │ │ │ ├── geod-calc.html
│ │ │ │ │ │ ├── geod-google-instructions.html
│ │ │ │ │ │ └── geod-google.html
│ │ │ │ │ ├── src/
│ │ │ │ │ │ ├── DMS.js
│ │ │ │ │ │ ├── Geodesic.js
│ │ │ │ │ │ ├── GeodesicLine.js
│ │ │ │ │ │ ├── Math.js
│ │ │ │ │ │ └── PolygonArea.js
│ │ │ │ │ └── test/
│ │ │ │ │ └── geodesictest.js
│ │ │ │ ├── legacy/
│ │ │ │ │ ├── C/
│ │ │ │ │ │ ├── 00README.txt
│ │ │ │ │ │ ├── CMakeLists.txt
│ │ │ │ │ │ ├── direct.c
│ │ │ │ │ │ ├── geodesic.c
│ │ │ │ │ │ ├── geodesic.h
│ │ │ │ │ │ ├── geodtest.c
│ │ │ │ │ │ ├── inverse.c
│ │ │ │ │ │ └── planimeter.c
│ │ │ │ │ └── Fortran/
│ │ │ │ │ ├── 00README.txt
│ │ │ │ │ ├── CMakeLists.txt
│ │ │ │ │ ├── geoddirect.for
│ │ │ │ │ ├── geodesic.for
│ │ │ │ │ ├── geodesic.inc
│ │ │ │ │ ├── geodinverse.for
│ │ │ │ │ ├── geodtest.for
│ │ │ │ │ ├── ngscommon.for
│ │ │ │ │ ├── ngsforward.for
│ │ │ │ │ ├── ngsinverse.for
│ │ │ │ │ └── planimeter.for
│ │ │ │ ├── ltmain.sh
│ │ │ │ ├── m4/
│ │ │ │ │ ├── libtool.m4
│ │ │ │ │ ├── ltoptions.m4
│ │ │ │ │ ├── ltsugar.m4
│ │ │ │ │ ├── ltversion.m4
│ │ │ │ │ ├── lt~obsolete.m4
│ │ │ │ │ └── pkg.m4
│ │ │ │ ├── man/
│ │ │ │ │ ├── CMakeLists.txt
│ │ │ │ │ ├── CartConvert.1
│ │ │ │ │ ├── CartConvert.1.html
│ │ │ │ │ ├── CartConvert.pod
│ │ │ │ │ ├── CartConvert.usage
│ │ │ │ │ ├── ConicProj.1
│ │ │ │ │ ├── ConicProj.1.html
│ │ │ │ │ ├── ConicProj.pod
│ │ │ │ │ ├── ConicProj.usage
│ │ │ │ │ ├── GeoConvert.1
│ │ │ │ │ ├── GeoConvert.1.html
│ │ │ │ │ ├── GeoConvert.pod
│ │ │ │ │ ├── GeoConvert.usage
│ │ │ │ │ ├── GeodSolve.1
│ │ │ │ │ ├── GeodSolve.1.html
│ │ │ │ │ ├── GeodSolve.pod
│ │ │ │ │ ├── GeodSolve.usage
│ │ │ │ │ ├── GeodesicProj.1
│ │ │ │ │ ├── GeodesicProj.1.html
│ │ │ │ │ ├── GeodesicProj.pod
│ │ │ │ │ ├── GeodesicProj.usage
│ │ │ │ │ ├── GeoidEval.1
│ │ │ │ │ ├── GeoidEval.1.html
│ │ │ │ │ ├── GeoidEval.pod
│ │ │ │ │ ├── GeoidEval.usage
│ │ │ │ │ ├── Gravity.1
│ │ │ │ │ ├── Gravity.1.html
│ │ │ │ │ ├── Gravity.pod
│ │ │ │ │ ├── Gravity.usage
│ │ │ │ │ ├── MagneticField.1
│ │ │ │ │ ├── MagneticField.1.html
│ │ │ │ │ ├── MagneticField.pod
│ │ │ │ │ ├── MagneticField.usage
│ │ │ │ │ ├── Makefile.am
│ │ │ │ │ ├── Makefile.in
│ │ │ │ │ ├── Makefile.mk
│ │ │ │ │ ├── Planimeter.1
│ │ │ │ │ ├── Planimeter.1.html
│ │ │ │ │ ├── Planimeter.pod
│ │ │ │ │ ├── Planimeter.usage
│ │ │ │ │ ├── RhumbSolve.1
│ │ │ │ │ ├── RhumbSolve.1.html
│ │ │ │ │ ├── RhumbSolve.pod
│ │ │ │ │ ├── RhumbSolve.usage
│ │ │ │ │ ├── TransverseMercatorProj.1
│ │ │ │ │ ├── TransverseMercatorProj.1.html
│ │ │ │ │ ├── TransverseMercatorProj.pod
│ │ │ │ │ ├── TransverseMercatorProj.usage
│ │ │ │ │ ├── dummy.1.html.in
│ │ │ │ │ ├── dummy.1.in
│ │ │ │ │ ├── dummy.usage.in
│ │ │ │ │ ├── makeusage.sh
│ │ │ │ │ └── script.8.in
│ │ │ │ ├── matlab/
│ │ │ │ │ ├── CMakeLists.txt
│ │ │ │ │ ├── Makefile.am
│ │ │ │ │ ├── Makefile.in
│ │ │ │ │ ├── Makefile.mk
│ │ │ │ │ ├── geographiclib/
│ │ │ │ │ │ ├── Contents.m
│ │ │ │ │ │ ├── cassini_fwd.m
│ │ │ │ │ │ ├── cassini_inv.m
│ │ │ │ │ │ ├── defaultellipsoid.m
│ │ │ │ │ │ ├── ecc2flat.m
│ │ │ │ │ │ ├── eqdazim_fwd.m
│ │ │ │ │ │ ├── eqdazim_inv.m
│ │ │ │ │ │ ├── flat2ecc.m
│ │ │ │ │ │ ├── gedistance.m
│ │ │ │ │ │ ├── gedoc.m
│ │ │ │ │ │ ├── geocent_fwd.m
│ │ │ │ │ │ ├── geocent_inv.m
│ │ │ │ │ │ ├── geodarea.m
│ │ │ │ │ │ ├── geoddistance.m
│ │ │ │ │ │ ├── geoddoc.m
│ │ │ │ │ │ ├── geodreckon.m
│ │ │ │ │ │ ├── geographiclib_test.m
│ │ │ │ │ │ ├── geoid_height.m
│ │ │ │ │ │ ├── geoid_load.m
│ │ │ │ │ │ ├── gereckon.m
│ │ │ │ │ │ ├── gnomonic_fwd.m
│ │ │ │ │ │ ├── gnomonic_inv.m
│ │ │ │ │ │ ├── loccart_fwd.m
│ │ │ │ │ │ ├── loccart_inv.m
│ │ │ │ │ │ ├── mgrs_fwd.m
│ │ │ │ │ │ ├── mgrs_inv.m
│ │ │ │ │ │ ├── polarst_fwd.m
│ │ │ │ │ │ ├── polarst_inv.m
│ │ │ │ │ │ ├── private/
│ │ │ │ │ │ │ ├── A1m1f.m
│ │ │ │ │ │ │ ├── A2m1f.m
│ │ │ │ │ │ │ ├── A3coeff.m
│ │ │ │ │ │ │ ├── A3f.m
│ │ │ │ │ │ │ ├── AngDiff.m
│ │ │ │ │ │ │ ├── AngNormalize.m
│ │ │ │ │ │ │ ├── AngRound.m
│ │ │ │ │ │ │ ├── C1f.m
│ │ │ │ │ │ │ ├── C1pf.m
│ │ │ │ │ │ │ ├── C2f.m
│ │ │ │ │ │ │ ├── C3coeff.m
│ │ │ │ │ │ │ ├── C3f.m
│ │ │ │ │ │ │ ├── C4coeff.m
│ │ │ │ │ │ │ ├── C4f.m
│ │ │ │ │ │ │ ├── G4coeff.m
│ │ │ │ │ │ │ ├── GeoRotation.m
│ │ │ │ │ │ │ ├── LatFix.m
│ │ │ │ │ │ │ ├── SinCosSeries.m
│ │ │ │ │ │ │ ├── atan2dx.m
│ │ │ │ │ │ │ ├── cbrtx.m
│ │ │ │ │ │ │ ├── copysignx.m
│ │ │ │ │ │ │ ├── cvmgt.m
│ │ │ │ │ │ │ ├── eatanhe.m
│ │ │ │ │ │ │ ├── geoid_file.m
│ │ │ │ │ │ │ ├── geoid_load_file.m
│ │ │ │ │ │ │ ├── norm2.m
│ │ │ │ │ │ │ ├── sincosdx.m
│ │ │ │ │ │ │ ├── sumx.m
│ │ │ │ │ │ │ ├── swap.m
│ │ │ │ │ │ │ ├── tauf.m
│ │ │ │ │ │ │ └── taupf.m
│ │ │ │ │ │ ├── projdoc.m
│ │ │ │ │ │ ├── tranmerc_fwd.m
│ │ │ │ │ │ ├── tranmerc_inv.m
│ │ │ │ │ │ ├── utmups_fwd.m
│ │ │ │ │ │ └── utmups_inv.m
│ │ │ │ │ └── geographiclib-legacy/
│ │ │ │ │ ├── Contents.m
│ │ │ │ │ ├── geocentricforward.m
│ │ │ │ │ ├── geocentricreverse.m
│ │ │ │ │ ├── geodesicdirect.m
│ │ │ │ │ ├── geodesicinverse.m
│ │ │ │ │ ├── geodesicline.m
│ │ │ │ │ ├── geoidheight.m
│ │ │ │ │ ├── localcartesianforward.m
│ │ │ │ │ ├── localcartesianreverse.m
│ │ │ │ │ ├── mgrsforward.m
│ │ │ │ │ ├── mgrsreverse.m
│ │ │ │ │ ├── polygonarea.m
│ │ │ │ │ ├── utmupsforward.m
│ │ │ │ │ └── utmupsreverse.m
│ │ │ │ ├── maxima/
│ │ │ │ │ ├── Makefile.mk
│ │ │ │ │ ├── auxlat.mac
│ │ │ │ │ ├── ellint.mac
│ │ │ │ │ ├── gearea.mac
│ │ │ │ │ ├── geod.mac
│ │ │ │ │ ├── geodesic.mac
│ │ │ │ │ ├── polyprint.mac
│ │ │ │ │ ├── rhumbarea.mac
│ │ │ │ │ ├── tm.mac
│ │ │ │ │ └── tmseries.mac
│ │ │ │ ├── missing
│ │ │ │ ├── python/
│ │ │ │ │ ├── MANIFEST.in
│ │ │ │ │ ├── Makefile.am
│ │ │ │ │ ├── Makefile.in
│ │ │ │ │ ├── Makefile.mk
│ │ │ │ │ ├── README.rst
│ │ │ │ │ ├── doc/
│ │ │ │ │ │ ├── code.rst
│ │ │ │ │ │ ├── conf.py
│ │ │ │ │ │ ├── examples.rst
│ │ │ │ │ │ ├── geodesics.rst
│ │ │ │ │ │ ├── index.rst
│ │ │ │ │ │ └── interface.rst
│ │ │ │ │ ├── geographiclib/
│ │ │ │ │ │ ├── CMakeLists.txt
│ │ │ │ │ │ ├── __init__.py
│ │ │ │ │ │ ├── accumulator.py
│ │ │ │ │ │ ├── constants.py
│ │ │ │ │ │ ├── geodesic.py
│ │ │ │ │ │ ├── geodesiccapability.py
│ │ │ │ │ │ ├── geodesicline.py
│ │ │ │ │ │ ├── geomath.py
│ │ │ │ │ │ ├── polygonarea.py
│ │ │ │ │ │ └── test/
│ │ │ │ │ │ ├── __init__.py
│ │ │ │ │ │ └── test_geodesic.py
│ │ │ │ │ └── setup.py
│ │ │ │ ├── src/
│ │ │ │ │ ├── Accumulator.cpp
│ │ │ │ │ ├── AlbersEqualArea.cpp
│ │ │ │ │ ├── AzimuthalEquidistant.cpp
│ │ │ │ │ ├── CMakeLists.txt
│ │ │ │ │ ├── CassiniSoldner.cpp
│ │ │ │ │ ├── CircularEngine.cpp
│ │ │ │ │ ├── DMS.cpp
│ │ │ │ │ ├── Ellipsoid.cpp
│ │ │ │ │ ├── EllipticFunction.cpp
│ │ │ │ │ ├── GARS.cpp
│ │ │ │ │ ├── GeoCoords.cpp
│ │ │ │ │ ├── Geocentric.cpp
│ │ │ │ │ ├── Geodesic.cpp
│ │ │ │ │ ├── GeodesicExact.cpp
│ │ │ │ │ ├── GeodesicExactC4.cpp
│ │ │ │ │ ├── GeodesicLine.cpp
│ │ │ │ │ ├── GeodesicLineExact.cpp
│ │ │ │ │ ├── Geohash.cpp
│ │ │ │ │ ├── Geoid.cpp
│ │ │ │ │ ├── Georef.cpp
│ │ │ │ │ ├── Gnomonic.cpp
│ │ │ │ │ ├── GravityCircle.cpp
│ │ │ │ │ ├── GravityModel.cpp
│ │ │ │ │ ├── LambertConformalConic.cpp
│ │ │ │ │ ├── LocalCartesian.cpp
│ │ │ │ │ ├── MGRS.cpp
│ │ │ │ │ ├── MagneticCircle.cpp
│ │ │ │ │ ├── MagneticModel.cpp
│ │ │ │ │ ├── Makefile.am
│ │ │ │ │ ├── Makefile.in
│ │ │ │ │ ├── Makefile.mk
│ │ │ │ │ ├── Math.cpp
│ │ │ │ │ ├── NormalGravity.cpp
│ │ │ │ │ ├── OSGB.cpp
│ │ │ │ │ ├── PolarStereographic.cpp
│ │ │ │ │ ├── PolygonArea.cpp
│ │ │ │ │ ├── Rhumb.cpp
│ │ │ │ │ ├── SphericalEngine.cpp
│ │ │ │ │ ├── TransverseMercator.cpp
│ │ │ │ │ ├── TransverseMercatorExact.cpp
│ │ │ │ │ ├── UTMUPS.cpp
│ │ │ │ │ └── Utility.cpp
│ │ │ │ ├── tools/
│ │ │ │ │ ├── CMakeLists.txt
│ │ │ │ │ ├── CartConvert.cpp
│ │ │ │ │ ├── ConicProj.cpp
│ │ │ │ │ ├── GeoConvert.cpp
│ │ │ │ │ ├── GeodSolve.cpp
│ │ │ │ │ ├── GeodesicProj.cpp
│ │ │ │ │ ├── GeoidEval.cpp
│ │ │ │ │ ├── Gravity.cpp
│ │ │ │ │ ├── MagneticField.cpp
│ │ │ │ │ ├── Makefile.am
│ │ │ │ │ ├── Makefile.in
│ │ │ │ │ ├── Makefile.mk
│ │ │ │ │ ├── Planimeter.cpp
│ │ │ │ │ ├── RhumbSolve.cpp
│ │ │ │ │ ├── TransverseMercatorProj.cpp
│ │ │ │ │ ├── geographiclib-get-geoids.sh
│ │ │ │ │ ├── geographiclib-get-gravity.sh
│ │ │ │ │ ├── geographiclib-get-magnetic.sh
│ │ │ │ │ └── tests.cmake
│ │ │ │ ├── windows/
│ │ │ │ │ ├── CartConvert-vc10.vcxproj
│ │ │ │ │ ├── CartConvert-vc10x.vcxproj
│ │ │ │ │ ├── CartConvert-vc9.vcproj
│ │ │ │ │ ├── ConicProj-vc10.vcxproj
│ │ │ │ │ ├── ConicProj-vc10x.vcxproj
│ │ │ │ │ ├── ConicProj-vc9.vcproj
│ │ │ │ │ ├── GeoConvert-vc10.vcxproj
│ │ │ │ │ ├── GeoConvert-vc10x.vcxproj
│ │ │ │ │ ├── GeoConvert-vc9.vcproj
│ │ │ │ │ ├── GeodSolve-vc10.vcxproj
│ │ │ │ │ ├── GeodSolve-vc10x.vcxproj
│ │ │ │ │ ├── GeodSolve-vc9.vcproj
│ │ │ │ │ ├── GeodesicProj-vc10.vcxproj
│ │ │ │ │ ├── GeodesicProj-vc10x.vcxproj
│ │ │ │ │ ├── GeodesicProj-vc9.vcproj
│ │ │ │ │ ├── Geographic-vc10.vcxproj
│ │ │ │ │ ├── Geographic-vc10x.vcxproj
│ │ │ │ │ ├── Geographic-vc13n.vcxproj
│ │ │ │ │ ├── Geographic-vc9.vcproj
│ │ │ │ │ ├── GeographicLib-vc10.sln
│ │ │ │ │ ├── GeographicLib-vc10x.sln
│ │ │ │ │ ├── GeographicLib-vc9.sln
│ │ │ │ │ ├── GeoidEval-vc10.vcxproj
│ │ │ │ │ ├── GeoidEval-vc10x.vcxproj
│ │ │ │ │ ├── GeoidEval-vc9.vcproj
│ │ │ │ │ ├── Gravity-vc10.vcxproj
│ │ │ │ │ ├── Gravity-vc10x.vcxproj
│ │ │ │ │ ├── Gravity-vc9.vcproj
│ │ │ │ │ ├── MagneticField-vc10.vcxproj
│ │ │ │ │ ├── MagneticField-vc10x.vcxproj
│ │ │ │ │ ├── MagneticField-vc9.vcproj
│ │ │ │ │ ├── NETGeographic-vc10.sln
│ │ │ │ │ ├── NETGeographic-vc10.vcxproj
│ │ │ │ │ ├── NETGeographic-vc13.sln
│ │ │ │ │ ├── NETGeographic-vc13.vcxproj
│ │ │ │ │ ├── Planimeter-vc10.vcxproj
│ │ │ │ │ ├── Planimeter-vc10x.vcxproj
│ │ │ │ │ ├── Planimeter-vc9.vcproj
│ │ │ │ │ ├── RhumbSolve-vc10.vcxproj
│ │ │ │ │ ├── RhumbSolve-vc10x.vcxproj
│ │ │ │ │ ├── RhumbSolve-vc9.vcproj
│ │ │ │ │ ├── TransverseMercatorProj-vc10.vcxproj
│ │ │ │ │ ├── TransverseMercatorProj-vc10x.vcxproj
│ │ │ │ │ └── TransverseMercatorProj-vc9.vcproj
│ │ │ │ └── wrapper/
│ │ │ │ ├── 00README.txt
│ │ │ │ ├── C/
│ │ │ │ │ ├── 00README.txt
│ │ │ │ │ ├── CMakeLists.txt
│ │ │ │ │ ├── cgeoid.cpp
│ │ │ │ │ ├── cgeoid.h
│ │ │ │ │ └── geoidtest.c
│ │ │ │ ├── js/
│ │ │ │ │ └── 00README.txt
│ │ │ │ ├── matlab/
│ │ │ │ │ ├── 00README.txt
│ │ │ │ │ ├── geodesicinverse.cpp
│ │ │ │ │ ├── geodesicinverse.m
│ │ │ │ │ └── geographiclibinterface.m
│ │ │ │ └── python/
│ │ │ │ ├── 00README.txt
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ └── PyGeographicLib.cpp
│ │ │ ├── Spectra/
│ │ │ │ ├── GenEigsBase.h
│ │ │ │ ├── GenEigsComplexShiftSolver.h
│ │ │ │ ├── GenEigsRealShiftSolver.h
│ │ │ │ ├── GenEigsSolver.h
│ │ │ │ ├── LinAlg/
│ │ │ │ │ ├── Arnoldi.h
│ │ │ │ │ ├── BKLDLT.h
│ │ │ │ │ ├── DoubleShiftQR.h
│ │ │ │ │ ├── Lanczos.h
│ │ │ │ │ ├── TridiagEigen.h
│ │ │ │ │ ├── UpperHessenbergEigen.h
│ │ │ │ │ └── UpperHessenbergQR.h
│ │ │ │ ├── MatOp/
│ │ │ │ │ ├── DenseCholesky.h
│ │ │ │ │ ├── DenseGenComplexShiftSolve.h
│ │ │ │ │ ├── DenseGenMatProd.h
│ │ │ │ │ ├── DenseGenRealShiftSolve.h
│ │ │ │ │ ├── DenseSymMatProd.h
│ │ │ │ │ ├── DenseSymShiftSolve.h
│ │ │ │ │ ├── SparseCholesky.h
│ │ │ │ │ ├── SparseGenMatProd.h
│ │ │ │ │ ├── SparseGenRealShiftSolve.h
│ │ │ │ │ ├── SparseRegularInverse.h
│ │ │ │ │ ├── SparseSymMatProd.h
│ │ │ │ │ ├── SparseSymShiftSolve.h
│ │ │ │ │ └── internal/
│ │ │ │ │ ├── ArnoldiOp.h
│ │ │ │ │ ├── SymGEigsCholeskyOp.h
│ │ │ │ │ └── SymGEigsRegInvOp.h
│ │ │ │ ├── SymEigsBase.h
│ │ │ │ ├── SymEigsShiftSolver.h
│ │ │ │ ├── SymEigsSolver.h
│ │ │ │ ├── SymGEigsSolver.h
│ │ │ │ ├── Util/
│ │ │ │ │ ├── CompInfo.h
│ │ │ │ │ ├── GEigsMode.h
│ │ │ │ │ ├── SelectionRule.h
│ │ │ │ │ ├── SimpleRandom.h
│ │ │ │ │ └── TypeTraits.h
│ │ │ │ └── contrib/
│ │ │ │ ├── LOBPCGSolver.h
│ │ │ │ └── PartialSVDSolver.h
│ │ │ ├── SuiteSparse_config/
│ │ │ │ ├── Makefile
│ │ │ │ ├── README.txt
│ │ │ │ ├── SuiteSparse_config.c
│ │ │ │ ├── SuiteSparse_config.h
│ │ │ │ ├── SuiteSparse_config.mk
│ │ │ │ └── xerbla/
│ │ │ │ ├── Makefile
│ │ │ │ ├── xerbla.c
│ │ │ │ ├── xerbla.f
│ │ │ │ └── xerbla.h
│ │ │ ├── ceres/
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── autodiff.h
│ │ │ │ ├── eigen.h
│ │ │ │ ├── example.h
│ │ │ │ ├── fixed_array.h
│ │ │ │ ├── fpclassify.h
│ │ │ │ ├── jet.h
│ │ │ │ ├── macros.h
│ │ │ │ ├── manual_constructor.h
│ │ │ │ ├── rotation.h
│ │ │ │ └── variadic_evaluate.h
│ │ │ └── metis/
│ │ │ ├── BUILD-Windows.txt
│ │ │ ├── BUILD.txt
│ │ │ ├── CMakeLists.txt
│ │ │ ├── Changelog
│ │ │ ├── GKlib/
│ │ │ │ ├── BUILD.txt
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── GKlib.h
│ │ │ │ ├── GKlibSystem.cmake
│ │ │ │ ├── Makefile
│ │ │ │ ├── b64.c
│ │ │ │ ├── blas.c
│ │ │ │ ├── conf/
│ │ │ │ │ └── check_thread_storage.c
│ │ │ │ ├── csr.c
│ │ │ │ ├── error.c
│ │ │ │ ├── evaluate.c
│ │ │ │ ├── fkvkselect.c
│ │ │ │ ├── fs.c
│ │ │ │ ├── getopt.c
│ │ │ │ ├── gk_arch.h
│ │ │ │ ├── gk_defs.h
│ │ │ │ ├── gk_externs.h
│ │ │ │ ├── gk_getopt.h
│ │ │ │ ├── gk_macros.h
│ │ │ │ ├── gk_mkblas.h
│ │ │ │ ├── gk_mkmemory.h
│ │ │ │ ├── gk_mkpqueue.h
│ │ │ │ ├── gk_mkpqueue2.h
│ │ │ │ ├── gk_mkrandom.h
│ │ │ │ ├── gk_mksort.h
│ │ │ │ ├── gk_mkutils.h
│ │ │ │ ├── gk_proto.h
│ │ │ │ ├── gk_struct.h
│ │ │ │ ├── gk_types.h
│ │ │ │ ├── gkregex.c
│ │ │ │ ├── gkregex.h
│ │ │ │ ├── graph.c
│ │ │ │ ├── htable.c
│ │ │ │ ├── io.c
│ │ │ │ ├── itemsets.c
│ │ │ │ ├── mcore.c
│ │ │ │ ├── memory.c
│ │ │ │ ├── ms_inttypes.h
│ │ │ │ ├── ms_stat.h
│ │ │ │ ├── ms_stdint.h
│ │ │ │ ├── omp.c
│ │ │ │ ├── pdb.c
│ │ │ │ ├── pqueue.c
│ │ │ │ ├── random.c
│ │ │ │ ├── rw.c
│ │ │ │ ├── seq.c
│ │ │ │ ├── sort.c
│ │ │ │ ├── string.c
│ │ │ │ ├── test/
│ │ │ │ │ ├── CMakeLists.txt
│ │ │ │ │ ├── Makefile.in.old
│ │ │ │ │ ├── Makefile.old
│ │ │ │ │ ├── fis.c
│ │ │ │ │ ├── gkgraph.c
│ │ │ │ │ ├── gksort.c
│ │ │ │ │ ├── rw.c
│ │ │ │ │ └── strings.c
│ │ │ │ ├── timers.c
│ │ │ │ ├── tokenizer.c
│ │ │ │ └── util.c
│ │ │ ├── Install.txt
│ │ │ ├── LICENSE.txt
│ │ │ ├── Makefile
│ │ │ ├── graphs/
│ │ │ │ ├── 4elt.graph
│ │ │ │ ├── README
│ │ │ │ ├── copter2.graph
│ │ │ │ ├── mdual.graph
│ │ │ │ ├── metis.mesh
│ │ │ │ └── test.mgraph
│ │ │ ├── include/
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ └── metis.h
│ │ │ ├── libmetis/
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── auxapi.c
│ │ │ │ ├── balance.c
│ │ │ │ ├── bucketsort.c
│ │ │ │ ├── checkgraph.c
│ │ │ │ ├── coarsen.c
│ │ │ │ ├── compress.c
│ │ │ │ ├── contig.c
│ │ │ │ ├── debug.c
│ │ │ │ ├── defs.h
│ │ │ │ ├── fm.c
│ │ │ │ ├── fortran.c
│ │ │ │ ├── frename.c
│ │ │ │ ├── gklib.c
│ │ │ │ ├── gklib_defs.h
│ │ │ │ ├── gklib_rename.h
│ │ │ │ ├── graph.c
│ │ │ │ ├── initpart.c
│ │ │ │ ├── kmetis.c
│ │ │ │ ├── kwayfm.c
│ │ │ │ ├── kwayrefine.c
│ │ │ │ ├── macros.h
│ │ │ │ ├── mcutil.c
│ │ │ │ ├── mesh.c
│ │ │ │ ├── meshpart.c
│ │ │ │ ├── metislib.h
│ │ │ │ ├── minconn.c
│ │ │ │ ├── mincover.c
│ │ │ │ ├── mmd.c
│ │ │ │ ├── ometis.c
│ │ │ │ ├── options.c
│ │ │ │ ├── parmetis.c
│ │ │ │ ├── pmetis.c
│ │ │ │ ├── proto.h
│ │ │ │ ├── refine.c
│ │ │ │ ├── rename.h
│ │ │ │ ├── separator.c
│ │ │ │ ├── sfm.c
│ │ │ │ ├── srefine.c
│ │ │ │ ├── stat.c
│ │ │ │ ├── stdheaders.h
│ │ │ │ ├── struct.h
│ │ │ │ ├── timing.c
│ │ │ │ ├── util.c
│ │ │ │ └── wspace.c
│ │ │ ├── metis.h
│ │ │ ├── programs/
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── cmdline_gpmetis.c
│ │ │ │ ├── cmdline_m2gmetis.c
│ │ │ │ ├── cmdline_mpmetis.c
│ │ │ │ ├── cmdline_ndmetis.c
│ │ │ │ ├── cmpfillin.c
│ │ │ │ ├── defs.h
│ │ │ │ ├── gpmetis.c
│ │ │ │ ├── graphchk.c
│ │ │ │ ├── io.c
│ │ │ │ ├── m2gmetis.c
│ │ │ │ ├── metisbin.h
│ │ │ │ ├── mpmetis.c
│ │ │ │ ├── ndmetis.c
│ │ │ │ ├── proto.h
│ │ │ │ ├── smbfactor.c
│ │ │ │ ├── stat.c
│ │ │ │ └── struct.h
│ │ │ └── vsgen.bat
│ │ ├── CMakeLists.txt
│ │ ├── base/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── ConcurrentMap.h
│ │ │ ├── DSFMap.h
│ │ │ ├── DSFVector.cpp
│ │ │ ├── DSFVector.h
│ │ │ ├── FastDefaultAllocator.h
│ │ │ ├── FastList.h
│ │ │ ├── FastMap.h
│ │ │ ├── FastSet.h
│ │ │ ├── FastVector.h
│ │ │ ├── GenericValue.h
│ │ │ ├── Group.h
│ │ │ ├── Lie.h
│ │ │ ├── LieMatrix.h
│ │ │ ├── LieScalar.h
│ │ │ ├── LieVector.h
│ │ │ ├── Manifold.h
│ │ │ ├── Matrix.cpp
│ │ │ ├── Matrix.h
│ │ │ ├── OptionalJacobian.h
│ │ │ ├── ProductLieGroup.h
│ │ │ ├── SymmetricBlockMatrix.cpp
│ │ │ ├── SymmetricBlockMatrix.h
│ │ │ ├── Testable.h
│ │ │ ├── TestableAssertions.h
│ │ │ ├── ThreadsafeException.h
│ │ │ ├── Value.h
│ │ │ ├── Vector.cpp
│ │ │ ├── Vector.h
│ │ │ ├── VectorSpace.h
│ │ │ ├── VerticalBlockMatrix.cpp
│ │ │ ├── VerticalBlockMatrix.h
│ │ │ ├── WeightedSampler.h
│ │ │ ├── chartTesting.h
│ │ │ ├── cholesky.cpp
│ │ │ ├── cholesky.h
│ │ │ ├── concepts.h
│ │ │ ├── debug.cpp
│ │ │ ├── debug.h
│ │ │ ├── deprecated/
│ │ │ │ ├── LieMatrix.h
│ │ │ │ ├── LieScalar.h
│ │ │ │ └── LieVector.h
│ │ │ ├── lieProxies.h
│ │ │ ├── make_shared.h
│ │ │ ├── numericalDerivative.h
│ │ │ ├── serialization.h
│ │ │ ├── serializationTestHelpers.h
│ │ │ ├── testLie.h
│ │ │ ├── tests/
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── testCholesky.cpp
│ │ │ │ ├── testDSFMap.cpp
│ │ │ │ ├── testDSFVector.cpp
│ │ │ │ ├── testDebug.cpp
│ │ │ │ ├── testFastContainers.cpp
│ │ │ │ ├── testGroup.cpp
│ │ │ │ ├── testLieMatrix.cpp
│ │ │ │ ├── testLieScalar.cpp
│ │ │ │ ├── testLieVector.cpp
│ │ │ │ ├── testMatrix.cpp
│ │ │ │ ├── testNumericalDerivative.cpp
│ │ │ │ ├── testOptionalJacobian.cpp
│ │ │ │ ├── testSerializationBase.cpp
│ │ │ │ ├── testSymmetricBlockMatrix.cpp
│ │ │ │ ├── testTestableAssertions.cpp
│ │ │ │ ├── testTreeTraversal.cpp
│ │ │ │ ├── testVector.cpp
│ │ │ │ ├── testVerticalBlockMatrix.cpp
│ │ │ │ └── testWeightedSampler.cpp
│ │ │ ├── timing.cpp
│ │ │ ├── timing.h
│ │ │ ├── treeTraversal/
│ │ │ │ ├── parallelTraversalTasks.h
│ │ │ │ └── statistics.h
│ │ │ ├── treeTraversal-inst.h
│ │ │ ├── types.cpp
│ │ │ └── types.h
│ │ ├── config.h.in
│ │ ├── discrete/
│ │ │ ├── AlgebraicDecisionTree.h
│ │ │ ├── Assignment.h
│ │ │ ├── CMakeLists.txt
│ │ │ ├── DecisionTree-inl.h
│ │ │ ├── DecisionTree.h
│ │ │ ├── DecisionTreeFactor.cpp
│ │ │ ├── DecisionTreeFactor.h
│ │ │ ├── DiscreteBayesNet.cpp
│ │ │ ├── DiscreteBayesNet.h
│ │ │ ├── DiscreteBayesTree.cpp
│ │ │ ├── DiscreteBayesTree.h
│ │ │ ├── DiscreteConditional.cpp
│ │ │ ├── DiscreteConditional.h
│ │ │ ├── DiscreteEliminationTree.cpp
│ │ │ ├── DiscreteEliminationTree.h
│ │ │ ├── DiscreteFactor.cpp
│ │ │ ├── DiscreteFactor.h
│ │ │ ├── DiscreteFactorGraph.cpp
│ │ │ ├── DiscreteFactorGraph.h
│ │ │ ├── DiscreteJunctionTree.cpp
│ │ │ ├── DiscreteJunctionTree.h
│ │ │ ├── DiscreteKey.cpp
│ │ │ ├── DiscreteKey.h
│ │ │ ├── DiscreteMarginals.h
│ │ │ ├── Potentials.cpp
│ │ │ ├── Potentials.h
│ │ │ ├── Signature.cpp
│ │ │ ├── Signature.h
│ │ │ └── tests/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── data/
│ │ │ │ ├── FG/
│ │ │ │ │ └── alarm.fg
│ │ │ │ └── UAI/
│ │ │ │ ├── sampleMARKOV.uai
│ │ │ │ ├── sampleMARKOV.uai.evid
│ │ │ │ ├── uai08_test1.uai
│ │ │ │ ├── uai08_test1.uai.evid
│ │ │ │ ├── uai08_test1.uai.output
│ │ │ │ ├── uai08_test2.uai
│ │ │ │ ├── uai08_test2.uai.evid
│ │ │ │ ├── uai08_test2.uai.output
│ │ │ │ ├── uai08_test3.uai
│ │ │ │ ├── uai08_test3.uai.evid
│ │ │ │ └── uai08_test3.uai.output
│ │ │ ├── testAlgebraicDecisionTree.cpp
│ │ │ ├── testDecisionTree.cpp
│ │ │ ├── testDecisionTreeFactor.cpp
│ │ │ ├── testDiscreteBayesNet.cpp
│ │ │ ├── testDiscreteBayesTree.cpp
│ │ │ ├── testDiscreteConditional.cpp
│ │ │ ├── testDiscreteFactor.cpp
│ │ │ ├── testDiscreteFactorGraph.cpp
│ │ │ ├── testDiscreteMarginals.cpp
│ │ │ └── testSignature.cpp
│ │ ├── geometry/
│ │ │ ├── BearingRange.h
│ │ │ ├── CMakeLists.txt
│ │ │ ├── Cal3Bundler.cpp
│ │ │ ├── Cal3Bundler.h
│ │ │ ├── Cal3DS2.cpp
│ │ │ ├── Cal3DS2.h
│ │ │ ├── Cal3DS2_Base.cpp
│ │ │ ├── Cal3DS2_Base.h
│ │ │ ├── Cal3Fisheye.cpp
│ │ │ ├── Cal3Fisheye.h
│ │ │ ├── Cal3Unified.cpp
│ │ │ ├── Cal3Unified.h
│ │ │ ├── Cal3_S2.cpp
│ │ │ ├── Cal3_S2.h
│ │ │ ├── Cal3_S2Stereo.cpp
│ │ │ ├── Cal3_S2Stereo.h
│ │ │ ├── CalibratedCamera.cpp
│ │ │ ├── CalibratedCamera.h
│ │ │ ├── CameraSet.h
│ │ │ ├── Cyclic.cpp
│ │ │ ├── Cyclic.h
│ │ │ ├── EssentialMatrix.cpp
│ │ │ ├── EssentialMatrix.h
│ │ │ ├── Line3.cpp
│ │ │ ├── Line3.h
│ │ │ ├── OrientedPlane3.cpp
│ │ │ ├── OrientedPlane3.h
│ │ │ ├── PinholeCamera.h
│ │ │ ├── PinholePose.h
│ │ │ ├── PinholeSet.h
│ │ │ ├── Point2.cpp
│ │ │ ├── Point2.h
│ │ │ ├── Point3.cpp
│ │ │ ├── Point3.h
│ │ │ ├── Pose2.cpp
│ │ │ ├── Pose2.h
│ │ │ ├── Pose3.cpp
│ │ │ ├── Pose3.h
│ │ │ ├── Quaternion.h
│ │ │ ├── Rot2.cpp
│ │ │ ├── Rot2.h
│ │ │ ├── Rot3.cpp
│ │ │ ├── Rot3.h
│ │ │ ├── Rot3M.cpp
│ │ │ ├── Rot3Q.cpp
│ │ │ ├── SO3.cpp
│ │ │ ├── SO3.h
│ │ │ ├── SO4.cpp
│ │ │ ├── SO4.h
│ │ │ ├── SOn-inl.h
│ │ │ ├── SOn.cpp
│ │ │ ├── SOn.h
│ │ │ ├── SimpleCamera.cpp
│ │ │ ├── SimpleCamera.h
│ │ │ ├── StereoCamera.cpp
│ │ │ ├── StereoCamera.h
│ │ │ ├── StereoPoint2.cpp
│ │ │ ├── StereoPoint2.h
│ │ │ ├── Unit3.cpp
│ │ │ ├── Unit3.h
│ │ │ ├── concepts.h
│ │ │ ├── tests/
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── testBearingRange.cpp
│ │ │ │ ├── testCal3Bundler.cpp
│ │ │ │ ├── testCal3DFisheye.cpp
│ │ │ │ ├── testCal3DS2.cpp
│ │ │ │ ├── testCal3Unified.cpp
│ │ │ │ ├── testCal3_S2.cpp
│ │ │ │ ├── testCalibratedCamera.cpp
│ │ │ │ ├── testCameraSet.cpp
│ │ │ │ ├── testCyclic.cpp
│ │ │ │ ├── testEssentialMatrix.cpp
│ │ │ │ ├── testLine3.cpp
│ │ │ │ ├── testOrientedPlane3.cpp
│ │ │ │ ├── testPinholeCamera.cpp
│ │ │ │ ├── testPinholePose.cpp
│ │ │ │ ├── testPinholeSet.cpp
│ │ │ │ ├── testPoint2.cpp
│ │ │ │ ├── testPoint3.cpp
│ │ │ │ ├── testPose2.cpp
│ │ │ │ ├── testPose3.cpp
│ │ │ │ ├── testPoseAdjointMap.h
│ │ │ │ ├── testQuaternion.cpp
│ │ │ │ ├── testRot2.cpp
│ │ │ │ ├── testRot3.cpp
│ │ │ │ ├── testRot3M.cpp
│ │ │ │ ├── testRot3Q.cpp
│ │ │ │ ├── testSO3.cpp
│ │ │ │ ├── testSO4.cpp
│ │ │ │ ├── testSOn.cpp
│ │ │ │ ├── testSerializationGeometry.cpp
│ │ │ │ ├── testSimpleCamera.cpp
│ │ │ │ ├── testStereoCamera.cpp
│ │ │ │ ├── testStereoPoint2.cpp
│ │ │ │ ├── testTriangulation.cpp
│ │ │ │ └── testUnit3.cpp
│ │ │ ├── triangulation.cpp
│ │ │ └── triangulation.h
│ │ ├── global_includes.h
│ │ ├── groups.dox
│ │ ├── gtsam.i
│ │ ├── inference/
│ │ │ ├── BayesNet-inst.h
│ │ │ ├── BayesNet.h
│ │ │ ├── BayesTree-inst.h
│ │ │ ├── BayesTree.cpp
│ │ │ ├── BayesTree.h
│ │ │ ├── BayesTreeCliqueBase-inst.h
│ │ │ ├── BayesTreeCliqueBase.h
│ │ │ ├── CMakeLists.txt
│ │ │ ├── ClusterTree-inst.h
│ │ │ ├── ClusterTree.h
│ │ │ ├── Conditional-inst.h
│ │ │ ├── Conditional.h
│ │ │ ├── EliminateableFactorGraph-inst.h
│ │ │ ├── EliminateableFactorGraph.h
│ │ │ ├── EliminationTree-inst.h
│ │ │ ├── EliminationTree.h
│ │ │ ├── Factor.cpp
│ │ │ ├── Factor.h
│ │ │ ├── FactorGraph-inst.h
│ │ │ ├── FactorGraph.h
│ │ │ ├── ISAM-inst.h
│ │ │ ├── ISAM.h
│ │ │ ├── JunctionTree-inst.h
│ │ │ ├── JunctionTree.h
│ │ │ ├── Key.cpp
│ │ │ ├── Key.h
│ │ │ ├── LabeledSymbol.cpp
│ │ │ ├── LabeledSymbol.h
│ │ │ ├── MetisIndex-inl.h
│ │ │ ├── MetisIndex.h
│ │ │ ├── Ordering.cpp
│ │ │ ├── Ordering.h
│ │ │ ├── Symbol.cpp
│ │ │ ├── Symbol.h
│ │ │ ├── VariableIndex-inl.h
│ │ │ ├── VariableIndex.cpp
│ │ │ ├── VariableIndex.h
│ │ │ ├── VariableSlots.cpp
│ │ │ ├── VariableSlots.h
│ │ │ ├── graph-inl.h
│ │ │ ├── graph.h
│ │ │ ├── inference-inst.h
│ │ │ ├── inferenceExceptions.h
│ │ │ └── tests/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── testKey.cpp
│ │ │ ├── testLabeledSymbol.cpp
│ │ │ ├── testOrdering.cpp
│ │ │ ├── testSymbol.cpp
│ │ │ └── testVariableSlots.cpp
│ │ ├── linear/
│ │ │ ├── BinaryJacobianFactor.h
│ │ │ ├── CMakeLists.txt
│ │ │ ├── ConjugateGradientSolver.cpp
│ │ │ ├── ConjugateGradientSolver.h
│ │ │ ├── Errors.cpp
│ │ │ ├── Errors.h
│ │ │ ├── GaussianBayesNet.cpp
│ │ │ ├── GaussianBayesNet.h
│ │ │ ├── GaussianBayesTree-inl.h
│ │ │ ├── GaussianBayesTree.cpp
│ │ │ ├── GaussianBayesTree.h
│ │ │ ├── GaussianConditional-inl.h
│ │ │ ├── GaussianConditional.cpp
│ │ │ ├── GaussianConditional.h
│ │ │ ├── GaussianDensity.cpp
│ │ │ ├── GaussianDensity.h
│ │ │ ├── GaussianEliminationTree.cpp
│ │ │ ├── GaussianEliminationTree.h
│ │ │ ├── GaussianFactor.cpp
│ │ │ ├── GaussianFactor.h
│ │ │ ├── GaussianFactorGraph.cpp
│ │ │ ├── GaussianFactorGraph.h
│ │ │ ├── GaussianISAM.cpp
│ │ │ ├── GaussianISAM.h
│ │ │ ├── GaussianJunctionTree.cpp
│ │ │ ├── GaussianJunctionTree.h
│ │ │ ├── HessianFactor-inl.h
│ │ │ ├── HessianFactor.cpp
│ │ │ ├── HessianFactor.h
│ │ │ ├── IterativeSolver.cpp
│ │ │ ├── IterativeSolver.h
│ │ │ ├── JacobianFactor-inl.h
│ │ │ ├── JacobianFactor.cpp
│ │ │ ├── JacobianFactor.h
│ │ │ ├── KalmanFilter.cpp
│ │ │ ├── KalmanFilter.h
│ │ │ ├── LossFunctions.cpp
│ │ │ ├── LossFunctions.h
│ │ │ ├── NoiseModel.cpp
│ │ │ ├── NoiseModel.h
│ │ │ ├── PCGSolver.cpp
│ │ │ ├── PCGSolver.h
│ │ │ ├── Preconditioner.cpp
│ │ │ ├── Preconditioner.h
│ │ │ ├── RegularHessianFactor.h
│ │ │ ├── RegularJacobianFactor.h
│ │ │ ├── Sampler.cpp
│ │ │ ├── Sampler.h
│ │ │ ├── Scatter.cpp
│ │ │ ├── Scatter.h
│ │ │ ├── SubgraphBuilder.cpp
│ │ │ ├── SubgraphBuilder.h
│ │ │ ├── SubgraphPreconditioner.cpp
│ │ │ ├── SubgraphPreconditioner.h
│ │ │ ├── SubgraphSolver.cpp
│ │ │ ├── SubgraphSolver.h
│ │ │ ├── VectorValues.cpp
│ │ │ ├── VectorValues.h
│ │ │ ├── iterative-inl.h
│ │ │ ├── iterative.cpp
│ │ │ ├── iterative.h
│ │ │ ├── linearAlgorithms-inst.h
│ │ │ ├── linearExceptions.cpp
│ │ │ ├── linearExceptions.h
│ │ │ └── tests/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── testErrors.cpp
│ │ │ ├── testGaussianBayesNet.cpp
│ │ │ ├── testGaussianBayesTree.cpp
│ │ │ ├── testGaussianConditional.cpp
│ │ │ ├── testGaussianDensity.cpp
│ │ │ ├── testGaussianFactorGraph.cpp
│ │ │ ├── testHessianFactor.cpp
│ │ │ ├── testJacobianFactor.cpp
│ │ │ ├── testKalmanFilter.cpp
│ │ │ ├── testNoiseModel.cpp
│ │ │ ├── testRegularHessianFactor.cpp
│ │ │ ├── testRegularJacobianFactor.cpp
│ │ │ ├── testSampler.cpp
│ │ │ ├── testScatter.cpp
│ │ │ ├── testSerializationLinear.cpp
│ │ │ └── testVectorValues.cpp
│ │ ├── mainpage.dox
│ │ ├── navigation/
│ │ │ ├── .gitignore
│ │ │ ├── AHRSFactor.cpp
│ │ │ ├── AHRSFactor.h
│ │ │ ├── AttitudeFactor.cpp
│ │ │ ├── AttitudeFactor.h
│ │ │ ├── CMakeLists.txt
│ │ │ ├── CombinedImuFactor.cpp
│ │ │ ├── CombinedImuFactor.h
│ │ │ ├── GPSFactor.cpp
│ │ │ ├── GPSFactor.h
│ │ │ ├── ImuBias.cpp
│ │ │ ├── ImuBias.h
│ │ │ ├── ImuFactor.cpp
│ │ │ ├── ImuFactor.h
│ │ │ ├── MagFactor.h
│ │ │ ├── ManifoldPreintegration.cpp
│ │ │ ├── ManifoldPreintegration.h
│ │ │ ├── NavState.cpp
│ │ │ ├── NavState.h
│ │ │ ├── PreintegratedRotation.cpp
│ │ │ ├── PreintegratedRotation.h
│ │ │ ├── PreintegrationBase.cpp
│ │ │ ├── PreintegrationBase.h
│ │ │ ├── PreintegrationParams.cpp
│ │ │ ├── PreintegrationParams.h
│ │ │ ├── Scenario.h
│ │ │ ├── ScenarioRunner.cpp
│ │ │ ├── ScenarioRunner.h
│ │ │ ├── TangentPreintegration.cpp
│ │ │ ├── TangentPreintegration.h
│ │ │ ├── expressions.h
│ │ │ └── tests/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── imuFactorTesting.h
│ │ │ ├── testAHRSFactor.cpp
│ │ │ ├── testAttitudeFactor.cpp
│ │ │ ├── testCombinedImuFactor.cpp
│ │ │ ├── testGPSFactor.cpp
│ │ │ ├── testGeographicLib.cpp
│ │ │ ├── testImuBias.cpp
│ │ │ ├── testImuFactor.cpp
│ │ │ ├── testImuFactorSerialization.cpp
│ │ │ ├── testMagFactor.cpp
│ │ │ ├── testManifoldPreintegration.cpp
│ │ │ ├── testNavExpressions.cpp
│ │ │ ├── testNavState.cpp
│ │ │ ├── testPoseVelocityBias.cpp
│ │ │ ├── testScenario.cpp
│ │ │ ├── testScenarioRunner.cpp
│ │ │ └── testTangentPreintegration.cpp
│ │ ├── nonlinear/
│ │ │ ├── AdaptAutoDiff.h
│ │ │ ├── CMakeLists.txt
│ │ │ ├── DoglegOptimizer.cpp
│ │ │ ├── DoglegOptimizer.h
│ │ │ ├── DoglegOptimizerImpl.cpp
│ │ │ ├── DoglegOptimizerImpl.h
│ │ │ ├── Expression-inl.h
│ │ │ ├── Expression.h
│ │ │ ├── ExpressionFactor.h
│ │ │ ├── ExpressionFactorGraph.h
│ │ │ ├── ExtendedKalmanFilter-inl.h
│ │ │ ├── ExtendedKalmanFilter.h
│ │ │ ├── FunctorizedFactor.h
│ │ │ ├── GaussNewtonOptimizer.cpp
│ │ │ ├── GaussNewtonOptimizer.h
│ │ │ ├── ISAM2-impl.cpp
│ │ │ ├── ISAM2-impl.h
│ │ │ ├── ISAM2.cpp
│ │ │ ├── ISAM2.h
│ │ │ ├── ISAM2Clique.cpp
│ │ │ ├── ISAM2Clique.h
│ │ │ ├── ISAM2Params.cpp
│ │ │ ├── ISAM2Params.h
│ │ │ ├── ISAM2Result.h
│ │ │ ├── ISAM2UpdateParams.h
│ │ │ ├── LevenbergMarquardtOptimizer.cpp
│ │ │ ├── LevenbergMarquardtOptimizer.h
│ │ │ ├── LevenbergMarquardtParams.cpp
│ │ │ ├── LevenbergMarquardtParams.h
│ │ │ ├── LinearContainerFactor.cpp
│ │ │ ├── LinearContainerFactor.h
│ │ │ ├── Marginals.cpp
│ │ │ ├── Marginals.h
│ │ │ ├── NonlinearConjugateGradientOptimizer.cpp
│ │ │ ├── NonlinearConjugateGradientOptimizer.h
│ │ │ ├── NonlinearEquality.h
│ │ │ ├── NonlinearFactor.cpp
│ │ │ ├── NonlinearFactor.h
│ │ │ ├── NonlinearFactorGraph.cpp
│ │ │ ├── NonlinearFactorGraph.h
│ │ │ ├── NonlinearISAM.cpp
│ │ │ ├── NonlinearISAM.h
│ │ │ ├── NonlinearOptimizer.cpp
│ │ │ ├── NonlinearOptimizer.h
│ │ │ ├── NonlinearOptimizerParams.cpp
│ │ │ ├── NonlinearOptimizerParams.h
│ │ │ ├── PriorFactor.h
│ │ │ ├── Symbol.h
│ │ │ ├── Values-inl.h
│ │ │ ├── Values.cpp
│ │ │ ├── Values.h
│ │ │ ├── WhiteNoiseFactor.h
│ │ │ ├── expressionTesting.h
│ │ │ ├── expressions.h
│ │ │ ├── factorTesting.h
│ │ │ ├── internal/
│ │ │ │ ├── CallRecord.h
│ │ │ │ ├── ExecutionTrace.h
│ │ │ │ ├── ExpressionNode.h
│ │ │ │ ├── JacobianMap.h
│ │ │ │ ├── LevenbergMarquardtState.h
│ │ │ │ └── NonlinearOptimizerState.h
│ │ │ ├── nonlinearExceptions.h
│ │ │ ├── tests/
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── testAdaptAutoDiff.cpp
│ │ │ │ ├── testCallRecord.cpp
│ │ │ │ ├── testExecutionTrace.cpp
│ │ │ │ ├── testExpression.cpp
│ │ │ │ ├── testFactorTesting.cpp
│ │ │ │ ├── testFunctorizedFactor.cpp
│ │ │ │ ├── testLinearContainerFactor.cpp
│ │ │ │ ├── testSerializationNonlinear.cpp
│ │ │ │ ├── testValues.cpp
│ │ │ │ └── testWhiteNoiseFactor.cpp
│ │ │ └── utilities.h
│ │ ├── precompiled_header.cpp
│ │ ├── precompiled_header.h
│ │ ├── sam/
│ │ │ ├── BearingFactor.h
│ │ │ ├── BearingRangeFactor.h
│ │ │ ├── CMakeLists.txt
│ │ │ ├── RangeFactor.h
│ │ │ └── tests/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── testBearingFactor.cpp
│ │ │ ├── testBearingRangeFactor.cpp
│ │ │ └── testRangeFactor.cpp
│ │ ├── sfm/
│ │ │ ├── BinaryMeasurement.h
│ │ │ ├── CMakeLists.txt
│ │ │ ├── ShonanAveraging.cpp
│ │ │ ├── ShonanAveraging.h
│ │ │ ├── ShonanFactor.cpp
│ │ │ ├── ShonanFactor.h
│ │ │ ├── ShonanGaugeFactor.h
│ │ │ ├── TranslationFactor.h
│ │ │ ├── TranslationRecovery.cpp
│ │ │ ├── TranslationRecovery.h
│ │ │ └── tests/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── testBinaryMeasurement.cpp
│ │ │ ├── testShonanAveraging.cpp
│ │ │ ├── testShonanFactor.cpp
│ │ │ ├── testShonanGaugeFactor.cpp
│ │ │ └── testTranslationFactor.cpp
│ │ ├── slam/
│ │ │ ├── AntiFactor.h
│ │ │ ├── BearingFactor.h
│ │ │ ├── BearingRangeFactor.h
│ │ │ ├── BetweenFactor.h
│ │ │ ├── BoundingConstraint.h
│ │ │ ├── CMakeLists.txt
│ │ │ ├── EssentialMatrixConstraint.cpp
│ │ │ ├── EssentialMatrixConstraint.h
│ │ │ ├── EssentialMatrixFactor.h
│ │ │ ├── FrobeniusFactor.cpp
│ │ │ ├── FrobeniusFactor.h
│ │ │ ├── GeneralSFMFactor.h
│ │ │ ├── InitializePose.h
│ │ │ ├── InitializePose3.cpp
│ │ │ ├── InitializePose3.h
│ │ │ ├── JacobianFactorQ.h
│ │ │ ├── JacobianFactorQR.h
│ │ │ ├── JacobianFactorSVD.h
│ │ │ ├── KarcherMeanFactor-inl.h
│ │ │ ├── KarcherMeanFactor.h
│ │ │ ├── OrientedPlane3Factor.cpp
│ │ │ ├── OrientedPlane3Factor.h
│ │ │ ├── PoseRotationPrior.h
│ │ │ ├── PoseTranslationPrior.h
│ │ │ ├── PriorFactor.h
│ │ │ ├── ProjectionFactor.h
│ │ │ ├── RangeFactor.h
│ │ │ ├── ReferenceFrameFactor.h
│ │ │ ├── RegularImplicitSchurFactor.h
│ │ │ ├── RotateFactor.h
│ │ │ ├── SmartFactorBase.h
│ │ │ ├── SmartFactorParams.h
│ │ │ ├── SmartProjectionFactor.h
│ │ │ ├── SmartProjectionPoseFactor.h
│ │ │ ├── StereoFactor.h
│ │ │ ├── TriangulationFactor.h
│ │ │ ├── dataset.cpp
│ │ │ ├── dataset.h
│ │ │ ├── expressions.h
│ │ │ ├── lago.cpp
│ │ │ ├── lago.h
│ │ │ └── tests/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── smartFactorScenarios.h
│ │ │ ├── testAntiFactor.cpp
│ │ │ ├── testBetweenFactor.cpp
│ │ │ ├── testDataset.cpp
│ │ │ ├── testEssentialMatrixConstraint.cpp
│ │ │ ├── testEssentialMatrixFactor.cpp
│ │ │ ├── testFrobeniusFactor.cpp
│ │ │ ├── testGeneralSFMFactor.cpp
│ │ │ ├── testGeneralSFMFactor_Cal3Bundler.cpp
│ │ │ ├── testInitializePose.cpp
│ │ │ ├── testInitializePose3.cpp
│ │ │ ├── testKarcherMeanFactor.cpp
│ │ │ ├── testLago.cpp
│ │ │ ├── testOrientedPlane3Factor.cpp
│ │ │ ├── testPoseRotationPrior.cpp
│ │ │ ├── testPoseTranslationPrior.cpp
│ │ │ ├── testPriorFactor.cpp
│ │ │ ├── testProjectionFactor.cpp
│ │ │ ├── testReferenceFrameFactor.cpp
│ │ │ ├── testRegularImplicitSchurFactor.cpp
│ │ │ ├── testRotateFactor.cpp
│ │ │ ├── testSlamExpressions.cpp
│ │ │ ├── testSmartFactorBase.cpp
│ │ │ ├── testSmartProjectionFactor.cpp
│ │ │ ├── testSmartProjectionPoseFactor.cpp
│ │ │ ├── testStereoFactor.cpp
│ │ │ └── testTriangulationFactor.cpp
│ │ └── symbolic/
│ │ ├── CMakeLists.txt
│ │ ├── SymbolicBayesNet.cpp
│ │ ├── SymbolicBayesNet.h
│ │ ├── SymbolicBayesTree.cpp
│ │ ├── SymbolicBayesTree.h
│ │ ├── SymbolicConditional.cpp
│ │ ├── SymbolicConditional.h
│ │ ├── SymbolicEliminationTree.cpp
│ │ ├── SymbolicEliminationTree.h
│ │ ├── SymbolicFactor-inst.h
│ │ ├── SymbolicFactor.cpp
│ │ ├── SymbolicFactor.h
│ │ ├── SymbolicFactorGraph.cpp
│ │ ├── SymbolicFactorGraph.h
│ │ ├── SymbolicISAM.cpp
│ │ ├── SymbolicISAM.h
│ │ ├── SymbolicJunctionTree.cpp
│ │ ├── SymbolicJunctionTree.h
│ │ └── tests/
│ │ ├── CMakeLists.txt
│ │ ├── symbolicExampleGraphs.h
│ │ ├── testSerializationSymbolic.cpp
│ │ ├── testSymbolicBayesNet.cpp
│ │ ├── testSymbolicBayesTree.cpp
│ │ ├── testSymbolicConditional.cpp
│ │ ├── testSymbolicEliminationTree.cpp
│ │ ├── testSymbolicFactor.cpp
│ │ ├── testSymbolicFactorGraph.cpp
│ │ ├── testSymbolicISAM.cpp
│ │ ├── testSymbolicJunctionTree.cpp
│ │ └── testVariableIndex.cpp
│ ├── gtsam_extra.cmake.in
│ ├── gtsam_unstable/
│ │ ├── CMakeLists.txt
│ │ ├── base/
│ │ │ ├── BTree.h
│ │ │ ├── CMakeLists.txt
│ │ │ ├── DSF.h
│ │ │ ├── Dummy.cpp
│ │ │ ├── Dummy.h
│ │ │ ├── FixedVector.h
│ │ │ └── tests/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── testBTree.cpp
│ │ │ ├── testDSF.cpp
│ │ │ └── testFixedVector.cpp
│ │ ├── discrete/
│ │ │ ├── AllDiff.cpp
│ │ │ ├── AllDiff.h
│ │ │ ├── BinaryAllDiff.h
│ │ │ ├── CMakeLists.txt
│ │ │ ├── CSP.cpp
│ │ │ ├── CSP.h
│ │ │ ├── Constraint.h
│ │ │ ├── Domain.cpp
│ │ │ ├── Domain.h
│ │ │ ├── Scheduler.cpp
│ │ │ ├── Scheduler.h
│ │ │ ├── SingleValue.cpp
│ │ │ ├── SingleValue.h
│ │ │ ├── examples/
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── Doodle.csv
│ │ │ │ ├── Doodle.xls
│ │ │ │ ├── Doodle2012.csv
│ │ │ │ ├── Doodle2012.xls
│ │ │ │ ├── Doodle2013.csv
│ │ │ │ ├── Doodle2013.xls
│ │ │ │ ├── intrusive.xlsx
│ │ │ │ ├── schedulingExample.cpp
│ │ │ │ ├── schedulingQuals12.cpp
│ │ │ │ ├── schedulingQuals13.cpp
│ │ │ │ └── small.csv
│ │ │ └── tests/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── testCSP.cpp
│ │ │ ├── testLoopyBelief.cpp
│ │ │ ├── testScheduler.cpp
│ │ │ └── testSudoku.cpp
│ │ ├── dynamics/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── DynamicsPriors.h
│ │ │ ├── FullIMUFactor.h
│ │ │ ├── IMUFactor.h
│ │ │ ├── Pendulum.h
│ │ │ ├── PoseRTV.cpp
│ │ │ ├── PoseRTV.h
│ │ │ ├── SimpleHelicopter.cpp
│ │ │ ├── SimpleHelicopter.h
│ │ │ ├── VelocityConstraint.h
│ │ │ ├── VelocityConstraint3.h
│ │ │ └── tests/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── testIMUSystem.cpp
│ │ │ ├── testPendulumFactors.cpp
│ │ │ ├── testPoseRTV.cpp
│ │ │ ├── testSimpleHelicopter.cpp
│ │ │ ├── testVelocityConstraint.cpp
│ │ │ └── testVelocityConstraint3.cpp
│ │ ├── examples/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── ConcurrentCalibration.cpp
│ │ │ ├── ConcurrentFilteringAndSmoothingExample.cpp
│ │ │ ├── FixedLagSmootherExample.cpp
│ │ │ ├── README.md
│ │ │ ├── SmartProjectionFactorExample.cpp
│ │ │ ├── SmartRangeExample_plaza1.cpp
│ │ │ ├── SmartRangeExample_plaza2.cpp
│ │ │ ├── SmartStereoProjectionFactorExample.cpp
│ │ │ ├── TimeOfArrivalExample.cpp
│ │ │ └── plotRangeResults.p
│ │ ├── geometry/
│ │ │ ├── BearingS2.cpp
│ │ │ ├── BearingS2.h
│ │ │ ├── CMakeLists.txt
│ │ │ ├── Event.cpp
│ │ │ ├── Event.h
│ │ │ ├── InvDepthCamera3.h
│ │ │ ├── Pose3Upright.cpp
│ │ │ ├── Pose3Upright.h
│ │ │ ├── SimPolygon2D.cpp
│ │ │ ├── SimPolygon2D.h
│ │ │ ├── SimWall2D.cpp
│ │ │ ├── SimWall2D.h
│ │ │ ├── Similarity3.cpp
│ │ │ ├── Similarity3.h
│ │ │ └── tests/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── testBearingS2.cpp
│ │ │ ├── testEvent.cpp
│ │ │ ├── testInvDepthCamera3.cpp
│ │ │ ├── testPose3Upright.cpp
│ │ │ ├── testSimPolygon2D.cpp
│ │ │ ├── testSimWall2D.cpp
│ │ │ └── testSimilarity3.cpp
│ │ ├── gtsam_unstable.i
│ │ ├── linear/
│ │ │ ├── ActiveSetSolver-inl.h
│ │ │ ├── ActiveSetSolver.h
│ │ │ ├── CMakeLists.txt
│ │ │ ├── EqualityFactorGraph.h
│ │ │ ├── InequalityFactorGraph.h
│ │ │ ├── InfeasibleInitialValues.h
│ │ │ ├── InfeasibleOrUnboundedProblem.h
│ │ │ ├── LP.h
│ │ │ ├── LPInitSolver.cpp
│ │ │ ├── LPInitSolver.h
│ │ │ ├── LPSolver.cpp
│ │ │ ├── LPSolver.h
│ │ │ ├── LinearCost.h
│ │ │ ├── LinearEquality.h
│ │ │ ├── LinearInequality.h
│ │ │ ├── QP.h
│ │ │ ├── QPInitSo
================================================
FILE CONTENTS
================================================
================================================
FILE: .gitmodules
================================================
[submodule "ros-bridge"]
path = ros-bridge
url = https://github.com/carla-simulator/ros-bridge.git
branch = master
================================================
FILE: LICENSE
================================================
MIT License
Copyright (c) 2022 Jie Cheng
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.
================================================
FILE: README.md
================================================
# GPIR
This is the project page of the paper "Real-Time Trajectory Planning for Autonomous Driving with Gaussian Process and Incremental Refinement", to appear in ICRA 2022.
GPIR is developed aiming to provide an unified real-time trajectory planning framework in dynamic environment for autonomous driving.
## About
*Demo video*: [YouTube](https://youtu.be/PFfj7PzZ3PU)
*Author*: Jie Cheng, Yingbing Chen, Qingwen Zhang, Lu Gan and Ming Liu, [RAM-LAB](https://ram-lab.com/)
If you find this repo helpful for your research, please cite our related paper.
```bibtex
@inproceedings{Jie2022gpir,
title = {Real-Time Trajectory Planning for Autonomous Driving with {G}aussian Process and Incremental Refinement},
author = {Cheng, Jie and Chen, Yingbing and Zhang, Qingwen and Gan, Lu and Liu, Chengju and Liu, Ming},
booktitle = {2022 IEEE International Conference on Robotics and Automation (ICRA)},
year = {2022},
organization = {IEEE}
}
```
## Prerequisites
Our software is developed and tested in Ubuntu20.04 with ROS noetic. Follow [this link](http://wiki.ros.org/noetic/Installation/Ubuntu) to install noetic.
### Simulation environment
We use **Carla-0.9.11** as the simulator (download via this [link](https://github.com/carla-simulator/carla/releases/tag/0.9.11)), and recommend to use a conda environment.
```
conda create -n carla_py37 python=3.7
```
To use the Carla PythonAPI, you need to export the path or install it
```
export PYTHONPATH=$PYTHONPATH:/carla_directory/PythonAPI/carla/dist/carla-0.9.11-py3.7-linux-x86_64.egg
```
or
```
pip install /carla_directory/PythonAPI/carla/dist/carla-0.9.11-py3.7-linux-x86_64.egg
```
Note that ROS melodic or below use Python2, and you may need to change python version above accordingly.
## Build
### Clone the repository
```
cd ${YOUR_WORKSPACE}/src
git clone --recurse-submodules https://github.com/jchengai/gpir.git
```
### Setup dependencies
```
cd gpir
conda activate carla_py37
pip install -r ./requirements.txt
bash ./setup.sh
```
You may check the pip path via `which pip`.
### Build gpir
```
cd ../../
catkin_make -DCMAKE_BUILD_TYPE=RELEASE -j4
source ./devel/setup.sh
```
## Run a demo
### Start carla-0.9.11
```
cd to_your_carla_folder && ./carla.sh
```
### Start carla ros bridge
```
roslaunch planning_core carla_setup.launch
```
### Start gp_planner
```
roslaunch planning_core planning.launch
```
<p align="center">
<img src="misc/demo.jpeg" width="600"/>
</p>
### Start the control console
Since this repo does not contain the behavior planner, we provide a simple interface for manually controlling the behavior of the Ego vehicle.
```
roslaunch planning_core keyboard.launch
```
<p align="center">
<img src="misc/keyboard.png" width="400"/>
</p>
## Acknowledgements
We would like to express sincere thanks to the authors of the following tools and packages:
- Opendrive map parser: [ad_map](https://github.com/carla-simulator/map)
- QP solver: [osqp](https://github.com/osqp/osqp)
- iSAM solver: [GTSAM](https://github.com/borglab/gtsam)
- Visualization: [EPSILON](https://github.com/HKUST-Aerial-Robotics/EPSILON)
- Spline smoothing & some math utils: [Apollo](https://github.com/ApolloAuto/apollo)
Please let me know if your work is not properly cited or acknowledged, and thanks again for these authors who kindly open-sourcing their work to the community.
## License
The source code is released under [MIT](https://opensource.org/licenses/MIT) license.
## Disclaimer
This is research code, it is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of merchantability or fitness for a particular purpose.
================================================
FILE: common/.gitignore
================================================
**/build
**/install
================================================
FILE: common/CMakeLists.txt
================================================
cmake_minimum_required(VERSION 3.13.0)
project(common CXX)
if(NOT CMAKE_BUILD_TYPE)
set(CMAKE_BUILD_TYPE Release)
endif()
set(CMAKE_CXX_STANDARD 14)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CXX_EXTENSIONS OFF)
set(CMAKE_CXX_FLAGS "-Wall -Wextra")
set(CMAKE_CXX_FLAGS_DEBUG "-g")
set(CMAKE_CXX_FLAGS_RELEASE "-O2")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -march=native")
catkin_package()
set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${PROJECT_SOURCE_DIR}/cmake/")
find_package(Glog REQUIRED)
find_package(Eigen3 REQUIRED)
find_package(catkin REQUIRED COMPONENTS
roscpp
std_msgs
)
include_directories(SYSTEM ${EIGEN3_INCLUDE_DIR})
include_directories(${CMAKE_SOURCE_DIR}/gpir)
add_subdirectory(utils)
add_subdirectory(solver)
add_subdirectory(frenet)
add_subdirectory(geometry)
add_subdirectory(smoothing)
add_library(common INTERFACE)
target_link_libraries(common INTERFACE
common::utils
common::solver
common::frenet
common::geometry
common::smoothing
)
================================================
FILE: common/base/state.h
================================================
/**
* Copyright (C) 2022, RAM-LAB, Hong Kong University of Science and Technology
* This file is part of GPIR (https://github.com/jchengai/gpir).
* If you find this repo helpful, please cite the respective publication as
* listed on the above website.
*/
#pragma once
#include <Eigen/Core>
namespace common {
struct State {
double s = 0.0;
double stamp = 0.0;
double heading = 0.0;
double velocity = 0.0;
double acceleration = 0.0;
double jerk = 0.0;
double kappa = 0.0;
double steer = 0.0;
Eigen::Vector2d position;
Eigen::Vector3d debug;
Eigen::Vector3d frenet_d;
Eigen::Vector3d frenet_s;
std::string DebugString() const {
std::ostringstream os;
os << "stamp: " << stamp << ", heading: " << heading
<< ", velocity: " << velocity << ", acceleration: " << acceleration
<< " kappa: " << kappa << ", pos (" << position.x() << ", "
<< position.y() << ")";
return os.str();
}
EIGEN_MAKE_ALIGNED_OPERATOR_NEW
};
} // namespace common
================================================
FILE: common/base/trajectory.h
================================================
/**
* Copyright (C) 2022, RAM-LAB, Hong Kong University of Science and Technology
* This file is part of GPIR (https://github.com/jchengai/gpir).
* If you find this repo helpful, please cite the respective publication as
* listed on the above website.
*/
#pragma once
#include <Eigen/Dense>
#include <iomanip>
#include <vector>
#include <iostream>
#include "common/base/state.h"
#include "common/utils/math.h"
namespace common {
class Trajectory : public std::vector<common::State> {
public:
Trajectory() = default;
virtual ~Trajectory() = default;
int GetNearsetIndex(const Eigen::Vector2d& pos) const {
int min_index = 0;
double dis = 0;
double min_dis = std::numeric_limits<double>::infinity();
for (size_t i = 0; i < size(); ++i) {
dis = (data()[i].position - pos).squaredNorm();
if (dis < min_dis) {
min_index = i;
min_dis = dis;
}
}
return min_index;
}
const common::State& GetNearestState(const Eigen::Vector2d& pos) const {
return data()[GetNearsetIndex(pos)];
}
const common::State GetInterpolatedNearestState(
const Eigen::Vector2d& pos) const {
auto index = GetNearsetIndex(pos);
const auto& near_state = data()[index];
auto tanget = Eigen::Vector2d(std::cos(near_state.heading),
std::sin(near_state.heading));
Eigen::Vector2d vec = pos - near_state.position;
auto next_index = index;
if (vec.dot(tanget) >= 0) {
next_index += 1;
} else {
next_index = index;
index = std::max(0, index - 1);
}
// std::cout << "wtf??" << std::endl;
const auto& s0 = data()[index];
const auto& s1 = data()[next_index];
double w =
(pos.x() - s0.position.x()) / (s1.position.x() - s0.position.x());
common::State inter_state;
inter_state.position = (1 - w) * s0.position + w * s1.position;
inter_state.heading = common::InterpolateAngle(
s0.heading, s0.position.x(), s1.heading, s1.position.x(), pos.x());
inter_state.kappa = (1 - w) * s0.kappa + w * s1.kappa;
inter_state.velocity = (1 - w) * s0.velocity + w * s1.velocity;
// std::cout << "wtf???" << std::endl;
return inter_state;
}
};
inline std::ostream& operator<<(std::ostream& os,
const Trajectory& trajectory) {
os << "Trajectory: \n";
for (const auto& point : trajectory) {
os << std::fixed << std::setprecision(4) << "[" << std::left
<< "x: " << std::setw(6) << point.position.x() << ", "
<< "y: " << std::setw(6) << point.position.y() << ", "
<< "s: " << std::setw(6) << point.s << ", "
<< "v: " << std::setw(6) << point.velocity << ", "
<< "a: " << std::setw(6) << point.acceleration << "]\n";
}
return os;
}
} // namespace common
================================================
FILE: common/base/type.h
================================================
/**
* Copyright (C) 2022, RAM-LAB, Hong Kong University of Science and Technology
* This file is part of GPIR (https://github.com/jchengai/gpir).
* If you find this repo helpful, please cite the respective publication as
* listed on the above website.
*/
#pragma once
#include <vector>
#include <Eigen/Dense>
template<typename T>
using vector_Eigen = std::vector<T, Eigen::aligned_allocator<T>>;
using vector_Eigen2d = vector_Eigen<Eigen::Vector2d>;
using vector_Eigen3d = vector_Eigen<Eigen::Vector3d>;
================================================
FILE: common/cmake/FindGlog.cmake
================================================
# - Try to find Glog
#
# The following variables are optionally searched for defaults
# GLOG_ROOT_DIR: Base directory where all GLOG components are found
#
# The following are set after configuration is done:
# GLOG_FOUND
# GLOG_INCLUDE_DIRS
# GLOG_LIBRARIES
# GLOG_LIBRARYRARY_DIRS
include(FindPackageHandleStandardArgs)
set(GLOG_ROOT_DIR "" CACHE PATH "Folder contains Google glog")
if(WIN32)
find_path(GLOG_INCLUDE_DIR glog/logging.h
PATHS ${GLOG_ROOT_DIR}/src/windows)
else()
find_path(GLOG_INCLUDE_DIR glog/logging.h
PATHS ${GLOG_ROOT_DIR})
endif()
if(MSVC)
find_library(GLOG_LIBRARY_RELEASE libglog_static
PATHS ${GLOG_ROOT_DIR}
PATH_SUFFIXES Release)
find_library(GLOG_LIBRARY_DEBUG libglog_static
PATHS ${GLOG_ROOT_DIR}
PATH_SUFFIXES Debug)
set(GLOG_LIBRARY optimized ${GLOG_LIBRARY_RELEASE} debug ${GLOG_LIBRARY_DEBUG})
else()
find_library(GLOG_LIBRARY glog
PATHS ${GLOG_ROOT_DIR}
PATH_SUFFIXES lib lib64)
endif()
find_package_handle_standard_args(Glog DEFAULT_MSG GLOG_INCLUDE_DIR GLOG_LIBRARY)
if(GLOG_FOUND)
set(GLOG_INCLUDE_DIRS ${GLOG_INCLUDE_DIR})
set(GLOG_LIBRARIES ${GLOG_LIBRARY})
message(STATUS "Found glog (include: ${GLOG_INCLUDE_DIR}, library: ${GLOG_LIBRARY})")
mark_as_advanced(GLOG_ROOT_DIR GLOG_LIBRARY_RELEASE GLOG_LIBRARY_DEBUG
GLOG_LIBRARY GLOG_INCLUDE_DIR)
endif()
================================================
FILE: common/frenet/CMakeLists.txt
================================================
add_library(common_frenet)
add_library(common::frenet ALIAS common_frenet)
target_sources(common_frenet PRIVATE
frenet_transform.cc
)
target_link_libraries(common_frenet
common::utils
)
================================================
FILE: common/frenet/frenet_state.h
================================================
/**
* Copyright (C) 2022, RAM-LAB, Hong Kong University of Science and Technology
* This file is part of GPIR (https://github.com/jchengai/gpir).
* If you find this repo helpful, please cite the respective publication as
* listed on the above website.
*/
#pragma once
#include <Eigen/Dense>
#include <array>
#include <string>
namespace common {
struct FrenetPoint {
double s = 0.0;
double d = 0.0;
FrenetPoint() = default;
FrenetPoint(const double s, const double d) : s(s), d(d) {}
std::string DebugString() const {
return "[FrenetPoint] s: " + std::to_string(s) +
", d: " + std::to_string(d);
}
};
struct FrenetReferencePoint {
Eigen::Vector2d point;
double s = 0.0;
double theta = 0.0;
double kappa = 0.0;
double dkappa = 0.0;
std::string DebugString() const {
std::ostringstream os;
os << "[FrenetReferencePoint]:\n "
<< "point: (" << point.x() << ", " << point.y() << ")\n "
<< "s: " << s << "\n "
<< "theta: " << theta << "\n "
<< "kappa: " << kappa << "\n "
<< "dkappa: " << dkappa << "\n";
return os.str();
}
};
struct FrenetState {
FrenetState() = default;
FrenetState(const Eigen::Vector3d& s, const Eigen::Vector3d& d)
: s(s), d(d) {}
enum class DerivativeType {
kDs = 0,
kDt = 1,
};
Eigen::Vector3d s;
Eigen::Vector3d d;
DerivativeType type = DerivativeType::kDs;
FrenetPoint frenet_point() { return FrenetPoint(s[0], d[0]); }
std::string DebugString() const {
std::ostringstream os;
os << "[FrenetState]:\n "
<< "s: (" << s[0] << ", " << s[1] << ", " << s[2] << ")\n "
<< "d: (" << d[0] << ", " << d[1] << ", " << d[2] << ")\n";
return os.str();
}
EIGEN_MAKE_ALIGNED_OPERATOR_NEW
};
} // namespace common
================================================
FILE: common/frenet/frenet_transform.cc
================================================
/**
* Copyright (C) 2022, RAM-LAB, Hong Kong University of Science and Technology
* This file is part of GPIR (https://github.com/jchengai/gpir).
* If you find this repo helpful, please cite the respective publication as
* listed on the above website.
*/
#include "common/frenet/frenet_transform.h"
#include <glog/logging.h>
#include "common/utils/math.h"
namespace common {
constexpr double kEpsilon = 1e-6;
void FrenetTransfrom::StateToFrenetState(const State& state,
const FrenetReferencePoint& ref,
FrenetState* frenet_state) {
Eigen::Vector2d normal(-std::sin(ref.theta), std::cos(ref.theta));
frenet_state->d[0] = (state.position - ref.point).dot(normal);
const double one_minus_kappa_rd = 1 - ref.kappa * frenet_state->d[0];
const double delta_theta = NormalizeAngle(state.heading - ref.theta);
const double tan_delta_theta = std::tan(delta_theta);
const double cos_delta_theta = std::cos(delta_theta);
frenet_state->d[1] = one_minus_kappa_rd * tan_delta_theta;
const double dkappa_d_kappa_dd =
ref.dkappa * frenet_state->d[0] + ref.kappa * frenet_state->d[1];
frenet_state->d[2] =
-dkappa_d_kappa_dd * tan_delta_theta +
one_minus_kappa_rd / (cos_delta_theta * cos_delta_theta) *
(ref.kappa * one_minus_kappa_rd / cos_delta_theta - ref.kappa);
frenet_state->s[0] = ref.s;
frenet_state->s[1] = state.velocity * cos_delta_theta / one_minus_kappa_rd;
const double d_delta_theta =
1.0 / (1.0 + tan_delta_theta * tan_delta_theta) *
(frenet_state->d[2] * one_minus_kappa_rd +
frenet_state->d[1] * frenet_state->d[1] * ref.kappa) /
(one_minus_kappa_rd * one_minus_kappa_rd);
frenet_state->s[2] =
(state.acceleration * cos_delta_theta -
frenet_state->s[1] * frenet_state->s[1] *
(frenet_state->d[1] * d_delta_theta - dkappa_d_kappa_dd)) /
one_minus_kappa_rd;
}
void FrenetTransfrom::FrenetStateToState(const FrenetState& frenet_state,
const FrenetReferencePoint& ref,
State* state) {
Eigen::Vector2d normal(-std::sin(ref.theta), std::cos(ref.theta));
const double one_minus_kappa_rd = 1 - ref.kappa * frenet_state.d[0];
const double tan_delta_theta = frenet_state.d[1] / one_minus_kappa_rd;
const double delta_theta = std::atan2(frenet_state.d[1], one_minus_kappa_rd);
const double cos_delta_theta = std::cos(delta_theta);
state->s = ref.s;
state->position = normal * frenet_state.d[0] + ref.point;
state->velocity = frenet_state.s[1] * one_minus_kappa_rd / cos_delta_theta;
state->heading = NormalizeAngle(delta_theta + ref.theta);
const double dkappa_d_kappa_dd =
ref.dkappa * frenet_state.d[0] + ref.kappa * frenet_state.d[1];
state->kappa = (((frenet_state.d[2] + dkappa_d_kappa_dd * tan_delta_theta) *
(cos_delta_theta * cos_delta_theta) / one_minus_kappa_rd) +
ref.kappa) *
cos_delta_theta / one_minus_kappa_rd;
const double d_delta_theta =
1.0 / (1.0 + tan_delta_theta * tan_delta_theta) *
(frenet_state.d[2] * one_minus_kappa_rd +
frenet_state.d[1] * frenet_state.d[1] * ref.kappa) /
(one_minus_kappa_rd * one_minus_kappa_rd);
state->acceleration =
frenet_state.s[2] * one_minus_kappa_rd / cos_delta_theta +
frenet_state.s[1] * frenet_state.s[1] / cos_delta_theta *
(frenet_state.d[1] - dkappa_d_kappa_dd);
}
void FrenetTransfrom::LateralFrenetStateToState(const Eigen::Vector3d& d,
const FrenetReferencePoint& ref,
common::State* state) {
Eigen::Vector2d normal(-std::sin(ref.theta), std::cos(ref.theta));
const double one_minus_kappa_rd = 1 - ref.kappa * d[0];
const double tan_delta_theta = d[1] / one_minus_kappa_rd;
const double delta_theta = std::atan2(d[1], one_minus_kappa_rd);
const double cos_delta_theta = std::cos(delta_theta);
const double dkappa_d_kappa_dd = ref.dkappa * d[0] + ref.kappa * d[1];
state->s = ref.s;
state->position = normal * d[0] + ref.point;
state->heading = NormalizeAngle(delta_theta + ref.theta);
state->kappa = (((d[2] + dkappa_d_kappa_dd * tan_delta_theta) *
(cos_delta_theta * cos_delta_theta) / one_minus_kappa_rd) +
ref.kappa) *
cos_delta_theta / one_minus_kappa_rd;
}
double FrenetTransfrom::GetCurvature(const std::array<double, 3>& d,
const double kappa_r,
const double dkappa_r) {
const double one_minus_kappa_rd = 1 - kappa_r * d[0];
const double delta_theta = std::atan2(d[1], one_minus_kappa_rd);
const double tan_delta_theta = d[1] / one_minus_kappa_rd;
const double cos_delta_theta = std::cos(delta_theta);
const double dkappa_d_kappa_dd = dkappa_r * d[0] + kappa_r * d[1];
return (((d[2] + dkappa_d_kappa_dd * tan_delta_theta) *
(cos_delta_theta * cos_delta_theta) / one_minus_kappa_rd) +
kappa_r) *
cos_delta_theta / one_minus_kappa_rd;
}
} // namespace common
================================================
FILE: common/frenet/frenet_transform.h
================================================
/**
* Copyright (C) 2022, RAM-LAB, Hong Kong University of Science and Technology
* This file is part of GPIR (https://github.com/jchengai/gpir).
* If you find this repo helpful, please cite the respective publication as
* listed on the above website.
*/
#pragma once
#include "common/base/state.h"
#include "common/base/trajectory.h"
#include "common/frenet/frenet_state.h"
namespace common {
class FrenetTransfrom {
public:
static void StateToFrenetState(const State& state,
const FrenetReferencePoint& ref,
FrenetState* frenet_state);
// static void SpeedProfileToFrenet(const Eigen::Vector3d& s, const
// FrenetReferencePoint& ref, Eigen::Vector3d)
static void FrenetStateToState(const FrenetState& frenet_state,
const FrenetReferencePoint& ref, State* state);
static void LateralFrenetStateToState(const Eigen::Vector3d& d,
const FrenetReferencePoint& ref,
common::State* state);
static double GetCurvature(const std::array<double, 3>& d,
const double kappa_r, const double dkappa_r);
};
} // namespace common
================================================
FILE: common/geometry/CMakeLists.txt
================================================
add_library(common_geometry)
add_library(common::geometry ALIAS common_geometry)
target_sources(common_geometry PRIVATE
box2d.cc
)
================================================
FILE: common/geometry/box2d.cc
================================================
/**
* Copyright (C) 2022, RAM-LAB, Hong Kong University of Science and Technology
* This file is part of GPIR (https://github.com/jchengai/gpir).
* If you find this repo helpful, please cite the respective publication as
* listed on the above website.
*/
#include "common/geometry/box2d.h"
namespace common {
Box2D::Box2D(const Eigen::Vector2d& center, const double length,
const double width, const double angle, const double height)
: center_(center),
half_length_(length / 2.0),
half_width_(width / 2.0),
angle_(angle),
height_(height) {
CalculateCorners();
}
void Box2D::CalculateCorners() {
cos_angle_ = std::cos(angle_);
sin_angle_ = std::sin(angle_);
helper_[0] = cos_angle_ * half_length_;
helper_[1] = sin_angle_ * half_length_;
helper_[2] = sin_angle_ * half_width_;
helper_[3] = -cos_angle_ * half_width_;
corners_.clear();
corners_.emplace_back(center_.x() + helper_[0] + helper_[2],
center_.y() + helper_[1] + helper_[3]);
corners_.emplace_back(center_.x() + helper_[0] - helper_[2],
center_.y() + helper_[1] - helper_[3]);
corners_.emplace_back(center_.x() - helper_[0] - helper_[2],
center_.y() - helper_[1] - helper_[3]);
corners_.emplace_back(center_.x() - helper_[0] + helper_[2],
center_.y() - helper_[1] + helper_[3]);
auto x_minmax = std::minmax_element(
corners_.cbegin(), corners_.cend(),
[](const Eigen::Vector2d& p1, const Eigen::Vector2d p2) -> bool {
return p1.x() < p2.x();
});
auto y_minmax = std::minmax_element(
corners_.cbegin(), corners_.cend(),
[](const Eigen::Vector2d& p1, const Eigen::Vector2d p2) -> bool {
return p1.y() < p2.y();
});
xlim_[0] = x_minmax.first->x();
xlim_[1] = x_minmax.second->x();
ylim_[0] = y_minmax.first->y();
ylim_[1] = y_minmax.second->y();
}
bool Box2D::HasOverlapWith(const Box2D& box) {
if (box.xlim_[1] < xlim_[0] || box.xlim_[0] > xlim_[1] ||
box.ylim_[1] < ylim_[0] || box.ylim_[0] > ylim_[1]) {
return false;
}
const double dx = box.center_.x() - center_.x();
const double dy = box.center_.y() - center_.y();
return std::abs(dx * cos_angle_ + dy * sin_angle_) <=
std::abs(box.helper_[0] * cos_angle_ +
box.helper_[1] * sin_angle_) +
std::abs(box.helper_[2] * cos_angle_ +
box.helper_[3] * sin_angle_) +
half_length_ &&
std::abs(dx * sin_angle_ - dy * cos_angle_) <=
std::abs(box.helper_[0] * sin_angle_ -
box.helper_[1] * cos_angle_) +
std::abs(box.helper_[2] * sin_angle_ -
box.helper_[3] * cos_angle_) +
half_width_ &&
std::abs(dx * box.cos_angle_ + dy * box.sin_angle_) <=
std::abs(helper_[0] * box.cos_angle_ +
helper_[1] * box.sin_angle_) +
std::abs(helper_[2] * box.cos_angle_ +
helper_[3] * box.sin_angle_) +
box.half_length_ &&
std::abs(dx * box.sin_angle_ - dy * box.cos_angle_) <=
std::abs(helper_[0] * box.sin_angle_ -
helper_[1] * box.cos_angle_) +
std::abs(helper_[2] * box.sin_angle_ -
helper_[3] * box.cos_angle_) +
box.half_width_;
}
} // namespace common
================================================
FILE: common/geometry/box2d.h
================================================
/**
* Copyright (C) 2022, RAM-LAB, Hong Kong University of Science and Technology
* This file is part of GPIR (https://github.com/jchengai/gpir).
* If you find this repo helpful, please cite the respective publication as
* listed on the above website.
*/
#pragma once
#include <Eigen/Core>
#include <vector>
#include "common/base/type.h"
namespace common {
class Box2D {
public:
Box2D() = default;
Box2D(const Eigen::Vector2d& center, const double length, const double width,
const double angle, const double height = 0.0);
~Box2D() = default;
bool HasOverlapWith(const Box2D& box);
inline double angle() const { return angle_; }
inline double length() const { return 2 * half_length_; }
inline double width() const { return 2 * half_width_; }
inline double height() const { return height_; }
inline const Eigen::Vector2d& center() const { return center_; }
inline const vector_Eigen<Eigen::Vector2d>& GetArchorPoints() const {
return corners_;
}
inline const std::array<double, 2>& xlim() const { return xlim_; }
inline const std::array<double, 2>& ylim() const { return ylim_; }
private:
void CalculateCorners();
private:
Eigen::Vector2d center_;
double half_length_ = 0.0;
double half_width_ = 0.0;
double angle_ = 0.0;
double height_ = 0.0;
double cos_angle_ = 0.0;
double sin_angle_ = 0.0;
// right-bottom cornor is the start point, clock-wise
vector_Eigen<Eigen::Vector2d> corners_;
// <min, max> of aabb
std::array<double, 2> xlim_{1e9, -1e9};
std::array<double, 2> ylim_{1e9, -1e9};
// for efficiency
std::array<double, 4> helper_{0, 0, 0, 0};
};
} // namespace common
================================================
FILE: common/graph/dijkstra.hpp
================================================
/**
* Copyright (C) 2022, RAM-LAB, Hong Kong University of Science and Technology
* This file is part of GPIR (https://github.com/jchengai/gpir).
* If you find this repo helpful, please cite the respective publication as
* listed on the above website.
*/
#pragma once
#include <algorithm>
#include <iostream>
#include <limits>
#include <queue>
#include <unordered_map>
#include <utility>
namespace common {
template <typename T = int, typename Hash = std::hash<T>>
class Dijkstra {
struct DijkstraVertex {
T index;
T parent; // same as index if not assigned
std::vector<std::pair<T, double>>
edges; // might repeat, users' reasonability
double dist = std::numeric_limits<double>::infinity();
DijkstraVertex() = default;
DijkstraVertex(const T _index) : index(_index), parent(_index) {}
};
public:
Dijkstra() = default;
void AddEdge(const T& from, const T& to, const double weight);
bool FindPath(const T& source, const T& target, std::vector<T>* path);
private:
std::unordered_map<T, DijkstraVertex, Hash> graph_;
};
template <typename T, typename Hash>
void Dijkstra<T, Hash>::AddEdge(const T& from, const T& to,
const double weight) {
auto it_from = graph_.find(from);
if (it_from == graph_.end()) {
DijkstraVertex vertex(from);
vertex.edges.emplace_back(std::pair<T, double>(to, weight));
graph_[from] = vertex;
} else {
it_from->second.edges.emplace_back(std::pair<T, double>(to, weight));
}
if (graph_.find(to) == graph_.end()) {
graph_[to] = DijkstraVertex(to);
}
}
template <typename T, typename Hash>
bool Dijkstra<T, Hash>::FindPath(const T& source, const T& target,
std::vector<T>* path) {
typedef typename std::pair<T, double> Edge;
typedef typename std::vector<std::pair<T, double>> Edges;
if (graph_.find(source) == graph_.end() ||
graph_.find(target) == graph_.end()) {
fprintf(stderr, "source vertex or target vertex is not in the graph\n");
return false;
} else if (source == target) {
fprintf(stderr, "source and target is same\n");
return false;
}
auto Compare = [](const Edge& e1, const Edge& e2) -> bool {
return e1.second > e2.second;
};
std::priority_queue<Edge, Edges, decltype(Compare)> unvisited_set(Compare);
unvisited_set.push(Edge(source, 0));
graph_[source].dist = 0;
while (!unvisited_set.empty()) {
T current_index = unvisited_set.top().first;
if (current_index == target) break;
double current_dist = unvisited_set.top().second;
unvisited_set.pop();
const auto& vertex = graph_[current_index];
for (const auto& edge : vertex.edges) {
auto& next_vertex = graph_[edge.first];
if (current_dist + edge.second < next_vertex.dist) {
next_vertex.dist = current_dist + edge.second;
unvisited_set.push(Edge(next_vertex.index, next_vertex.dist));
next_vertex.parent = current_index;
}
}
}
if (graph_[target].dist == std::numeric_limits<double>::max()) {
fprintf(stderr, "cannot find a path\n");
return false;
}
path->emplace_back(target);
while (true) {
const auto& current_vertex = graph_[path->back()];
if (current_vertex.index != current_vertex.parent) {
path->emplace_back(current_vertex.parent);
} else {
break;
}
}
std::reverse(path->begin(), path->end());
return true;
}
} // namespace common
================================================
FILE: common/package.xml
================================================
<?xml version="1.0"?>
<package format="2">
<name>common</name>
<version>0.0.0</version>
<description>The common package</description>
<maintainer email="jchengai@todo.todo">udi</maintainer>
<license>TODO</license>
<buildtool_depend>catkin</buildtool_depend>
<build_depend>roscpp</build_depend>
<build_export_depend>roscpp</build_export_depend>
<exec_depend>roscpp</exec_depend>
</package>
================================================
FILE: common/smoothing/CMakeLists.txt
================================================
add_library(common_smoothing)
add_library(common::smoothing ALIAS common_smoothing)
target_sources(common_smoothing
PRIVATE
affine_constraint.cc
discrete_points_math.cc
osqp_spline1d_solver.cc
osqp_spline2d_solver.cc
polynomialxd.cc
spline1d_constraint.cc
spline1d_kernel_helper.cc
spline1d_kernel.cc
spline1d_seg.cc
spline1d.cc
spline2d_constraint.cc
spline2d_kernel.cc
spline2d_seg
spline2d.cc
)
target_link_libraries(common_smoothing
glog
common_solver
)
================================================
FILE: common/smoothing/LICENSE
================================================
Copyright (c) 2018 Apollo Authors. All Rights Reserved
Apache License
Version 2.0, January 2004
http://www.apache.org/licenses/
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
1. Definitions.
"License" shall mean the terms and conditions for use, reproduction,
and distribution as defined by Sections 1 through 9 of this document.
"Licensor" shall mean the copyright owner or entity authorized by
the copyright owner that is granting the License.
"Legal Entity" shall mean the union of the acting entity and all
other entities that control, are controlled by, or are under common
control with that entity. For the purposes of this definition,
"control" means (i) the power, direct or indirect, to cause the
direction or management of such entity, whether by contract or
otherwise, or (ii) ownership of fifty percent (50%) or more of the
outstanding shares, or (iii) beneficial ownership of such entity.
"You" (or "Your") shall mean an individual or Legal Entity
exercising permissions granted by this License.
"Source" form shall mean the preferred form for making modifications,
including but not limited to software source code, documentation
source, and configuration files.
"Object" form shall mean any form resulting from mechanical
transformation or translation of a Source form, including but
not limited to compiled object code, generated documentation,
and conversions to other media types.
"Work" shall mean the work of authorship, whether in Source or
Object form, made available under the License, as indicated by a
copyright notice that is included in or attached to the work
(an example is provided in the Appendix below).
"Derivative Works" shall mean any work, whether in Source or Object
form, that is based on (or derived from) the Work and for which the
editorial revisions, annotations, elaborations, or other modifications
represent, as a whole, an original work of authorship. For the purposes
of this License, Derivative Works shall not include works that remain
separable from, or merely link (or bind by name) to the interfaces of,
the Work and Derivative Works thereof.
"Contribution" shall mean any work of authorship, including
the original version of the Work and any modifications or additions
to that Work or Derivative Works thereof, that is intentionally
submitted to Licensor for inclusion in the Work by the copyright owner
or by an individual or Legal Entity authorized to submit on behalf of
the copyright owner. For the purposes of this definition, "submitted"
means any form of electronic, verbal, or written communication sent
to the Licensor or its representatives, including but not limited to
communication on electronic mailing lists, source code control systems,
and issue tracking systems that are managed by, or on behalf of, the
Licensor for the purpose of discussing and improving the Work, but
excluding communication that is conspicuously marked or otherwise
designated in writing by the copyright owner as "Not a Contribution."
"Contributor" shall mean Licensor and any individual or Legal Entity
on behalf of whom a Contribution has been received by Licensor and
subsequently incorporated within the Work.
2. Grant of Copyright License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
copyright license to reproduce, prepare Derivative Works of,
publicly display, publicly perform, sublicense, and distribute the
Work and such Derivative Works in Source or Object form.
3. Grant of Patent License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
(except as stated in this section) patent license to make, have made,
use, offer to sell, sell, import, and otherwise transfer the Work,
where such license applies only to those patent claims licensable
by such Contributor that are necessarily infringed by their
Contribution(s) alone or by combination of their Contribution(s)
with the Work to which such Contribution(s) was submitted. If You
institute patent litigation against any entity (including a
cross-claim or counterclaim in a lawsuit) alleging that the Work
or a Contribution incorporated within the Work constitutes direct
or contributory patent infringement, then any patent licenses
granted to You under this License for that Work shall terminate
as of the date such litigation is filed.
4. Redistribution. You may reproduce and distribute copies of the
Work or Derivative Works thereof in any medium, with or without
modifications, and in Source or Object form, provided that You
meet the following conditions:
(a) You must give any other recipients of the Work or
Derivative Works a copy of this License; and
(b) You must cause any modified files to carry prominent notices
stating that You changed the files; and
(c) You must retain, in the Source form of any Derivative Works
that You distribute, all copyright, patent, trademark, and
attribution notices from the Source form of the Work,
excluding those notices that do not pertain to any part of
the Derivative Works; and
(d) If the Work includes a "NOTICE" text file as part of its
distribution, then any Derivative Works that You distribute must
include a readable copy of the attribution notices contained
within such NOTICE file, excluding those notices that do not
pertain to any part of the Derivative Works, in at least one
of the following places: within a NOTICE text file distributed
as part of the Derivative Works; within the Source form or
documentation, if provided along with the Derivative Works; or,
within a display generated by the Derivative Works, if and
wherever such third-party notices normally appear. The contents
of the NOTICE file are for informational purposes only and
do not modify the License. You may add Your own attribution
notices within Derivative Works that You distribute, alongside
or as an addendum to the NOTICE text from the Work, provided
that such additional attribution notices cannot be construed
as modifying the License.
You may add Your own copyright statement to Your modifications and
may provide additional or different license terms and conditions
for use, reproduction, or distribution of Your modifications, or
for any such Derivative Works as a whole, provided Your use,
reproduction, and distribution of the Work otherwise complies with
the conditions stated in this License.
5. Submission of Contributions. Unless You explicitly state otherwise,
any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions.
6. Trademarks. This License does not grant permission to use the trade
names, trademarks, service marks, or product names of the Licensor,
except as required for reasonable and customary use in describing the
origin of the Work and reproducing the content of the NOTICE file.
7. Disclaimer of Warranty. Unless required by applicable law or
agreed to in writing, Licensor provides the Work (and each
Contributor provides its Contributions) on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
implied, including, without limitation, any warranties or conditions
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
PARTICULAR PURPOSE. You are solely responsible for determining the
appropriateness of using or redistributing the Work and assume any
risks associated with Your exercise of permissions under this License.
8. Limitation of Liability. In no event and under no legal theory,
whether in tort (including negligence), contract, or otherwise,
unless required by applicable law (such as deliberate and grossly
negligent acts) or agreed to in writing, shall any Contributor be
liable to You for damages, including any direct, indirect, special,
incidental, or consequential damages of any character arising as a
result of this License or out of the use or inability to use the
Work (including but not limited to damages for loss of goodwill,
work stoppage, computer failure or malfunction, or any and all
other commercial damages or losses), even if such Contributor
has been advised of the possibility of such damages.
9. Accepting Warranty or Additional Liability. While redistributing
the Work or Derivative Works thereof, You may choose to offer,
and charge a fee for, acceptance of support, warranty, indemnity,
or other liability obligations and/or rights consistent with this
License. However, in accepting such obligations, You may act only
on Your own behalf and on Your sole responsibility, not on behalf
of any other Contributor, and only if You agree to indemnify,
defend, and hold each Contributor harmless for any liability
incurred by, or claims asserted against, such Contributor by reason
of your accepting any such warranty or additional liability.
END OF TERMS AND CONDITIONS
APPENDIX: How to apply the Apache License to your work.
To apply the Apache License to your work, attach the following
boilerplate notice, with the fields enclosed by brackets "[]"
replaced with your own identifying information. (Don't include
the brackets!) The text should be enclosed in the appropriate
comment syntax for the file format. We also recommend that a
file or class name and description of purpose be included on the
same "printed page" as the copyright notice for easier
identification within third-party archives.
Copyright (c) 2017 Apollo Authors. All Rights Reserve.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
================================================
FILE: common/smoothing/README.md
================================================
The code in this folder is a practice re-implementation of the original [Apollo](https://github.com/ApolloAuto/apollo/tree/master/modules/planning/math/smoothing_spline) smoothing_spline.
The copyright credits to the original authors.
================================================
FILE: common/smoothing/affine_constraint.cc
================================================
/******************************************************************************
* Copyright 2017 The Apollo Authors. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*****************************************************************************/
#include "common/smoothing/affine_constraint.h"
#include <glog/logging.h>
#include <iostream>
#include <utility>
namespace common {
AffineConstraint::AffineConstraint(const Eigen::MatrixXd& constraint_matrix,
const std::vector<double>& lower_bound,
const std::vector<double>& upper_bound)
: constraint_matrix_(constraint_matrix),
lower_bound_(lower_bound),
upper_bound_(upper_bound) {
CHECK_EQ(lower_bound_.size(), upper_bound_.size());
CHECK_EQ(constraint_matrix_.rows(), lower_bound_.size());
}
const Eigen::MatrixXd& AffineConstraint::constraint_matrix() const {
return constraint_matrix_;
}
const std::vector<double>& AffineConstraint::lower_bound() const {
return lower_bound_;
}
const std::vector<double>& AffineConstraint::upper_bound() const {
return upper_bound_;
}
bool AffineConstraint::AddConstraint(const Eigen::MatrixXd& constraint_matrix,
const std::vector<double>& lower_bound,
const std::vector<double>& upper_bound) {
if (static_cast<uint32_t>(constraint_matrix.rows()) != lower_bound.size() ||
static_cast<uint32_t>(constraint_matrix.rows()) != upper_bound.size()) {
LOG(ERROR) << "Fail to add constraint because constraint matrix rows != "
"constraint boundary rows.";
return false;
}
if (constraint_matrix_.rows() == 0) {
constraint_matrix_ = constraint_matrix;
lower_bound_ = lower_bound;
upper_bound_ = upper_bound;
return true;
}
if (constraint_matrix_.cols() != constraint_matrix.cols()) {
LOG(ERROR)
<< "constraint_matrix_ cols and constraint_matrix cols do not match.";
LOG(ERROR) << "constraint_matrix_.cols() = " << constraint_matrix_.cols();
LOG(ERROR) << "constraint_matrix.cols() = " << constraint_matrix.cols();
return false;
}
Eigen::MatrixXd expand_constraint_matrix(
constraint_matrix_.rows() + constraint_matrix.rows(),
constraint_matrix_.cols());
/* matrix resize doesn't save memory allocation operation */
expand_constraint_matrix << constraint_matrix_, constraint_matrix;
constraint_matrix_ = std::move(expand_constraint_matrix);
lower_bound_.insert(lower_bound_.end(), lower_bound.begin(),
lower_bound.end());
upper_bound_.insert(upper_bound_.end(), upper_bound.begin(),
upper_bound.end());
return true;
}
void AffineConstraint::Print() const {
for (size_t i = 0; i < lower_bound_.size(); ++i) {
printf("%d: lower_bound: %.2f, upper_bound: %.2f\n", static_cast<int>(i), lower_bound_[i],
upper_bound_[i]);
}
}
} // namespace common
================================================
FILE: common/smoothing/affine_constraint.h
================================================
/******************************************************************************
* Copyright 2017 The Apollo Authors. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*****************************************************************************/
#pragma once
#include <Eigen/Core>
#include <vector>
#include "common/base/type.h"
#define udrive_inf ((double)1e30) // NOLINT
namespace common {
/**
* @class AffineConstraint
* @brief constraint in form of "l <= Ax <= u", equality constraint means l = u
*/
class AffineConstraint {
public:
AffineConstraint() = default;
AffineConstraint(const Eigen::MatrixXd& constraint_matrix,
const std::vector<double>& lower_bound,
const std::vector<double>& upper_bound);
const Eigen::MatrixXd& constraint_matrix() const;
const std::vector<double>& lower_bound() const;
const std::vector<double>& upper_bound() const;
bool AddConstraint(const Eigen::MatrixXd& constraint_matrix,
const std::vector<double>& lower_bound,
const std::vector<double>& upper_bound);
void Print() const;
private:
Eigen::MatrixXd constraint_matrix_;
std::vector<double> lower_bound_;
std::vector<double> upper_bound_;
};
} // namespace common
================================================
FILE: common/smoothing/discrete_points_math.cc
================================================
/******************************************************************************
* Copyright 2017 The Apollo Authors. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*****************************************************************************/
#include <glog/logging.h>
#include <cmath>
#include "common/smoothing/discrete_points_math.h"
namespace common {
bool DiscretePointsMath::ComputePathProfile(
const std::vector<std::pair<double, double>>& xy_points,
std::vector<double>* headings, std::vector<double>* accumulated_s,
std::vector<double>* kappas, std::vector<double>* dkappas) {
CHECK_NOTNULL(headings);
CHECK_NOTNULL(kappas);
CHECK_NOTNULL(dkappas);
headings->clear();
kappas->clear();
dkappas->clear();
if (xy_points.size() < 2) {
return false;
}
std::vector<double> dxs;
std::vector<double> dys;
std::vector<double> y_over_s_first_derivatives;
std::vector<double> x_over_s_first_derivatives;
std::vector<double> y_over_s_second_derivatives;
std::vector<double> x_over_s_second_derivatives;
// Get finite difference approximated dx and dy for heading and kappa
// calculation
std::size_t points_size = xy_points.size();
for (std::size_t i = 0; i < points_size; ++i) {
double x_delta = 0.0;
double y_delta = 0.0;
if (i == 0) {
x_delta = (xy_points[i + 1].first - xy_points[i].first);
y_delta = (xy_points[i + 1].second - xy_points[i].second);
} else if (i == points_size - 1) {
x_delta = (xy_points[i].first - xy_points[i - 1].first);
y_delta = (xy_points[i].second - xy_points[i - 1].second);
} else {
x_delta = 0.5 * (xy_points[i + 1].first - xy_points[i - 1].first);
y_delta = 0.5 * (xy_points[i + 1].second - xy_points[i - 1].second);
}
dxs.push_back(x_delta);
dys.push_back(y_delta);
}
// Heading calculation
for (std::size_t i = 0; i < points_size; ++i) {
headings->push_back(std::atan2(dys[i], dxs[i]));
}
// Get linear interpolated s for dkappa calculation
double distance = 0.0;
accumulated_s->push_back(distance);
double fx = xy_points[0].first;
double fy = xy_points[0].second;
double nx = 0.0;
double ny = 0.0;
for (std::size_t i = 1; i < points_size; ++i) {
nx = xy_points[i].first;
ny = xy_points[i].second;
double end_segment_s =
std::sqrt((fx - nx) * (fx - nx) + (fy - ny) * (fy - ny));
accumulated_s->push_back(end_segment_s + distance);
distance += end_segment_s;
fx = nx;
fy = ny;
}
// Get finite difference approximated first derivative of y and x respective
// to s for kappa calculation
for (std::size_t i = 0; i < points_size; ++i) {
double xds = 0.0;
double yds = 0.0;
if (i == 0) {
xds = (xy_points[i + 1].first - xy_points[i].first) /
(accumulated_s->at(i + 1) - accumulated_s->at(i));
yds = (xy_points[i + 1].second - xy_points[i].second) /
(accumulated_s->at(i + 1) - accumulated_s->at(i));
} else if (i == points_size - 1) {
xds = (xy_points[i].first - xy_points[i - 1].first) /
(accumulated_s->at(i) - accumulated_s->at(i - 1));
yds = (xy_points[i].second - xy_points[i - 1].second) /
(accumulated_s->at(i) - accumulated_s->at(i - 1));
} else {
xds = (xy_points[i + 1].first - xy_points[i - 1].first) /
(accumulated_s->at(i + 1) - accumulated_s->at(i - 1));
yds = (xy_points[i + 1].second - xy_points[i - 1].second) /
(accumulated_s->at(i + 1) - accumulated_s->at(i - 1));
}
x_over_s_first_derivatives.push_back(xds);
y_over_s_first_derivatives.push_back(yds);
}
// Get finite difference approximated second derivative of y and x respective
// to s for kappa calculation
for (std::size_t i = 0; i < points_size; ++i) {
double xdds = 0.0;
double ydds = 0.0;
if (i == 0) {
xdds =
(x_over_s_first_derivatives[i + 1] - x_over_s_first_derivatives[i]) /
(accumulated_s->at(i + 1) - accumulated_s->at(i));
ydds =
(y_over_s_first_derivatives[i + 1] - y_over_s_first_derivatives[i]) /
(accumulated_s->at(i + 1) - accumulated_s->at(i));
} else if (i == points_size - 1) {
xdds =
(x_over_s_first_derivatives[i] - x_over_s_first_derivatives[i - 1]) /
(accumulated_s->at(i) - accumulated_s->at(i - 1));
ydds =
(y_over_s_first_derivatives[i] - y_over_s_first_derivatives[i - 1]) /
(accumulated_s->at(i) - accumulated_s->at(i - 1));
} else {
xdds = (x_over_s_first_derivatives[i + 1] -
x_over_s_first_derivatives[i - 1]) /
(accumulated_s->at(i + 1) - accumulated_s->at(i - 1));
ydds = (y_over_s_first_derivatives[i + 1] -
y_over_s_first_derivatives[i - 1]) /
(accumulated_s->at(i + 1) - accumulated_s->at(i - 1));
}
x_over_s_second_derivatives.push_back(xdds);
y_over_s_second_derivatives.push_back(ydds);
}
for (std::size_t i = 0; i < points_size; ++i) {
double xds = x_over_s_first_derivatives[i];
double yds = y_over_s_first_derivatives[i];
double xdds = x_over_s_second_derivatives[i];
double ydds = y_over_s_second_derivatives[i];
double kappa =
(xds * ydds - yds * xdds) /
(std::sqrt(xds * xds + yds * yds) * (xds * xds + yds * yds) + 1e-6);
kappas->push_back(kappa);
}
// Dkappa calculation
for (std::size_t i = 0; i < points_size; ++i) {
double dkappa = 0.0;
if (i == 0) {
dkappa = (kappas->at(i + 1) - kappas->at(i)) /
(accumulated_s->at(i + 1) - accumulated_s->at(i));
} else if (i == points_size - 1) {
dkappa = (kappas->at(i) - kappas->at(i - 1)) /
(accumulated_s->at(i) - accumulated_s->at(i - 1));
} else {
dkappa = (kappas->at(i + 1) - kappas->at(i - 1)) /
(accumulated_s->at(i + 1) - accumulated_s->at(i - 1));
}
dkappas->push_back(dkappa);
}
return true;
}
} // namespace common
================================================
FILE: common/smoothing/discrete_points_math.h
================================================
/******************************************************************************
* Copyright 2017 The Apollo Authors. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*****************************************************************************/
#pragma once
#include <utility>
#include <vector>
namespace common {
class DiscretePointsMath {
public:
DiscretePointsMath() = delete;
static bool ComputePathProfile(
const std::vector<std::pair<double, double>>& xy_points,
std::vector<double>* headings, std::vector<double>* accumulated_s,
std::vector<double>* kappas, std::vector<double>* dkappas);
};
} // namespace common
================================================
FILE: common/smoothing/osqp_spline1d_solver.cc
================================================
/******************************************************************************
* Copyright 2017 The Apollo Authors. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*****************************************************************************/
#include "common/smoothing/osqp_spline1d_solver.h"
#include <glog/logging.h>
#include <algorithm>
#include "common/solver/osqp/osqp_interface.h"
namespace common {
OsqpSpline1dSolver::OsqpSpline1dSolver(const std::vector<double>& t_knots,
const uint32_t order)
: Spline1dSolver(t_knots, order) {}
void OsqpSpline1dSolver::Reset(const std::vector<double>& t_knots,
const uint32_t order) {
spline_ = Spline1d(t_knots, order);
kernel_ = Spline1dKernel(t_knots, order);
constraint_ = Spline1dConstraint(t_knots, order);
}
Spline1dConstraint* OsqpSpline1dSolver::mutable_constraint() {
return &constraint_;
}
Spline1dKernel* OsqpSpline1dSolver::mutable_kernel() { return &kernel_; }
Spline1d* OsqpSpline1dSolver::mutable_spline() { return &spline_; }
bool OsqpSpline1dSolver::Solve() {
const Eigen::MatrixXd& P = kernel_.kernel_matrix();
const Eigen::MatrixXd& A = constraint_.constraint_matrix();
Eigen::VectorXd q = kernel_.gradient();
const size_t n = A.rows();
// have to copy once anyway
std::vector<double> lower_bound(constraint_.lower_bound());
std::vector<double> upper_bound(constraint_.upper_bound());
// Eigen::Map does not create its own memory
Eigen::VectorXd l =
Eigen::Map<Eigen::VectorXd, Eigen::Aligned>(lower_bound.data(), n);
Eigen::VectorXd u =
Eigen::Map<Eigen::VectorXd, Eigen::Aligned>(upper_bound.data(), n);
Eigen::VectorXd solution;
if (!OsqpInterface::Solve(P, q, A, l, u, &solution)) {
LOG(ERROR) << "fail to solve the spline";
return false;
}
return spline_.set_splines(solution, spline_.spline_order());
}
// extract
const Spline1d& OsqpSpline1dSolver::spline() const { return spline_; }
} // namespace common
================================================
FILE: common/smoothing/osqp_spline1d_solver.h
================================================
/******************************************************************************
* Copyright 2017 The Apollo Authors. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*****************************************************************************/
#pragma once
#include <vector>
#include "common/smoothing/spline1d_solver.h"
namespace common {
class OsqpSpline1dSolver final : public Spline1dSolver {
public:
OsqpSpline1dSolver(const std::vector<double>& t_knots, const uint32_t order);
// ~OsqpSpline1dSolver() = default;
void Reset(const std::vector<double>& t_knots, const uint32_t order) override;
// customize setup
Spline1dConstraint* mutable_constraint() override;
Spline1dKernel* mutable_kernel() override;
Spline1d* mutable_spline() override;
// solve
bool Solve() override;
// extract
const Spline1d& spline() const override;
};
} // namespace common
================================================
FILE: common/smoothing/osqp_spline2d_solver.cc
================================================
/******************************************************************************
* Copyright 2017 The Apollo Authors. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*****************************************************************************/
#include "common/smoothing/osqp_spline2d_solver.h"
#include <glog/logging.h>
#include <algorithm>
#include "common/solver/osqp/osqp_interface.h"
namespace common {
OsqpSpline2dSolver::OsqpSpline2dSolver(const std::vector<double>& t_knots,
const uint32_t order)
: Spline2dSolver(t_knots, order) {}
void OsqpSpline2dSolver::Reset(const std::vector<double>& t_knots,
const uint32_t order) {
spline_ = Spline2d(t_knots, order);
kernel_ = Spline2dKernel(t_knots, order);
constraint_ = Spline2dConstraint(t_knots, order);
}
Spline2dConstraint* OsqpSpline2dSolver::mutable_constraint() {
return &constraint_;
}
Spline2dKernel* OsqpSpline2dSolver::mutable_kernel() { return &kernel_; }
Spline2d* OsqpSpline2dSolver::mutable_spline() { return &spline_; }
bool OsqpSpline2dSolver::Solve() {
const Eigen::MatrixXd& P = kernel_.kernel_matrix();
const Eigen::MatrixXd& A = constraint_.constraint_matrix();
Eigen::VectorXd q = kernel_.gradient();
const size_t n = A.rows();
// have to copy once anyway
std::vector<double> lower_bound(constraint_.lower_bound());
std::vector<double> upper_bound(constraint_.upper_bound());
// Eigen::Map does not create its own memory
Eigen::VectorXd l =
Eigen::Map<Eigen::VectorXd, Eigen::Aligned>(lower_bound.data(), n);
Eigen::VectorXd u =
Eigen::Map<Eigen::VectorXd, Eigen::Aligned>(upper_bound.data(), n);
Eigen::VectorXd solution;
if (!OsqpInterface::Solve(P, q, A, l, u, &solution)) {
LOG(ERROR) << "fail to solve the spline";
return false;
}
return spline_.set_splines(solution, spline_.spline_order());
}
// extract
const Spline2d& OsqpSpline2dSolver::spline() const { return spline_; }
} // namespace common
================================================
FILE: common/smoothing/osqp_spline2d_solver.h
================================================
/******************************************************************************
* Copyright 2017 The Apollo Authors. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*****************************************************************************/
#pragma once
#include <vector>
#include "common/smoothing/spline2d_solver.h"
namespace common {
class OsqpSpline2dSolver final : public Spline2dSolver {
public:
OsqpSpline2dSolver(const std::vector<double>& t_knots, const uint32_t order);
~OsqpSpline2dSolver() = default;
void Reset(const std::vector<double>& t_knots, const uint32_t order) override;
// customize setup
Spline2dConstraint* mutable_constraint() override;
Spline2dKernel* mutable_kernel() override;
Spline2d* mutable_spline() override;
// solve
bool Solve() override;
// extract
const Spline2d& spline() const override;
};
} // namespace common
================================================
FILE: common/smoothing/polynomialxd.cc
================================================
/******************************************************************************
* Copyright 2017 The Apollo Authors. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*****************************************************************************/
#include <glog/logging.h>
#include "common/smoothing/polynomialxd.h"
namespace common {
PolynomialXd::PolynomialXd(const std::uint32_t order)
: params_(order + 1, 0.0) {
CHECK_GE(order, 0);
}
PolynomialXd::PolynomialXd(const std::vector<double>& params)
: params_(params) {
CHECK(!params.empty());
}
std::uint32_t PolynomialXd::order() const {
return static_cast<std::uint32_t>(params_.size()) - 1;
}
void PolynomialXd::SetParams(const std::vector<double>& params) {
CHECK(!params.empty());
params_ = params;
}
const std::vector<double>& PolynomialXd::params() const { return params_; }
PolynomialXd PolynomialXd::DerivedFrom(const PolynomialXd& base) {
std::vector<double> params;
if (base.order() <= 0) {
params.clear();
} else {
params.resize(base.params().size() - 1);
for (std::uint32_t i = 1; i < base.order() + 1; ++i) {
params[i - 1] = base[i] * i;
}
}
return PolynomialXd(params);
}
PolynomialXd PolynomialXd::IntegratedFrom(const PolynomialXd& base,
const double intercept) {
std::vector<double> params;
params.resize(base.params().size() + 1);
params[0] = intercept;
for (std::uint32_t i = 0; i < base.params().size(); ++i) {
params[i + 1] = base[i] / (i + 1);
}
return PolynomialXd(params);
}
double PolynomialXd::operator()(const double x) const {
double result = 0.0;
for (auto rit = params_.rbegin(); rit != params_.rend(); ++rit) {
result *= x;
result += (*rit);
}
return result;
}
double PolynomialXd::operator[](const std::uint32_t index) const {
if (index >= params_.size()) {
return 0.0;
} else {
return params_[index];
}
}
} // namespace common
================================================
FILE: common/smoothing/polynomialxd.h
================================================
/******************************************************************************
* Copyright 2017 The Apollo Authors. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*****************************************************************************/
#pragma once
#include <cinttypes>
#include <vector>
namespace common {
/**
* @class PolynomialXd
* @brief y = a0 + a1*x + a2*x2^2 + ... + an*xn^n
*/
class PolynomialXd {
public:
PolynomialXd() = default;
explicit PolynomialXd(const std::uint32_t order);
explicit PolynomialXd(const std::vector<double>& params);
~PolynomialXd() = default;
double operator()(const double x) const;
double operator[](const std::uint32_t index) const;
void SetParams(const std::vector<double>& params);
static PolynomialXd DerivedFrom(const PolynomialXd& base);
static PolynomialXd IntegratedFrom(const PolynomialXd& base,
const double intercept = 0.0);
std::uint32_t order() const;
const std::vector<double>& params() const;
private:
std::vector<double> params_;
};
} // namespace common
================================================
FILE: common/smoothing/spline1d.cc
================================================
/******************************************************************************
* Copyright 2017 The Apollo Authors. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*****************************************************************************/
#include "common/smoothing/spline1d.h"
namespace common {
Spline1d::Spline1d(const std::vector<double>& x_knots, const uint32_t order)
: x_knots_(x_knots), spline_order_(order) {
for (uint32_t i = 1; i < x_knots_.size(); ++i) {
splines_.emplace_back(spline_order_);
}
}
double Spline1d::operator()(const double x) const {
if (splines_.empty()) {
return 0.0;
}
uint32_t index = FindSegStartIndex(x);
return splines_[index](x - x_knots_[index]);
}
double Spline1d::Derivative(const double x) const {
// zero order spline
if (splines_.empty()) {
return 0.0;
}
uint32_t index = FindSegStartIndex(x);
return splines_[index].Derivative(x - x_knots_[index]);
}
double Spline1d::SecondOrderDerivative(const double x) const {
if (splines_.empty()) {
return 0.0;
}
uint32_t index = FindSegStartIndex(x);
return splines_[index].SecondOrderDerivative(x - x_knots_[index]);
}
double Spline1d::ThirdOrderDerivative(const double x) const {
if (splines_.empty()) {
return 0.0;
}
uint32_t index = FindSegStartIndex(x);
return splines_[index].ThirdOrderDerivative(x - x_knots_[index]);
}
bool Spline1d::set_splines(const Eigen::MatrixXd& param_matrix,
const uint32_t order) {
const uint32_t num_params = order + 1;
// check if the parameter size fit
if (x_knots_.size() * num_params !=
num_params + static_cast<uint32_t>(param_matrix.rows())) {
return false;
}
for (uint32_t i = 0; i < splines_.size(); ++i) {
std::vector<double> spline_piece(num_params, 0.0);
for (uint32_t j = 0; j < num_params; ++j) {
spline_piece[j] = param_matrix(i * num_params + j, 0);
}
splines_[i].SetParams(spline_piece);
}
spline_order_ = order;
return true;
}
const std::vector<double>& Spline1d::x_knots() const { return x_knots_; }
uint32_t Spline1d::spline_order() const { return spline_order_; }
const std::vector<Spline1dSeg>& Spline1d::splines() const { return splines_; }
size_t Spline1d::FindSegStartIndex(const double x) const {
auto upper_bound = std::upper_bound(x_knots_.begin(), x_knots_.end(), x);
return std::min<size_t>(upper_bound - x_knots_.begin() - 1,
x_knots_.size() - 2);
}
} // namespace common
================================================
FILE: common/smoothing/spline1d.h
================================================
/******************************************************************************
* Copyright 2017 The Apollo Authors. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*****************************************************************************/
#pragma once
#include <Eigen/Core>
#include <algorithm>
#include <vector>
#include "common/smoothing/spline1d_seg.h"
namespace common {
class Spline1d {
public:
Spline1d() = default;
Spline1d(const std::vector<double>& x_knots, const uint32_t order);
double operator()(const double x) const;
double Derivative(const double x) const;
double SecondOrderDerivative(const double x) const;
double ThirdOrderDerivative(const double x) const;
bool set_splines(const Eigen::MatrixXd& param_matrix, const uint32_t order);
const std::vector<double>& x_knots() const;
uint32_t spline_order() const;
const std::vector<Spline1dSeg>& splines() const;
private:
size_t FindSegStartIndex(const double x) const;
private:
std::vector<Spline1dSeg> splines_;
std::vector<double> x_knots_;
uint32_t spline_order_;
};
} // namespace common
================================================
FILE: common/smoothing/spline1d_constraint.cc
================================================
/******************************************************************************
* Copyright 2017 The Apollo Authors. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*****************************************************************************/
#include "common/smoothing/spline1d_constraint.h"
namespace common {
Spline1dConstraint::Spline1dConstraint(const std::vector<double>& x_knots,
const uint32_t order)
: x_knots_(x_knots), spline_order_(order) {
spline_param_num_ = spline_order_ + 1;
columns_ = (x_knots_.size() - 1) * spline_param_num_;
}
bool Spline1dConstraint::AddConstraint(const Eigen::MatrixXd constraint,
const std::vector<double>& lower_bound,
const std::vector<double>& upper_bound) {
return affine_constraint_.AddConstraint(constraint, lower_bound, upper_bound);
}
bool Spline1dConstraint::AddBoundary(const std::vector<double>& x,
const std::vector<double>& lower_bound,
const std::vector<double>& upper_bound) {
size_t constraint_size = x.size();
Eigen::MatrixXd constraint = Eigen::MatrixXd::Zero(constraint_size, columns_);
for (size_t i = 0; i < constraint_size; ++i) {
const size_t index = FindSegStartIndex(x[i]);
const double corrected_x = x[i] - x_knots_[index];
double coef = 1.0;
for (size_t j = 0; j < spline_param_num_; ++j) {
constraint(i, j + index * spline_param_num_) = coef;
coef *= corrected_x;
}
}
return affine_constraint_.AddConstraint(constraint, lower_bound, upper_bound);
}
bool Spline1dConstraint::AddDerivativeBoundary(
const std::vector<double>& x, const std::vector<double>& lower_bound,
const std::vector<double>& upper_bound) {
size_t constraint_size = x.size();
Eigen::MatrixXd constraint = Eigen::MatrixXd::Zero(constraint_size, columns_);
for (size_t i = 0; i < constraint_size; ++i) {
const size_t index = FindSegStartIndex(x[i]);
const double corrected_x = x[i] - x_knots_[index];
double coef = 1.0;
for (size_t j = 1; j < spline_param_num_; ++j) {
constraint(i, j + index * spline_param_num_) = coef * j;
coef *= corrected_x;
}
}
return affine_constraint_.AddConstraint(constraint, lower_bound, upper_bound);
}
bool Spline1dConstraint::AddSecondDerivativeBoundary(
const std::vector<double>& x, const std::vector<double>& lower_bound,
const std::vector<double>& upper_bound) {
size_t constraint_size = x.size();
Eigen::MatrixXd constraint = Eigen::MatrixXd::Zero(constraint_size, columns_);
for (size_t i = 0; i < constraint_size; ++i) {
const size_t index = FindSegStartIndex(x[i]);
const double corrected_x = x[i] - x_knots_[index];
double coef = 1.0;
for (size_t j = 2; j < spline_param_num_; ++j) {
constraint(i, j + index * spline_param_num_) = coef * j * (j - 1);
coef *= corrected_x;
}
}
return affine_constraint_.AddConstraint(constraint, lower_bound, upper_bound);
}
bool Spline1dConstraint::AddThirdDerivativeBoundary(
const std::vector<double>& x, const std::vector<double>& lower_bound,
const std::vector<double>& upper_bound) {
size_t constraint_size = x.size();
Eigen::MatrixXd constraint = Eigen::MatrixXd::Zero(constraint_size, columns_);
for (size_t i = 0; i < constraint_size; ++i) {
const size_t index = FindSegStartIndex(x[i]);
const double corrected_x = x[i] - x_knots_[index];
double coef = 1.0;
for (size_t j = 3; j < spline_param_num_; ++j) {
constraint(i, j + index * spline_param_num_) =
coef * j * (j - 1) * (j - 2);
coef *= corrected_x;
}
}
return affine_constraint_.AddConstraint(constraint, lower_bound, upper_bound);
}
bool Spline1dConstraint::AddPointConstraint(const double x, const double fx) {
return AddBoundary(std::vector<double>{x}, std::vector<double>{fx},
std::vector<double>{fx});
}
bool Spline1dConstraint::AddPointDerivativeConstraint(const double x,
const double dfx) {
return AddDerivativeBoundary(std::vector<double>{x}, std::vector<double>{dfx},
std::vector<double>{dfx});
}
bool Spline1dConstraint::AddPointSecondDerivativeConstraint(const double x,
const double ddfx) {
return AddSecondDerivativeBoundary(std::vector<double>{x},
std::vector<double>{ddfx},
std::vector<double>{ddfx});
}
bool Spline1dConstraint::AddPointThirdDerivativeConstraint(const double x,
const double dddfx) {
return AddThirdDerivativeBoundary(std::vector<double>{x},
std::vector<double>{dddfx},
std::vector<double>{dddfx});
}
bool Spline1dConstraint::AddSmoothConstraint() {
if (x_knots_.size() <= 2) return false;
size_t n_constraint = x_knots_.size() - 2;
Eigen::MatrixXd constraint = Eigen::MatrixXd::Zero(n_constraint, columns_);
for (size_t i = 0; i < n_constraint; ++i) {
double left_coef = 1.0;
double right_coef = -1.0;
const double x_left = x_knots_[i + 1] - x_knots_[i];
const double x_right = 0.0;
for (size_t j = 0; j < spline_param_num_; ++j) {
constraint(i, j + i * spline_param_num_) = left_coef;
constraint(i, j + (i + 1) * spline_param_num_) = right_coef;
left_coef *= x_left;
right_coef *= x_right;
}
}
std::vector<double> lower_bound = std::vector<double>(n_constraint, 0.0),
upper_bound = std::vector<double>(n_constraint, 0.0);
return affine_constraint_.AddConstraint(constraint, lower_bound, upper_bound);
}
bool Spline1dConstraint::AddDerivativeSmoothConstraint() {
if (x_knots_.size() <= 2) return false;
size_t n_constraint = (x_knots_.size() - 2) * 2;
Eigen::MatrixXd constraint = Eigen::MatrixXd::Zero(n_constraint, columns_);
for (size_t i = 0; i < n_constraint; i += 2) {
double left_coef = 1.0;
double left_dcoef = 1.0;
double right_coef = -1.0;
double right_dcoef = -1.0;
const double x_left = x_knots_[i / 2 + 1] - x_knots_[i / 2];
const double x_right = 0.0;
for (size_t j = 0; j < spline_param_num_; ++j) {
constraint(i, spline_param_num_ * i / 2 + j) = left_coef;
constraint(i, spline_param_num_ * (i / 2 + 1) + j) = right_coef;
if (j >= 1) {
constraint(i + 1, spline_param_num_ * i / 2 + j) = left_dcoef * j;
constraint(i + 1, spline_param_num_ * (i / 2 + 1) + j) =
right_dcoef * j;
left_dcoef = left_coef;
right_dcoef = right_coef;
}
left_coef *= x_left;
right_coef *= x_right;
}
}
std::vector<double> lower_bound = std::vector<double>(n_constraint, 0.0),
upper_bound = std::vector<double>(n_constraint, 0.0);
return affine_constraint_.AddConstraint(constraint, lower_bound, upper_bound);
}
bool Spline1dConstraint::AddSecondDerivativeSmoothConstraint() {
if (x_knots_.size() <= 2) return false;
size_t n_constraint = (x_knots_.size() - 2) * 3;
Eigen::MatrixXd constraint = Eigen::MatrixXd::Zero(n_constraint, columns_);
for (size_t i = 0; i < n_constraint; i += 3) {
double left_coef = 1.0;
double left_dcoef = 1.0;
double left_ddcoef = 1.0;
double right_coef = -1.0;
double right_dcoef = -1.0;
double right_ddcoef = -1.0;
const double x_left = x_knots_[i / 3 + 1] - x_knots_[i / 3];
const double x_right = 0.0;
for (size_t j = 0; j < spline_param_num_; ++j) {
constraint(i, spline_param_num_ * i / 3 + j) = left_coef;
constraint(i, spline_param_num_ * (i / 3 + 1) + j) = right_coef;
if (j >= 2) {
constraint(i + 2, spline_param_num_ * i / 3 + j) =
left_ddcoef * j * (j - 1);
constraint(i + 2, spline_param_num_ * (i / 3 + 1) + j) =
right_ddcoef * j * (j - 1);
left_ddcoef = left_dcoef;
right_ddcoef = right_dcoef;
}
if (j >= 1) {
constraint(i + 1, spline_param_num_ * i / 3 + j) = left_dcoef * j;
constraint(i + 1, spline_param_num_ * (i / 3 + 1) + j) =
right_dcoef * j;
left_dcoef = left_coef;
right_dcoef = right_coef;
}
left_coef *= x_left;
right_coef *= x_right;
}
}
std::vector<double> lower_bound = std::vector<double>(n_constraint, 0.0),
upper_bound = std::vector<double>(n_constraint, 0.0);
return affine_constraint_.AddConstraint(constraint, lower_bound, upper_bound);
}
bool Spline1dConstraint::AddThirdDerivativeSmoothConstraint() {
if (x_knots_.size() <= 2) return false;
size_t n_constraint = (x_knots_.size() - 2) * 4;
Eigen::MatrixXd constraint = Eigen::MatrixXd::Zero(n_constraint, columns_);
for (size_t i = 0; i < n_constraint; i += 4) {
double left_coef = 1.0;
double left_dcoef = 1.0;
double left_ddcoef = 1.0;
double left_dddcoef = 1.0;
double right_coef = -1.0;
double right_dcoef = -1.0;
double right_ddcoef = -1.0;
double right_dddcoef = -1.0;
const double x_left = x_knots_[i / 4 + 1] - x_knots_[i / 4];
const double x_right = 0.0;
for (size_t j = 0; j < spline_param_num_; ++j) {
constraint(i, spline_param_num_ * i / 4 + j) = left_coef;
constraint(i, spline_param_num_ * (i / 4 + 1) + j) = right_coef;
if (j >= 3) {
constraint(i + 3, spline_param_num_ * i / 4 + j) =
left_dddcoef * j * (j - 1) * (j - 2);
constraint(i + 3, spline_param_num_ * (i / 4 + 1) + j) =
right_dddcoef * j * (j - 1) * (j - 2);
left_dddcoef = left_ddcoef;
right_dddcoef = right_ddcoef;
}
if (j >= 2) {
constraint(i + 2, spline_param_num_ * i / 4 + j) =
left_ddcoef * j * (j - 1);
constraint(i + 2, spline_param_num_ * (i / 4 + 1) + j) =
right_ddcoef * j * (j - 1);
left_ddcoef = left_dcoef;
right_ddcoef = right_dcoef;
}
if (j >= 1) {
constraint(i + 1, spline_param_num_ * i / 4 + j) = left_dcoef * j;
constraint(i + 1, spline_param_num_ * (i / 4 + 1) + j) =
right_dcoef * j;
left_dcoef = left_coef;
right_dcoef = right_coef;
}
left_coef *= x_left;
right_coef *= x_right;
}
}
std::vector<double> lower_bound = std::vector<double>(n_constraint, 0.0),
upper_bound = std::vector<double>(n_constraint, 0.0);
return affine_constraint_.AddConstraint(constraint, lower_bound, upper_bound);
}
size_t Spline1dConstraint::FindSegStartIndex(const double x) const {
auto upper_bound = std::upper_bound(x_knots_.begin(), x_knots_.end(), x);
return std::min<size_t>(upper_bound - x_knots_.begin() - 1,
x_knots_.size() - 2);
}
const AffineConstraint& Spline1dConstraint::affine_constraint() const {
return affine_constraint_;
}
const Eigen::MatrixXd& Spline1dConstraint::constraint_matrix() const {
return affine_constraint_.constraint_matrix();
}
const std::vector<double>& Spline1dConstraint::lower_bound() const {
return affine_constraint_.lower_bound();
}
const std::vector<double>& Spline1dConstraint::upper_bound() const {
return affine_constraint_.upper_bound();
}
} // namespace common
================================================
FILE: common/smoothing/spline1d_constraint.h
================================================
/******************************************************************************
* Copyright 2017 The Apollo Authors. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*****************************************************************************/
#pragma once
#include <glog/logging.h>
#include <Eigen/Core>
#include <algorithm>
#include <iostream>
#include <vector>
#include "common/smoothing/affine_constraint.h"
namespace common {
/**
* @class Spline1dConstraint
* @brief specify one-dimension polynomial spline constraint in matrix form
*/
class Spline1dConstraint {
public:
Spline1dConstraint() = default;
Spline1dConstraint(const std::vector<double>& x_knots, const uint32_t order);
bool AddConstraint(const Eigen::MatrixXd constraint,
const std::vector<double>& lower_bound,
const std::vector<double>& upper_bound);
bool AddBoundary(const std::vector<double>& x,
const std::vector<double>& lower_bound,
const std::vector<double>& upper_bound);
bool AddDerivativeBoundary(const std::vector<double>& x,
const std::vector<double>& lower_bound,
const std::vector<double>& upper_bound);
bool AddSecondDerivativeBoundary(const std::vector<double>& x,
const std::vector<double>& lower_bound,
const std::vector<double>& upper_bound);
bool AddThirdDerivativeBoundary(const std::vector<double>& x,
const std::vector<double>& lower_bound,
const std::vector<double>& upper_bound);
bool AddPointConstraint(const double x, const double fx);
bool AddPointDerivativeConstraint(const double x, const double dfx);
bool AddPointSecondDerivativeConstraint(const double x, const double ddfx);
bool AddPointThirdDerivativeConstraint(const double x, const double dddfx);
bool AddSmoothConstraint();
bool AddDerivativeSmoothConstraint();
bool AddSecondDerivativeSmoothConstraint();
bool AddThirdDerivativeSmoothConstraint();
const AffineConstraint& affine_constraint() const;
const Eigen::MatrixXd& constraint_matrix() const;
const std::vector<double>& lower_bound() const;
const std::vector<double>& upper_bound() const;
private:
size_t FindSegStartIndex(const double x) const;
private:
AffineConstraint affine_constraint_;
std::vector<double> x_knots_;
uint32_t spline_order_ = 0;
uint32_t spline_param_num_ = 0;
uint32_t columns_;
};
} // namespace common
================================================
FILE: common/smoothing/spline1d_kernel.cc
================================================
/******************************************************************************
* Copyright 2017 The Apollo Authors. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*****************************************************************************/
#include "common/smoothing/spline1d_kernel.h"
#include <glog/logging.h>
#include "common/smoothing/spline1d_kernel_helper.h"
namespace common {
Spline1dKernel::Spline1dKernel(const std::vector<double>& x_knots,
const uint32_t spline_order)
: x_knots_(x_knots), spline_order_(spline_order) {
spline_param_num_ = spline_order_ + 1;
total_params_ = (x_knots_.size() - 1) * spline_param_num_;
kernel_matrix_ = Eigen::MatrixXd::Zero(total_params_, total_params_);
gradient_ = Eigen::MatrixXd::Zero(total_params_, 1);
}
const Eigen::MatrixXd& Spline1dKernel::kernel_matrix() const {
return kernel_matrix_;
}
const Eigen::MatrixXd& Spline1dKernel::gradient() const { return gradient_; }
void Spline1dKernel::AddRegularization(const double regularized_param) {
Eigen::MatrixXd id_matrix =
Eigen::MatrixXd::Identity(kernel_matrix_.rows(), kernel_matrix_.cols());
kernel_matrix_ += 2.0 * id_matrix * regularized_param;
}
void Spline1dKernel::AddKernel(const Eigen::MatrixXd& kernel) {
CHECK(kernel.rows() == kernel_matrix_.rows())
<< "kernel row size doesn't match";
CHECK(kernel.cols() == kernel_matrix_.cols())
<< "kernel col size doesn't match";
kernel_matrix_ += kernel;
}
void Spline1dKernel::AddGradient(const Eigen::MatrixXd& gradient) {
CHECK(gradient.rows() == gradient_.rows())
<< "gradient row size doesn't match";
CHECK(gradient.cols() == gradient_.cols())
<< "gradient col size doesn't match";
gradient_ += gradient;
}
void Spline1dKernel::AddNthDerivativekernelMatrix(const uint32_t n,
const double weight) {
uint32_t spline_seg_num = x_knots_.size() - 1;
for (uint32_t i = 0; i < spline_seg_num; ++i) {
Eigen::MatrixXd seg_kernel_matrix =
2 *
Spline1dKernelHelper::Instance().Kernel(spline_order_, n,
x_knots_[i + 1] - x_knots_[i]) *
weight;
kernel_matrix_.block(i * spline_param_num_, i * spline_param_num_,
spline_param_num_, spline_param_num_) +=
seg_kernel_matrix;
}
}
// 计算sum_{t==0}^{x} {f'(t) * f'(t)}, 用以最小化导数平方
void Spline1dKernel::AddDerivativeKernelMatrix(const double weight) {
AddNthDerivativekernelMatrix(1, weight);
}
void Spline1dKernel::AddSecondOrderDerivativeMatrix(const double weight) {
AddNthDerivativekernelMatrix(2, weight);
}
void Spline1dKernel::AddThirdOrderDerivativeMatrix(const double weight) {
AddNthDerivativekernelMatrix(3, weight);
}
/*
计算[spline(t) - ref_fx]的最小二次型
*/
bool Spline1dKernel::AddReferenceLineKernelMatrix(
const std::vector<double>& x_coord, const std::vector<double>& ref_fx,
const double weight) {
if (ref_fx.size() != x_coord.size()) {
return false;
}
const uint32_t num_params = spline_order_ + 1;
for (size_t i = 0; i < x_coord.size(); ++i) {
auto cur_index = FindSegStartIndex(x_coord[i]);
double cur_rel_x = x_coord[i] - x_knots_[cur_index];
// update offset
double offset_coef = -2.0 * ref_fx[i] * weight;
for (size_t j = 0; j < num_params; ++j) {
gradient_(j + cur_index * num_params, 0) += offset_coef;
offset_coef *= cur_rel_x;
}
// update kernel matrix
Eigen::MatrixXd ref_kernel(num_params, num_params);
double cur_x = 1.0;
std::vector<double> power_x;
for (uint32_t n = 0; n + 1 < 2 * num_params; ++n) {
power_x.emplace_back(cur_x);
cur_x *= cur_rel_x;
}
for (uint32_t r = 0; r < num_params; ++r) {
for (uint32_t c = 0; c < num_params; ++c) {
ref_kernel(r, c) = 2.0 * power_x[r + c];
}
}
kernel_matrix_.block(cur_index * num_params, cur_index * num_params,
num_params, num_params) += weight * ref_kernel;
}
return true;
}
bool Spline1dKernel::AddDerivativeReferenceLineKernelMatrix(
const std::vector<double>& x_coord, const std::vector<double>& ref_dfx,
const double weight) {
if (ref_dfx.size() != x_coord.size()) {
return false;
}
const uint32_t num_params = spline_order_ + 1;
for (size_t i = 0; i < x_coord.size(); ++i) {
auto cur_index = FindSegStartIndex(x_coord[i]);
double cur_rel_x = x_coord[i] - x_knots_[cur_index];
// update offset
double x_power = 1.0;
Eigen::VectorXd coefficients = Eigen::VectorXd::Zero(6);
for (int j = 1; j < 6; ++j) {
coefficients(j) = j * x_power;
x_power *= cur_rel_x;
}
for (size_t j = 0; j < num_params; ++j) {
gradient_(j + cur_index * num_params, 0) -=
2.0 * ref_dfx[i] * weight * coefficients(j);
}
LOG(INFO) << "ref: " << ref_dfx[i];
// update kernel matrix
Eigen::MatrixXd ref_kernel = 2 * coefficients * coefficients.transpose();
kernel_matrix_.block(cur_index * num_params, cur_index * num_params,
num_params, num_params) += weight * ref_kernel;
}
return true;
}
size_t Spline1dKernel::FindSegStartIndex(const double x) const {
auto upper_bound = std::upper_bound(x_knots_.begin(), x_knots_.end(), x);
return std::min<size_t>(upper_bound - x_knots_.begin() - 1,
x_knots_.size() - 2);
}
} // namespace common
================================================
FILE: common/smoothing/spline1d_kernel.h
================================================
/******************************************************************************
* Copyright 2017 The Apollo Authors. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*****************************************************************************/
#pragma once
#include <Eigen/Core>
#include <algorithm>
#include <cinttypes>
#include <vector>
#include "common/base/type.h"
namespace common {
class Spline1dKernel {
public:
Spline1dKernel() = default;
Spline1dKernel(const std::vector<double>& x_knots,
const uint32_t spline_order);
void AddKernel(const Eigen::MatrixXd& kernel);
void AddGradient(const Eigen::MatrixXd& gradient);
void AddRegularization(const double regularized_param);
void AddDerivativeKernelMatrix(const double weight);
void AddSecondOrderDerivativeMatrix(const double weight);
void AddThirdOrderDerivativeMatrix(const double weight);
bool AddReferenceLineKernelMatrix(const std::vector<double>& x_coord,
const std::vector<double>& ref_fx,
const double weight);
bool AddDerivativeReferenceLineKernelMatrix(
const std::vector<double>& x_coord, const std::vector<double>& ref_dfx,
const double weight);
const Eigen::MatrixXd& kernel_matrix() const;
const Eigen::MatrixXd& gradient() const;
private:
void AddNthDerivativekernelMatrix(const uint32_t n, const double weight);
size_t FindSegStartIndex(const double x) const;
private:
Eigen::MatrixXd kernel_matrix_;
Eigen::MatrixXd gradient_;
std::vector<double> x_knots_;
uint32_t spline_order_ = 0;
uint32_t spline_param_num_ = 0;
uint32_t total_params_ = 0;
};
} // namespace common
================================================
FILE: common/smoothing/spline1d_kernel_helper.cc
================================================
/******************************************************************************
* Copyright 2017 The Apollo Authors. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*****************************************************************************/
#include <utility>
#include <vector>
#include "common/smoothing/spline1d_kernel_helper.h"
namespace common {
Spline1dKernelHelper& Spline1dKernelHelper::Instance() {
static Spline1dKernelHelper spline1d_kernel_helper;
return spline1d_kernel_helper;
}
Spline1dKernelHelper::Spline1dKernelHelper() { BuildKernelMap(); }
Eigen::MatrixXd Spline1dKernelHelper::Kernel(const uint32_t spline_order,
const uint32_t nth_derivative,
const double integral_length) {
uint32_t num_params = spline_order + 1;
std::string kernel_type =
std::to_string(spline_order) + "_" + std::to_string(nth_derivative);
const auto& derivative_matrix = kernel_map_[kernel_type];
Eigen::MatrixXd term_matrix;
IntegratedTermMatrix(num_params, nth_derivative, integral_length,
&term_matrix);
return derivative_matrix.block(0, 0, num_params, num_params)
.cwiseProduct(term_matrix);
}
void Spline1dKernelHelper::BuildKernelMap() {
for (uint32_t order = 3; order <= 5; ++order) {
const uint32_t num_params = order + 1;
for (uint32_t derivative = 0; derivative <= 3; ++derivative) {
std::string kernel_type =
std::to_string(order) + "_" + std::to_string(derivative);
if (derivative == 0) {
CalculateFx(num_params);
kernel_map_[kernel_type] = kernel_fx_;
} else if (derivative == 1) {
CalculateDerivative(num_params);
kernel_map_[kernel_type] = kernel_derivative_;
} else if (derivative == 2) {
CalculateSecondOrderDerivative(num_params);
kernel_map_[kernel_type] = kernel_second_order_derivative_;
} else if (derivative == 3) {
CalculateThirdOrderDerivative(num_params);
kernel_map_[kernel_type] = kernel_third_order_derivative_;
}
}
}
}
void Spline1dKernelHelper::IntegratedTermMatrix(
const uint32_t num_params, const uint16_t derivative, const double x,
Eigen::MatrixXd* term_matrix) const {
if (term_matrix->rows() != term_matrix->cols() ||
term_matrix->rows() != static_cast<int>(num_params)) {
term_matrix->resize(num_params, num_params);
}
std::vector<double> x_pow(2 * num_params + 1, 1.0);
for (uint32_t i = 1; i < 2 * num_params + 1; ++i) {
x_pow[i] = x_pow[i - 1] * x;
}
if (derivative == 0) {
for (uint32_t r = 0; r < num_params; ++r) {
for (uint32_t c = 0; c < num_params; ++c) {
(*term_matrix)(r, c) = x_pow[r + c + 1];
}
}
} else if (derivative == 1) {
for (uint32_t r = 1; r < num_params; ++r) {
for (uint32_t c = 1; c < num_params; ++c) {
(*term_matrix)(r, c) = x_pow[r + c - 1];
}
}
(*term_matrix).block(0, 0, num_params, 1) =
Eigen::MatrixXd::Zero(num_params, 1);
(*term_matrix).block(0, 0, 1, num_params) =
Eigen::MatrixXd::Zero(1, num_params);
} else if (derivative == 2) {
for (uint32_t r = 2; r < num_params; ++r) {
for (uint32_t c = 2; c < num_params; ++c) {
(*term_matrix)(r, c) = x_pow[r + c - 3];
}
}
(*term_matrix).block(0, 0, num_params, 2) =
Eigen::MatrixXd::Zero(num_params, 2);
(*term_matrix).block(0, 0, 2, num_params) =
Eigen::MatrixXd::Zero(2, num_params);
} else if (derivative == 3) {
for (uint32_t r = 3; r < num_params; ++r) {
for (uint32_t c = 3; c < num_params; ++c) {
(*term_matrix)(r, c) = x_pow[r + c - 5];
}
}
(*term_matrix).block(0, 0, num_params, 3) =
Eigen::MatrixXd::Zero(num_params, 3);
(*term_matrix).block(0, 0, 3, num_params) =
Eigen::MatrixXd::Zero(3, num_params);
}
}
void Spline1dKernelHelper::CalculateFx(const uint32_t num_params) {
kernel_fx_ = Eigen::MatrixXd::Zero(num_params, num_params);
for (int r = 0; r < kernel_fx_.rows(); ++r) {
for (int c = 0; c < kernel_fx_.cols(); ++c) {
kernel_fx_(r, c) = 1.0 / (r + c + 1.0);
}
}
}
void Spline1dKernelHelper::CalculateDerivative(const uint32_t num_params) {
kernel_derivative_ = Eigen::MatrixXd::Zero(num_params, num_params);
for (int r = 1; r < kernel_derivative_.rows(); ++r) {
for (int c = 1; c < kernel_derivative_.cols(); ++c) {
kernel_derivative_(r, c) = r * c / (r + c - 1.0);
}
}
}
void Spline1dKernelHelper::CalculateSecondOrderDerivative(
const uint32_t num_params) {
kernel_second_order_derivative_ =
Eigen::MatrixXd::Zero(num_params, num_params);
for (int r = 2; r < kernel_second_order_derivative_.rows(); ++r) {
for (int c = 2; c < kernel_second_order_derivative_.cols(); ++c) {
kernel_second_order_derivative_(r, c) =
(r * r - r) * (c * c - c) / (r + c - 3.0);
}
}
}
void Spline1dKernelHelper::CalculateThirdOrderDerivative(
const uint32_t num_params) {
kernel_third_order_derivative_ =
Eigen::MatrixXd::Zero(num_params, num_params);
for (int r = 3; r < kernel_third_order_derivative_.rows(); ++r) {
for (int c = 3; c < kernel_third_order_derivative_.cols(); ++c) {
kernel_third_order_derivative_(r, c) =
(r * r - r) * (r - 2) * (c * c - c) * (c - 2) / (r + c - 5.0);
}
}
}
} // namespace common
================================================
FILE: common/smoothing/spline1d_kernel_helper.h
================================================
/******************************************************************************
* Copyright 2017 The Apollo Authors. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*****************************************************************************/
#pragma once
#include <Eigen/Core>
#include <string>
#include <unordered_map>
namespace common {
class Spline1dKernelHelper {
public:
static Spline1dKernelHelper& Instance();
Eigen::MatrixXd Kernel(const uint32_t spline_order,
const uint32_t nth_derivative,
const double integral_length);
private:
Spline1dKernelHelper();
Spline1dKernelHelper(const Spline1dKernelHelper&) = delete;
Spline1dKernelHelper& operator=(const Spline1dKernelHelper&) = delete;
Eigen::MatrixXd DerivativeKernel(const uint32_t num_of_params,
const double accumulated_x);
Eigen::MatrixXd SecondOrderDerivativeKernel(const uint32_t num_of_params,
const double accumulated_x);
Eigen::MatrixXd ThirdOrderDerivativeKernel(const uint32_t num_of_params,
const double accumulated_x);
void IntegratedTermMatrix(const uint32_t num_of_params,
const uint16_t derivative, const double x,
Eigen::MatrixXd* term_matrix) const;
void CalculateFx(const uint32_t num_of_params);
void CalculateDerivative(const uint32_t num_of_params);
void CalculateSecondOrderDerivative(const uint32_t num_of_params);
void CalculateThirdOrderDerivative(const uint32_t num_of_params);
void BuildKernelMap();
private:
std::unordered_map<std::string, Eigen::MatrixXd> kernel_map_;
Eigen::MatrixXd kernel_fx_;
Eigen::MatrixXd kernel_derivative_;
Eigen::MatrixXd kernel_second_order_derivative_;
Eigen::MatrixXd kernel_third_order_derivative_;
};
} // namespace common
================================================
FILE: common/smoothing/spline1d_seg.cc
================================================
/******************************************************************************
* Copyright 2017 The Apollo Authors. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*****************************************************************************/
#include "common/smoothing/spline1d_seg.h"
namespace common {
Spline1dSeg::Spline1dSeg(const uint32_t order) {
SetSplineFunc(PolynomialXd(order));
}
Spline1dSeg::Spline1dSeg(const std::vector<double>& params) {
SetSplineFunc(PolynomialXd(params));
}
void Spline1dSeg::SetParams(const std::vector<double>& params) {
SetSplineFunc(PolynomialXd(params));
}
void Spline1dSeg::SetSplineFunc(const PolynomialXd& spline_func) {
spline_func_ = spline_func;
derivative_ = PolynomialXd::DerivedFrom(spline_func_);
second_order_derivative_ = PolynomialXd::DerivedFrom(derivative_);
third_order_derivative_ = PolynomialXd::DerivedFrom(second_order_derivative_);
}
double Spline1dSeg::operator()(const double x) const { return spline_func_(x); }
double Spline1dSeg::Derivative(const double x) const { return derivative_(x); }
double Spline1dSeg::SecondOrderDerivative(const double x) const {
return second_order_derivative_(x);
}
double Spline1dSeg::ThirdOrderDerivative(const double x) const {
return third_order_derivative_(x);
}
const PolynomialXd& Spline1dSeg::spline_func() const { return spline_func_; }
const PolynomialXd& Spline1dSeg::Derivative() const { return derivative_; }
const PolynomialXd& Spline1dSeg::SecondOrderDerivative() const {
return second_order_derivative_;
}
const PolynomialXd& Spline1dSeg::ThirdOrderDerivative() const {
return third_order_derivative_;
}
} // namespace common
================================================
FILE: common/smoothing/spline1d_seg.h
================================================
/******************************************************************************
* Copyright 2017 The Apollo Authors. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*****************************************************************************/
#pragma once
#include <vector>
#include "common/smoothing/polynomialxd.h"
namespace common {
class Spline1dSeg {
public:
// order represents the highest order.
explicit Spline1dSeg(const uint32_t order);
explicit Spline1dSeg(const std::vector<double>& params);
~Spline1dSeg() = default;
void SetParams(const std::vector<double>& params);
double operator()(const double x) const;
double Derivative(const double x) const;
double SecondOrderDerivative(const double x) const;
double ThirdOrderDerivative(const double x) const;
const PolynomialXd& spline_func() const;
const PolynomialXd& Derivative() const;
const PolynomialXd& SecondOrderDerivative() const;
const PolynomialXd& ThirdOrderDerivative() const;
private:
inline void SetSplineFunc(const PolynomialXd& spline_func);
PolynomialXd spline_func_;
PolynomialXd derivative_;
PolynomialXd second_order_derivative_;
PolynomialXd third_order_derivative_;
};
} // namespace common
================================================
FILE: common/smoothing/spline1d_solver.h
================================================
/******************************************************************************
* Copyright 2017 The Apollo Authors. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*****************************************************************************/
#pragma once
#include <Eigen/Core>
#include <vector>
#include "common/smoothing/spline1d.h"
#include "common/smoothing/spline1d_constraint.h"
#include "common/smoothing/spline1d_kernel.h"
namespace common {
class Spline1dSolver {
public:
Spline1dSolver(const std::vector<double>& x_knots, const uint32_t order)
: spline_(x_knots, order),
constraint_(x_knots, order),
kernel_(x_knots, order) {}
virtual ~Spline1dSolver() = default;
virtual void Reset(const std::vector<double>& t_knots,
const uint32_t order) = 0;
// customize setup
virtual Spline1dConstraint* mutable_constraint() = 0;
virtual Spline1dKernel* mutable_kernel() = 0;
virtual Spline1d* mutable_spline() = 0;
// solve
virtual bool Solve() = 0;
// extract
virtual const Spline1d& spline() const = 0;
protected:
Spline1d spline_;
Spline1dConstraint constraint_;
Spline1dKernel kernel_;
};
} // namespace common
================================================
FILE: common/smoothing/spline2d.cc
================================================
/******************************************************************************
* Copyright 2017 The Apollo Authors. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*****************************************************************************/
#include "common/smoothing/spline2d.h"
#include "common/utils/math.h"
namespace common {
Spline2d::Spline2d(const std::vector<double>& t_knots, const uint32_t order)
: t_knots_(t_knots), spline_order_(order) {
if (t_knots.size() > 1) {
for (uint32_t i = 1; i < t_knots_.size(); ++i) {
splines_.emplace_back(spline_order_);
}
}
}
Eigen::Vector2d Spline2d::pos(const double t) const {
uint32_t index = find_index(t);
const double param = t - t_knots_[index];
return Eigen::Vector2d(splines_[index].x(param), splines_[index].y(param));
}
double Spline2d::theta(const double t) const {
uint32_t index = find_index(t);
const double param = t - t_knots_[index];
return std::atan2(splines_[index].DerivativeY(param),
splines_[index].DerivativeX(param));
}
void Spline2d::GetCurvature(const double t, double* kappa,
double* dkappa) const {
if (splines_.empty()) return;
uint32_t index = find_index(t);
const double param = t - t_knots_[index];
const double dx = splines_[index].DerivativeX(param);
const double ddx = splines_[index].SecondDerivativeX(param);
const double dddx = splines_[index].ThirdDerivativeX(param);
const double dy = splines_[index].DerivativeY(param);
const double ddy = splines_[index].SecondDerivativeX(param);
const double dddy = splines_[index].ThirdDerivativeX(param);
*kappa = Curvature(dx, ddx, dy, ddy);
*dkappa = CurvatureDerivative(dx, ddx, dddx, dy, ddy, dddy);
}
double Spline2d::GetCurvature(const double t) const {
if (splines_.empty()) return 0.0;
uint32_t index = find_index(t);
const double param = t - t_knots_[index];
const double dx = splines_[index].DerivativeX(param);
const double ddx = splines_[index].SecondDerivativeX(param);
const double dy = splines_[index].DerivativeY(param);
const double ddy = splines_[index].SecondDerivativeX(param);
return Curvature(dx, ddx, dy, ddy);
}
std::pair<double, double> Spline2d::operator()(const double t) const {
if (splines_.empty()) {
return std::make_pair(0.0, 0.0);
}
uint32_t index = find_index(t);
return splines_[index](t - t_knots_[index]);
}
double Spline2d::x(const double t) const {
if (splines_.empty()) {
return 0.0;
}
uint32_t index = find_index(t);
return splines_[index].x(t - t_knots_[index]);
}
double Spline2d::y(const double t) const {
if (splines_.empty()) {
return 0.0;
}
uint32_t index = find_index(t);
return splines_[index].y(t - t_knots_[index]);
}
double Spline2d::DerivativeX(const double t) const {
// zero order spline
if (splines_.empty()) {
return 0.0;
}
uint32_t index = find_index(t);
return splines_[index].DerivativeX(t - t_knots_[index]);
}
double Spline2d::DerivativeY(const double t) const {
// zero order spline
if (splines_.empty()) {
return 0.0;
}
uint32_t index = find_index(t);
return splines_[index].DerivativeY(t - t_knots_[index]);
}
double Spline2d::Derivative(const double t) const {
if (splines_.empty()) {
return 0.0;
}
uint32_t index = find_index(t);
return splines_[index].DerivativeY(t - t_knots_[index]) /
splines_[index].DerivativeX(t - t_knots_[index]);
}
double Spline2d::SecondDerivativeX(const double t) const {
if (splines_.empty()) {
return 0.0;
}
uint32_t index = find_index(t);
return splines_[index].SecondDerivativeX(t - t_knots_[index]);
}
double Spline2d::SecondDerivativeY(const double t) const {
if (splines_.empty()) {
return 0.0;
}
uint32_t index = find_index(t);
return splines_[index].SecondDerivativeY(t - t_knots_[index]);
}
double Spline2d::ThirdDerivativeX(const double t) const {
if (splines_.empty()) {
return 0.0;
}
uint32_t index = find_index(t);
return splines_[index].ThirdDerivativeX(t - t_knots_[index]);
}
double Spline2d::ThirdDerivativeY(const double t) const {
if (splines_.empty()) {
return 0.0;
}
uint32_t index = find_index(t);
return splines_[index].ThirdDerivativeY(t - t_knots_[index]);
}
/**
* @brief: set splines
**/
bool Spline2d::set_splines(const Eigen::MatrixXd& params,
const uint32_t order) {
const uint32_t num_params = order + 1;
const uint32_t num_seg = t_knots_.size() - 1;
// check if the parameter size fit
if (2 * num_seg * num_params != static_cast<uint32_t>(params.rows())) {
return false;
}
const uint32_t offset = num_seg * num_params;
for (uint32_t i = 0; i < splines_.size(); ++i) {
std::vector<double> spline_piece_x(num_params, 0.0);
std::vector<double> spline_piece_y(num_params, 0.0);
for (uint32_t j = 0; j < num_params; ++j) {
spline_piece_x[j] = params(i * num_params + j, 0);
spline_piece_y[j] = params(i * num_params + offset + j, 0);
}
splines_[i].SetParams(spline_piece_x, spline_piece_y);
}
spline_order_ = order;
return true;
}
const Spline2dSeg& Spline2d::smoothing_spline(const uint32_t index) const {
return splines_[index];
}
const std::vector<double>& Spline2d::t_knots() const { return t_knots_; }
uint32_t Spline2d::spline_order() const { return spline_order_; }
uint32_t Spline2d::find_index(const double t) const {
auto upper_bound = std::upper_bound(t_knots_.begin(), t_knots_.end(), t);
return std::min<size_t>(upper_bound - t_knots_.begin() - 1,
t_knots_.size() - 2);
}
} // namespace common
================================================
FILE: common/smoothing/spline2d.h
================================================
/******************************************************************************
* Copyright 2017 The Apollo Authors. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*****************************************************************************/
#pragma once
#include <Eigen/Core>
#include <algorithm>
#include <utility>
#include <vector>
#include "common/smoothing/spline2d_seg.h"
namespace common {
class Spline2d {
public:
Spline2d() = default;
Spline2d(const std::vector<double>& t_knots, const uint32_t order);
Eigen::Vector2d pos(const double t) const;
double theta(const double t) const;
std::pair<double, double> operator()(const double t) const;
double x(const double t) const;
double y(const double t) const;
double DerivativeX(const double t) const;
double DerivativeY(const double t) const;
double Derivative(const double t) const;
double SecondDerivativeX(const double t) const;
double SecondDerivativeY(const double t) const;
double ThirdDerivativeX(const double t) const;
double ThirdDerivativeY(const double t) const;
bool set_splines(const Eigen::MatrixXd& params, const uint32_t order);
const Spline2dSeg& smoothing_spline(const uint32_t index) const;
const std::vector<double>& t_knots() const;
uint32_t spline_order() const;
void GetCurvature(const double t, double* kappa, double* dkappa) const;
double GetCurvature(const double t) const;
private:
uint32_t find_index(const double x) const;
private:
std::vector<Spline2dSeg> splines_;
std::vector<double> t_knots_;
uint32_t spline_order_;
};
class Spline2dPoint {
public:
Spline2dPoint() = default;
Spline2dPoint(const Spline2d& spline2d, const double t)
: fx_(spline2d.x(t)),
fy_(spline2d.y(t)),
dfx_(spline2d.DerivativeX(t)),
dfy_(spline2d.DerivativeY(t)),
ddfx_(spline2d.SecondDerivativeX(t)),
ddfy_(spline2d.SecondDerivativeY(t)),
dddfx_(spline2d.ThirdDerivativeX(t)),
dddfy_(spline2d.ThirdDerivativeY(t)) {}
double fx() const { return fx_; }
double fy() const { return fy_; }
double dfx() const { return dfx_; }
double dfy() const { return dfy_; }
double ddfx() const { return ddfx_; }
double ddfy() const { return ddfy_; }
double dddfx() const { return dddfx_; }
double dddfy() const { return dddfy_; }
private:
double fx_ = 0.0;
double fy_ = 0.0;
double dfx_ = 0.0;
double dfy_ = 0.0;
double ddfx_ = 0.0;
double ddfy_ = 0.0;
double dddfx_ = 0.0;
double dddfy_ = 0.0;
};
} // namespace common
================================================
FILE: common/smoothing/spline2d_constraint.cc
================================================
/******************************************************************************
* Copyright 2017 The Apollo Authors. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*****************************************************************************/
#include "common/smoothing/spline2d_constraint.h"
#include "common/utils/math.h"
namespace common {
Spline2dConstraint::Spline2dConstraint(const std::vector<double>& t_knots,
const uint32_t order)
: t_knots_(t_knots), spline_order_(order) {
x_constraint_ = Spline1dConstraint(t_knots_, spline_order_);
y_constraint_ = Spline1dConstraint(t_knots_, spline_order_);
spline_param_num_ = spline_order_ + 1;
total_param_ =
2 * spline_param_num_ * (static_cast<uint32_t>(t_knots.size()) - 1);
constraint_matrix_ = Eigen::MatrixXd::Zero(0, 0);
lower_bound_ = std::vector<double>{};
upper_bound_ = std::vector<double>{};
}
bool Spline2dConstraint::Add2dBoundary(
const std::vector<double>& t,
const vector_Eigen<Eigen::Vector2d>& lower_bound,
const vector_Eigen<Eigen::Vector2d>& upper_bound) {
CHECK_EQ(lower_bound.size(), upper_bound.size());
size_t boundary_size = lower_bound.size();
std::vector<double> x_lower_bound(boundary_size),
x_upper_bound(boundary_size);
std::vector<double> y_lower_bound(boundary_size),
y_upper_bound(boundary_size);
for (uint32_t i = 0; i < boundary_size; ++i) {
x_lower_bound[i] = lower_bound[i].x();
x_upper_bound[i] = upper_bound[i].x();
y_lower_bound[i] = lower_bound[i].y();
y_upper_bound[i] = upper_bound[i].y();
}
bool add_x_constraint = x_constraint_.AddBoundary(t, std::move(x_lower_bound),
std::move(x_upper_bound));
bool add_y_constraint = y_constraint_.AddBoundary(t, std::move(y_lower_bound),
std::move(y_upper_bound));
return add_x_constraint && add_y_constraint;
}
bool Spline2dConstraint::Add2dStationLateralBoundary(
const std::vector<double>& t, const vector_Eigen<Eigen::Vector2d>& ref_xy,
const std::vector<double>& ref_theta, const std::vector<double>& lon_tol,
const std::vector<double>& lat_tol) {
if (t.size() != ref_xy.size() || ref_xy.size() != ref_theta.size() ||
ref_theta.size() != lon_tol.size() || lon_tol.size() != lat_tol.size()) {
return false;
}
Eigen::MatrixXd sl_constraints =
Eigen::MatrixXd::Zero(2 * t.size(), total_param_);
std::vector<double> lower_bound, upper_bound;
for (uint32_t i = 0; i < t.size(); ++i) {
const uint32_t index = FindSegStartIndex(t[i]);
const double d_lateral = SignDistance(ref_xy[i], ref_theta[i]);
const double d_longitudinal =
SignDistance(ref_xy[i], ref_theta[i] - M_PI_2);
const double t_corrected = t[i] - t_knots_[index];
std::vector<double> lateral_coef = AffineCoef(ref_theta[i], t_corrected);
std::vector<double> longitudianl_coef =
AffineCoef(ref_theta[i] - M_PI_2, t_corrected);
const uint32_t index_offset = index * spline_param_num_;
for (uint32_t j = 0; j < spline_param_num_; ++j) {
sl_constraints(2 * i, index_offset + j) = lateral_coef[j];
sl_constraints(2 * i, index_offset + total_param_ / 2 + j) =
lateral_coef[spline_param_num_ + j];
sl_constraints(2 * i + 1, index_offset + j) = longitudianl_coef[j];
sl_constraints(2 * i + 1, index_offset + total_param_ / 2 + j) =
longitudianl_coef[spline_param_num_ + j];
}
lower_bound.emplace_back(d_lateral - lat_tol[i]);
lower_bound.emplace_back(d_longitudinal - lon_tol[i]);
upper_bound.emplace_back(d_lateral + lat_tol[i]);
upper_bound.emplace_back(d_longitudinal + lon_tol[i]);
}
return coxy_constraint_.AddConstraint(sl_constraints, lower_bound,
upper_bound);
}
bool Spline2dConstraint::Add2dDerivativeBoundary(
const std::vector<double>& t,
const vector_Eigen<Eigen::Vector2d>& lower_bound,
const vector_Eigen<Eigen::Vector2d>& upper_bound) {
CHECK_EQ(lower_bound.size(), upper_bound.size());
size_t boundary_size = lower_bound.size();
std::vector<double> x_lower_bound(boundary_size),
x_upper_bound(boundary_size);
std::vector<double> y_lower_bound(boundary_size),
y_upper_bound(boundary_size);
for (uint32_t i = 0; i < boundary_size; ++i) {
x_lower_bound[i] = lower_bound[i].x();
x_upper_bound[i] = upper_bound[i].x();
y_lower_bound[i] = lower_bound[i].y();
y_upper_bound[i] = upper_bound[i].y();
}
bool add_x_constraint = x_constraint_.AddDerivativeBoundary(
t, std::move(x_lower_bound), std::move(x_upper_bound));
bool add_y_constraint = y_constraint_.AddDerivativeBoundary(
t, std::move(y_lower_bound), std::move(y_upper_bound));
return add_x_constraint && add_y_constraint;
}
bool Spline2dConstraint::Add2dSecondDerivativeBoundary(
const std::vector<double>& t,
const vector_Eigen<Eigen::Vector2d>& lower_bound,
const vector_Eigen<Eigen::Vector2d>& upper_bound) {
CHECK_EQ(lower_bound.size(), upper_bound.size());
size_t boundary_size = lower_bound.size();
std::vector<double> x_lower_bound(boundary_size),
x_upper_bound(boundary_size);
std::vector<double> y_lower_bound(boundary_size),
y_upper_bound(boundary_size);
for (uint32_t i = 0; i < boundary_size; ++i) {
x_lower_bound[i] = lower_bound[i].x();
x_upper_bound[i] = upper_bound[i].x();
y_lower_bound[i] = lower_bound[i].y();
y_upper_bound[i] = upper_bound[i].y();
}
bool add_x_constraint = x_constraint_.AddSecondDerivativeBoundary(
t, std::move(x_lower_bound), std::move(x_upper_bound));
bool add_y_constraint = y_constraint_.AddSecondDerivativeBoundary(
t, std::move(y_lower_bound), std::move(y_upper_bound));
return add_x_constraint && add_y_constraint;
}
bool Spline2dConstraint::Add2dThirdDerivativeBoundary(
const std::vector<double>& t,
const vector_Eigen<Eigen::Vector2d>& lower_bound,
const vector_Eigen<Eigen::Vector2d>& upper_bound) {
CHECK_EQ(lower_bound.size(), upper_bound.size());
size_t boundary_size = lower_bound.size();
std::vector<double> x_lower_bound(boundary_size),
x_upper_bound(boundary_size);
std::vector<double> y_lower_bound(boundary_size),
y_upper_bound(boundary_size);
for (uint32_t i = 0; i < boundary_size; ++i) {
x_lower_bound[i] = lower_bound[i].x();
x_upper_bound[i] = upper_bound[i].x();
y_lower_bound[i] = lower_bound[i].y();
y_upper_bound[i] = upper_bound[i].y();
}
bool add_x_constraint = x_constraint_.AddThirdDerivativeBoundary(
t, std::move(x_lower_bound), std::move(x_upper_bound));
bool add_y_constraint = y_constraint_.AddThirdDerivativeBoundary(
t, std::move(y_lower_bound), std::move(y_upper_bound));
return add_x_constraint && add_y_constraint;
}
bool Spline2dConstraint::Add2dPointConstraint(const double t,
const Eigen::Vector2d ft) {
bool add_x_constraint = x_constraint_.AddPointConstraint(t, ft.x());
bool add_y_constraint = y_constraint_.AddPointConstraint(t, ft.y());
return add_x_constraint && add_y_constraint;
}
bool Spline2dConstraint::Add2dPointDerivativeConstraint(
const double t, const Eigen::Vector2d dft) {
bool add_x_constraint =
x_constraint_.AddPointDerivativeConstraint(t, dft.x());
bool add_y_constraint =
y_constraint_.AddPointDerivativeConstraint(t, dft.y());
return add_x_constraint && add_y_constraint;
}
bool Spline2dConstraint::Add2dPointSecondDerivativeConstraint(
const double t, const Eigen::Vector2d ddft) {
bool add_x_constraint =
x_constraint_.AddPointSecondDerivativeConstraint(t, ddft.x());
bool add_y_constraint =
y_constraint_.AddPointSecondDerivativeConstraint(t, ddft.y());
return add_x_constraint && add_y_constraint;
}
bool Spline2dConstraint::Add2dPointThirdDerivativeConstraint(
const double t, const Eigen::Vector2d dddft) {
bool add_x_constraint =
x_constraint_.AddPointThirdDerivativeConstraint(t, dddft.x());
bool add_y_constraint =
y_constraint_.AddPointThirdDerivativeConstraint(t, dddft.y());
return add_x_constraint && add_y_constraint;
}
bool Spline2dConstraint::Add2dSmoothConstraint() {
bool add_x_constraint = x_constraint_.AddSmoothConstraint();
bool add_y_constraint = y_constraint_.AddSmoothConstraint();
return add_x_constraint && add_y_constraint;
}
bool Spline2dConstraint::Add2dDerivativeSmoothConstraint() {
bool add_x_constraint = x_constraint_.AddDerivativeSmoothConstraint();
bool add_y_constraint = y_constraint_.AddDerivativeSmoothConstraint();
return add_x_constraint && add_y_constraint;
}
bool Spline2dConstraint::Add2dSecondDerivativeSmoothConstraint() {
bool add_x_constraint = x_constraint_.AddSecondDerivativeSmoothConstraint();
bool add_y_constraint = y_constraint_.AddSecondDerivativeSmoothConstraint();
return add_x_constraint && add_y_constraint;
}
bool Spline2dConstraint::Add2dThirdDerivativeSmoothConstraint() {
bool add_x_constraint = x_constraint_.AddThirdDerivativeSmoothConstraint();
bool add_y_constraint = y_constraint_.AddThirdDerivativeSmoothConstraint();
return add_x_constraint && add_y_constraint;
}
bool Spline2dConstraint::AddPointAngleConstraint(const double t,
const double angle) {
const uint32_t index = FindSegStartIndex(t);
const double t_corrected = t - t_knots_[index];
Eigen::MatrixXd angle_constraint = Eigen::MatrixXd::Zero(1, total_param_);
Eigen::MatrixXd derivative_contraint =
Eigen::MatrixXd::Zero(1, total_param_ / 2);
double x_coef = std::sin(angle);
double y_coef = -std::cos(angle);
double coef = 1.0;
for (uint32_t i = 1; i < spline_param_num_; ++i) {
angle_constraint(0, index * spline_param_num_ + i) = x_coef * i;
angle_constraint(0, index * spline_param_num_ + total_param_ / 2 + i) =
y_coef * i;
derivative_contraint(0, index * spline_param_num_ + i) = coef * i;
x_coef *= t_corrected;
y_coef *= t_corrected;
coef *= t_corrected;
}
coxy_constraint_.AddConstraint(angle_constraint, std::vector<double>{0.0},
std::vector<double>{0.0});
int dx_sign = 1;
int dy_sign = 1;
double normalized_angle = fmod(angle, M_PI * 2);
if (normalized_angle < 0) {
normalized_angle += M_PI * 2;
}
if (normalized_angle > (M_PI / 2) && normalized_angle < (M_PI * 1.5)) {
dx_sign = -1;
}
if (normalized_angle >= M_PI) {
dy_sign = -1;
}
bool add_x_constraint = x_constraint_.AddConstraint(
derivative_contraint * dx_sign, std::vector<double>{0.0},
std::vector<double>{udrive_inf});
bool add_y_constraint = y_constraint_.AddConstraint(
derivative_contraint * dy_sign, std::vector<double>{0.0},
std::vector<double>{udrive_inf});
return add_x_constraint && add_y_constraint;
}
bool Spline2dConstraint::AddPointVelocityConstraint(const double t,
const double fabs_v,
const int gear,
const double heading) {
double normalized_angle = 0.0;
if (gear > 0) {
normalized_angle = NormalizeAngle(heading);
} else {
normalized_angle = NormalizeAngle(heading + M_PI);
}
/* minimum planning velocity should be above control deadzone */
double normalized_v = std::max(fabs_v, 0.1);
double vx = normalized_v * std::cos(normalized_angle);
double vy = normalized_v * std::sin(normalized_angle);
bool add_x_constraint = x_constraint_.AddPointDerivativeConstraint(t, vx);
bool add_y_constraint = y_constraint_.AddPointDerivativeConstraint(t, vy);
return add_x_constraint && add_y_constraint;
}
bool Spline2dConstraint::AddPointAccelerationConstraint(
const double t, const double a, const int gear, const double a_direction) {
double ax = a * std::cos(a_direction);
double ay = a * std::sin(a_direction);
bool add_x_constraint =
x_constraint_.AddPointSecondDerivativeConstraint(t, ax);
bool add_y_constraint =
y_constraint_.AddPointSecondDerivativeConstraint(t, ay);
return add_x_constraint && add_y_constraint;
}
bool Spline2dConstraint::AddPointKineticBicycleModelConstraint(
const double t, const Eigen::Vector2d position, const double v,
const double a, const double steer, const double heading,
const double wheel_base) {
double vx = v * std::cos(heading);
double vy = v * std::sin(heading);
double ax = a * std::cos(heading) -
v * v * std::sin(heading) * std::tan(steer) / wheel_base;
double ay = a * std::sin(heading) +
v * v * std::cos(heading) * std::tan(steer) / wheel_base;
bool add_x_constraint =
x_constraint_.AddPointConstraint(t, position.x()) &&
x_constraint_.AddPointDerivativeConstraint(t, vx) &&
x_constraint_.AddPointSecondDerivativeConstraint(t, ax);
bool add_y_constraint =
y_constraint_.AddPointConstraint(t, position.y()) &&
y_constraint_.AddPointDerivativeConstraint(t, vy) &&
y_constraint_.AddPointSecondDerivativeConstraint(t, ay);
return add_x_constraint && add_y_constraint;
}
size_t Spline2dConstraint::FindSegStartIndex(const double t) const {
auto upper_bound = std::upper_bound(t_knots_.begin(), t_knots_.end(), t);
return std::min<size_t>(upper_bound - t_knots_.begin() - 1,
t_knots_.size() - 2);
}
double Spline2dConstraint::SignDistance(const Eigen::Vector2d& ref_point,
const double ref_angle) const {
return ref_point.x() * (-std::sin(ref_angle)) +
ref_point.y() * std::cos(ref_angle);
}
std::vector<double> Spline2dConstraint::AffineCoef(const double angle,
const double t) const {
const uint32_t num_params = spline_order_ + 1;
std::vector<double> result(num_params * 2, 0.0);
double x_coef = -std::sin(angle);
double y_coef = std::cos(angle);
for (uint32_t i = 0; i < num_params; ++i) {
result[i] = x_coef;
result[i + num_params] = y_coef;
x_coef *= t;
y_coef *= t;
}
return result;
}
const Eigen::MatrixXd& Spline2dConstraint::constraint_matrix() {
uint32_t ind_constraints = x_constraint_.constraint_matrix().rows() +
y_constraint_.constraint_matrix().rows();
uint32_t coo_constraints = coxy_constraint_.constraint_matrix().rows();
constraint_matrix_ =
Eigen::MatrixXd::Zero(ind_constraints + coo_constraints, total_param_);
if (ind_constraints) {
constraint_matrix_.block(0, 0, ind_constraints / 2, total_param_ / 2) =
x_constraint_.constraint_matrix();
constraint_matrix_.block(ind_constraints / 2, total_param_ / 2,
ind_constraints / 2, total_param_ / 2) =
y_constraint_.constraint_matrix();
}
if (coo_constraints) {
constraint_matrix_.block(ind_constraints, 0, coo_constraints,
total_param_) =
coxy_constraint_.constraint_matrix();
}
return constraint_matrix_;
}
const std::vector<double>& Spline2dConstraint::lower_bound() {
const auto& x_lower_bound = x_constraint_.affine_constraint().lower_bound();
const auto& y_lower_bound = y_constraint_.affine_constraint().lower_bound();
const auto& coo_lower_bound = coxy_constraint_.lower_bound();
lower_bound_ = x_lower_bound;
lower_bound_.insert(lower_bound_.end(), y_lower_bound.begin(),
y_lower_bound.end());
lower_bound_.insert(lower_bound_.end(), coo_lower_bound.begin(),
coo_lower_bound.end());
return lower_bound_;
}
const std::vector<double>& Spline2dConstraint::upper_bound() {
const auto& x_upper_bound = x_constraint_.affine_constraint().upper_bound();
const auto& y_upper_bound = y_constraint_.affine_constraint().upper_bound();
const auto& coo_upper_bound = coxy_constraint_.upper_bound();
upper_bound_ = x_upper_bound;
upper_bound_.insert(upper_bound_.end(), y_upper_bound.begin(),
y_upper_bound.end());
upper_bound_.insert(upper_bound_.end(), coo_upper_bound.begin(),
coo_upper_bound.end());
return upper_bound_;
}
const AffineConstraint& Spline2dConstraint::x_affine_constraint() {
return x_constraint_.affine_constraint();
}
const AffineConstraint& Spline2dConstraint::y_affine_constraint() {
return y_constraint_.affine_constraint();
}
} // namespace common
================================================
FILE: common/smoothing/spline2d_constraint.h
================================================
/******************************************************************************
* Copyright 2017 The Apollo Authors. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*****************************************************************************/
#pragma once
#include <Eigen/Core>
#include <algorithm>
#include <cinttypes>
#include <cmath>
#include <utility>
#include <vector>
#include "common/smoothing/spline1d_constraint.h"
namespace common {
/**
* @class Spline2dConstraint
* @brief specify two-dimension polynomial spline constraint in matrix form
*/
class Spline2dConstraint {
public:
Spline2dConstraint() = default;
Spline2dConstraint(const std::vector<double>& t_knots, const uint32_t order);
bool Add2dBoundary(const std::vector<double>& t,
const vector_Eigen<Eigen::Vector2d>& lower_bound,
const vector_Eigen<Eigen::Vector2d>& upper_bound);
// TODO(chengjie): add 2d station-lateral boundary constraint
bool Add2dStationLateralBoundary(const std::vector<double>& t,
const vector_Eigen<Eigen::Vector2d>& ref_xy,
const std::vector<double>& ref_theta,
const std::vector<double>& lon_tol,
const std::vector<double>& lat_tol);
bool Add2dDerivativeBoundary(const std::vector<double>& t,
const vector_Eigen<Eigen::Vector2d>& lower_bound,
const vector_Eigen<Eigen::Vector2d>& upper_bound);
bool Add2dSecondDerivativeBoundary(
const std::vector<double>& t,
const vector_Eigen<Eigen::Vector2d>& lower_bound,
const vector_Eigen<Eigen::Vector2d>& upper_bound);
bool Add2dThirdDerivativeBoundary(
const std::vector<double>& t,
const vector_Eigen<Eigen::Vector2d>& lower_bound,
const vector_Eigen<Eigen::Vector2d>& upper_bound);
bool Add2dPointConstraint(const double t, const Eigen::Vector2d ft);
bool Add2dPointDerivativeConstraint(const double t,
const Eigen::Vector2d dft);
bool Add2dPointSecondDerivativeConstraint(const double t,
const Eigen::Vector2d ddft);
bool Add2dPointThirdDerivativeConstraint(const double t,
const Eigen::Vector2d dddft);
bool Add2dSmoothConstraint();
bool Add2dDerivativeSmoothConstraint();
bool Add2dSecondDerivativeSmoothConstraint();
bool Add2dThirdDerivativeSmoothConstraint();
bool AddPointAngleConstraint(const double t, const double angle);
bool AddPointVelocityConstraint(const double t, const double fabs_v,
const int gear, const double heading);
bool AddPointAccelerationConstraint(const double t, const double a,
const int gear, const double a_direction);
/* velocity and acceleration contraint according to kinetic bicycle model */
bool AddPointKineticBicycleModelConstraint(const double t,
const Eigen::Vector2d position,
const double v, const double a,
const double steer,
const double heading,
const double wheel_base);
const AffineConstraint& x_affine_constraint();
const AffineConstraint& y_affine_constraint();
const Eigen::MatrixXd& constraint_matrix();
const std::vector<double>& lower_bound();
const std::vector<double>& upper_bound();
private:
size_t FindSegStartIndex(const double t) const;
double SignDistance(const Eigen::Vector2d& ref_point,
const double ref_angle) const;
std::vector<double> AffineCoef(const double angle, const double t) const;
private:
// independent x,y constraint
Spline1dConstraint x_constraint_;
Spline1dConstraint y_constraint_;
// cooperative x,y constraint
AffineConstraint coxy_constraint_;
std::vector<double> t_knots_;
uint32_t spline_order_ = 0;
uint32_t spline_param_num_ = 0;
uint32_t total_param_;
Eigen::MatrixXd constraint_matrix_;
std::vector<double> lower_bound_;
std::vector<double> upper_bound_;
};
} // namespace common
================================================
FILE: common/smoothing/spline2d_kernel.cc
================================================
/******************************************************************************
* Copyright 2017 The Apollo Authors. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*****************************************************************************/
#include "common/smoothing/spline2d_kernel.h"
#include <glog/logging.h>
namespace common {
Spline2dKernel::Spline2dKernel(const std::vector<double>& t_knots,
const uint32_t spline_order)
: t_knots_(t_knots), spline_order_(spline_order) {
x_kernel_ = Spline1dKernel(t_knots_, spline_order_);
y_kernel_ = Spline1dKernel(t_knots_, spline_order_);
spline_param_num_ = spline_order_ + 1;
total_params_ = 2 * (t_knots_.size() - 1) * spline_param_num_;
cooperative_kernel_ = Eigen::MatrixXd::Zero(total_params_, total_params_);
}
void Spline2dKernel::AddRegularization(const double regularized_param) {
x_kernel_.AddRegularization(regularized_param);
y_kernel_.AddRegularization(regularized_param);
}
void Spline2dKernel::Add2dDerivativeKernelMatrix(const double weight) {
x_kernel_.AddDerivativeKernelMatrix(weight);
y_kernel_.AddDerivativeKernelMatrix(weight);
}
void Spline2dKernel::Add2dSecondOrderDerivativeMatrix(const double weight) {
x_kernel_.AddSecondOrderDerivativeMatrix(weight);
y_kernel_.AddSecondOrderDerivativeMatrix(weight);
}
void Spline2dKernel::Add2dThirdOrderDerivativeMatrix(const double weight) {
x_kernel_.AddThirdOrderDerivativeMatrix(weight);
y_kernel_.AddThirdOrderDerivativeMatrix(weight);
}
bool Spline2dKernel::Add2dReferenceLineKernelMatrix(
const std::vector<double>& t_coord,
const vector_Eigen<Eigen::Vector2d>& ref_ft, const double weight) {
size_t ref_size = ref_ft.size();
std::vector<double> fx(ref_size), fy(ref_size);
for (size_t i = 0; i < ref_size; ++i) {
fx[i] = ref_ft[i].x();
fy[i] = ref_ft[i].y();
}
bool add_x_ref = x_kernel_.AddReferenceLineKernelMatrix(t_coord, fx, weight);
bool add_y_ref = y_kernel_.AddReferenceLineKernelMatrix(t_coord, fy, weight);
return add_x_ref && add_y_ref;
}
void Spline2dKernel::Add2dLateralOffsetKernelMatrix(
const std::vector<double>& t_coord,
const vector_Eigen<Eigen::Vector2d>& ref_ft,
const ::std::vector<double> ref_angle, const double weight) {
CHECK_EQ(t_coord.size(), ref_ft.size());
CHECK_EQ(ref_angle.size(), ref_ft.size());
const uint32_t num_params = spline_order_ + 1;
Eigen::MatrixXd kernel_x =
Eigen::MatrixXd::Zero(total_params_ / 2, total_params_ / 2);
Eigen::MatrixXd kernel_y =
Eigen::MatrixXd::Zero(total_params_ / 2, total_params_ / 2);
Eigen::MatrixXd gradient_x = Eigen::MatrixXd::Zero(total_params_ / 2, 1);
Eigen::MatrixXd gradient_y = Eigen::MatrixXd::Zero(total_params_ / 2, 1);
Eigen::MatrixXd kernel_x_seg, kernel_y_seg;
Eigen::MatrixXd gradient_x_seg, gradient_y_seg;
for (size_t i = 0; i < t_coord.size(); ++i) {
const uint32_t index = FindSegStartIndex(t_coord[i]);
const double t_corrected = t_coord[i] - t_knots_[index];
const double sin_0 = std::sin(ref_angle[i]);
const double cos_0 = std::cos(ref_angle[i]);
const double sqr_sin_0 = sin_0 * sin_0;
const double sqr_cos_0 = cos_0 * cos_0;
kernel_x_seg = Eigen::MatrixXd::Zero(num_params, num_params);
kernel_y_seg = Eigen::MatrixXd::Zero(num_params, num_params);
gradient_x_seg = Eigen::MatrixXd::Zero(num_params, 1);
gradient_y_seg = Eigen::MatrixXd::Zero(num_params, 1);
std::vector<double> t_power;
double t_current = 1.0;
for (uint32_t n = 0; n + 1 < 2 * num_params; ++n) {
t_power.emplace_back(t_current);
t_current *= t_corrected;
}
/**
* independent part:
* sin0^2 * x^2 - 2 * (xr * sin0^2 - yr * sin0 * cos0) * x
* cos0^2 * y^2 - 2 * (yr * cos0^2 - xr * sin0 * cos0) * y
*/
const double gradient_x_coeff =
-2 * ref_ft[i].x() * sqr_sin_0 + 2 * ref_ft[i].y() * sin_0 * cos_0;
const double gradient_y_coeff =
-2 * ref_ft[i].y() * sqr_cos_0 + 2 * ref_ft[i].x() * sin_0 * cos_0;
for (uint32_t r = 0; r < num_params; ++r) {
gradient_x_seg(r, 0) = gradient_x_coeff * t_power[r];
gradient_y_seg(r, 0) = gradient_y_coeff * t_power[r];
for (uint32_t c = 0; c < num_params; ++c) {
kernel_x_seg(r, c) = 2.0 * sqr_sin_0 * t_power[r + c];
kernel_y_seg(r, c) = 2.0 * sqr_cos_0 * t_power[r + c];
}
}
kernel_x.block(index * num_params, index * num_params, num_params,
num_params) += weight * kernel_x_seg;
kernel_y.block(index * num_params, index * num_params, num_params,
num_params) += weight * kernel_y_seg;
gradient_x.block(index * num_params, 0, num_params, 1) +=
weight * gradient_x_seg;
gradient_y.block(index * num_params, 0, num_params, 1) +=
weight * gradient_y_seg;
/* cooperative part: -2*x*y*sin0*cos0 */
const uint32_t x_offset = index * num_params;
const uint32_t y_offset = total_params_ / 2 + index * num_params;
const double cooperative_coeff = weight * sin_0 * cos_0;
for (uint32_t r = 0; r < num_params; ++r) {
for (uint32_t c = 0; c < num_params; ++c) {
cooperative_kernel_(x_offset + r, y_offset + c) +=
-2 * cooperative_coeff * t_power[r + c];
cooperative_kernel_(y_offset + r, x_offset + c) +=
-2 * cooperative_coeff * t_power[r + c];
}
}
}
x_kernel_.AddKernel(kernel_x);
x_kernel_.AddGradient(gradient_x);
y_kernel_.AddKernel(kernel_y);
y_kernel_.AddGradient(gradient_y);
}
void Spline2dKernel::Add2dLongitudinalOffsetKernelMatrix(
const std::vector<double>& t_coord,
const vector_Eigen<Eigen::Vector2d>& ref_ft,
const ::std::vector<double> ref_angle, const double weight) {
std::vector<double> ref_angle_longitudinal;
for (size_t i = 0; i < ref_angle.size(); ++i) {
ref_angle_longitudinal.emplace_back(ref_angle[i] - M_PI_2);
}
Add2dLateralOffsetKernelMatrix(t_coord, ref_ft, ref_angle_longitudinal,
weight);
}
const Eigen::MatrixXd& Spline2dKernel::kernel_matrix() {
uint32_t x_rows = x_kernel_.kernel_matrix().rows();
uint32_t y_rows = y_kernel_.kernel_matrix().rows();
kernel_matrix_ = Eigen::MatrixXd::Zero(x_rows + y_rows, total_params_);
kernel_matrix_.block(0, 0, x_rows, total_params_ / 2) =
x_kernel_.kernel_matrix();
kernel_matrix_.block(x_rows, total_params_ / 2, y_rows, total_params_ / 2) =
y_kernel_.kernel_matrix();
kernel_matrix_ += cooperative_kernel_;
return kernel_matrix_;
}
const Eigen::MatrixXd& Spline2dKernel::gradient() {
uint32_t x_rows = x_kernel_.gradient().rows();
uint32_t y_rows = y_kernel_.gradient().rows();
gradient_ = Eigen::MatrixXd::Zero(x_rows + y_rows, 1);
gradient_.block(0, 0, x_rows, 1) = x_kernel_.gradient();
gradient_.block(x_rows, 0, y_rows, 1) = y_kernel_.gradient();
return gradient_;
}
size_t Spline2dKernel::FindSegStartIndex(const double t) const {
auto upper_bound = std::upper_bound(t_knots_.begin(), t_knots_.end(), t);
return std::min<size_t>(upper_bound - t_knots_.begin() - 1,
t_knots_.size() - 2);
}
} // namespace common
================================================
FILE: common/smoothing/spline2d_kernel.h
================================================
/******************************************************************************
* Copyright 2017 The Apollo Authors. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*****************************************************************************/
#pragma once
#include <Eigen/Core>
#include <algorithm>
#include <cinttypes>
#include <vector>
#include "common/smoothing/spline1d_kernel.h"
namespace common {
class Spline2dKernel {
public:
Spline2dKernel(const std::vector<double>& t_knots,
const uint32_t spline_order);
void AddRegularization(const double regularized_param);
void Add2dDerivativeKernelMatrix(const double weight);
void Add2dSecondOrderDerivativeMatrix(const double weight);
void Add2dThirdOrderDerivativeMatrix(const double weight);
bool Add2dReferenceLineKernelMatrix(
const std::vector<double>& t_coord,
const vector_Eigen<Eigen::Vector2d>& ref_ft, const double weight);
void Add2dLateralOffsetKernelMatrix(
const std::vector<double>& t_coord,
const vector_Eigen<Eigen::Vector2d>& ref_ft,
const ::std::vector<double> ref_angle, const double weight);
void Add2dLongitudinalOffsetKernelMatrix(
const std::vector<double>& t_coord,
const vector_Eigen<Eigen::Vector2d>& ref_ft,
const ::std::vector<double> ref_angle, const double weight);
size_t FindSegStartIndex(const double t) const;
const Eigen::MatrixXd& kernel_matrix();
const Eigen::MatrixXd& gradient();
private:
/* kernel only contains x's component */
Spline1dKernel x_kernel_;
/* kernel only contains y's component */
Spline1dKernel y_kernel_;
/* kernel contains both x and y's component */
Eigen::MatrixXd cooperative_kernel_;
Eigen::MatrixXd kernel_matrix_;
Eigen::MatrixXd gradient_;
std::vector<double> t_knots_;
uint32_t spline_order_ = 0;
uint32_t spline_param_num_ = 0;
uint32_t total_params_ = 0;
};
} // namespace common
================================================
FILE: common/smoothing/spline2d_seg.cc
================================================
/******************************************************************************
* Copyright 2017 The Apollo Authors. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*****************************************************************************/
#include "common/smoothing/spline2d_seg.h"
namespace common {
Spline2dSeg::Spline2dSeg(const uint32_t order)
: spline_func_x_(order), spline_func_y_(order) {
derivative_x_ = PolynomialXd::DerivedFrom(spline_func_x_);
derivative_y_ = PolynomialXd::DerivedFrom(spline_func_y_);
second_derivative_x_ = PolynomialXd::DerivedFrom(derivative_x_);
second_derivative_y_ = PolynomialXd::DerivedFrom(derivative_y_);
third_derivative_x_ = PolynomialXd::DerivedFrom(second_derivative_x_);
third_derivative_y_ = PolynomialXd::DerivedFrom(second_derivative_y_);
}
Spline2dSeg::Spline2dSeg(const std::vector<double>& x_param,
const std::vector<double>& y_param)
: spline_func_x_(x_param), spline_func_y_(y_param) {
derivative_x_ = PolynomialXd::DerivedFrom(spline_func_x_);
derivative_y_ = PolynomialXd::DerivedFrom(spline_func_y_);
second_derivative_x_ = PolynomialXd::DerivedFrom(derivative_x_);
second_derivative_y_ = PolynomialXd::DerivedFrom(derivative_y_);
third_derivative_x_ = PolynomialXd::DerivedFrom(second_derivative_x_);
third_derivative_y_ = PolynomialXd::DerivedFrom(second_derivative_y_);
}
bool Spline2dSeg::SetParams(const std::vector<double>& x_param,
const std::vector<double>& y_param) {
if (x_param.size() != y_param.size()) {
return false;
}
spline_func_x_ = PolynomialXd(x_param);
spline_func_y_ = PolynomialXd(y_param);
derivative_x_ = PolynomialXd::DerivedFrom(spline_func_x_);
derivative_y_ = PolynomialXd::DerivedFrom(spline_func_y_);
second_derivative_x_ = PolynomialXd::DerivedFrom(derivative_x_);
second_derivative_y_ = PolynomialXd::DerivedFrom(derivative_y_);
third_derivative_x_ = PolynomialXd::DerivedFrom(second_derivative_x_);
third_derivative_y_ = PolynomialXd::DerivedFrom(second_derivative_y_);
return true;
}
std::pair<double, double> Spline2dSeg::operator()(const double t) const {
return std::make_pair(spline_func_x_(t), spline_func_y_(t));
}
double Spline2dSeg::x(const double t) const { return spline_func_x_(t); }
double Spline2dSeg::y(const double t) const { return spline_func_y_(t); }
double Spline2dSeg::DerivativeX(const double t) const {
return derivative_x_(t);
}
double Spline2dSeg::DerivativeY(const double t) const {
return derivative_y_(t);
}
double Spline2dSeg::SecondDerivativeX(const double t) const {
return second_derivative_x_(t);
}
double Spline2dSeg::SecondDerivativeY(const double t) const {
return second_derivative_y_(t);
}
double Spline2dSeg::ThirdDerivativeX(const double t) const {
return third_derivative_x_(t);
}
double Spline2dSeg::ThirdDerivativeY(const double t) const {
return third_derivative_y_(t);
}
const PolynomialXd& Spline2dSeg::spline_func_x() const {
return spline_func_x_;
}
const PolynomialXd& Spline2dSeg::spline_func_y() const {
return spline_func_y_;
}
const PolynomialXd& Spline2dSeg::DerivativeX() const { return derivative_x_; }
const PolynomialXd& Spline2dSeg::DerivativeY() const { return derivative_y_; }
const PolynomialXd& Spline2dSeg::SecondDerivativeX() const {
return second_derivative_x_;
}
const PolynomialXd& Spline2dSeg::SecondDerivativeY() const {
return second_derivative_y_;
}
const PolynomialXd& Spline2dSeg::ThirdDerivativeX() const {
return third_derivative_x_;
}
const PolynomialXd& Spline2dSeg::ThirdDerivativeY() const {
return third_derivative_y_;
}
} // namespace common
================================================
FILE: common/smoothing/spline2d_seg.h
================================================
/******************************************************************************
* Copyright 2017 The Apollo Authors. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*****************************************************************************/
#pragma once
#include <utility>
#include <vector>
#include "common/smoothing/polynomialxd.h"
namespace common {
class Spline2dSeg {
public:
// order represent the number of parameters (not the highest order);
explicit Spline2dSeg(const uint32_t order);
explicit Spline2dSeg(const std::vector<double>& x_param,
const std::vector<double>& y_param);
~Spline2dSeg() = default;
bool SetParams(const std::vector<double>& x_param,
const std::vector<double>& y_param);
std::pair<double, double> operator()(const double t) const;
double x(const double t) const;
double y(const double t) const;
double DerivativeX(const double t) const;
double DerivativeY(const double t) const;
double SecondDerivativeX(const double t) const;
double SecondDerivativeY(const double t) const;
double ThirdDerivativeX(const double t) const;
double ThirdDerivativeY(const double t) const;
const PolynomialXd& spline_func_x() const;
const PolynomialXd& spline_func_y() const;
const PolynomialXd& DerivativeX() const;
const PolynomialXd& DerivativeY() const;
const PolynomialXd& SecondDerivativeX() const;
const PolynomialXd& SecondDerivativeY() const;
const PolynomialXd& ThirdDerivativeX() const;
const PolynomialXd& ThirdDerivativeY() const;
private:
PolynomialXd spline_func_x_;
PolynomialXd spline_func_y_;
PolynomialXd derivative_x_;
PolynomialXd derivative_y_;
PolynomialXd second_derivative_x_;
PolynomialXd second_derivative_y_;
PolynomialXd third_derivative_x_;
PolynomialXd third_derivative_y_;
};
} // namespace common
================================================
FILE: common/smoothing/spline2d_solver.h
================================================
/******************************************************************************
* Copyright 2017 The Apollo Authors. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*****************************************************************************/
#pragma once
#include <Eigen/Core>
#include <vector>
#include "common/smoothing/spline2d.h"
#include "common/smoothing/spline2d_constraint.h"
#include "common/smoothing/spline2d_kernel.h"
namespace common {
class Spline2dSolver {
public:
Spline2dSolver() = default;
Spline2dSolver(const std::vector<double>& t_knots, const uint32_t order)
: spline_(t_knots, order),
kernel_(t_knots, order),
constraint_(t_knots, order) {}
virtual ~Spline2dSolver() {}
virtual void Reset(const std::vector<double>& t_knots,
const uint32_t order) = 0;
// customize setup
virtual Spline2dConstraint* mutable_constraint() = 0;
virtual Spline2dKernel* mutable_kernel() = 0;
virtual Spline2d* mutable_spline() = 0;
// solve
virtual bool Solve() = 0;
// extract
virtual const Spline2d& spline() const = 0;
protected:
Spline2d spline_;
Spline2dKernel kernel_;
Spline2dConstraint constraint_;
};
} // namespace common
================================================
FILE: common/solver/CMakeLists.txt
================================================
set(osqp_DIR ${PROJECT_SOURCE_DIR}/thirdparty/osqp/install/lib/cmake/osqp)
find_package(osqp REQUIRED)
add_library(common_solver)
add_library(common::solver ALIAS common_solver)
target_sources(common_solver PRIVATE
osqp/osqp_interface.cc
)
target_include_directories(common_solver PUBLIC
${PROJECT_SOURCE_DIR}/thirdparty/osqp/install/include
)
target_link_libraries(common_solver
glog
osqp::osqpstatic
)
================================================
FILE: common/solver/osqp/osqp_interface.cc
================================================
#include "common/solver/osqp/osqp_interface.h"
#include <glog/logging.h>
#include <iostream>
#include "common/solver/osqp/osqp_sparse_matrix.h"
namespace common {
bool OsqpInterface::Solve(
const ColSparseMatrix& P,
Eigen::Ref<Eigen::Matrix<c_float, Eigen::Dynamic, 1>> q,
const ColSparseMatrix& A,
Eigen::Ref<Eigen::Matrix<c_float, Eigen::Dynamic, 1>> l,
Eigen::Ref<Eigen::Matrix<c_float, Eigen::Dynamic, 1>> u,
Eigen::VectorXd* x) {
OSQPSettings* settings =
static_cast<OSQPSettings*>(c_malloc(sizeof(OSQPSettings)));
OSQPData* data = static_cast<OSQPData*>(c_malloc(sizeof(OSQPData)));
data->P = nullptr;
data->A = nullptr;
data->n = P.rows();
data->m = A.rows();
ColSparseMatrix P_uppper_triangular = P.triangularView<Eigen::Upper>();
if (!CreateOsqpSparseMatrix(P_uppper_triangular, data->P)) {
return false;
}
if (!CreateOsqpSparseMatrix(A, data->A)) {
return false;
}
data->q = q.data();
data->l = l.data();
data->u = u.data();
osqp_set_default_settings(settings);
settings->alpha = 1.0;
settings->eps_abs = 1.0e-05;
settings->eps_rel = 1.0e-05;
settings->max_iter = 5000;
settings->polish = true;
settings->verbose = false;
OSQPWorkspace* work;
c_int exitflag = osqp_setup(&work, data, settings);
osqp_solve(work);
auto status = work->info->status_val;
if (status < 0 || (status != 1 && status != 2)) {
LOG(ERROR) << "failed optimization status:\t" << work->info->status;
return false;
} else if (work->solution == nullptr) {
LOG(ERROR) << "The solution from OSQP is nullptr";
return false;
}
c_float* solution = work->solution->x;
(*x) = Eigen::Map<Eigen::VectorXd>(solution, work->data->n, 1);
// Cleanup
osqp_cleanup(work);
c_free(data->A);
c_free(data->P);
c_free(data);
c_free(settings);
return true;
}
bool OsqpInterface::Solve(
const Eigen::MatrixXd& P,
Eigen::Ref<Eigen::Matrix<c_float, Eigen::Dynamic, 1>> q,
const Eigen::MatrixXd& A,
Eigen::Ref<Eigen::Matrix<c_float, Eigen::Dynamic, 1>> l,
Eigen::Ref<Eigen::Matrix<c_float, Eigen::Dynamic, 1>> u,
Eigen::VectorXd* x) {
std::vector<c_float> P_data;
std::vector<c_int> P_indices;
std::vector<c_int> P_indptr;
const Eigen::MatrixXd& P_upper = P.triangularView<Eigen::Upper>();
DenseToCSCMatrix(P_upper, &P_data, &P_indices, &P_indptr);
std::vector<c_float> A_data;
std::vector<c_int> A_indices;
std::vector<c_int> A_indptr;
DenseToCSCMatrix(A, &A_data, &A_indices, &A_indptr);
OSQPSettings* settings =
static_cast<OSQPSettings*>(c_malloc(sizeof(OSQPSettings)));
OSQPData* data = static_cast<OSQPData*>(c_malloc(sizeof(OSQPData)));
data->n = P.rows();
data->m = A.rows();
data->P = csc_matrix(data->n, data->n, P_data.size(), P_data.data(),
P_indices.data(), P_indptr.data());
data->q = q.data();
data->A = csc_matrix(data->m, data->n, A_data.size(), A_data.data(),
A_indices.data(), A_indptr.data());
data->l = l.data();
data->u = u.data();
osqp_set_default_settings(settings);
settings->alpha = 1.0;
settings->eps_abs = 1.0e-05;
settings->eps_rel = 1.0e-05;
settings->max_iter = 5000;
settings->polish = true;
settings->verbose = false;
OSQPWorkspace* work;
c_int exitflag = osqp_setup(&work, data, settings);
osqp_solve(work);
auto status = work->info->status_val;
if (status < 0 || (status != 1 && status != 2)) {
LOG(ERROR) << "failed optimization status:\t" << work->info->status;
return false;
} else if (work->solution == nullptr) {
LOG(ERROR) << "The solution from OSQP is nullptr";
return false;
}
c_float* solution = work->solution->x;
(*x) = Eigen::Map<Eigen::VectorXd>(solution, work->data->n, 1);
// Cleanup
osqp_cleanup(work);
c_free(data->A);
c_free(data->P);
c_free(data);
c_free(settings);
return true;
}
} // namespace common
================================================
FILE: common/solver/osqp/osqp_interface.h
================================================
#pragma once
#include <osqp/osqp.h>
#include <Eigen/Dense>
#include <Eigen/Sparse>
namespace common {
using ColSparseMatrix = Eigen::SparseMatrix<double, Eigen::ColMajor>;
/**
* @class OsqpInterface (ADMM based qp solver)
* @brief solve convex quadratic programming problem
*
* min_{x} 1/2 x'Px + q'x
* s.t. l <= Ax <= u
*
* Note: osqp use sparse matrix representation
* [compressed-column](https://people.sc.fsu.edu/~jburkardt/data/cc/cc.html)
*/
class OsqpInterface {
public:
// please notice that q, l, u may be modified during optimization
static bool Solve(const ColSparseMatrix& P,
Eigen::Ref<Eigen::Matrix<c_float, Eigen::Dynamic, 1>> q,
const ColSparseMatrix& A,
Eigen::Ref<Eigen::Matrix<c_float, Eigen::Dynamic, 1>> l,
Eigen::Ref<Eigen::Matrix<c_float, Eigen::Dynamic, 1>> u,
Eigen::VectorXd* x);
// Although dense matrix interface is provided, one should notice that dense
// matrix P, A will be convert to sparse matrix anyway.
static bool Solve(const Eigen::MatrixXd& P,
Eigen::Ref<Eigen::Matrix<c_float, Eigen::Dynamic, 1>> q,
const Eigen::MatrixXd& A,
Eigen::Ref<Eigen::Matrix<c_float, Eigen::Dynamic, 1>> l,
Eigen::Ref<Eigen::Matrix<c_float, Eigen::Dynamic, 1>> u,
Eigen::VectorXd* x);
};
} // namespace common
================================================
FILE: common/solver/osqp/osqp_sparse_matrix.h
================================================
#pragma once
#include <glog/logging.h>
#include <osqp/cs.h>
#include <Eigen/Sparse>
namespace common {
template <typename Derived>
bool CreateOsqpSparseMatrix(
const Eigen::SparseCompressedBase<Derived>& eigenSparseMatrix,
csc*& osqpSparseMatrix) {
// Copying into a new sparse matrix to be sure to use a CSC matrix
Eigen::SparseMatrix<typename Derived::value_type, Eigen::ColMajor>
colMajorCopy;
// This may perform merory allocation, but this is already the case for
// allocating the osqpSparseMatrix
colMajorCopy = eigenSparseMatrix;
// get number of row, columns and nonZeros from Eigen SparseMatrix
c_int rows = colMajorCopy.rows();
c_int cols = colMajorCopy.cols();
c_int numberOfNonZeroCoeff = colMajorCopy.nonZeros();
// get innerr and outer index
const int* outerIndexPtr = colMajorCopy.outerIndexPtr();
const int* innerNonZerosPtr = colMajorCopy.innerNonZeroPtr();
// instantiate csc matrix
// MEMORY ALLOCATION!!
if (osqpSparseMatrix != nullptr) {
LOG(ERROR) << "[OsqpEigen::SparseMatrixHelper::createOsqpSparseMatrix] "
"osqpSparseMatrix pointer is not a null pointer! ";
return false;
}
osqpSparseMatrix = csc_spalloc(rows, cols, numberOfNonZeroCoeff, 1, 0);
int innerOsqpPosition = 0;
for (int k = 0; k < cols; k++) {
if (colMajorCopy.isCompressed()) {
osqpSparseMatrix->p[k] = static_cast<c_int>(outerIndexPtr[k]);
} else {
if (k == 0) {
osqpSparseMatrix->p[k] = 0;
} else {
osqpSparseMatrix->p[k] =
osqpSparseMatrix->p[k - 1] + innerNonZerosPtr[k - 1];
}
}
for (typename Eigen::SparseMatrix<typename Derived::value_type,
Eigen::ColMajor>::InnerIterator
it(colMajorCopy, k);
it; ++it) {
osqpSparseMatrix->i[innerOsqpPosition] = static_cast<c_int>(it.row());
osqpSparseMatrix->x[innerOsqpPosition] = static_cast<c_float>(it.value());
innerOsqpPosition++;
}
}
osqpSparseMatrix->p[static_cast<int>(cols)] =
static_cast<c_int>(innerOsqpPosition);
assert(innerOsqpPosition == numberOfNonZeroCoeff);
return true;
}
template <typename T, int M, int N, typename D>
void DenseToCSCMatrix(const Eigen::Matrix<T, M, N>& dense_matrix,
std::vector<T>* data, std::vector<D>* indices,
std::vector<D>* indptr) {
static constexpr double epsilon = 1e-9;
int data_count = 0;
for (int c = 0; c < dense_matrix.cols(); ++c) {
indptr->emplace_back(data_count);
for (int r = 0; r < dense_matrix.rows(); ++r) {
if (std::fabs(dense_matrix(r, c)) < epsilon) {
continue;
}
data->emplace_back(dense_matrix(r, c));
++data_count;
indices->emplace_back(r);
}
}
indptr->emplace_back(data_count);
}
} // namespace common
================================================
FILE: common/thirdparty/osqp/.bumpversion.cfg
================================================
[bumpversion]
current_version = 0.6.2
commit = True
tag = True
parse = (?P<major>\d+)\.(?P<minor>\d+)\.(?P<patch>\d+)(\.(?P<release>[a-z]+)(?P<dev>\d+))?
serialize =
{major}.{minor}.{patch}.{release}{dev}
{major}.{minor}.{patch}
[bumpversion:part:release]
optional_value = gamma
values =
dev
gamma
[bumpversion:part:dev]
[bumpversion:file:README.md]
[bumpversion:file:docs/conf.py]
[bumpversion:file:docs/doxygen.conf]
[bumpversion:file:docs/get_started/CC++.rst]
[bumpversion:file:docs/get_started/matlab.rst]
[bumpversion:file:include/constants.h]
[bumpversion:file:.travis.yml]
[bumpversion:file:appveyor.yml]
================================================
FILE: common/thirdparty/osqp/.editorconfig
================================================
# https://editorconfig.org
root = true
[*.{c, h, cpp, hpp}]
charset = utf-8
indent_style = space
indent_size = 2
end_of_line = lf
trim_trailing_whitespace = true
# Python
[*.py]
indent_size = 4
# Python
[*.yml]
indent_size = 2
# CMake
[CMakeLists.txt]
indent_size = 4
================================================
FILE: common/thirdparty/osqp/.gitattributes
================================================
* text=auto
*.c text
*.h text
*.cpp text
================================================
FILE: common/thirdparty/osqp/.gitignore
================================================
# C language
# -------------------------------------------------------------------
# Compile commands for cquery
compile_commands.json
# Out folder
out/
# Prerequisites
*.d
# Object files
*.o
*.ko
*.obj
*.elf
# Linker output
*.ilk
*.map
*.exp
# Precompiled Headers
*.gch
*.pch
# Libraries
*.lib
*.a
*.la
*.lo
# Shared objects (inc. Windows DLLs)
*.dll
*.so
*.so.*
*.dylib
# Executables
*.exe
*.out
*.app
*.i*86
*.x86_64
*.hex
# Debug files
*.dSYM/
*.su
*.idb
*.pdb
# Kernel Module Compile Results
*.mod*
modules.order
Module.symvers
Mkfile.old
dkms.conf
# Code coverage
*.gcda
*.gcno
coverage.info
coverage_html/
# Doxygen output
docs/doxygen_out
# Editor files
# -------------------------------------------------------------------
*.swp
.ycm_extra_conf.py
*.swo
*.vscode/
# Gurobi
# -------------------------------------------------------------------
gurobi.log
# Tags
# -------------------------------------------------------------------
tags
.tags
.tags1
TAGS
# Python Language
# -------------------------------------------------------------------
# Byte-compiled / optimized / DLL files
__pycache__/
*.py[cod]
*$py.class
# C extensions
*.so
# Distribution / packaging
.Python
env/
build/
develop-eggs/
dist/
downloads/
eggs/
.eggs/
lib/
lib64/
parts/
sdist/
var/
*.egg-info/
.installed.cfg
*.egg
# PyInstaller
# Usually these files are written by a python script from a template
# before PyInstaller builds the exe, so as to inject date/other infos into it.
*.manifest
*.spec
# Installer logs
pip-log.txt
pip-delete-this-directory.txt
# Unit test / coverage reports
htmlcov/
.tox/
.coverage
.coverage.*
.cache
nosetests.xml
coverage.xml
*,cover
.hypothesis/
# Translations
*.mo
*.pot
# Django stuff:
*.log
local_settings.py
# Flask stuff:
instance/
.webassets-cache
# Scrapy stuff:
.scrapy
# Sphinx documentation
docs/_build/
# PyBuilder
target/
# IPython Notebook
.ipynb_checkpoints
# pyenv
.python-version
# celery beat schedule file
celerybeat-schedule
# dotenv
.env
# virtualenv
.venv/
venv/
ENV/
# Spyder project settings
.spyderproject
# Rope project settings
.ropeproject
# Python 3 porting backup files
*.bak
# Mac OSX Files
# -------------------------------------------------------------------
.DS_Store
# Matlab
# -------------------------------------------------------------------
# Files generated during compilation
*.o
*.m~
*.mexmaci64*
*.mexw64*
*.mexa64*
out/
*.asv
# Other data files
# *.mat
# Emacs
\#*\#
.\#*
*~
# Clang completer
# -------------------------------------------------------------------
.clang_complete
# CMake Files
# -------------------------------------------------------------------
*.stamp
.cquery_cached_index
================================================
FILE: common/thirdparty/osqp/.gitmodules
================================================
[submodule "lin_sys/direct/qdldl/qdldl_sources"]
path = lin_sys/direct/qdldl/qdldl_sources
url = https://github.com/oxfordcontrol/qdldl.git
================================================
FILE: common/thirdparty/osqp/.travis.yml
================================================
language: C
matrix:
include:
- os: linux
dist: xenial
- os: osx
# Specify version to avoid bug (https://github.com/travis-ci/travis-ci/issues/6522)
osx_image: xcode9.3
sudo: required
env:
global:
- OSQP_VERSION="0.6.2"
- DEPS_DIR="${HOME}/deps"
# Bintray API key
- secure: "RgZWa1zTkbXzbF+TW89CDa0OD+hjVrZCSnsG9X3OQRyMRcR8yp61SudC0sopJyAhrXA++6zRENI/T1rTmTr1WYcitF22x3fzVvPL+IQEUCxXPV6GOb3cBB/f3rxkpxeBYXO+tgsH1ad+A9T2oihO0/94fKVpZ5uN5mjJbP4yatF+DyEk5+IlHkp0yrgNxyLYEo7QCaDQJhffBJCa4R3C2sb2oL5S3JV6C1svWeSRVey5lrkNwk+rL1Af0kIEfWCXYBq5dchDLFGgfJlzFTw3i/UmKSqtdkq/Eq3vKpvvqMCHcm9ibcWeJX1iNSXVmblycLitI/K1LjONWvrAioHsv9qRaf+YXtLtyb1WXLmaPdi0P138TIDMHLslFYBq1Sf+1WZJ5U3KItzNXjFw/c2yUIDXMePrXNbHodYwND+3QS+yAoIHXT0buxUjjEbD6g54YfqjsTX8w510l+dy7WZQUM6GJn7byiEDfEEu9RbhLuDRHMG8h2viya9aLgIEAMq92/XbS6v01aX24dPmrlSZEocqwrp8yJxGU4tYk+gj4rnWXYF7XfaOVvINc5RRwejZ1mIkMg1fCEqaBmKQiOwDuypoG0L9kDaX85fGwo7/LIdApsJWZvXewlW8ZQERSqFwXDJpQXjS8iHcCzJUR+WUWkrVMYzzr74Fr+XeKmQeQC4="
- PYTHON_VERSION="3.6"
# OSQP_DOCS_DEPLOY_EMAIL
- secure: "EOnlXwP6GSEq4gm9lxTG6QHH4PUA2r2KOZULbdFXbn11Nr0z/ubjjzOGwGLCQdJcvz40G4Ks9Lty8RZqFvrIXXfMgli1jPR9N9jTPANog9abB+GOzjYn5IqBJMN4ZaR8DDpzHB4n9QE2w5I1ihTLIEnZ0Jxm9ckxYBlx9ndeRPEE0qqePkM1oP+GiT+WIidv9r9z3p6kKG+x4BF6d2SgzNGVL8v7yyPtVDGyUvLu/CGvY6pDgUqp0KImpOgjtrKTtFtYergBHTBPoLpxRLjw0RZRlaPquiitvwm4QxdYDmlyDahnoST330m0vvca2oCA76E3AlobUK8MDGxB+CiUfTM3e51mKCq3UO4o7g6BKT5ZF+0YpCFyfvvJZg6TupdfWdtlNG15rcgVgzOKAPrlaEe0qtCOUduPTHECCkOO/yUyEOU8+LEEvnESNdrJhfnPtkWBRJ607TjfKS6tLFcHjHobPtG4yB0ZBoOSWVjngIkJc/1vQNfrDXuBhWcF861GPnStv44ziNLl8+KL+9ekjPitVubInsxGNDtz0qVtMGigTK8xGxE0EjoUroIXc/DSfuFcPj4t7j56C7xFjxRz+nREGhq158XOiq0qLUtEdBPSvh9yxdn35n1L3D1kGM4oSHWhAslV55GZqorJfI/HBWelVhsVM+6HAoezQ9aJaQ4="
# OSQP_DOCS_DEPLOY_GH_TOKEN
- secure: "F+9E43Mw6DpmS//G48Rwh1BOr1fpwYN1RtxLA01E+VM3H3h6a0jgv0iXaTA1nAI7Ept7+RXCwH8TG6MFmGj+ygAB/6C8qUWXPhZugqi/ekXzEvQlA/kU1YjDKm1Uh57ZKrm7lLMt6X8RSuy4VWRa0ZyZ6yc7X+wFwRwz+u9kneQu0/U1BWY26FG0CWK639r8yD5nX2d33E723kCVT1o9R/hK5t01ow61/AE1AIevvjTYhaw8mGbDw0sWKVcPng4+2y8Nlh+E1lE5QQRgUntO4LYJfuMMuJlcHLwxAacJ8DQBpbop4WWxCkuccvaVBgeUNXNFIgq88lwAFYTiEC1LCoFxzEZuIbmfGJNTYZrjvIsxZaoavRVVDcdRVU+4sC/Nr3GHVh/WF+XsOzFN9ij+fvOd5SaEAN0KU6Wlw3lrvTjHnvDFFz5WVkeZMn+47flGl6aoPLfSi7IoNqch2iuAUr0qJ8CRC79/Avhbij9bPLEkEdMKnAcoJYL4V89xGKS67LJb3m8iS0FaCTYB7Fy4T0Gg6cxeLJbaJukj6kUUpJOuZSOFwf9QCA+u5SyYzcanPgPZsHOlZ9xB+6snDdZ+2G3VGsNnrTZoeqRSDelt4aKpI0JkYe0MFkm95AYxzf/utjWYz07QeewmPi7c15PpFr8XmRoGYtpIxVRV12y2Dqs="
install:
# Source to export variables
- source ${TRAVIS_BUILD_DIR}/ci/travis/install.sh
script:
- bash ${TRAVIS_BUILD_DIR}/ci/travis/script.sh
deploy:
# Deploy shared libraries to bintray
- provider: script
script: "bash ${TRAVIS_BUILD_DIR}/ci/travis/deploy.sh"
on:
tags: true
skip_cleanup: true # to upload artifacts created during the build
# Deploy docs
- provider: script
script: "bash ${TRAVIS_BUILD_DIR}/ci/travis/docs.sh"
on:
branch: master
================================================
FILE: common/thirdparty/osqp/.valgrind-suppress.supp
================================================
{
ignore_get_max_threads_intel
Memcheck:Param
sched_setaffinity(mask)
fun:syscall
fun:__kmp_affinity_determine_capable
fun:_Z20__kmp_env_initializePKc
fun:__kmp_middle_initialize
fun:omp_get_num_procs@@VERSION
fun:mkl_serv_domain_get_max_threads
obj:*
}
{
ignore mkl_get_max_threads
Memcheck:Cond
fun:mkl_serv_domain_get_max_threads
obj:*
}
{
ignore_libiomp_intel
Memcheck:Cond
fun:__intel_sse2_strrchr
fun:*_INTERNAL_45_______src_thirdparty_tbb_omp_dynamic_link_cpp_*
fun:__sti__$E
obj:*libiomp*.so
}
{
mkl_malloc
Memcheck:Leak
match-leak-kinds: definite
fun:malloc
fun:_dl_signal_error
fun:_dl_open
fun:dlopen_doit
fun:_dl_catch_error
fun:_dlerror_run
fun:dlopen@@GLIBC_2.2.5
fun:mkl_serv_inspector_suppress
fun:mkl_serv_lock
fun:mkl_serv_core_register_cleanup
fun:__sti__$E
fun:call_init.part.0
}
{
another_intel
Memcheck:Addr16
fun:__intel_sse2_strrchr
fun:_ZN67_INTERNAL_45_______src_thirdparty_tbb_omp_dynamic_link_cpp_d77f5ef55__kmp12init_dl_dataEv
fun:__sti__$E
obj:*libiomp5.so
obj:*libiomp5.so
}
================================================
FILE: common/thirdparty/osqp/CHANGELOG.md
================================================
Version 0.6.2 (6 January 2021)
------------------------------
* Fix segfault python multithreading
* Compatibility python 3.9
* Updated QDLDL to version 0.1.5
* Drop Python 2.7 support
Version 0.6.0 (30 August 2019)
------------------------------
* Added meaningful return values to internal functions. Changed syntax of `osqp_setup` function. It now returns an exitflag.
* `osqp_setup` function requires `P` to be upper triangular. It returns a nonzero exitflag otherwise.
* Custom memory allocators via cmake and the configure file.
* Changed interfaces to linsys solver functions. The solve function now computes `(x_tilde,z_tilde)` instead of `(x_tilde,nu)`. This allows to implement custom linear system solvers (also indirect).
* Added `solve` function in Python interface that performs `setup` `solve` and `cleanup` for you directly and disables GIL.
* Improved code generation folder structure.
Version 0.5.0 (10 December 2018)
----------------
* Added `update_time` to the info structure.
* Fixed [#101](https://github.com/oxfordcontrol/osqp/issues/101).
Version 0.4.1 (25 September 2018)
---------------------------------
* Updated QDLDL to version 0.1.3.
* Added check for nonconvex cost function (non-positive semidefinite `P`) after factorization is performed.
* Added complete sources distribution on bintray.com (including QDLDL).
Version 0.4.0 (23 July 2018)
----------------------------
* Added check for nonconvex cost function (non-positive semidefinite `P`).
* Removed SuiteSparse LDL in favor of [QDLDL](https://github.com/oxfordcontrol/qdldl).
* Static library `libosqpstatic` now renamed as `libosqp`.
Version 0.3.1 (10 June 2018)
----------------------------
* Fixed [#62](https://github.com/oxfordcontrol/osqp/issues/62).
* Moved interfaces to separate repositories
* Fixed [#54](https://github.com/oxfordcontrol/osqp/issues/54).
* Changes to support Matlab 2018a
* Added support for new interface in R
Version 0.3.0 (5 March 2018)
----------------------------
* Added `time_limit` option
* Added CUTEst interface
* Fixed bug in upper triangular `P` extraction. Now the solver can accept both complete `P` matrix or just the upper triangular part.
* Fixed [#33](https://github.com/oxfordcontrol/osqp/issues/33)
* Fixed [#34](https://github.com/oxfordcontrol/osqp/issues/34)
* Allow `eps_rel=0` [#40](https://github.com/oxfordcontrol/osqp/issues/40)
* Fixed bug when calling `osqp_solve` or `osqp_cleanup` after failed linear system initialization
* Add "install" CMake target and installation of CMake configuration files
* Fixed potential name conflict with SCS [47](https://github.com/oxfordcontrol/osqp/issues/47)
* Changed `set_default_settings` to `osqp_set_default_settings` and brought function to main API header `osqp.h`
* Fixed [#49](https://github.com/oxfordcontrol/osqp/issues/49)
Version 0.2.1 (25 November 2017)
---------------------------------
* Fixed problem with code generation and pypi `data_files` (everything now in [MANIFEST.in](https://github.com/pypa/sampleproject/issues/30))
Version 0.2.0 (23 November 2017)
---------------------------------
* Added adaptive rho -> Much more reliable convergence!
* Simplified several settings
* "early_terminate" and "early_terminate_interval" -> "check_termination"
* "scaling_iter" removed and put inside "scaling" parameter
* Julia interface [OSQP.jl](https://github.com/oxfordcontrol/OSQP.jl)
* Shared libraries available on bintray.com
* Added inaccurate return statuses
* Added new object-oriented structure for linear system solvers
* Added MKL Pardiso interface using shared dynamic library loader
* Added diagonal rho vector with different values for equality/inequality constraints (interface still have scalar rho)
* Return certificates of infeasibility in results structure
* Now code generation produces a static library
Version 0.1.3 (21 September 2017)
---------------------------------
* Fixed sources distribution on Python
Version 0.1.2 (20 July 2017)
------------------------------
* Added option to terminate with scaled or unscaled residual
* Now Matlab interface does support logical entries for the settings
* Fixed bug in index ordering of sparse matrices of Python interface
* Changed 2-norms to inf-norms
* Fixed code generation bug when scaling is disabled [#7](https://github.com/oxfordcontrol/osqp/issues/7)
* Removed warnings in code-generation for standard <= C99
* Fixed MATLAB 2015b compatibility [#6](https://github.com/oxfordcontrol/osqp/issues/6)
Version 0.1.1 (11 April 2017)
-----------------------------
* Fixed crashes during polishing when factorization fails
* Added package to Pypi
* Fixed relative paths Matlab
Version 0.1.0 (10 April 2017)
-----------------------------
* Linux, Mac and Windows
* Interface to Python 2.7, 3.5+
* Interface to Matlab 2015b+
* Embedded code generation
================================================
FILE: common/thirdparty/osqp/CMakeLists.txt
================================================
# Minimum version required
cmake_minimum_required (VERSION 3.2)
# Project name
project (osqp)
# Export compile commands
set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
# Set the output folder where your program will be created
set(EXECUTABLE_OUTPUT_PATH ${PROJECT_BINARY_DIR}/out)
set(LIBRARY_OUTPUT_PATH ${PROJECT_BINARY_DIR}/out)
# Some non-standard CMake modules
LIST(APPEND CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}/configure/cmake)
INCLUDE(FindPythonModule)
INCLUDE(Utils)
# include(FindMKL) # Find MKL module
# Detect operating system
# ----------------------------------------------
message(STATUS "We are on a ${CMAKE_SYSTEM_NAME} system")
if(${CMAKE_SYSTEM_NAME} STREQUAL "Linux")
set(IS_LINUX ON)
elseif(${CMAKE_SYSTEM_NAME} STREQUAL "Darwin")
set(IS_MAC ON)
elseif(${CMAKE_SYSTEM_NAME} STREQUAL "Windows")
set(IS_WINDOWS ON)
endif()
# Set options
# ----------------------------------------------
# Are unittests generated?
option (UNITTESTS "Enable unittests generation" OFF)
# Is the code generated for embedded platforms?
# 1 : Yes. Matrix update not allowed.
# 2 : Yes. Matrix update allowed.
if (NOT DEFINED EMBEDDED)
message(STATUS "Embedded is OFF")
else()
message(STATUS "Embedded is ${EMBEDDED}")
endif()
# Is printing enabled?
option (PRINTING "Enable solver printing" ON)
if (DEFINED EMBEDDED)
message(STATUS "Disabling printing for embedded")
set(PRINTING OFF)
endif()
message(STATUS "Printing is ${PRINTING}")
# Is profiling enabled?
option (PROFILING "Enable solver profiling (timing)" ON)
if (DEFINED EMBEDDED)
message(STATUS "Disabling profiling for embedded")
set(PROFILING OFF)
endif()
message(STATUS "Profiling is ${PROFILING}")
# Is user interrupt enabled?
option (CTRLC "Enable user interrupt (Ctrl-C)" ON)
if (DEFINED EMBEDDED)
message(STATUS "Disabling user interrupt for embedded")
set(CTRLC OFF)
endif()
message(STATUS "User interrupt is ${CTRLC}")
# Use floats instead of integers
option (DFLOAT "Use float numbers instead of doubles" OFF)
message(STATUS "Floats are ${DFLOAT}")
# Use long integers for indexing
option (DLONG "Use long integers (64bit) for indexing" ON)
if (NOT (CMAKE_SIZEOF_VOID_P EQUAL 8))
message(STATUS "Disabling long integers (64bit) on 32bit machine")
set(DLONG OFF)
endif()
message(STATUS "Long integers (64bit) are ${DLONG}")
option (DEBUG "Debug mode" OFF)
if (CMAKE_BUILD_TYPE STREQUAL "Debug")
set (DEBUG ON)
message(STATUS "Debug mode is ${DEBUG}")
endif()
# Add code coverage
option (COVERAGE "Perform code coverage" OFF)
message(STATUS "Code coverage is ${COVERAGE}")
# Memory allocators
# ----------------------------------------------
#Report on custom user header options. This is intended to allow
#users to provide definitions of their own memory functions
# The header should define the functions as follows
#
# define c_malloc mymalloc
# define c_calloc mycalloc
# define c_realloc myrealloc
# define c_free myfree
if(OSQP_CUSTOM_MEMORY)
message(STATUS "User custom memory management header: ${OSQP_CUSTOM_MEMORY}")
endif()
# Linear solvers dependencies
# ---------------------------------------------
option (ENABLE_MKL_PARDISO "Enable MKL Pardiso solver" ON)
if (DFLOAT)
message(STATUS "Disabling MKL Pardiso Solver with floats")
set(ENABLE_MKL_PARDISO OFF)
elseif(DEFINED EMBEDDED)
message(STATUS "Disabling MKL Pardiso Solver for embedded")
set(ENABLE_MKL_PARDISO OFF)
endif()
message(STATUS "MKL Pardiso: ${ENABLE_MKL_PARDISO}")
# Generate header file with the global options
# ---------------------------------------------
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/configure/osqp_configure.h.in
${CMAKE_CURRENT_SOURCE_DIR}/include/osqp_configure.h
NEWLINE_STYLE LF)
# Set Compiler flags
# ----------------------------------------------
set(CMAKE_POSITION_INDEPENDENT_CODE ON) # -fPIC
if (NOT MSVC)
if (COVERAGE)
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} --coverage")
if(FORTRAN)
set(CMAKE_FORTRAN_FLAGS "${CMAKE_FORTRAN_FLAGS} --coverage")
endif(FORTRAN)
endif()
if (DEBUG)
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -O0 -g")
else()
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -O3")
endif()
set(CMAKE_C_STANDARD_LIBRARIES "${CMAKE_C_STANDARD_LIBRARIES} -lm") # Include math
# Include real time library in linux
if(${CMAKE_SYSTEM_NAME} STREQUAL "Linux")
set(CMAKE_C_STANDARD_LIBRARIES "${CMAKE_C_STANDARD_LIBRARIES} -lrt -ldl")
endif()
endif (NOT MSVC)
# Set sources and includes
# ----------------------------------------------
add_subdirectory (src)
add_subdirectory (include)
# if we are building the Python interface, let's look for Python
# and set some options
# -----------------------------------------------------------------
if (PYTHON)
# Python include directories need to be passed by the python compilation process
if (NOT PYTHON_INCLUDE_DIRS)
message( FATAL_ERROR "You need Python include directories to build the Python interface" )
endif (NOT PYTHON_INCLUDE_DIRS)
# Include directories for Python headers
include_directories(${PYTHON_INCLUDE_DIRS})
# Pass PYTHON flag to C compiler
add_definitions(-DPYTHON)
if (UNITTESTS)
# Disable unittests
message(STATUS "Disabling UNITTESTS because we are building Python interface")
set(UNITTESTS OFF)
endif (UNITTESTS)
endif (PYTHON)
# if we are building the Matlab interface, let's look for Matlab
# and set some options
# -----------------------------------------------------------------
if (MATLAB)
find_package(Matlab)
if (NOT Matlab_FOUND)
message( FATAL_ERROR "You need Matlab libraries to build the Matlab interface" )
endif (NOT Matlab_FOUND)
# Include directories for Matlab headers
include_directories(${Matlab_INCLUDE_DIRS})
message(STATUS "Matlab root is " ${Matlab_ROOT_DIR})
# Pass MATLAB flag to C compiler
add_definitions(-DMATLAB)
# Insist on the pre 2018 complex data API
# so that mxGetPr will work correctly
add_definitions(-DMATLAB_MEXSRC_RELEASE=R2017b)
message(STATUS "Using Matlab pre-2018a API for mxGetPr compatibility")
if (UNITTESTS)
# Disable unittests
message(STATUS "Disabling UNITTESTS because we are building Matlab interface")
set(UNITTESTS OFF)
endif (UNITTESTS)
endif (MATLAB)
# if we are building the R interface, let's look for R
# and set some options
# -----------------------------------------------------------------
if (R_LANG)
message(STATUS "We are building the R interface")
# Look for R libraries
find_package(R)
if (NOT R_FOUND)
message( FATAL_ERROR "You need R libraries to build the R interface" )
endif (NOT R_FOUND)
message(STATUS "R exec is: " ${R_EXEC})
message(STATUS "R root dir is: " ${R_ROOT_DIR})
message(STATUS "R includes are in: " ${R_INCLUDE_DIRS})
# Include directories for R headers
include_directories(${R_INCLUDE_DIRS})
# Pass R_LANG flag to C compiler
add_definitions(-DR_LANG)
if (UNITTESTS)
# Disable unittests
message(STATUS "Disabling UNITTESTS because we are building the R interface")
set(UNITTESTS OFF)
endif (UNITTESTS)
endif (R_LANG)
# Create Static Library
# ----------------------------------------------
# Add linear system solvers cumulative library
add_subdirectory(lin_sys)
# Static library
add_library (osqpstatic STATIC ${osqp_src} ${osqp_headers} ${linsys_solvers})
# Give same name to static library output
set_target_properties(osqpstatic PROPERTIES OUTPUT_NAME osqp)
# Include directories for linear system solvers
target_include_directories(osqpstatic PRIVATE ${linsys_solvers_includes})
# Declare include directories for the cmake exported target
target_include_directories(osqpstatic
PUBLIC "$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>"
"$<INSTALL_INTERFACE:$<INSTALL_PREFIX>/${CMAKE_INSTALL_INCLUDEDIR}/osqp>")
# Install Static Library
# ----------------------------------------------
include(GNUInstallDirs)
install(TARGETS osqpstatic
EXPORT ${PROJECT_NAME}
ARCHIVE DESTINATION "${CMAKE_INSTALL_LIBDIR}"
LIBRARY DESTINATION "${CMAKE_INSTALL_LIBDIR}"
RUNTIME DESTINATION "${CMAKE_INSTALL_BINDIR}")
# Install Headers
# ----------------------------------------------
install(FILES ${osqp_headers} DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}/osqp")
if (MATLAB)
target_link_libraries (osqpstatic ${Matlab_LIBRARIES})
endif (MATLAB)
# If we are building Python/Matlab/R interface:
# - do not build shared library
# - do not build demo
if (NOT PYTHON AND NOT MATLAB AND NOT R_LANG AND NOT EMBEDDED)
# Create osqp shared library
# NB: Add all the linear system solvers here
add_library (osqp SHARED ${osqp_src} ${osqp_headers} ${linsys_solvers})
# Include directories for linear system solvers
target_include_directories(osqp PRIVATE ${linsys_solvers_includes})
# Declare include directories for the cmake exported target
target_include_directories(osqp
PUBLIC "$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>"
"$<INSTALL_INTERFACE:$<INSTALL_PREFIX>/${CMAKE_INSTALL_INCLUDEDIR}/osqp>")
# Install osqp shared library
install(TARGETS osqp
EXPORT ${PROJECT_NAME}
LIBRARY DESTINATION "${CMAKE_INSTALL_LIBDIR}"
ARCHIVE DESTINATION "${CMAKE_INSTALL_LIBDIR}"
RUNTIME DESTINATION "${CMAKE_INSTALL_BINDIR}")
# Create demo executable (linked to static library)
add_executable (osqp_demo ${PROJECT_SOURCE_DIR}/examples/osqp_demo.c)
target_link_libraries (osqp_demo osqpstatic)
endif (NOT PYTHON AND NOT MATLAB AND NOT R_LANG AND NOT EMBEDDED)
# Create CMake packages for the build directory
# ----------------------------------------------
include(CMakePackageConfigHelpers)
export(EXPORT ${PROJECT_NAME}
FILE "${CMAKE_CURRENT_BINARY_DIR}/osqp-targets.cmake"
NAMESPACE osqp::)
if(NOT EXISTS ${CMAKE_CURRENT_BINARY_DIR}/osqp-config.cmake)
file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/osqp-config.cmake "include(\"\${CMAKE_CURRENT_LIST_DIR}/osqp-targets.cmake\")\n")
endif()
# Create CMake packages for the install directory
# ----------------------------------------------
set(ConfigPackageLocation ${CMAKE_INSTALL_LIBDIR}/cmake/osqp)
install(EXPORT ${PROJECT_NAME}
FILE osqp-targets.cmake
NAMESPACE osqp::
DESTINATION ${ConfigPackageLocation})
install(FILES ${CMAKE_CURRENT_BINARY_DIR}/osqp-config.cmake
DESTINATION ${ConfigPackageLocation})
# Add uninstall command
# ----------------------------------------------
if(NOT TARGET uninstall)
configure_file(
"${CMAKE_CURRENT_SOURCE_DIR}/configure/cmake/cmake_uninstall.cmake.in"
Showing preview only (428K chars total). Download the full file or copy to clipboard to get everything.
gitextract_p9zhc6xs/ ├── .gitmodules ├── LICENSE ├── README.md ├── common/ │ ├── .gitignore │ ├── CMakeLists.txt │ ├── base/ │ │ ├── state.h │ │ ├── trajectory.h │ │ └── type.h │ ├── cmake/ │ │ └── FindGlog.cmake │ ├── frenet/ │ │ ├── CMakeLists.txt │ │ ├── frenet_state.h │ │ ├── frenet_transform.cc │ │ └── frenet_transform.h │ ├── geometry/ │ │ ├── CMakeLists.txt │ │ ├── box2d.cc │ │ └── box2d.h │ ├── graph/ │ │ └── dijkstra.hpp │ ├── package.xml │ ├── smoothing/ │ │ ├── CMakeLists.txt │ │ ├── LICENSE │ │ ├── README.md │ │ ├── affine_constraint.cc │ │ ├── affine_constraint.h │ │ ├── discrete_points_math.cc │ │ ├── discrete_points_math.h │ │ ├── osqp_spline1d_solver.cc │ │ ├── osqp_spline1d_solver.h │ │ ├── osqp_spline2d_solver.cc │ │ ├── osqp_spline2d_solver.h │ │ ├── polynomialxd.cc │ │ ├── polynomialxd.h │ │ ├── spline1d.cc │ │ ├── spline1d.h │ │ ├── spline1d_constraint.cc │ │ ├── spline1d_constraint.h │ │ ├── spline1d_kernel.cc │ │ ├── spline1d_kernel.h │ │ ├── spline1d_kernel_helper.cc │ │ ├── spline1d_kernel_helper.h │ │ ├── spline1d_seg.cc │ │ ├── spline1d_seg.h │ │ ├── spline1d_solver.h │ │ ├── spline2d.cc │ │ ├── spline2d.h │ │ ├── spline2d_constraint.cc │ │ ├── spline2d_constraint.h │ │ ├── spline2d_kernel.cc │ │ ├── spline2d_kernel.h │ │ ├── spline2d_seg.cc │ │ ├── spline2d_seg.h │ │ └── spline2d_solver.h │ ├── solver/ │ │ ├── CMakeLists.txt │ │ └── osqp/ │ │ ├── osqp_interface.cc │ │ ├── osqp_interface.h │ │ └── osqp_sparse_matrix.h │ ├── thirdparty/ │ │ └── osqp/ │ │ ├── .bumpversion.cfg │ │ ├── .editorconfig │ │ ├── .gitattributes │ │ ├── .gitignore │ │ ├── .gitmodules │ │ ├── .travis.yml │ │ ├── .valgrind-suppress.supp │ │ ├── CHANGELOG.md │ │ ├── CMakeLists.txt │ │ ├── LICENSE │ │ ├── NOTICE │ │ ├── README.md │ │ ├── ROADMAP.md │ │ ├── appveyor.yml │ │ ├── ci/ │ │ │ ├── appveyor/ │ │ │ │ ├── deploy.cmd │ │ │ │ ├── install.cmd │ │ │ │ └── script.cmd │ │ │ └── travis/ │ │ │ ├── deploy.sh │ │ │ ├── docs.sh │ │ │ ├── install.sh │ │ │ └── script.sh │ │ ├── configure/ │ │ │ ├── cmake/ │ │ │ │ ├── FindPythonModule.cmake │ │ │ │ ├── FindR.cmake │ │ │ │ ├── Utils.cmake │ │ │ │ └── cmake_uninstall.cmake.in │ │ │ └── osqp_configure.h.in │ │ ├── docs/ │ │ │ ├── Makefile │ │ │ ├── _static/ │ │ │ │ └── css/ │ │ │ │ └── osqp_theme.css │ │ │ ├── _templates/ │ │ │ │ └── layout.html │ │ │ ├── citing/ │ │ │ │ └── index.rst │ │ │ ├── codegen/ │ │ │ │ ├── index.rst │ │ │ │ ├── matlab.rst │ │ │ │ └── python.rst │ │ │ ├── conf.py │ │ │ ├── contributing/ │ │ │ │ └── index.rst │ │ │ ├── doxygen.conf │ │ │ ├── examples/ │ │ │ │ ├── huber.rst │ │ │ │ ├── index.rst │ │ │ │ ├── lasso.rst │ │ │ │ ├── least-squares.rst │ │ │ │ ├── mpc.rst │ │ │ │ ├── portfolio.rst │ │ │ │ ├── setup-and-solve.rst │ │ │ │ ├── svm.rst │ │ │ │ ├── update-matrices.rst │ │ │ │ └── update-vectors.rst │ │ │ ├── get_started/ │ │ │ │ ├── CC++.rst │ │ │ │ ├── cutest.rst │ │ │ │ ├── index.rst │ │ │ │ ├── julia.rst │ │ │ │ ├── linear_system_solvers.rst │ │ │ │ ├── matlab.rst │ │ │ │ ├── python.rst │ │ │ │ ├── r.rst │ │ │ │ └── sources.rst │ │ │ ├── index.rst │ │ │ ├── interfaces/ │ │ │ │ ├── CC++.rst │ │ │ │ ├── cutest.rst │ │ │ │ ├── eigen_google.rst │ │ │ │ ├── eigen_robotology.rst │ │ │ │ ├── fortran.rst │ │ │ │ ├── index.rst │ │ │ │ ├── julia.rst │ │ │ │ ├── linear_systems_solvers.rst │ │ │ │ ├── matlab.rst │ │ │ │ ├── python.rst │ │ │ │ ├── rlang.rst │ │ │ │ ├── ruby.rst │ │ │ │ ├── rust.rst │ │ │ │ ├── solver_settings.rst │ │ │ │ └── status_values.rst │ │ │ ├── make.bat │ │ │ ├── parsers/ │ │ │ │ ├── cvxpy.rst │ │ │ │ ├── index.rst │ │ │ │ ├── jump.rst │ │ │ │ └── yalmip.rst │ │ │ ├── requirements.txt │ │ │ └── solver/ │ │ │ └── index.rst │ │ ├── examples/ │ │ │ └── osqp_demo.c │ │ ├── include/ │ │ │ ├── .gitignore │ │ │ ├── CMakeLists.txt │ │ │ ├── auxil.h │ │ │ ├── constants.h │ │ │ ├── cs.h │ │ │ ├── ctrlc.h │ │ │ ├── error.h │ │ │ ├── glob_opts.h │ │ │ ├── kkt.h │ │ │ ├── lin_alg.h │ │ │ ├── lin_sys.h │ │ │ ├── osqp.h │ │ │ ├── polish.h │ │ │ ├── proj.h │ │ │ ├── scaling.h │ │ │ ├── types.h │ │ │ └── util.h │ │ ├── lin_sys/ │ │ │ ├── CMakeLists.txt │ │ │ ├── direct/ │ │ │ │ ├── CMakeLists.txt │ │ │ │ ├── pardiso/ │ │ │ │ │ ├── CMakeLists.txt │ │ │ │ │ ├── pardiso_interface.c │ │ │ │ │ ├── pardiso_interface.h │ │ │ │ │ ├── pardiso_loader.c │ │ │ │ │ └── pardiso_loader.h │ │ │ │ └── qdldl/ │ │ │ │ ├── CMakeLists.txt │ │ │ │ ├── amd/ │ │ │ │ │ ├── LICENSE │ │ │ │ │ ├── include/ │ │ │ │ │ │ ├── SuiteSparse_config.h │ │ │ │ │ │ ├── amd.h │ │ │ │ │ │ └── amd_internal.h │ │ │ │ │ └── src/ │ │ │ │ │ ├── SuiteSparse_config.c │ │ │ │ │ ├── amd_1.c │ │ │ │ │ ├── amd_2.c │ │ │ │ │ ├── amd_aat.c │ │ │ │ │ ├── amd_control.c │ │ │ │ │ ├── amd_defaults.c │ │ │ │ │ ├── amd_info.c │ │ │ │ │ ├── amd_order.c │ │ │ │ │ ├── amd_post_tree.c │ │ │ │ │ ├── amd_postorder.c │ │ │ │ │ ├── amd_preprocess.c │ │ │ │ │ └── amd_valid.c │ │ │ │ ├── qdldl_interface.c │ │ │ │ ├── qdldl_interface.h │ │ │ │ └── qdldl_sources/ │ │ │ │ ├── .editorconfig │ │ │ │ ├── .gitignore │ │ │ │ ├── .travis.yml │ │ │ │ ├── CHANGELOG.md │ │ │ │ ├── CMakeLists.txt │ │ │ │ ├── LICENSE │ │ │ │ ├── README.md │ │ │ │ ├── appveyor.yml │ │ │ │ ├── configure/ │ │ │ │ │ ├── cmake/ │ │ │ │ │ │ └── cmake_uninstall.cmake.in │ │ │ │ │ └── qdldl_types.h.in │ │ │ │ ├── examples/ │ │ │ │ │ └── example.c │ │ │ │ ├── include/ │ │ │ │ │ ├── .gitignore │ │ │ │ │ └── qdldl.h │ │ │ │ ├── src/ │ │ │ │ │ └── qdldl.c │ │ │ │ └── tests/ │ │ │ │ ├── CMakeLists.txt │ │ │ │ ├── minunit.h │ │ │ │ ├── qdldl_tester.c │ │ │ │ ├── test_basic.h │ │ │ │ ├── test_identity.h │ │ │ │ ├── test_osqp_kkt.h │ │ │ │ ├── test_rank_deficient.h │ │ │ │ ├── test_singleton.h │ │ │ │ ├── test_sym_structure.h │ │ │ │ ├── test_tril_structure.h │ │ │ │ ├── test_two_by_two.h │ │ │ │ └── test_zero_on_diag.h │ │ │ ├── lib_handler.c │ │ │ └── lib_handler.h │ │ ├── src/ │ │ │ ├── CMakeLists.txt │ │ │ ├── auxil.c │ │ │ ├── cs.c │ │ │ ├── ctrlc.c │ │ │ ├── error.c │ │ │ ├── kkt.c │ │ │ ├── lin_alg.c │ │ │ ├── lin_sys.c │ │ │ ├── osqp.c │ │ │ ├── polish.c │ │ │ ├── proj.c │ │ │ ├── scaling.c │ │ │ └── util.c │ │ └── tests/ │ │ ├── .gitignore │ │ ├── CMakeLists.txt │ │ ├── README.md │ │ ├── __init__.py │ │ ├── basic_qp/ │ │ │ ├── CMakeLists.txt │ │ │ ├── __init__.py │ │ │ ├── generate_problem.py │ │ │ └── test_basic_qp.h │ │ ├── basic_qp2/ │ │ │ ├── CMakeLists.txt │ │ │ ├── __init__.py │ │ │ ├── generate_problem.py │ │ │ └── test_basic_qp2.h │ │ ├── custom_memory/ │ │ │ ├── custom_memory.c │ │ │ └── custom_memory.h │ │ ├── demo/ │ │ │ ├── CMakeLists.txt │ │ │ └── test_demo.h │ │ ├── generate_tests_data.py │ │ ├── lin_alg/ │ │ │ ├── CMakeLists.txt │ │ │ ├── __init__.py │ │ │ ├── generate_problem.py │ │ │ └── test_lin_alg.h │ │ ├── minunit.h │ │ ├── non_cvx/ │ │ │ ├── CMakeLists.txt │ │ │ ├── __init__.py │ │ │ ├── generate_problem.py │ │ │ └── test_non_cvx.h │ │ ├── osqp_tester.c │ │ ├── osqp_tester.h │ │ ├── primal_dual_infeasibility/ │ │ │ ├── CMakeLists.txt │ │ │ ├── __init__.py │ │ │ ├── generate_problem.py │ │ │ └── test_primal_dual_infeasibility.h │ │ ├── primal_infeasibility/ │ │ │ ├── CMakeLists.txt │ │ │ ├── __init__.py │ │ │ ├── generate_problem.py │ │ │ └── test_primal_infeasibility.h │ │ ├── solve_linsys/ │ │ │ ├── CMakeLists.txt │ │ │ ├── __init__.py │ │ │ ├── generate_problem.py │ │ │ └── test_solve_linsys.h │ │ ├── unconstrained/ │ │ │ ├── CMakeLists.txt │ │ │ ├── __init__.py │ │ │ ├── generate_problem.py │ │ │ └── test_unconstrained.h │ │ ├── update_matrices/ │ │ │ ├── CMakeLists.txt │ │ │ ├── __init__.py │ │ │ ├── generate_problem.py │ │ │ └── test_update_matrices.h │ │ └── utils/ │ │ ├── __init__.py │ │ └── codegen_utils.py │ └── utils/ │ ├── CMakeLists.txt │ ├── boxcar_filter.h │ ├── color_map.cc │ ├── color_map.h │ ├── common_visual.cc │ ├── common_visual.h │ ├── contains.hpp │ ├── io_utils.cc │ ├── io_utils.h │ ├── math.cc │ ├── math.h │ ├── stdout_color.h │ ├── str_utils.h │ └── timer.h ├── gp_planner/ │ ├── CMakeLists.txt │ ├── gp/ │ │ ├── CMakeLists.txt │ │ ├── factors/ │ │ │ ├── gp_interpolate_kappa_limit_factor.cc │ │ │ ├── gp_interpolate_kappa_limit_factor.h │ │ │ ├── gp_interpolate_obstacle_factor.cc │ │ │ ├── gp_interpolate_obstacle_factor.h │ │ │ ├── gp_kappa_limit_factor.cc │ │ │ ├── gp_kappa_limit_factor.h │ │ │ ├── gp_lat_acc_limit_factor.cc │ │ │ ├── gp_lat_acc_limit_factor.h │ │ │ ├── gp_obstacle_factor.cc │ │ │ ├── gp_obstacle_factor.h │ │ │ ├── gp_prior_factor.cc │ │ │ └── gp_prior_factor.h │ │ ├── gp_incremental_path_planner.cc │ │ ├── gp_incremental_path_planner.h │ │ ├── interpolator/ │ │ │ └── gp_interpolator.h │ │ ├── model/ │ │ │ ├── white_noise_on_acceleration_model_1d.h │ │ │ └── white_noise_on_jerk_model_1d.h │ │ └── utils/ │ │ ├── bounded_penalty_function.h │ │ ├── curvature_utils.h │ │ ├── gp_path.cc │ │ ├── gp_path.h │ │ ├── gp_utils.cc │ │ ├── gp_utils.h │ │ └── penalty_function.h │ ├── gp_planner.cc │ ├── gp_planner.h │ ├── initializer/ │ │ ├── CMakeLists.txt │ │ ├── gp_initializer.cc │ │ └── gp_initializer.h │ ├── package.xml │ ├── sdf/ │ │ ├── CMakeLists.txt │ │ ├── grid_map_2d.cc │ │ ├── grid_map_2d.h │ │ ├── signed_distance_field_2d.cc │ │ └── signed_distance_field_2d.h │ ├── st_plan/ │ │ ├── CMakeLists.txt │ │ ├── st_graph.cc │ │ ├── st_graph.h │ │ ├── st_node.cc │ │ └── st_node.h │ └── thirdparty/ │ └── gtsam-4.1rc/ │ ├── .cproject │ ├── .gitignore │ ├── .project │ ├── .settings/ │ │ ├── .gitignore │ │ └── org.eclipse.cdt.core.prefs │ ├── CMakeLists.txt │ ├── CppUnitLite/ │ │ ├── CMakeLists.txt │ │ ├── Failure.h │ │ ├── Test.cpp │ │ ├── Test.h │ │ ├── TestHarness.h │ │ ├── TestRegistry.cpp │ │ ├── TestRegistry.h │ │ ├── TestResult.cpp │ │ └── TestResult.h │ ├── DEVELOP.md │ ├── GTSAM-Concepts.md │ ├── INSTALL.md │ ├── LICENSE │ ├── LICENSE.BSD │ ├── README.md │ ├── THANKS.md │ ├── USAGE.md │ ├── Using-GTSAM-EXPORT.md │ ├── cmake/ │ │ ├── CMakeLists.txt │ │ ├── Config.cmake.in │ │ ├── FindBoost.cmake │ │ ├── FindCython.cmake │ │ ├── FindEigen3.cmake │ │ ├── FindGooglePerfTools.cmake │ │ ├── FindMKL.cmake │ │ ├── FindNumPy.cmake │ │ ├── FindTBB.cmake │ │ ├── GTSAMCMakeToolsConfig.cmake │ │ ├── GtsamAddPch.cmake │ │ ├── GtsamBuildTypes.cmake │ │ ├── GtsamMakeConfigFile.cmake │ │ ├── GtsamMatlabWrap.cmake │ │ ├── GtsamPrinting.cmake │ │ ├── GtsamTesting.cmake │ │ ├── README.html │ │ ├── README.md │ │ ├── cmake_uninstall.cmake.in │ │ ├── dllexport.h.in │ │ ├── example_cmake_find_gtsam/ │ │ │ ├── CMakeLists.txt │ │ │ └── main.cpp │ │ ├── example_project/ │ │ │ ├── CMakeLists.txt │ │ │ ├── README.md │ │ │ ├── SayGoodbye.cpp │ │ │ ├── SayHello.cpp │ │ │ ├── example/ │ │ │ │ ├── PrintExamples.cpp │ │ │ │ └── PrintExamples.h │ │ │ ├── example.h │ │ │ └── tests/ │ │ │ └── testExample.cpp │ │ └── obsolete/ │ │ ├── FindCppUnitLite.cmake │ │ ├── FindWrap.cmake │ │ └── GtsamTestingObsolete.cmake │ ├── gtsam/ │ │ ├── 3rdparty/ │ │ │ ├── CCOLAMD/ │ │ │ │ ├── Demo/ │ │ │ │ │ ├── Makefile │ │ │ │ │ ├── ccolamd_example.c │ │ │ │ │ ├── ccolamd_example.out │ │ │ │ │ ├── ccolamd_l_example.c │ │ │ │ │ └── ccolamd_l_example.out │ │ │ │ ├── Doc/ │ │ │ │ │ ├── ChangeLog │ │ │ │ │ ├── License.txt │ │ │ │ │ └── lesser.txt │ │ │ │ ├── Include/ │ │ │ │ │ └── ccolamd.h │ │ │ │ ├── Lib/ │ │ │ │ │ └── Makefile │ │ │ │ ├── MATLAB/ │ │ │ │ │ ├── Contents.m │ │ │ │ │ ├── ccolamd.m │ │ │ │ │ ├── ccolamd_demo.m │ │ │ │ │ ├── ccolamd_install.m │ │ │ │ │ ├── ccolamd_make.m │ │ │ │ │ ├── ccolamd_test.m │ │ │ │ │ ├── ccolamdmex.c │ │ │ │ │ ├── ccolamdtestmex.c │ │ │ │ │ ├── ccolamdtestmex.m │ │ │ │ │ ├── csymamd.m │ │ │ │ │ ├── csymamdmex.c │ │ │ │ │ ├── csymamdtestmex.c │ │ │ │ │ ├── csymamdtestmex.m │ │ │ │ │ └── luflops.m │ │ │ │ ├── Makefile │ │ │ │ ├── README.txt │ │ │ │ └── Source/ │ │ │ │ └── ccolamd.c │ │ │ ├── CMakeLists.txt │ │ │ ├── Eigen/ │ │ │ │ ├── .hgeol │ │ │ │ ├── .hgignore │ │ │ │ ├── .hgtags │ │ │ │ ├── CMakeLists.txt │ │ │ │ ├── COPYING.BSD │ │ │ │ ├── COPYING.GPL │ │ │ │ ├── COPYING.LGPL │ │ │ │ ├── COPYING.MINPACK │ │ │ │ ├── COPYING.MPL2 │ │ │ │ ├── COPYING.README │ │ │ │ ├── CTestConfig.cmake │ │ │ │ ├── CTestCustom.cmake.in │ │ │ │ ├── Eigen/ │ │ │ │ │ ├── CMakeLists.txt │ │ │ │ │ ├── Cholesky │ │ │ │ │ ├── CholmodSupport │ │ │ │ │ ├── Core │ │ │ │ │ ├── Dense │ │ │ │ │ ├── Eigen │ │ │ │ │ ├── Eigenvalues │ │ │ │ │ ├── Geometry │ │ │ │ │ ├── Householder │ │ │ │ │ ├── IterativeLinearSolvers │ │ │ │ │ ├── Jacobi │ │ │ │ │ ├── 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/ │ │ │ │ │ │ ├── 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 │ │ │ │ │ │ ├── Inverse.h │ │ │ │ │ │ ├── Map.h │ │ │ │ │ │ ├── MapBase.h │ │ │ │ │ │ ├── MathFunctions.h │ │ │ │ │ │ ├── MathFunctionsImpl.h │ │ │ │ │ │ ├── Matrix.h │ │ │ │ │ │ ├── MatrixBase.h │ │ │ │ │ │ ├── NestByValue.h │ │ │ │ │ │ ├── NoAlias.h │ │ │ │ │ │ ├── NumTraits.h │ │ │ │ │ │ ├── PermutationMatrix.h │ │ │ │ │ │ ├── PlainObjectBase.h │ │ │ │ │ │ ├── Product.h │ │ │ │ │ │ ├── ProductEvaluators.h │ │ │ │ │ │ ├── Random.h │ │ │ │ │ │ ├── Redux.h │ │ │ │ │ │ ├── Ref.h │ │ │ │ │ │ ├── Replicate.h │ │ │ │ │ │ ├── ReturnByValue.h │ │ │ │ │ │ ├── Reverse.h │ │ │ │ │ │ ├── Select.h │ │ │ │ │ │ ├── SelfAdjointView.h │ │ │ │ │ │ ├── SelfCwiseBinaryOp.h │ │ │ │ │ │ ├── Solve.h │ │ │ │ │ │ ├── SolveTriangular.h │ │ │ │ │ │ ├── SolverBase.h │ │ │ │ │ │ ├── StableNorm.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/ │ │ │ │ │ │ │ │ ├── MathFunctions.h │ │ │ │ │ │ │ │ └── PacketMath.h │ │ │ │ │ │ │ ├── AltiVec/ │ │ │ │ │ │ │ │ ├── Complex.h │ │ │ │ │ │ │ │ ├── MathFunctions.h │ │ │ │ │ │ │ │ └── PacketMath.h │ │ │ │ │ │ │ ├── CUDA/ │ │ │ │ │ │ │ │ ├── Complex.h │ │ │ │ │ │ │ │ ├── Half.h │ │ │ │ │ │ │ │ ├── MathFunctions.h │ │ │ │ │ │ │ │ ├── PacketMath.h │ │ │ │ │ │ │ │ ├── PacketMathHalf.h │ │ │ │ │ │ │ │ └── TypeCasting.h │ │ │ │ │ │ │ ├── Default/ │ │ │ │ │ │ │ │ ├── ConjHelper.h │ │ │ │ │ │ │ │ └── Settings.h │ │ │ │ │ │ │ ├── NEON/ │ │ │ │ │ │ │ │ ├── Complex.h │ │ │ │ │ │ │ │ ├── MathFunctions.h │ │ │ │ │ │ │ │ └── PacketMath.h │ │ │ │ │ │ │ ├── SSE/ │ │ │ │ │ │ │ │ ├── Complex.h │ │ │ │ │ │ │ │ ├── MathFunctions.h │ │ │ │ │ │ │ │ ├── PacketMath.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 │ │ │ │ │ │ ├── Constants.h │ │ │ │ │ │ ├── DisableStupidWarnings.h │ │ │ │ │ │ ├── ForwardDeclarations.h │ │ │ │ │ │ ├── MKL_support.h │ │ │ │ │ │ ├── Macros.h │ │ │ │ │ │ ├── Memory.h │ │ │ │ │ │ ├── Meta.h │ │ │ │ │ │ ├── NonMPL2.h │ │ │ │ │ │ ├── ReenableStupidWarnings.h │ │ │ │ │ │ ├── StaticAssert.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 │ │ │ │ │ ├── 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 │ │ │ │ │ ├── MatrixCwiseBinaryOps.h │ │ │ │ │ └── MatrixCwiseUnaryOps.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/ │ │ │ │ │ │ └── gemm/ │ │ │ │ │ │ ├── changesets.txt │ │ │ │ │ │ ├── gemm.cpp │ │ │ │ │ │ ├── gemm_settings.txt │ │ │ │ │ │ ├── lazy_gemm.cpp │ │ │ │ │ │ ├── lazy_gemm_settings.txt │ │ │ │ │ │ ├── make_plot.sh │ │ │ │ │ │ └── run.sh │ │ │ │ │ ├── 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 │ │ │ │ │ │ ├── tensor_benchmarks.h │ │ │ │ │ │ ├── tensor_benchmarks_cpu.cc │ │ │ │ │ │ ├── tensor_benchmarks_fp16_gpu.cu │ │ │ │ │ │ ├── tensor_benchmarks_gpu.cu │ │ │ │ │ │ └── tensor_benchmarks_sycl.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 │ │ │ │ │ ├── FindLAPACK.cmake │ │ │ │ │ ├── FindMPFR.cmake │ │ │ │ │ ├── FindMetis.cmake │ │ │ │ │ ├── FindPTSCOTCH.cmake │ │ │ │ │ ├── FindPastix.cmake │ │ │ │ │ ├── FindSPQR.cmake │ │ │ │ │ ├── FindScotch.cmake │ │ │ │ │ ├── FindStandardMathLibrary.cmake │ │ │ │ │ ├── FindSuperLU.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/ │ │ │ │ │ ├── A05_PortingFrom2To3.dox │ │ │ │ │ ├── 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 │ │ │ │ │ ├── TutorialReshapeSlicing.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_FixedVectorBlock.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 │ │ │ │ │ │ ├── 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_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.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_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_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_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 │ │ │ │ │ │ ├── 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 │ │ │ │ │ │ ├── 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_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 │ │ │ │ │ │ ├── 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 │ │ │ │ │ ├── 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 │ │ │ │ │ ├── release.in │ │ │ │ │ └── relicense.py │ │ │ │ ├── signature_of_eigen3_matrix_library │ │ │ │ ├── test/ │ │ │ │ │ ├── CMakeLists.txt │ │ │ │ │ ├── adjoint.cpp │ │ │ │ │ ├── array.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 │ │ │ │ │ ├── cuda_basic.cu │ │ │ │ │ ├── cuda_common.h │ │ │ │ │ ├── denseLM.cpp │ │ │ │ │ ├── dense_storage.cpp │ │ │ │ │ ├── determinant.cpp │ │ │ │ │ ├── diagonal.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 │ │ │ │ │ ├── half_float.cpp │ │ │ │ │ ├── hessenberg.cpp │ │ │ │ │ ├── householder.cpp │ │ │ │ │ ├── incomplete_cholesky.cpp │ │ │ │ │ ├── inplace_decomposition.cpp │ │ │ │ │ ├── integer_types.cpp │ │ │ │ │ ├── inverse.cpp │ │ │ │ │ ├── is_same_dense.cpp │ │ │ │ │ ├── jacobi.cpp │ │ │ │ │ ├── jacobisvd.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 │ │ │ │ │ ├── nesting_ops.cpp │ │ │ │ │ ├── nomalloc.cpp │ │ │ │ │ ├── nullary.cpp │ │ │ │ │ ├── numext.cpp │ │ │ │ │ ├── packetmath.cpp │ │ │ │ │ ├── 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 │ │ │ │ │ ├── resize.cpp │ │ │ │ │ ├── rvalue_types.cpp │ │ │ │ │ ├── schur_complex.cpp │ │ │ │ │ ├── schur_real.cpp │ │ │ │ │ ├── selfadjoint.cpp │ │ │ │ │ ├── simplicial_cholesky.cpp │ │ │ │ │ ├── sizeof.cpp │ │ │ │ │ ├── sizeoverflow.cpp │ │ │ │ │ ├── smallvectors.cpp │ │ │ │ │ ├── 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 │ │ │ │ │ ├── spqr_support.cpp │ │ │ │ │ ├── stable_norm.cpp │ │ │ │ │ ├── stddeque.cpp │ │ │ │ │ ├── stddeque_overload.cpp │ │ │ │ │ ├── stdlist.cpp │ │ │ │ │ ├── stdlist_overload.cpp │ │ │ │ │ ├── stdvector.cpp │ │ │ │ │ ├── stdvector_overload.cpp │ │ │ │ │ ├── superlu_support.cpp │ │ │ │ │ ├── svd_common.h │ │ │ │ │ ├── svd_fill.h │ │ │ │ │ ├── swap.cpp │ │ │ │ │ ├── triangular.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 │ │ │ │ │ │ │ ├── TensorBroadcasting.h │ │ │ │ │ │ │ ├── TensorChipping.h │ │ │ │ │ │ │ ├── TensorConcatenation.h │ │ │ │ │ │ │ ├── TensorContraction.h │ │ │ │ │ │ │ ├── TensorContractionBlocking.h │ │ │ │ │ │ │ ├── TensorContractionCuda.h │ │ │ │ │ │ │ ├── TensorContractionMapper.h │ │ │ │ │ │ │ ├── TensorContractionThreadPool.h │ │ │ │ │ │ │ ├── TensorConversion.h │ │ │ │ │ │ │ ├── TensorConvolution.h │ │ │ │ │ │ │ ├── TensorCostModel.h │ │ │ │ │ │ │ ├── TensorCustomOp.h │ │ │ │ │ │ │ ├── TensorDevice.h │ │ │ │ │ │ │ ├── TensorDeviceCuda.h │ │ │ │ │ │ │ ├── TensorDeviceDefault.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 │ │ │ │ │ │ │ ├── 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 │ │ │ │ │ │ │ ├── TensorReductionSycl.h │ │ │ │ │ │ │ ├── TensorRef.h │ │ │ │ │ │ │ ├── TensorReverse.h │ │ │ │ │ │ │ ├── TensorScan.h │ │ │ │ │ │ │ ├── TensorShuffling.h │ │ │ │ │ │ │ ├── TensorStorage.h │ │ │ │ │ │ │ ├── TensorStriding.h │ │ │ │ │ │ │ ├── TensorSycl.h │ │ │ │ │ │ │ ├── TensorSyclConvertToDeviceExpression.h │ │ │ │ │ │ │ ├── TensorSyclExprConstructor.h │ │ │ │ │ │ │ ├── TensorSyclExtractAccessor.h │ │ │ │ │ │ │ ├── TensorSyclExtractFunctors.h │ │ │ │ │ │ │ ├── TensorSyclLeafCount.h │ │ │ │ │ │ │ ├── TensorSyclPlaceHolderExpr.h │ │ │ │ │ │ │ ├── TensorSyclRun.h │ │ │ │ │ │ │ ├── TensorSyclTuple.h │ │ │ │ │ │ │ ├── TensorTraits.h │ │ │ │ │ │ │ ├── TensorUInt128.h │ │ │ │ │ │ │ └── TensorVolumePatch.h │ │ │ │ │ │ ├── TensorSymmetry/ │ │ │ │ │ │ │ ├── DynamicSymmetry.h │ │ │ │ │ │ │ ├── StaticSymmetry.h │ │ │ │ │ │ │ ├── Symmetry.h │ │ │ │ │ │ │ └── util/ │ │ │ │ │ │ │ └── TemplateGroupTheory.h │ │ │ │ │ │ ├── ThreadPool/ │ │ │ │ │ │ │ ├── EventCount.h │ │ │ │ │ │ │ ├── NonBlockingThreadPool.h │ │ │ │ │ │ │ ├── RunQueue.h │ │ │ │ │ │ │ ├── SimpleThreadPool.h │ │ │ │ │ │ │ ├── ThreadEnvironment.h │ │ │ │ │ │ │ ├── ThreadLocal.h │ │ │ │ │ │ │ ├── ThreadPoolInterface.h │ │ │ │ │ │ │ └── ThreadYield.h │ │ │ │ │ │ └── util/ │ │ │ │ │ │ ├── CXX11Meta.h │ │ │ │ │ │ ├── CXX11Workarounds.h │ │ │ │ │ │ ├── EmulateArray.h │ │ │ │ │ │ ├── EmulateCXX11Meta.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/ │ │ │ │ │ │ ├── SpecialFunctionsArrayAPI.h │ │ │ │ │ │ ├── SpecialFunctionsFunctors.h │ │ │ │ │ │ ├── SpecialFunctionsHalf.h │ │ │ │ │ │ ├── SpecialFunctionsImpl.h │ │ │ │ │ │ ├── SpecialFunctionsPacketMath.h │ │ │ │ │ │ └── arch/ │ │ │ │ │ │ └── CUDA/ │ │ │ │ │ │ └── CudaSpecialFunctions.h │ │ │ │ │ └── Splines/ │ │ │ │ │ ├── Spline.h │ │ │ │ │ ├── SplineFitting.h │ │ │ │ │ └── SplineFwd.h │ │ │ │ ├── README.txt │ │ │ │ ├── bench/ │ │ │ │ │ └── bench_svd.cpp │ │ │ │ ├── doc/ │ │ │ │ │ ├── CMakeLists.txt │ │ │ │ │ ├── Overview.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 │ │ │ │ │ └── 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 │ │ │ │ ├── cxx11_eventcount.cpp │ │ │ │ ├── cxx11_meta.cpp │ │ │ │ ├── cxx11_non_blocking_thread_pool.cpp │ │ │ │ ├── cxx11_runqueue.cpp │ │ │ │ ├── cxx11_tensor_argmax.cpp │ │ │ │ ├── cxx11_tensor_argmax_cuda.cu │ │ │ │ ├── cxx11_tensor_assign.cpp │ │ │ │ ├── cxx11_tensor_broadcast_sycl.cpp │ │ │ │ ├── cxx11_tensor_broadcasting.cpp │ │ │ │ ├── cxx11_tensor_cast_float16_cuda.cu │ │ │ │ ├── cxx11_tensor_casts.cpp │ │ │ │ ├── cxx11_tensor_chipping.cpp │ │ │ │ ├── cxx11_tensor_comparisons.cpp │ │ │ │ ├── cxx11_tensor_complex_cuda.cu │ │ │ │ ├── cxx11_tensor_complex_cwise_ops_cuda.cu │ │ │ │ ├── cxx11_tensor_concatenation.cpp │ │ │ │ ├── cxx11_tensor_const.cpp │ │ │ │ ├── cxx11_tensor_contract_cuda.cu │ │ │ │ ├── cxx11_tensor_contraction.cpp │ │ │ │ ├── cxx11_tensor_convolution.cpp │ │ │ │ ├── cxx11_tensor_cuda.cu │ │ │ │ ├── cxx11_tensor_custom_index.cpp │ │ │ │ ├── cxx11_tensor_custom_op.cpp │ │ │ │ ├── cxx11_tensor_device.cu │ │ │ │ ├── cxx11_tensor_device_sycl.cpp │ │ │ │ ├── cxx11_tensor_dimension.cpp │ │ │ │ ├── cxx11_tensor_empty.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_ifft.cpp │ │ │ │ ├── cxx11_tensor_image_patch.cpp │ │ │ │ ├── cxx11_tensor_index_list.cpp │ │ │ │ ├── cxx11_tensor_inflation.cpp │ │ │ │ ├── cxx11_tensor_intdiv.cpp │ │ │ │ ├── cxx11_tensor_io.cpp │ │ │ │ ├── cxx11_tensor_layout_swap.cpp │ │ │ │ ├── cxx11_tensor_lvalue.cpp │ │ │ │ ├── cxx11_tensor_map.cpp │ │ │ │ ├── cxx11_tensor_math.cpp │ │ │ │ ├── cxx11_tensor_mixed_indices.cpp │ │ │ │ ├── cxx11_tensor_morphing.cpp │ │ │ │ ├── cxx11_tensor_notification.cpp │ │ │ │ ├── cxx11_tensor_of_complex.cpp │ │ │ │ ├── cxx11_tensor_of_const_values.cpp │ │ │ │ ├── cxx11_tensor_of_float16_cuda.cu │ │ │ │ ├── cxx11_tensor_of_strings.cpp │ │ │ │ ├── cxx11_tensor_padding.cpp │ │ │ │ ├── cxx11_tensor_patch.cpp │ │ │ │ ├── cxx11_tensor_random.cpp │ │ │ │ ├── cxx11_tensor_random_cuda.cu │ │ │ │ ├── cxx11_tensor_reduction.cpp │ │ │ │ ├── cxx11_tensor_reduction_cuda.cu │ │ │ │ ├── cxx11_tensor_reduction_sycl.cpp │ │ │ │ ├── cxx11_tensor_ref.cpp │ │ │ │ ├── cxx11_tensor_reverse.cpp │ │ │ │ ├── cxx11_tensor_roundings.cpp │ │ │ │ ├── cxx11_tensor_scan.cpp │ │ │ │ ├── cxx11_tensor_scan_cuda.cu │ │ │ │ ├── cxx11_tensor_shuffling.cpp │ │ │ │ ├── cxx11_tensor_simple.cpp │ │ │ │ ├── cxx11_tensor_striding.cpp │ │ │ │ ├── cxx11_tensor_sugar.cpp │ │ │ │ ├── cxx11_tensor_sycl.cpp │ │ │ │ ├── cxx11_tensor_symmetry.cpp │ │ │ │ ├── cxx11_tensor_thread_pool.cpp │ │ │ │ ├── cxx11_tensor_uint128.cpp │ │ │ │ ├── cxx11_tensor_volume_patch.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 │ │ │ │ └── splines.cpp │ │ │ ├── GeographicLib/ │ │ │ │ ├── 00README.txt │ │ │ │ ├── AUTHORS │ │ │ │ ├── CMakeLists.txt │ │ │ │ ├── INSTALL │ │ │ │ ├── LICENSE.txt │ │ │ │ ├── Makefile │ │ │ │ ├── Makefile.am │ │ │ │ ├── Makefile.in │ │ │ │ ├── Makefile.mk │ │ │ │ ├── NEWS │ │ │ │ ├── README.md │ │ │ │ ├── aclocal.m4 │ │ │ │ ├── cmake/ │ │ │ │ │ ├── CMakeLists.txt │ │ │ │ │ ├── FindGeographicLib.cmake │ │ │ │ │ ├── Makefile.am │ │ │ │ │ ├── Makefile.in │ │ │ │ │ ├── Makefile.mk │ │ │ │ │ ├── project-config-version.cmake.in │ │ │ │ │ ├── project-config.cmake.in │ │ │ │ │ └── project.pc.in │ │ │ │ ├── compile │ │ │ │ ├── config.guess │ │ │ │ ├── config.sub │ │ │ │ ├── configure │ │ │ │ ├── configure.ac │ │ │ │ ├── depcomp │ │ │ │ ├── doc/ │ │ │ │ │ ├── CMakeLists.txt │ │ │ │ │ ├── GeographicLib.dox.in │ │ │ │ │ ├── Makefile.am │ │ │ │ │ ├── Makefile.in │ │ │ │ │ ├── Makefile.mk │ │ │ │ │ ├── NETGeographicLib.dox │ │ │ │ │ ├── doxyfile-c.in │ │ │ │ │ ├── doxyfile-for.in │ │ │ │ │ ├── doxyfile-net.in │ │ │ │ │ ├── doxyfile.in │ │ │ │ │ ├── geodesic-c.dox │ │ │ │ │ ├── geodesic-for.dox │ │ │ │ │ ├── geodseries30.html │ │ │ │ │ ├── index.html.in │ │ │ │ │ ├── tmseries30.html │ │ │ │ │ └── utilities.html.in │ │ │ │ ├── dotnet/ │ │ │ │ │ ├── NETGeographicLib/ │ │ │ │ │ │ ├── Accumulator.cpp │ │ │ │ │ │ ├── Accumulator.h │ │ │ │ │ │ ├── AlbersEqualArea.cpp │ │ │ │ │ │ ├── AlbersEqualArea.h │ │ │ │ │ │ ├── AssemblyInfo.cpp │ │ │ │ │ │ ├── AzimuthalEquidistant.cpp │ │ │ │ │ │ ├── AzimuthalEquidistant.h │ │ │ │ │ │ ├── CMakeLists.txt │ │ │ │ │ │ ├── CassiniSoldner.cpp │ │ │ │ │ │ ├── CassiniSoldner.h │ │ │ │ │ │ ├── CircularEngine.cpp │ │ │ │ │ │ ├── CircularEngine.h │ │ │ │ │ │ ├── DMS.cpp │ │ │ │ │ │ ├── DMS.h │ │ │ │ │ │ ├── Ellipsoid.cpp │ │ │ │ │ │ ├── Ellipsoid.h │ │ │ │ │ │ ├── EllipticFunction.cpp │ │ │ │ │ │ ├── EllipticFunction.h │ │ │ │ │ │ ├── GARS.cpp │ │ │ │ │ │ ├── GARS.h │ │ │ │ │ │ ├── GeoCoords.cpp │ │ │ │ │ │ ├── GeoCoords.h │ │ │ │ │ │ ├── Geocentric.cpp │ │ │ │ │ │ ├── Geocentric.h │ │ │ │ │ │ ├── Geodesic.cpp │ │ │ │ │ │ ├── Geodesic.h │ │ │ │ │ │ ├── GeodesicExact.cpp │ │ │ │ │ │ ├── GeodesicExact.h │ │ │ │ │ │ ├── GeodesicLine.cpp │ │ │ │ │ │ ├── GeodesicLine.h │ │ │ │ │ │ ├── GeodesicLineExact.cpp │ │ │ │ │ │ ├── GeodesicLineExact.h │ │ │ │ │ │ ├── Geohash.cpp │ │ │ │ │ │ ├── Geohash.h │ │ │ │ │ │ ├── Geoid.cpp │ │ │ │ │ │ ├── Geoid.h │ │ │ │ │ │ ├── Georef.cpp │ │ │ │ │ │ ├── Georef.h │ │ │ │ │ │ ├── Gnomonic.cpp │ │ │ │ │ │ ├── Gnomonic.h │ │ │ │ │ │ ├── GravityCircle.cpp │ │ │ │ │ │ ├── GravityCircle.h │ │ │ │ │ │ ├── GravityModel.cpp │ │ │ │ │ │ ├── GravityModel.h │ │ │ │ │ │ ├── LambertConformalConic.cpp │ │ │ │ │ │ ├── LambertConformalConic.h │ │ │ │ │ │ ├── LocalCartesian.cpp │ │ │ │ │ │ ├── LocalCartesian.h │ │ │ │ │ │ ├── MGRS.cpp │ │ │ │ │ │ ├── MGRS.h │ │ │ │ │ │ ├── MagneticCircle.cpp │ │ │ │ │ │ ├── MagneticCircle.h │ │ │ │ │ │ ├── MagneticModel.cpp │ │ │ │ │ │ ├── MagneticModel.h │ │ │ │ │ │ ├── NETGeographicLib.cpp │ │ │ │ │ │ ├── NETGeographicLib.h │ │ │ │ │ │ ├── NormalGravity.cpp │ │ │ │ │ │ ├── NormalGravity.h │ │ │ │ │ │ ├── OSGB.cpp │ │ │ │ │ │ ├── OSGB.h │ │ │ │ │ │ ├── PolarStereographic.cpp │ │ │ │ │ │ ├── PolarStereographic.h │ │ │ │ │ │ ├── PolygonArea.cpp │ │ │ │ │ │ ├── PolygonArea.h │ │ │ │ │ │ ├── ReadMe.txt │ │ │ │ │ │ ├── Rhumb.cpp │ │ │ │ │ │ ├── Rhumb.h │ │ │ │ │ │ ├── SphericalCoefficients.cpp │ │ │ │ │ │ ├── SphericalCoefficients.h │ │ │ │ │ │ ├── SphericalHarmonic.cpp │ │ │ │ │ │ ├── SphericalHarmonic.h │ │ │ │ │ │ ├── SphericalHarmonic1.cpp │ │ │ │ │ │ ├── SphericalHarmonic1.h │ │ │ │ │ │ ├── SphericalHarmonic2.cpp │ │ │ │ │ │ ├── SphericalHarmonic2.h │ │ │ │ │ │ ├── TransverseMercator.cpp │ │ │ │ │ │ ├── TransverseMercator.h │ │ │ │ │ │ ├── TransverseMercatorExact.cpp │ │ │ │ │ │ ├── TransverseMercatorExact.h │ │ │ │ │ │ ├── UTMUPS.cpp │ │ │ │ │ │ ├── UTMUPS.h │ │ │ │ │ │ ├── stdafx.cpp │ │ │ │ │ │ └── stdafx.h │ │ │ │ │ ├── Projections/ │ │ │ │ │ │ ├── AccumPanel.Designer.cs │ │ │ │ │ │ ├── AccumPanel.cs │ │ │ │ │ │ ├── AccumPanel.resx │ │ │ │ │ │ ├── AlbersPanel.Designer.cs │ │ │ │ │ │ ├── AlbersPanel.cs │ │ │ │ │ │ ├── AlbersPanel.resx │ │ │ │ │ │ ├── EllipsoidPanel.Designer.cs │ │ │ │ │ │ ├── EllipsoidPanel.cs │ │ │ │ │ │ ├── EllipsoidPanel.resx │ │ │ │ │ │ ├── EllipticPanel.Designer.cs │ │ │ │ │ │ ├── EllipticPanel.cs │ │ │ │ │ │ ├── EllipticPanel.resx │ │ │ │ │ │ ├── Form1.Designer.cs │ │ │ │ │ │ ├── Form1.cs │ │ │ │ │ │ ├── Form1.resx │ │ │ │ │ │ ├── GeocentricPanel.Designer.cs │ │ │ │ │ │ ├── GeocentricPanel.cs │ │ │ │ │ │ ├── GeocentricPanel.resx │ │ │ │ │ │ ├── GeodesicPanel.Designer.cs │ │ │ │ │ │ ├── GeodesicPanel.cs │ │ │ │ │ │ ├── GeodesicPanel.resx │ │ │ │ │ │ ├── GeoidPanel.Designer.cs │ │ │ │ │ │ ├── GeoidPanel.cs │ │ │ │ │ │ ├── GeoidPanel.resx │ │ │ │ │ │ ├── GravityPanel.Designer.cs │ │ │ │ │ │ ├── GravityPanel.cs │ │ │ │ │ │ ├── GravityPanel.resx │ │ │ │ │ │ ├── LocalCartesianPanel.Designer.cs │ │ │ │ │ │ ├── LocalCartesianPanel.cs │ │ │ │ │ │ ├── LocalCartesianPanel.resx │ │ │ │ │ │ ├── MagneticPanel.Designer.cs │ │ │ │ │ │ ├── MagneticPanel.cs │ │ │ │ │ │ ├── MagneticPanel.resx │ │ │ │ │ │ ├── MiscPanel.Designer.cs │ │ │ │ │ │ ├── MiscPanel.cs │ │ │ │ │ │ ├── MiscPanel.resx │ │ │ │ │ │ ├── PolarStereoPanel.Designer.cs │ │ │ │ │ │ ├── PolarStereoPanel.cs │ │ │ │ │ │ ├── PolarStereoPanel.resx │ │ │ │ │ │ ├── PolyPanel.Designer.cs │ │ │ │ │ │ ├── PolyPanel.cs │ │ │ │ │ │ ├── PolyPanel.resx │ │ │ │ │ │ ├── Program.cs │ │ │ │ │ │ ├── Projections-vs13.csproj │ │ │ │ │ │ ├── Projections.csproj │ │ │ │ │ │ ├── ProjectionsPanel.Designer.cs │ │ │ │ │ │ ├── ProjectionsPanel.cs │ │ │ │ │ │ ├── ProjectionsPanel.resx │ │ │ │ │ │ ├── Properties/ │ │ │ │ │ │ │ ├── AssemblyInfo.cs │ │ │ │ │ │ │ ├── Resources.Designer.cs │ │ │ │ │ │ │ ├── Resources.resx │ │ │ │ │ │ │ ├── Settings.Designer.cs │ │ │ │ │ │ │ └── Settings.settings │ │ │ │ │ │ ├── RhumbPanel.Designer.cs │ │ │ │ │ │ ├── RhumbPanel.cs │ │ │ │ │ │ ├── RhumbPanel.resx │ │ │ │ │ │ ├── SphericalHarmonicsPanel.Designer.cs │ │ │ │ │ │ ├── SphericalHarmonicsPanel.cs │ │ │ │ │ │ ├── SphericalHarmonicsPanel.resx │ │ │ │ │ │ ├── TypeIIIProjPanel.Designer.cs │ │ │ │ │ │ ├── TypeIIIProjPanel.cs │ │ │ │ │ │ └── TypeIIIProjPanel.resx │ │ │ │ │ └── examples/ │ │ │ │ │ ├── CS/ │ │ │ │ │ │ ├── example-Accumulator.cs │ │ │ │ │ │ ├── example-AlbersEqualArea.cs │ │ │ │ │ │ ├── example-AzimuthalEquidistant.cs │ │ │ │ │ │ ├── example-CassiniSoldner.cs │ │ │ │ │ │ ├── example-CircularEngine.cs │ │ │ │ │ │ ├── example-DMS.cs │ │ │ │ │ │ ├── example-Ellipsoid.cs │ │ │ │ │ │ ├── example-EllipticFunction.cs │ │ │ │ │ │ ├── example-GARS.cs │ │ │ │ │ │ ├── example-GeoCoords.cs │ │ │ │ │ │ ├── example-Geocentric.cs │ │ │ │ │ │ ├── example-Geodesic.cs │ │ │ │ │ │ ├── example-GeodesicExact.cs │ │ │ │ │ │ ├── example-GeodesicLine.cs │ │ │ │ │ │ ├── example-GeodesicLineExact.cs │ │ │ │ │ │ ├── example-Geohash.cs │ │ │ │ │ │ ├── example-Geoid.cs │ │ │ │ │ │ ├── example-Georef.cs │ │ │ │ │ │ ├── example-Gnomonic.cs │ │ │ │ │ │ ├── example-GravityCircle.cs │ │ │ │ │ │ ├── example-GravityModel.cs │ │ │ │ │ │ ├── example-LambertConformalConic.cs │ │ │ │ │ │ ├── example-LocalCartesian.cs │ │ │ │ │ │ ├── example-MGRS.cs │ │ │ │ │ │ ├── example-MagneticCircle.cs │ │ │ │ │ │ ├── example-MagneticModel.cs │ │ │ │ │ │ ├── example-NormalGravity.cs │ │ │ │ │ │ ├── example-OSGB.cs │ │ │ │ │ │ ├── example-PolarStereographic.cs │ │ │ │ │ │ ├── example-PolygonArea.cs │ │ │ │ │ │ ├── example-Rhumb.cs │ │ │ │ │ │ ├── example-RhumbLine.cs │ │ │ │ │ │ ├── example-SphericalHarmonic.cs │ │ │ │ │ │ ├── example-SphericalHarmonic1.cs │ │ │ │ │ │ ├── example-SphericalHarmonic2.cs │ │ │ │ │ │ ├── example-TransverseMercator.cs │ │ │ │ │ │ ├── example-TransverseMercatorExact.cs │ │ │ │ │ │ └── example-UTMUPS.cs │ │ │ │ │ ├── ManagedCPP/ │ │ │ │ │ │ ├── CMakeLists.txt │ │ │ │ │ │ ├── example-Accumulator.cpp │ │ │ │ │ │ ├── example-AlbersEqualArea.cpp │ │ │ │ │ │ ├── example-AzimuthalEquidistant.cpp │ │ │ │ │ │ ├── example-CassiniSoldner.cpp │ │ │ │ │ │ ├── example-CircularEngine.cpp │ │ │ │ │ │ ├── example-DMS.cpp │ │ │ │ │ │ ├── example-Ellipsoid.cpp │ │ │ │ │ │ ├── example-EllipticFunction.cpp │ │ │ │ │ │ ├── example-GARS.cpp │ │ │ │ │ │ ├── example-GeoCoords.cpp │ │ │ │ │ │ ├── example-Geocentric.cpp │ │ │ │ │ │ ├── example-Geodesic-small.cpp │ │ │ │ │ │ ├── example-Geodesic.cpp │ │ │ │ │ │ ├── example-GeodesicExact.cpp │ │ │ │ │ │ ├── example-GeodesicLine.cpp │ │ │ │ │ │ ├── example-GeodesicLineExact.cpp │ │ │ │ │ │ ├── example-Geohash.cpp │ │ │ │ │ │ ├── example-Geoid.cpp │ │ │ │ │ │ ├── example-Georef.cpp │ │ │ │ │ │ ├── example-Gnomonic.cpp │ │ │ │ │ │ ├── example-GravityCircle.cpp │ │ │ │ │ │ ├── example-GravityModel.cpp │ │ │ │ │ │ ├── example-LambertConformalConic.cpp │ │ │ │ │ │ ├── example-LocalCartesian.cpp │ │ │ │ │ │ ├── example-MGRS.cpp │ │ │ │ │ │ ├── example-MagneticCircle.cpp │ │ │ │ │ │ ├── example-MagneticModel.cpp │ │ │ │ │ │ ├── example-NormalGravity.cpp │ │ │ │ │ │ ├── example-OSGB.cpp │ │ │ │ │ │ ├── example-PolarStereographic.cpp │ │ │ │ │ │ ├── example-PolygonArea.cpp │ │ │ │ │ │ ├── example-Rhumb.cpp │ │ │ │ │ │ ├── example-RhumbLine.cpp │ │ │ │ │ │ ├── example-SphericalHarmonic.cpp │ │ │ │ │ │ ├── example-SphericalHarmonic1.cpp │ │ │ │ │ │ ├── example-SphericalHarmonic2.cpp │ │ │ │ │ │ ├── example-TransverseMercator.cpp │ │ │ │ │ │ ├── example-TransverseMercatorExact.cpp │ │ │ │ │ │ └── example-UTMUPS.cpp │ │ │ │ │ └── VB/ │ │ │ │ │ ├── example-Accumulator.vb │ │ │ │ │ ├── example-AlbersEqualArea.vb │ │ │ │ │ ├── example-AzimuthalEquidistant.vb │ │ │ │ │ ├── example-CassiniSoldner.vb │ │ │ │ │ ├── example-CircularEngine.vb │ │ │ │ │ ├── example-DMS.vb │ │ │ │ │ ├── example-Ellipsoid.vb │ │ │ │ │ ├── example-EllipticFunction.vb │ │ │ │ │ ├── example-GARS.vb │ │ │ │ │ ├── example-GeoCoords.vb │ │ │ │ │ ├── example-Geocentric.vb │ │ │ │ │ ├── example-Geodesic.vb │ │ │ │ │ ├── example-GeodesicExact.vb │ │ │ │ │ ├── example-GeodesicLine.vb │ │ │ │ │ ├── example-GeodesicLineExact.vb │ │ │ │ │ ├── example-Geohash.vb │ │ │ │ │ ├── example-Geoid.vb │ │ │ │ │ ├── example-Georef.vb │ │ │ │ │ ├── example-Gnomonic.vb │ │ │ │ │ ├── example-GravityCircle.vb │ │ │ │ │ ├── example-GravityModel.vb │ │ │ │ │ ├── example-LambertConformalConic.vb │ │ │ │ │ ├── example-LocalCartesian.vb │ │ │ │ │ ├── example-MGRS.vb │ │ │ │ │ ├── example-MagneticCircle.vb │ │ │ │ │ ├── example-MagneticModel.vb │ │ │ │ │ ├── example-NormalGravity.vb │ │ │ │ │ ├── example-OSGB.vb │ │ │ │ │ ├── example-PolarStereographic.vb │ │ │ │ │ ├── example-PolygonArea.vb │ │ │ │ │ ├── example-Rhumb.vb │ │ │ │ │ ├── example-RhumbLine.vb │ │ │ │ │ ├── example-SphericalHarmonic.vb │ │ │ │ │ ├── example-SphericalHarmonic1.vb │ │ │ │ │ ├── example-SphericalHarmonic2.vb │ │ │ │ │ ├── example-TransverseMercator.vb │ │ │ │ │ ├── example-TransverseMercatorExact.vb │ │ │ │ │ └── example-UTMUPS.vb │ │ │ │ ├── examples/ │ │ │ │ │ ├── CMakeLists.txt │ │ │ │ │ ├── GeoidToGTX.cpp │ │ │ │ │ ├── JacobiConformal.cpp │ │ │ │ │ ├── JacobiConformal.hpp │ │ │ │ │ ├── Makefile.am │ │ │ │ │ ├── Makefile.in │ │ │ │ │ ├── example-Accumulator.cpp │ │ │ │ │ ├── example-AlbersEqualArea.cpp │ │ │ │ │ ├── example-AzimuthalEquidistant.cpp │ │ │ │ │ ├── example-CassiniSoldner.cpp │ │ │ │ │ ├── example-CircularEngine.cpp │ │ │ │ │ ├── example-Constants.cpp │ │ │ │ │ ├── example-DMS.cpp │ │ │ │ │ ├── example-Ellipsoid.cpp │ │ │ │ │ ├── example-EllipticFunction.cpp │ │ │ │ │ ├── example-GARS.cpp │ │ │ │ │ ├── example-GeoCoords.cpp │ │ │ │ │ ├── example-Geocentric.cpp │ │ │ │ │ ├── example-Geodesic-small.cpp │ │ │ │ │ ├── example-Geodesic.cpp │ │ │ │ │ ├── example-GeodesicExact.cpp │ │ │ │ │ ├── example-GeodesicLine.cpp │ │ │ │ │ ├── example-GeodesicLineExact.cpp │ │ │ │ │ ├── example-GeographicErr.cpp │ │ │ │ │ ├── example-Geohash.cpp │ │ │ │ │ ├── example-Geoid.cpp │ │ │ │ │ ├── example-Georef.cpp │ │ │ │ │ ├── example-Gnomonic.cpp │ │ │ │ │ ├── example-GravityCircle.cpp │ │ │ │ │ ├── example-GravityModel.cpp │ │ │ │ │ ├── example-LambertConformalConic.cpp │ │ │ │ │ ├── example-LocalCartesian.cpp │ │ │ │ │ ├── example-MGRS.cpp │ │ │ │ │ ├── example-MagneticCircle.cpp │ │ │ │ │ ├── example-MagneticModel.cpp │ │ │ │ │ ├── example-Math.cpp │ │ │ │ │ ├── example-NearestNeighbor.cpp │ │ │ │ │ ├── example-NormalGravity.cpp │ │ │ │ │ ├── example-OSGB.cpp │ │ │ │ │ ├── example-PolarStereographic.cpp │ │ │ │ │ ├── example-PolygonArea.cpp │ │ │ │ │ ├── example-Rhumb.cpp │ │ │ │ │ ├── example-RhumbLine.cpp │ │ │ │ │ ├── example-SphericalEngine.cpp │ │ │ │ │ ├── example-SphericalHarmonic.cpp │ │ │ │ │ ├── example-SphericalHarmonic1.cpp │ │ │ │ │ ├── example-SphericalHarmonic2.cpp │ │ │ │ │ ├── example-TransverseMercator.cpp │ │ │ │ │ ├── example-TransverseMercatorExact.cpp │ │ │ │ │ ├── example-UTMUPS.cpp │ │ │ │ │ ├── example-Utility.cpp │ │ │ │ │ └── make-egmcof.cpp │ │ │ │ ├── include/ │ │ │ │ │ ├── GeographicLib/ │ │ │ │ │ │ ├── Accumulator.hpp │ │ │ │ │ │ ├── AlbersEqualArea.hpp │ │ │ │ │ │ ├── AzimuthalEquidistant.hpp │ │ │ │ │ │ ├── CMakeLists.txt │ │ │ │ │ │ ├── CassiniSoldner.hpp │ │ │ │ │ │ ├── CircularEngine.hpp │ │ │ │ │ │ ├── Config-ac.h.in │ │ │ │ │ │ ├── Config.h │ │ │ │ │ │ ├── Config.h.in │ │ │ │ │ │ ├── Constants.hpp │ │ │ │ │ │ ├── DMS.hpp │ │ │ │ │ │ ├── Ellipsoid.hpp │ │ │ │ │ │ ├── EllipticFunction.hpp │ │ │ │ │ │ ├── GARS.hpp │ │ │ │ │ │ ├── GeoCoords.hpp │ │ │ │ │ │ ├── Geocentric.hpp │ │ │ │ │ │ ├── Geodesic.hpp │ │ │ │ │ │ ├── GeodesicExact.hpp │ │ │ │ │ │ ├── GeodesicLine.hpp │ │ │ │ │ │ ├── GeodesicLineExact.hpp │ │ │ │ │ │ ├── Geohash.hpp │ │ │ │ │ │ ├── Geoid.hpp │ │ │ │ │ │ ├── Georef.hpp │ │ │ │ │ │ ├── Gnomonic.hpp │ │ │ │ │ │ ├── GravityCircle.hpp │ │ │ │ │ │ ├── GravityModel.hpp │ │ │ │ │ │ ├── LambertConformalConic.hpp │ │ │ │ │ │ ├── LocalCartesian.hpp │ │ │ │ │ │ ├── MGRS.hpp │ │ │ │ │ │ ├── MagneticCircle.hpp │ │ │ │ │ │ ├── MagneticModel.hpp │ │ │ │ │ │ ├── Math.hpp │ │ │ │ │ │ ├── NearestNeighbor.hpp │ │ │ │ │ │ ├── NormalGravity.hpp │ │ │ │ │ │ ├── OSGB.hpp │ │ │ │ │ │ ├── PolarStereographic.hpp │ │ │ │ │ │ ├── PolygonArea.hpp │ │ │ │ │ │ ├── Rhumb.hpp │ │ │ │ │ │ ├── SphericalEngine.hpp │ │ │ │ │ │ ├── SphericalHarmonic.hpp │ │ │ │ │ │ ├── SphericalHarmonic1.hpp │ │ │ │ │ │ ├── SphericalHarmonic2.hpp │ │ │ │ │ │ ├── TransverseMercator.hpp │ │ │ │ │ │ ├── TransverseMercatorExact.hpp │ │ │ │ │ │ ├── UTMUPS.hpp │ │ │ │ │ │ └── Utility.hpp │ │ │ │ │ ├── Makefile.am │ │ │ │ │ ├── Makefile.in │ │ │ │ │ └── Makefile.mk │ │ │ │ ├── install-sh │ │ │ │ ├── java/ │ │ │ │ │ ├── README.txt │ │ │ │ │ ├── direct/ │ │ │ │ │ │ ├── pom.xml │ │ │ │ │ │ └── src/ │ │ │ │ │ │ └── main/ │ │ │ │ │ │ └── java/ │ │ │ │ │ │ └── Direct.java │ │ │ │ │ ├── inverse/ │ │ │ │ │ │ ├── pom.xml │ │ │ │ │ │ └── src/ │ │ │ │ │ │ └── main/ │ │ │ │ │ │ └── java/ │ │ │ │ │ │ └── Inverse.java │ │ │ │ │ ├── planimeter/ │ │ │ │ │ │ ├── pom.xml │ │ │ │ │ │ └── src/ │ │ │ │ │ │ └── main/ │ │ │ │ │ │ └── java/ │ │ │ │ │ │ └── Planimeter.java │ │ │ │ │ ├── pom.xml │ │ │ │ │ └── src/ │ │ │ │ │ ├── main/ │ │ │ │ │ │ └── java/ │ │ │ │ │ │ └── net/ │ │ │ │ │ │ └── sf/ │ │ │ │ │ │ └── geographiclib/ │ │ │ │ │ │ ├── Accumulator.java │ │ │ │ │ │ ├── Constants.java │ │ │ │ │ │ ├── GeoMath.java │ │ │ │ │ │ ├── Geodesic.java │ │ │ │ │ │ ├── GeodesicData.java │ │ │ │ │ │ ├── GeodesicLine.java │ │ │ │ │ │ ├── GeodesicMask.java │ │ │ │ │ │ ├── GeographicErr.java │ │ │ │ │ │ ├── Gnomonic.java │ │ │ │ │ │ ├── GnomonicData.java │ │ │ │ │ │ ├── Pair.java │ │ │ │ │ │ ├── PolygonArea.java │ │ │ │ │ │ ├── PolygonResult.java │ │ │ │ │ │ └── package-info.java │ │ │ │ │ └── test/ │ │ │ │ │ └── java/ │ │ │ │ │ └── net/ │ │ │ │ │ └── sf/ │ │ │ │ │ └── geographiclib/ │ │ │ │ │ └── GeodesicTest.java │ │ │ │ ├── js/ │ │ │ │ │ ├── CMakeLists.txt │ │ │ │ │ ├── GeographicLib.md │ │ │ │ │ ├── HEADER.js │ │ │ │ │ ├── Makefile.am │ │ │ │ │ ├── Makefile.in │ │ │ │ │ ├── Makefile.mk │ │ │ │ │ ├── README.md │ │ │ │ │ ├── conf.json │ │ │ │ │ ├── doc/ │ │ │ │ │ │ ├── 1-geodesics.md │ │ │ │ │ │ ├── 2-interface.md │ │ │ │ │ │ ├── 3-examples.md │ │ │ │ │ │ └── tutorials.json │ │ │ │ │ ├── js-cat.sh │ │ │ │ │ ├── js-compress.sh │ │ │ │ │ ├── package.json │ │ │ │ │ ├── samples/ │ │ │ │ │ │ ├── geod-calc.html │ │ │ │ │ │ ├── geod-google-instructions.html │ │ │ │ │ │ └── geod-google.html │ │ │ │ │ ├── src/ │ │ │ │ │ │ ├── DMS.js │ │ │ │ │ │ ├── Geodesic.js │ │ │ │ │ │ ├── GeodesicLine.js │ │ │ │ │ │ ├── Math.js │ │ │ │ │ │ └── PolygonArea.js │ │ │ │ │ └── test/ │ │ │ │ │ └── geodesictest.js │ │ │ │ ├── legacy/ │ │ │ │ │ ├── C/ │ │ │ │ │ │ ├── 00README.txt │ │ │ │ │ │ ├── CMakeLists.txt │ │ │ │ │ │ ├── direct.c │ │ │ │ │ │ ├── geodesic.c │ │ │ │ │ │ ├── geodesic.h │ │ │ │ │ │ ├── geodtest.c │ │ │ │ │ │ ├── inverse.c │ │ │ │ │ │ └── planimeter.c │ │ │ │ │ └── Fortran/ │ │ │ │ │ ├── 00README.txt │ │ │ │ │ ├── CMakeLists.txt │ │ │ │ │ ├── geoddirect.for │ │ │ │ │ ├── geodesic.for │ │ │ │ │ ├── geodesic.inc │ │ │ │ │ ├── geodinverse.for │ │ │ │ │ ├── geodtest.for │ │ │ │ │ ├── ngscommon.for │ │ │ │ │ ├── ngsforward.for │ │ │ │ │ ├── ngsinverse.for │ │ │ │ │ └── planimeter.for │ │ │ │ ├── ltmain.sh │ │ │ │ ├── m4/ │ │ │ │ │ ├── libtool.m4 │ │ │ │ │ ├── ltoptions.m4 │ │ │ │ │ ├── ltsugar.m4 │ │ │ │ │ ├── ltversion.m4 │ │ │ │ │ ├── lt~obsolete.m4 │ │ │ │ │ └── pkg.m4 │ │ │ │ ├── man/ │ │ │ │ │ ├── CMakeLists.txt │ │ │ │ │ ├── CartConvert.1 │ │ │ │ │ ├── CartConvert.1.html │ │ │ │ │ ├── CartConvert.pod │ │ │ │ │ ├── CartConvert.usage │ │ │ │ │ ├── ConicProj.1 │ │ │ │ │ ├── ConicProj.1.html │ │ │ │ │ ├── ConicProj.pod │ │ │ │ │ ├── ConicProj.usage │ │ │ │ │ ├── GeoConvert.1 │ │ │ │ │ ├── GeoConvert.1.html │ │ │ │ │ ├── GeoConvert.pod │ │ │ │ │ ├── GeoConvert.usage │ │ │ │ │ ├── GeodSolve.1 │ │ │ │ │ ├── GeodSolve.1.html │ │ │ │ │ ├── GeodSolve.pod │ │ │ │ │ ├── GeodSolve.usage │ │ │ │ │ ├── GeodesicProj.1 │ │ │ │ │ ├── GeodesicProj.1.html │ │ │ │ │ ├── GeodesicProj.pod │ │ │ │ │ ├── GeodesicProj.usage │ │ │ │ │ ├── GeoidEval.1 │ │ │ │ │ ├── GeoidEval.1.html │ │ │ │ │ ├── GeoidEval.pod │ │ │ │ │ ├── GeoidEval.usage │ │ │ │ │ ├── Gravity.1 │ │ │ │ │ ├── Gravity.1.html │ │ │ │ │ ├── Gravity.pod │ │ │ │ │ ├── Gravity.usage │ │ │ │ │ ├── MagneticField.1 │ │ │ │ │ ├── MagneticField.1.html │ │ │ │ │ ├── MagneticField.pod │ │ │ │ │ ├── MagneticField.usage │ │ │ │ │ ├── Makefile.am │ │ │ │ │ ├── Makefile.in │ │ │ │ │ ├── Makefile.mk │ │ │ │ │ ├── Planimeter.1 │ │ │ │ │ ├── Planimeter.1.html │ │ │ │ │ ├── Planimeter.pod │ │ │ │ │ ├── Planimeter.usage │ │ │ │ │ ├── RhumbSolve.1 │ │ │ │ │ ├── RhumbSolve.1.html │ │ │ │ │ ├── RhumbSolve.pod │ │ │ │ │ ├── RhumbSolve.usage │ │ │ │ │ ├── TransverseMercatorProj.1 │ │ │ │ │ ├── TransverseMercatorProj.1.html │ │ │ │ │ ├── TransverseMercatorProj.pod │ │ │ │ │ ├── TransverseMercatorProj.usage │ │ │ │ │ ├── dummy.1.html.in │ │ │ │ │ ├── dummy.1.in │ │ │ │ │ ├── dummy.usage.in │ │ │ │ │ ├── makeusage.sh │ │ │ │ │ └── script.8.in │ │ │ │ ├── matlab/ │ │ │ │ │ ├── CMakeLists.txt │ │ │ │ │ ├── Makefile.am │ │ │ │ │ ├── Makefile.in │ │ │ │ │ ├── Makefile.mk │ │ │ │ │ ├── geographiclib/ │ │ │ │ │ │ ├── Contents.m │ │ │ │ │ │ ├── cassini_fwd.m │ │ │ │ │ │ ├── cassini_inv.m │ │ │ │ │ │ ├── defaultellipsoid.m │ │ │ │ │ │ ├── ecc2flat.m │ │ │ │ │ │ ├── eqdazim_fwd.m │ │ │ │ │ │ ├── eqdazim_inv.m │ │ │ │ │ │ ├── flat2ecc.m │ │ │ │ │ │ ├── gedistance.m │ │ │ │ │ │ ├── gedoc.m │ │ │ │ │ │ ├── geocent_fwd.m │ │ │ │ │ │ ├── geocent_inv.m │ │ │ │ │ │ ├── geodarea.m │ │ │ │ │ │ ├── geoddistance.m │ │ │ │ │ │ ├── geoddoc.m │ │ │ │ │ │ ├── geodreckon.m │ │ │ │ │ │ ├── geographiclib_test.m │ │ │ │ │ │ ├── geoid_height.m │ │ │ │ │ │ ├── geoid_load.m │ │ │ │ │ │ ├── gereckon.m │ │ │ │ │ │ ├── gnomonic_fwd.m │ │ │ │ │ │ ├── gnomonic_inv.m │ │ │ │ │ │ ├── loccart_fwd.m │ │ │ │ │ │ ├── loccart_inv.m │ │ │ │ │ │ ├── mgrs_fwd.m │ │ │ │ │ │ ├── mgrs_inv.m │ │ │ │ │ │ ├── polarst_fwd.m │ │ │ │ │ │ ├── polarst_inv.m │ │ │ │ │ │ ├── private/ │ │ │ │ │ │ │ ├── A1m1f.m │ │ │ │ │ │ │ ├── A2m1f.m │ │ │ │ │ │ │ ├── A3coeff.m │ │ │ │ │ │ │ ├── A3f.m │ │ │ │ │ │ │ ├── AngDiff.m │ │ │ │ │ │ │ ├── AngNormalize.m │ │ │ │ │ │ │ ├── AngRound.m │ │ │ │ │ │ │ ├── C1f.m │ │ │ │ │ │ │ ├── C1pf.m │ │ │ │ │ │ │ ├── C2f.m │ │ │ │ │ │ │ ├── C3coeff.m │ │ │ │ │ │ │ ├── C3f.m │ │ │ │ │ │ │ ├── C4coeff.m │ │ │ │ │ │ │ ├── C4f.m │ │ │ │ │ │ │ ├── G4coeff.m │ │ │ │ │ │ │ ├── GeoRotation.m │ │ │ │ │ │ │ ├── LatFix.m │ │ │ │ │ │ │ ├── SinCosSeries.m │ │ │ │ │ │ │ ├── atan2dx.m │ │ │ │ │ │ │ ├── cbrtx.m │ │ │ │ │ │ │ ├── copysignx.m │ │ │ │ │ │ │ ├── cvmgt.m │ │ │ │ │ │ │ ├── eatanhe.m │ │ │ │ │ │ │ ├── geoid_file.m │ │ │ │ │ │ │ ├── geoid_load_file.m │ │ │ │ │ │ │ ├── norm2.m │ │ │ │ │ │ │ ├── sincosdx.m │ │ │ │ │ │ │ ├── sumx.m │ │ │ │ │ │ │ ├── swap.m │ │ │ │ │ │ │ ├── tauf.m │ │ │ │ │ │ │ └── taupf.m │ │ │ │ │ │ ├── projdoc.m │ │ │ │ │ │ ├── tranmerc_fwd.m │ │ │ │ │ │ ├── tranmerc_inv.m │ │ │ │ │ │ ├── utmups_fwd.m │ │ │ │ │ │ └── utmups_inv.m │ │ │ │ │ └── geographiclib-legacy/ │ │ │ │ │ ├── Contents.m │ │ │ │ │ ├── geocentricforward.m │ │ │ │ │ ├── geocentricreverse.m │ │ │ │ │ ├── geodesicdirect.m │ │ │ │ │ ├── geodesicinverse.m │ │ │ │ │ ├── geodesicline.m │ │ │ │ │ ├── geoidheight.m │ │ │ │ │ ├── localcartesianforward.m │ │ │ │ │ ├── localcartesianreverse.m │ │ │ │ │ ├── mgrsforward.m │ │ │ │ │ ├── mgrsreverse.m │ │ │ │ │ ├── polygonarea.m │ │ │ │ │ ├── utmupsforward.m │ │ │ │ │ └── utmupsreverse.m │ │ │ │ ├── maxima/ │ │ │ │ │ ├── Makefile.mk │ │ │ │ │ ├── auxlat.mac │ │ │ │ │ ├── ellint.mac │ │ │ │ │ ├── gearea.mac │ │ │ │ │ ├── geod.mac │ │ │ │ │ ├── geodesic.mac │ │ │ │ │ ├── polyprint.mac │ │ │ │ │ ├── rhumbarea.mac │ │ │ │ │ ├── tm.mac │ │ │ │ │ └── tmseries.mac │ │ │ │ ├── missing │ │ │ │ ├── python/ │ │ │ │ │ ├── MANIFEST.in │ │ │ │ │ ├── Makefile.am │ │ │ │ │ ├── Makefile.in │ │ │ │ │ ├── Makefile.mk │ │ │ │ │ ├── README.rst │ │ │ │ │ ├── doc/ │ │ │ │ │ │ ├── code.rst │ │ │ │ │ │ ├── conf.py │ │ │ │ │ │ ├── examples.rst │ │ │ │ │ │ ├── geodesics.rst │ │ │ │ │ │ ├── index.rst │ │ │ │ │ │ └── interface.rst │ │ │ │ │ ├── geographiclib/ │ │ │ │ │ │ ├── CMakeLists.txt │ │ │ │ │ │ ├── __init__.py │ │ │ │ │ │ ├── accumulator.py │ │ │ │ │ │ ├── constants.py │ │ │ │ │ │ ├── geodesic.py │ │ │ │ │ │ ├── geodesiccapability.py │ │ │ │ │ │ ├── geodesicline.py │ │ │ │ │ │ ├── geomath.py │ │ │ │ │ │ ├── polygonarea.py │ │ │ │ │ │ └── test/ │ │ │ │ │ │ ├── __init__.py │ │ │ │ │ │ └── test_geodesic.py │ │ │ │ │ └── setup.py │ │ │ │ ├── src/ │ │ │ │ │ ├── Accumulator.cpp │ │ │ │ │ ├── AlbersEqualArea.cpp │ │ │ │ │ ├── AzimuthalEquidistant.cpp │ │ │ │ │ ├── CMakeLists.txt │ │ │ │ │ ├── CassiniSoldner.cpp │ │ │ │ │ ├── CircularEngine.cpp │ │ │ │ │ ├── DMS.cpp │ │ │ │ │ ├── Ellipsoid.cpp │ │ │ │ │ ├── EllipticFunction.cpp │ │ │ │ │ ├── GARS.cpp │ │ │ │ │ ├── GeoCoords.cpp │ │ │ │ │ ├── Geocentric.cpp │ │ │ │ │ ├── Geodesic.cpp │ │ │ │ │ ├── GeodesicExact.cpp │ │ │ │ │ ├── GeodesicExactC4.cpp │ │ │ │ │ ├── GeodesicLine.cpp │ │ │ │ │ ├── GeodesicLineExact.cpp │ │ │ │ │ ├── Geohash.cpp │ │ │ │ │ ├── Geoid.cpp │ │ │ │ │ ├── Georef.cpp │ │ │ │ │ ├── Gnomonic.cpp │ │ │ │ │ ├── GravityCircle.cpp │ │ │ │ │ ├── GravityModel.cpp │ │ │ │ │ ├── LambertConformalConic.cpp │ │ │ │ │ ├── LocalCartesian.cpp │ │ │ │ │ ├── MGRS.cpp │ │ │ │ │ ├── MagneticCircle.cpp │ │ │ │ │ ├── MagneticModel.cpp │ │ │ │ │ ├── Makefile.am │ │ │ │ │ ├── Makefile.in │ │ │ │ │ ├── Makefile.mk │ │ │ │ │ ├── Math.cpp │ │ │ │ │ ├── NormalGravity.cpp │ │ │ │ │ ├── OSGB.cpp │ │ │ │ │ ├── PolarStereographic.cpp │ │ │ │ │ ├── PolygonArea.cpp │ │ │ │ │ ├── Rhumb.cpp │ │ │ │ │ ├── SphericalEngine.cpp │ │ │ │ │ ├── TransverseMercator.cpp │ │ │ │ │ ├── TransverseMercatorExact.cpp │ │ │ │ │ ├── UTMUPS.cpp │ │ │ │ │ └── Utility.cpp │ │ │ │ ├── tools/ │ │ │ │ │ ├── CMakeLists.txt │ │ │ │ │ ├── CartConvert.cpp │ │ │ │ │ ├── ConicProj.cpp │ │ │ │ │ ├── GeoConvert.cpp │ │ │ │ │ ├── GeodSolve.cpp │ │ │ │ │ ├── GeodesicProj.cpp │ │ │ │ │ ├── GeoidEval.cpp │ │ │ │ │ ├── Gravity.cpp │ │ │ │ │ ├── MagneticField.cpp │ │ │ │ │ ├── Makefile.am │ │ │ │ │ ├── Makefile.in │ │ │ │ │ ├── Makefile.mk │ │ │ │ │ ├── Planimeter.cpp │ │ │ │ │ ├── RhumbSolve.cpp │ │ │ │ │ ├── TransverseMercatorProj.cpp │ │ │ │ │ ├── geographiclib-get-geoids.sh │ │ │ │ │ ├── geographiclib-get-gravity.sh │ │ │ │ │ ├── geographiclib-get-magnetic.sh │ │ │ │ │ └── tests.cmake │ │ │ │ ├── windows/ │ │ │ │ │ ├── CartConvert-vc10.vcxproj │ │ │ │ │ ├── CartConvert-vc10x.vcxproj │ │ │ │ │ ├── CartConvert-vc9.vcproj │ │ │ │ │ ├── ConicProj-vc10.vcxproj │ │ │ │ │ ├── ConicProj-vc10x.vcxproj │ │ │ │ │ ├── ConicProj-vc9.vcproj │ │ │ │ │ ├── GeoConvert-vc10.vcxproj │ │ │ │ │ ├── GeoConvert-vc10x.vcxproj │ │ │ │ │ ├── GeoConvert-vc9.vcproj │ │ │ │ │ ├── GeodSolve-vc10.vcxproj │ │ │ │ │ ├── GeodSolve-vc10x.vcxproj │ │ │ │ │ ├── GeodSolve-vc9.vcproj │ │ │ │ │ ├── GeodesicProj-vc10.vcxproj │ │ │ │ │ ├── GeodesicProj-vc10x.vcxproj │ │ │ │ │ ├── GeodesicProj-vc9.vcproj │ │ │ │ │ ├── Geographic-vc10.vcxproj │ │ │ │ │ ├── Geographic-vc10x.vcxproj │ │ │ │ │ ├── Geographic-vc13n.vcxproj │ │ │ │ │ ├── Geographic-vc9.vcproj │ │ │ │ │ ├── GeographicLib-vc10.sln │ │ │ │ │ ├── GeographicLib-vc10x.sln │ │ │ │ │ ├── GeographicLib-vc9.sln │ │ │ │ │ ├── GeoidEval-vc10.vcxproj │ │ │ │ │ ├── GeoidEval-vc10x.vcxproj │ │ │ │ │ ├── GeoidEval-vc9.vcproj │ │ │ │ │ ├── Gravity-vc10.vcxproj │ │ │ │ │ ├── Gravity-vc10x.vcxproj │ │ │ │ │ ├── Gravity-vc9.vcproj │ │ │ │ │ ├── MagneticField-vc10.vcxproj │ │ │ │ │ ├── MagneticField-vc10x.vcxproj │ │ │ │ │ ├── MagneticField-vc9.vcproj │ │ │ │ │ ├── NETGeographic-vc10.sln │ │ │ │ │ ├── NETGeographic-vc10.vcxproj │ │ │ │ │ ├── NETGeographic-vc13.sln │ │ │ │ │ ├── NETGeographic-vc13.vcxproj │ │ │ │ │ ├── Planimeter-vc10.vcxproj │ │ │ │ │ ├── Planimeter-vc10x.vcxproj │ │ │ │ │ ├── Planimeter-vc9.vcproj │ │ │ │ │ ├── RhumbSolve-vc10.vcxproj │ │ │ │ │ ├── RhumbSolve-vc10x.vcxproj │ │ │ │ │ ├── RhumbSolve-vc9.vcproj │ │ │ │ │ ├── TransverseMercatorProj-vc10.vcxproj │ │ │ │ │ ├── TransverseMercatorProj-vc10x.vcxproj │ │ │ │ │ └── TransverseMercatorProj-vc9.vcproj │ │ │ │ └── wrapper/ │ │ │ │ ├── 00README.txt │ │ │ │ ├── C/ │ │ │ │ │ ├── 00README.txt │ │ │ │ │ ├── CMakeLists.txt │ │ │ │ │ ├── cgeoid.cpp │ │ │ │ │ ├── cgeoid.h │ │ │ │ │ └── geoidtest.c │ │ │ │ ├── js/ │ │ │ │ │ └── 00README.txt │ │ │ │ ├── matlab/ │ │ │ │ │ ├── 00README.txt │ │ │ │ │ ├── geodesicinverse.cpp │ │ │ │ │ ├── geodesicinverse.m │ │ │ │ │ └── geographiclibinterface.m │ │ │ │ └── python/ │ │ │ │ ├── 00README.txt │ │ │ │ ├── CMakeLists.txt │ │ │ │ └── PyGeographicLib.cpp │ │ │ ├── Spectra/ │ │ │ │ ├── GenEigsBase.h │ │ │ │ ├── GenEigsComplexShiftSolver.h │ │ │ │ ├── GenEigsRealShiftSolver.h │ │ │ │ ├── GenEigsSolver.h │ │ │ │ ├── LinAlg/ │ │ │ │ │ ├── Arnoldi.h │ │ │ │ │ ├── BKLDLT.h │ │ │ │ │ ├── DoubleShiftQR.h │ │ │ │ │ ├── Lanczos.h │ │ │ │ │ ├── TridiagEigen.h │ │ │ │ │ ├── UpperHessenbergEigen.h │ │ │ │ │ └── UpperHessenbergQR.h │ │ │ │ ├── MatOp/ │ │ │ │ │ ├── DenseCholesky.h │ │ │ │ │ ├── DenseGenComplexShiftSolve.h │ │ │ │ │ ├── DenseGenMatProd.h │ │ │ │ │ ├── DenseGenRealShiftSolve.h │ │ │ │ │ ├── DenseSymMatProd.h │ │ │ │ │ ├── DenseSymShiftSolve.h │ │ │ │ │ ├── SparseCholesky.h │ │ │ │ │ ├── SparseGenMatProd.h │ │ │ │ │ ├── SparseGenRealShiftSolve.h │ │ │ │ │ ├── SparseRegularInverse.h │ │ │ │ │ ├── SparseSymMatProd.h │ │ │ │ │ ├── SparseSymShiftSolve.h │ │ │ │ │ └── internal/ │ │ │ │ │ ├── ArnoldiOp.h │ │ │ │ │ ├── SymGEigsCholeskyOp.h │ │ │ │ │ └── SymGEigsRegInvOp.h │ │ │ │ ├── SymEigsBase.h │ │ │ │ ├── SymEigsShiftSolver.h │ │ │ │ ├── SymEigsSolver.h │ │ │ │ ├── SymGEigsSolver.h │ │ │ │ ├── Util/ │ │ │ │ │ ├── CompInfo.h │ │ │ │ │ ├── GEigsMode.h │ │ │ │ │ ├── SelectionRule.h │ │ │ │ │ ├── SimpleRandom.h │ │ │ │ │ └── TypeTraits.h │ │ │ │ └── contrib/ │ │ │ │ ├── LOBPCGSolver.h │ │ │ │ └── PartialSVDSolver.h │ │ │ ├── SuiteSparse_config/ │ │ │ │ ├── Makefile │ │ │ │ ├── README.txt │ │ │ │ ├── SuiteSparse_config.c │ │ │ │ ├── SuiteSparse_config.h │ │ │ │ ├── SuiteSparse_config.mk │ │ │ │ └── xerbla/ │ │ │ │ ├── Makefile │ │ │ │ ├── xerbla.c │ │ │ │ ├── xerbla.f │ │ │ │ └── xerbla.h │ │ │ ├── ceres/ │ │ │ │ ├── CMakeLists.txt │ │ │ │ ├── autodiff.h │ │ │ │ ├── eigen.h │ │ │ │ ├── example.h │ │ │ │ ├── fixed_array.h │ │ │ │ ├── fpclassify.h │ │ │ │ ├── jet.h │ │ │ │ ├── macros.h │ │ │ │ ├── manual_constructor.h │ │ │ │ ├── rotation.h │ │ │ │ └── variadic_evaluate.h │ │ │ └── metis/ │ │ │ ├── BUILD-Windows.txt │ │ │ ├── BUILD.txt │ │ │ ├── CMakeLists.txt │ │ │ ├── Changelog │ │ │ ├── GKlib/ │ │ │ │ ├── BUILD.txt │ │ │ │ ├── CMakeLists.txt │ │ │ │ ├── GKlib.h │ │ │ │ ├── GKlibSystem.cmake │ │ │ │ ├── Makefile │ │ │ │ ├── b64.c │ │ │ │ ├── blas.c │ │ │ │ ├── conf/ │ │ │ │ │ └── check_thread_storage.c │ │ │ │ ├── csr.c │ │ │ │ ├── error.c │ │ │ │ ├── evaluate.c │ │ │ │ ├── fkvkselect.c │ │ │ │ ├── fs.c │ │ │ │ ├── getopt.c │ │ │ │ ├── gk_arch.h │ │ │ │ ├── gk_defs.h │ │ │ │ ├── gk_externs.h │ │ │ │ ├── gk_getopt.h │ │ │ │ ├── gk_macros.h │ │ │ │ ├── gk_mkblas.h │ │ │ │ ├── gk_mkmemory.h │ │ │ │ ├── gk_mkpqueue.h │ │ │ │ ├── gk_mkpqueue2.h │ │ │ │ ├── gk_mkrandom.h │ │ │ │ ├── gk_mksort.h │ │ │ │ ├── gk_mkutils.h │ │ │ │ ├── gk_proto.h │ │ │ │ ├── gk_struct.h │ │ │ │ ├── gk_types.h │ │ │ │ ├── gkregex.c │ │ │ │ ├── gkregex.h │ │ │ │ ├── graph.c │ │ │ │ ├── htable.c │ │ │ │ ├── io.c │ │ │ │ ├── itemsets.c │ │ │ │ ├── mcore.c │ │ │ │ ├── memory.c │ │ │ │ ├── ms_inttypes.h │ │ │ │ ├── ms_stat.h │ │ │ │ ├── ms_stdint.h │ │ │ │ ├── omp.c │ │ │ │ ├── pdb.c │ │ │ │ ├── pqueue.c │ │ │ │ ├── random.c │ │ │ │ ├── rw.c │ │ │ │ ├── seq.c │ │ │ │ ├── sort.c │ │ │ │ ├── string.c │ │ │ │ ├── test/ │ │ │ │ │ ├── CMakeLists.txt │ │ │ │ │ ├── Makefile.in.old │ │ │ │ │ ├── Makefile.old │ │ │ │ │ ├── fis.c │ │ │ │ │ ├── gkgraph.c │ │ │ │ │ ├── gksort.c │ │ │ │ │ ├── rw.c │ │ │ │ │ └── strings.c │ │ │ │ ├── timers.c │ │ │ │ ├── tokenizer.c │ │ │ │ └── util.c │ │ │ ├── Install.txt │ │ │ ├── LICENSE.txt │ │ │ ├── Makefile │ │ │ ├── graphs/ │ │ │ │ ├── 4elt.graph │ │ │ │ ├── README │ │ │ │ ├── copter2.graph │ │ │ │ ├── mdual.graph │ │ │ │ ├── metis.mesh │ │ │ │ └── test.mgraph │ │ │ ├── include/ │ │ │ │ ├── CMakeLists.txt │ │ │ │ └── metis.h │ │ │ ├── libmetis/ │ │ │ │ ├── CMakeLists.txt │ │ │ │ ├── auxapi.c │ │ │ │ ├── balance.c │ │ │ │ ├── bucketsort.c │ │ │ │ ├── checkgraph.c │ │ │ │ ├── coarsen.c │ │ │ │ ├── compress.c │ │ │ │ ├── contig.c │ │ │ │ ├── debug.c │ │ │ │ ├── defs.h │ │ │ │ ├── fm.c │ │ │ │ ├── fortran.c │ │ │ │ ├── frename.c │ │ │ │ ├── gklib.c │ │ │ │ ├── gklib_defs.h │ │ │ │ ├── gklib_rename.h │ │ │ │ ├── graph.c │ │ │ │ ├── initpart.c │ │ │ │ ├── kmetis.c │ │ │ │ ├── kwayfm.c │ │ │ │ ├── kwayrefine.c │ │ │ │ ├── macros.h │ │ │ │ ├── mcutil.c │ │ │ │ ├── mesh.c │ │ │ │ ├── meshpart.c │ │ │ │ ├── metislib.h │ │ │ │ ├── minconn.c │ │ │ │ ├── mincover.c │ │ │ │ ├── mmd.c │ │ │ │ ├── ometis.c │ │ │ │ ├── options.c │ │ │ │ ├── parmetis.c │ │ │ │ ├── pmetis.c │ │ │ │ ├── proto.h │ │ │ │ ├── refine.c │ │ │ │ ├── rename.h │ │ │ │ ├── separator.c │ │ │ │ ├── sfm.c │ │ │ │ ├── srefine.c │ │ │ │ ├── stat.c │ │ │ │ ├── stdheaders.h │ │ │ │ ├── struct.h │ │ │ │ ├── timing.c │ │ │ │ ├── util.c │ │ │ │ └── wspace.c │ │ │ ├── metis.h │ │ │ ├── programs/ │ │ │ │ ├── CMakeLists.txt │ │ │ │ ├── cmdline_gpmetis.c │ │ │ │ ├── cmdline_m2gmetis.c │ │ │ │ ├── cmdline_mpmetis.c │ │ │ │ ├── cmdline_ndmetis.c │ │ │ │ ├── cmpfillin.c │ │ │ │ ├── defs.h │ │ │ │ ├── gpmetis.c │ │ │ │ ├── graphchk.c │ │ │ │ ├── io.c │ │ │ │ ├── m2gmetis.c │ │ │ │ ├── metisbin.h │ │ │ │ ├── mpmetis.c │ │ │ │ ├── ndmetis.c │ │ │ │ ├── proto.h │ │ │ │ ├── smbfactor.c │ │ │ │ ├── stat.c │ │ │ │ └── struct.h │ │ │ └── vsgen.bat │ │ ├── CMakeLists.txt │ │ ├── base/ │ │ │ ├── CMakeLists.txt │ │ │ ├── ConcurrentMap.h │ │ │ ├── DSFMap.h │ │ │ ├── DSFVector.cpp │ │ │ ├── DSFVector.h │ │ │ ├── FastDefaultAllocator.h │ │ │ ├── FastList.h │ │ │ ├── FastMap.h │ │ │ ├── FastSet.h │ │ │ ├── FastVector.h │ │ │ ├── GenericValue.h │ │ │ ├── Group.h │ │ │ ├── Lie.h │ │ │ ├── LieMatrix.h │ │ │ ├── LieScalar.h │ │ │ ├── LieVector.h │ │ │ ├── Manifold.h │ │ │ ├── Matrix.cpp │ │ │ ├── Matrix.h │ │ │ ├── OptionalJacobian.h │ │ │ ├── ProductLieGroup.h │ │ │ ├── SymmetricBlockMatrix.cpp │ │ │ ├── SymmetricBlockMatrix.h │ │ │ ├── Testable.h │ │ │ ├── TestableAssertions.h │ │ │ ├── ThreadsafeException.h │ │ │ ├── Value.h │ │ │ ├── Vector.cpp │ │ │ ├── Vector.h │ │ │ ├── VectorSpace.h │ │ │ ├── VerticalBlockMatrix.cpp │ │ │ ├── VerticalBlockMatrix.h │ │ │ ├── WeightedSampler.h │ │ │ ├── chartTesting.h │ │ │ ├── cholesky.cpp │ │ │ ├── cholesky.h │ │ │ ├── concepts.h │ │ │ ├── debug.cpp │ │ │ ├── debug.h │ │ │ ├── deprecated/ │ │ │ │ ├── LieMatrix.h │ │ │ │ ├── LieScalar.h │ │ │ │ └── LieVector.h │ │ │ ├── lieProxies.h │ │ │ ├── make_shared.h │ │ │ ├── numericalDerivative.h │ │ │ ├── serialization.h │ │ │ ├── serializationTestHelpers.h │ │ │ ├── testLie.h │ │ │ ├── tests/ │ │ │ │ ├── CMakeLists.txt │ │ │ │ ├── testCholesky.cpp │ │ │ │ ├── testDSFMap.cpp │ │ │ │ ├── testDSFVector.cpp │ │ │ │ ├── testDebug.cpp │ │ │ │ ├── testFastContainers.cpp │ │ │ │ ├── testGroup.cpp │ │ │ │ ├── testLieMatrix.cpp │ │ │ │ ├── testLieScalar.cpp │ │ │ │ ├── testLieVector.cpp │ │ │ │ ├── testMatrix.cpp │ │ │ │ ├── testNumericalDerivative.cpp │ │ │ │ ├── testOptionalJacobian.cpp │ │ │ │ ├── testSerializationBase.cpp │ │ │ │ ├── testSymmetricBlockMatrix.cpp │ │ │ │ ├── testTestableAssertions.cpp │ │ │ │ ├── testTreeTraversal.cpp │ │ │ │ ├── testVector.cpp │ │ │ │ ├── testVerticalBlockMatrix.cpp │ │ │ │ └── testWeightedSampler.cpp │ │ │ ├── timing.cpp │ │ │ ├── timing.h │ │ │ ├── treeTraversal/ │ │ │ │ ├── parallelTraversalTasks.h │ │ │ │ └── statistics.h │ │ │ ├── treeTraversal-inst.h │ │ │ ├── types.cpp │ │ │ └── types.h │ │ ├── config.h.in │ │ ├── discrete/ │ │ │ ├── AlgebraicDecisionTree.h │ │ │ ├── Assignment.h │ │ │ ├── CMakeLists.txt │ │ │ ├── DecisionTree-inl.h │ │ │ ├── DecisionTree.h │ │ │ ├── DecisionTreeFactor.cpp │ │ │ ├── DecisionTreeFactor.h │ │ │ ├── DiscreteBayesNet.cpp │ │ │ ├── DiscreteBayesNet.h │ │ │ ├── DiscreteBayesTree.cpp │ │ │ ├── DiscreteBayesTree.h │ │ │ ├── DiscreteConditional.cpp │ │ │ ├── DiscreteConditional.h │ │ │ ├── DiscreteEliminationTree.cpp │ │ │ ├── DiscreteEliminationTree.h │ │ │ ├── DiscreteFactor.cpp │ │ │ ├── DiscreteFactor.h │ │ │ ├── DiscreteFactorGraph.cpp │ │ │ ├── DiscreteFactorGraph.h │ │ │ ├── DiscreteJunctionTree.cpp │ │ │ ├── DiscreteJunctionTree.h │ │ │ ├── DiscreteKey.cpp │ │ │ ├── DiscreteKey.h │ │ │ ├── DiscreteMarginals.h │ │ │ ├── Potentials.cpp │ │ │ ├── Potentials.h │ │ │ ├── Signature.cpp │ │ │ ├── Signature.h │ │ │ └── tests/ │ │ │ ├── CMakeLists.txt │ │ │ ├── data/ │ │ │ │ ├── FG/ │ │ │ │ │ └── alarm.fg │ │ │ │ └── UAI/ │ │ │ │ ├── sampleMARKOV.uai │ │ │ │ ├── sampleMARKOV.uai.evid │ │ │ │ ├── uai08_test1.uai │ │ │ │ ├── uai08_test1.uai.evid │ │ │ │ ├── uai08_test1.uai.output │ │ │ │ ├── uai08_test2.uai │ │ │ │ ├── uai08_test2.uai.evid │ │ │ │ ├── uai08_test2.uai.output │ │ │ │ ├── uai08_test3.uai │ │ │ │ ├── uai08_test3.uai.evid │ │ │ │ └── uai08_test3.uai.output │ │ │ ├── testAlgebraicDecisionTree.cpp │ │ │ ├── testDecisionTree.cpp │ │ │ ├── testDecisionTreeFactor.cpp │ │ │ ├── testDiscreteBayesNet.cpp │ │ │ ├── testDiscreteBayesTree.cpp │ │ │ ├── testDiscreteConditional.cpp │ │ │ ├── testDiscreteFactor.cpp │ │ │ ├── testDiscreteFactorGraph.cpp │ │ │ ├── testDiscreteMarginals.cpp │ │ │ └── testSignature.cpp │ │ ├── geometry/ │ │ │ ├── BearingRange.h │ │ │ ├── CMakeLists.txt │ │ │ ├── Cal3Bundler.cpp │ │ │ ├── Cal3Bundler.h │ │ │ ├── Cal3DS2.cpp │ │ │ ├── Cal3DS2.h │ │ │ ├── Cal3DS2_Base.cpp │ │ │ ├── Cal3DS2_Base.h │ │ │ ├── Cal3Fisheye.cpp │ │ │ ├── Cal3Fisheye.h │ │ │ ├── Cal3Unified.cpp │ │ │ ├── Cal3Unified.h │ │ │ ├── Cal3_S2.cpp │ │ │ ├── Cal3_S2.h │ │ │ ├── Cal3_S2Stereo.cpp │ │ │ ├── Cal3_S2Stereo.h │ │ │ ├── CalibratedCamera.cpp │ │ │ ├── CalibratedCamera.h │ │ │ ├── CameraSet.h │ │ │ ├── Cyclic.cpp │ │ │ ├── Cyclic.h │ │ │ ├── EssentialMatrix.cpp │ │ │ ├── EssentialMatrix.h │ │ │ ├── Line3.cpp │ │ │ ├── Line3.h │ │ │ ├── OrientedPlane3.cpp │ │ │ ├── OrientedPlane3.h │ │ │ ├── PinholeCamera.h │ │ │ ├── PinholePose.h │ │ │ ├── PinholeSet.h │ │ │ ├── Point2.cpp │ │ │ ├── Point2.h │ │ │ ├── Point3.cpp │ │ │ ├── Point3.h │ │ │ ├── Pose2.cpp │ │ │ ├── Pose2.h │ │ │ ├── Pose3.cpp │ │ │ ├── Pose3.h │ │ │ ├── Quaternion.h │ │ │ ├── Rot2.cpp │ │ │ ├── Rot2.h │ │ │ ├── Rot3.cpp │ │ │ ├── Rot3.h │ │ │ ├── Rot3M.cpp │ │ │ ├── Rot3Q.cpp │ │ │ ├── SO3.cpp │ │ │ ├── SO3.h │ │ │ ├── SO4.cpp │ │ │ ├── SO4.h │ │ │ ├── SOn-inl.h │ │ │ ├── SOn.cpp │ │ │ ├── SOn.h │ │ │ ├── SimpleCamera.cpp │ │ │ ├── SimpleCamera.h │ │ │ ├── StereoCamera.cpp │ │ │ ├── StereoCamera.h │ │ │ ├── StereoPoint2.cpp │ │ │ ├── StereoPoint2.h │ │ │ ├── Unit3.cpp │ │ │ ├── Unit3.h │ │ │ ├── concepts.h │ │ │ ├── tests/ │ │ │ │ ├── CMakeLists.txt │ │ │ │ ├── testBearingRange.cpp │ │ │ │ ├── testCal3Bundler.cpp │ │ │ │ ├── testCal3DFisheye.cpp │ │ │ │ ├── testCal3DS2.cpp │ │ │ │ ├── testCal3Unified.cpp │ │ │ │ ├── testCal3_S2.cpp │ │ │ │ ├── testCalibratedCamera.cpp │ │ │ │ ├── testCameraSet.cpp │ │ │ │ ├── testCyclic.cpp │ │ │ │ ├── testEssentialMatrix.cpp │ │ │ │ ├── testLine3.cpp │ │ │ │ ├── testOrientedPlane3.cpp │ │ │ │ ├── testPinholeCamera.cpp │ │ │ │ ├── testPinholePose.cpp │ │ │ │ ├── testPinholeSet.cpp │ │ │ │ ├── testPoint2.cpp │ │ │ │ ├── testPoint3.cpp │ │ │ │ ├── testPose2.cpp │ │ │ │ ├── testPose3.cpp │ │ │ │ ├── testPoseAdjointMap.h │ │ │ │ ├── testQuaternion.cpp │ │ │ │ ├── testRot2.cpp │ │ │ │ ├── testRot3.cpp │ │ │ │ ├── testRot3M.cpp │ │ │ │ ├── testRot3Q.cpp │ │ │ │ ├── testSO3.cpp │ │ │ │ ├── testSO4.cpp │ │ │ │ ├── testSOn.cpp │ │ │ │ ├── testSerializationGeometry.cpp │ │ │ │ ├── testSimpleCamera.cpp │ │ │ │ ├── testStereoCamera.cpp │ │ │ │ ├── testStereoPoint2.cpp │ │ │ │ ├── testTriangulation.cpp │ │ │ │ └── testUnit3.cpp │ │ │ ├── triangulation.cpp │ │ │ └── triangulation.h │ │ ├── global_includes.h │ │ ├── groups.dox │ │ ├── gtsam.i │ │ ├── inference/ │ │ │ ├── BayesNet-inst.h │ │ │ ├── BayesNet.h │ │ │ ├── BayesTree-inst.h │ │ │ ├── BayesTree.cpp │ │ │ ├── BayesTree.h │ │ │ ├── BayesTreeCliqueBase-inst.h │ │ │ ├── BayesTreeCliqueBase.h │ │ │ ├── CMakeLists.txt │ │ │ ├── ClusterTree-inst.h │ │ │ ├── ClusterTree.h │ │ │ ├── Conditional-inst.h │ │ │ ├── Conditional.h │ │ │ ├── EliminateableFactorGraph-inst.h │ │ │ ├── EliminateableFactorGraph.h │ │ │ ├── EliminationTree-inst.h │ │ │ ├── EliminationTree.h │ │ │ ├── Factor.cpp │ │ │ ├── Factor.h │ │ │ ├── FactorGraph-inst.h │ │ │ ├── FactorGraph.h │ │ │ ├── ISAM-inst.h │ │ │ ├── ISAM.h │ │ │ ├── JunctionTree-inst.h │ │ │ ├── JunctionTree.h │ │ │ ├── Key.cpp │ │ │ ├── Key.h │ │ │ ├── LabeledSymbol.cpp │ │ │ ├── LabeledSymbol.h │ │ │ ├── MetisIndex-inl.h │ │ │ ├── MetisIndex.h │ │ │ ├── Ordering.cpp │ │ │ ├── Ordering.h │ │ │ ├── Symbol.cpp │ │ │ ├── Symbol.h │ │ │ ├── VariableIndex-inl.h │ │ │ ├── VariableIndex.cpp │ │ │ ├── VariableIndex.h │ │ │ ├── VariableSlots.cpp │ │ │ ├── VariableSlots.h │ │ │ ├── graph-inl.h │ │ │ ├── graph.h │ │ │ ├── inference-inst.h │ │ │ ├── inferenceExceptions.h │ │ │ └── tests/ │ │ │ ├── CMakeLists.txt │ │ │ ├── testKey.cpp │ │ │ ├── testLabeledSymbol.cpp │ │ │ ├── testOrdering.cpp │ │ │ ├── testSymbol.cpp │ │ │ └── testVariableSlots.cpp │ │ ├── linear/ │ │ │ ├── BinaryJacobianFactor.h │ │ │ ├── CMakeLists.txt │ │ │ ├── ConjugateGradientSolver.cpp │ │ │ ├── ConjugateGradientSolver.h │ │ │ ├── Errors.cpp │ │ │ ├── Errors.h │ │ │ ├── GaussianBayesNet.cpp │ │ │ ├── GaussianBayesNet.h │ │ │ ├── GaussianBayesTree-inl.h │ │ │ ├── GaussianBayesTree.cpp │ │ │ ├── GaussianBayesTree.h │ │ │ ├── GaussianConditional-inl.h │ │ │ ├── GaussianConditional.cpp │ │ │ ├── GaussianConditional.h │ │ │ ├── GaussianDensity.cpp │ │ │ ├── GaussianDensity.h │ │ │ ├── GaussianEliminationTree.cpp │ │ │ ├── GaussianEliminationTree.h │ │ │ ├── GaussianFactor.cpp │ │ │ ├── GaussianFactor.h │ │ │ ├── GaussianFactorGraph.cpp │ │ │ ├── GaussianFactorGraph.h │ │ │ ├── GaussianISAM.cpp │ │ │ ├── GaussianISAM.h │ │ │ ├── GaussianJunctionTree.cpp │ │ │ ├── GaussianJunctionTree.h │ │ │ ├── HessianFactor-inl.h │ │ │ ├── HessianFactor.cpp │ │ │ ├── HessianFactor.h │ │ │ ├── IterativeSolver.cpp │ │ │ ├── IterativeSolver.h │ │ │ ├── JacobianFactor-inl.h │ │ │ ├── JacobianFactor.cpp │ │ │ ├── JacobianFactor.h │ │ │ ├── KalmanFilter.cpp │ │ │ ├── KalmanFilter.h │ │ │ ├── LossFunctions.cpp │ │ │ ├── LossFunctions.h │ │ │ ├── NoiseModel.cpp │ │ │ ├── NoiseModel.h │ │ │ ├── PCGSolver.cpp │ │ │ ├── PCGSolver.h │ │ │ ├── Preconditioner.cpp │ │ │ ├── Preconditioner.h │ │ │ ├── RegularHessianFactor.h │ │ │ ├── RegularJacobianFactor.h │ │ │ ├── Sampler.cpp │ │ │ ├── Sampler.h │ │ │ ├── Scatter.cpp │ │ │ ├── Scatter.h │ │ │ ├── SubgraphBuilder.cpp │ │ │ ├── SubgraphBuilder.h │ │ │ ├── SubgraphPreconditioner.cpp │ │ │ ├── SubgraphPreconditioner.h │ │ │ ├── SubgraphSolver.cpp │ │ │ ├── SubgraphSolver.h │ │ │ ├── VectorValues.cpp │ │ │ ├── VectorValues.h │ │ │ ├── iterative-inl.h │ │ │ ├── iterative.cpp │ │ │ ├── iterative.h │ │ │ ├── linearAlgorithms-inst.h │ │ │ ├── linearExceptions.cpp │ │ │ ├── linearExceptions.h │ │ │ └── tests/ │ │ │ ├── CMakeLists.txt │ │ │ ├── testErrors.cpp │ │ │ ├── testGaussianBayesNet.cpp │ │ │ ├── testGaussianBayesTree.cpp │ │ │ ├── testGaussianConditional.cpp │ │ │ ├── testGaussianDensity.cpp │ │ │ ├── testGaussianFactorGraph.cpp │ │ │ ├── testHessianFactor.cpp │ │ │ ├── testJacobianFactor.cpp │ │ │ ├── testKalmanFilter.cpp │ │ │ ├── testNoiseModel.cpp │ │ │ ├── testRegularHessianFactor.cpp │ │ │ ├── testRegularJacobianFactor.cpp │ │ │ ├── testSampler.cpp │ │ │ ├── testScatter.cpp │ │ │ ├── testSerializationLinear.cpp │ │ │ └── testVectorValues.cpp │ │ ├── mainpage.dox │ │ ├── navigation/ │ │ │ ├── .gitignore │ │ │ ├── AHRSFactor.cpp │ │ │ ├── AHRSFactor.h │ │ │ ├── AttitudeFactor.cpp │ │ │ ├── AttitudeFactor.h │ │ │ ├── CMakeLists.txt │ │ │ ├── CombinedImuFactor.cpp │ │ │ ├── CombinedImuFactor.h │ │ │ ├── GPSFactor.cpp │ │ │ ├── GPSFactor.h │ │ │ ├── ImuBias.cpp │ │ │ ├── ImuBias.h │ │ │ ├── ImuFactor.cpp │ │ │ ├── ImuFactor.h │ │ │ ├── MagFactor.h │ │ │ ├── ManifoldPreintegration.cpp │ │ │ ├── ManifoldPreintegration.h │ │ │ ├── NavState.cpp │ │ │ ├── NavState.h │ │ │ ├── PreintegratedRotation.cpp │ │ │ ├── PreintegratedRotation.h │ │ │ ├── PreintegrationBase.cpp │ │ │ ├── PreintegrationBase.h │ │ │ ├── PreintegrationParams.cpp │ │ │ ├── PreintegrationParams.h │ │ │ ├── Scenario.h │ │ │ ├── ScenarioRunner.cpp │ │ │ ├── ScenarioRunner.h │ │ │ ├── TangentPreintegration.cpp │ │ │ ├── TangentPreintegration.h │ │ │ ├── expressions.h │ │ │ └── tests/ │ │ │ ├── CMakeLists.txt │ │ │ ├── imuFactorTesting.h │ │ │ ├── testAHRSFactor.cpp │ │ │ ├── testAttitudeFactor.cpp │ │ │ ├── testCombinedImuFactor.cpp │ │ │ ├── testGPSFactor.cpp │ │ │ ├── testGeographicLib.cpp │ │ │ ├── testImuBias.cpp │ │ │ ├── testImuFactor.cpp │ │ │ ├── testImuFactorSerialization.cpp │ │ │ ├── testMagFactor.cpp │ │ │ ├── testManifoldPreintegration.cpp │ │ │ ├── testNavExpressions.cpp │ │ │ ├── testNavState.cpp │ │ │ ├── testPoseVelocityBias.cpp │ │ │ ├── testScenario.cpp │ │ │ ├── testScenarioRunner.cpp │ │ │ └── testTangentPreintegration.cpp │ │ ├── nonlinear/ │ │ │ ├── AdaptAutoDiff.h │ │ │ ├── CMakeLists.txt │ │ │ ├── DoglegOptimizer.cpp │ │ │ ├── DoglegOptimizer.h │ │ │ ├── DoglegOptimizerImpl.cpp │ │ │ ├── DoglegOptimizerImpl.h │ │ │ ├── Expression-inl.h │ │ │ ├── Expression.h │ │ │ ├── ExpressionFactor.h │ │ │ ├── ExpressionFactorGraph.h │ │ │ ├── ExtendedKalmanFilter-inl.h │ │ │ ├── ExtendedKalmanFilter.h │ │ │ ├── FunctorizedFactor.h │ │ │ ├── GaussNewtonOptimizer.cpp │ │ │ ├── GaussNewtonOptimizer.h │ │ │ ├── ISAM2-impl.cpp │ │ │ ├── ISAM2-impl.h │ │ │ ├── ISAM2.cpp │ │ │ ├── ISAM2.h │ │ │ ├── ISAM2Clique.cpp │ │ │ ├── ISAM2Clique.h │ │ │ ├── ISAM2Params.cpp │ │ │ ├── ISAM2Params.h │ │ │ ├── ISAM2Result.h │ │ │ ├── ISAM2UpdateParams.h │ │ │ ├── LevenbergMarquardtOptimizer.cpp │ │ │ ├── LevenbergMarquardtOptimizer.h │ │ │ ├── LevenbergMarquardtParams.cpp │ │ │ ├── LevenbergMarquardtParams.h │ │ │ ├── LinearContainerFactor.cpp │ │ │ ├── LinearContainerFactor.h │ │ │ ├── Marginals.cpp │ │ │ ├── Marginals.h │ │ │ ├── NonlinearConjugateGradientOptimizer.cpp │ │ │ ├── NonlinearConjugateGradientOptimizer.h │ │ │ ├── NonlinearEquality.h │ │ │ ├── NonlinearFactor.cpp │ │ │ ├── NonlinearFactor.h │ │ │ ├── NonlinearFactorGraph.cpp │ │ │ ├── NonlinearFactorGraph.h │ │ │ ├── NonlinearISAM.cpp │ │ │ ├── NonlinearISAM.h │ │ │ ├── NonlinearOptimizer.cpp │ │ │ ├── NonlinearOptimizer.h │ │ │ ├── NonlinearOptimizerParams.cpp │ │ │ ├── NonlinearOptimizerParams.h │ │ │ ├── PriorFactor.h │ │ │ ├── Symbol.h │ │ │ ├── Values-inl.h │ │ │ ├── Values.cpp │ │ │ ├── Values.h │ │ │ ├── WhiteNoiseFactor.h │ │ │ ├── expressionTesting.h │ │ │ ├── expressions.h │ │ │ ├── factorTesting.h │ │ │ ├── internal/ │ │ │ │ ├── CallRecord.h │ │ │ │ ├── ExecutionTrace.h │ │ │ │ ├── ExpressionNode.h │ │ │ │ ├── JacobianMap.h │ │ │ │ ├── LevenbergMarquardtState.h │ │ │ │ └── NonlinearOptimizerState.h │ │ │ ├── nonlinearExceptions.h │ │ │ ├── tests/ │ │ │ │ ├── CMakeLists.txt │ │ │ │ ├── testAdaptAutoDiff.cpp │ │ │ │ ├── testCallRecord.cpp │ │ │ │ ├── testExecutionTrace.cpp │ │ │ │ ├── testExpression.cpp │ │ │ │ ├── testFactorTesting.cpp │ │ │ │ ├── testFunctorizedFactor.cpp │ │ │ │ ├── testLinearContainerFactor.cpp │ │ │ │ ├── testSerializationNonlinear.cpp │ │ │ │ ├── testValues.cpp │ │ │ │ └── testWhiteNoiseFactor.cpp │ │ │ └── utilities.h │ │ ├── precompiled_header.cpp │ │ ├── precompiled_header.h │ │ ├── sam/ │ │ │ ├── BearingFactor.h │ │ │ ├── BearingRangeFactor.h │ │ │ ├── CMakeLists.txt │ │ │ ├── RangeFactor.h │ │ │ └── tests/ │ │ │ ├── CMakeLists.txt │ │ │ ├── testBearingFactor.cpp │ │ │ ├── testBearingRangeFactor.cpp │ │ │ └── testRangeFactor.cpp │ │ ├── sfm/ │ │ │ ├── BinaryMeasurement.h │ │ │ ├── CMakeLists.txt │ │ │ ├── ShonanAveraging.cpp │ │ │ ├── ShonanAveraging.h │ │ │ ├── ShonanFactor.cpp │ │ │ ├── ShonanFactor.h │ │ │ ├── ShonanGaugeFactor.h │ │ │ ├── TranslationFactor.h │ │ │ ├── TranslationRecovery.cpp │ │ │ ├── TranslationRecovery.h │ │ │ └── tests/ │ │ │ ├── CMakeLists.txt │ │ │ ├── testBinaryMeasurement.cpp │ │ │ ├── testShonanAveraging.cpp │ │ │ ├── testShonanFactor.cpp │ │ │ ├── testShonanGaugeFactor.cpp │ │ │ └── testTranslationFactor.cpp │ │ ├── slam/ │ │ │ ├── AntiFactor.h │ │ │ ├── BearingFactor.h │ │ │ ├── BearingRangeFactor.h │ │ │ ├── BetweenFactor.h │ │ │ ├── BoundingConstraint.h │ │ │ ├── CMakeLists.txt │ │ │ ├── EssentialMatrixConstraint.cpp │ │ │ ├── EssentialMatrixConstraint.h │ │ │ ├── EssentialMatrixFactor.h │ │ │ ├── FrobeniusFactor.cpp │ │ │ ├── FrobeniusFactor.h │ │ │ ├── GeneralSFMFactor.h │ │ │ ├── InitializePose.h │ │ │ ├── InitializePose3.cpp │ │ │ ├── InitializePose3.h │ │ │ ├── JacobianFactorQ.h │ │ │ ├── JacobianFactorQR.h │ │ │ ├── JacobianFactorSVD.h │ │ │ ├── KarcherMeanFactor-inl.h │ │ │ ├── KarcherMeanFactor.h │ │ │ ├── OrientedPlane3Factor.cpp │ │ │ ├── OrientedPlane3Factor.h │ │ │ ├── PoseRotationPrior.h │ │ │ ├── PoseTranslationPrior.h │ │ │ ├── PriorFactor.h │ │ │ ├── ProjectionFactor.h │ │ │ ├── RangeFactor.h │ │ │ ├── ReferenceFrameFactor.h │ │ │ ├── RegularImplicitSchurFactor.h │ │ │ ├── RotateFactor.h │ │ │ ├── SmartFactorBase.h │ │ │ ├── SmartFactorParams.h │ │ │ ├── SmartProjectionFactor.h │ │ │ ├── SmartProjectionPoseFactor.h │ │ │ ├── StereoFactor.h │ │ │ ├── TriangulationFactor.h │ │ │ ├── dataset.cpp │ │ │ ├── dataset.h │ │ │ ├── expressions.h │ │ │ ├── lago.cpp │ │ │ ├── lago.h │ │ │ └── tests/ │ │ │ ├── CMakeLists.txt │ │ │ ├── smartFactorScenarios.h │ │ │ ├── testAntiFactor.cpp │ │ │ ├── testBetweenFactor.cpp │ │ │ ├── testDataset.cpp │ │ │ ├── testEssentialMatrixConstraint.cpp │ │ │ ├── testEssentialMatrixFactor.cpp │ │ │ ├── testFrobeniusFactor.cpp │ │ │ ├── testGeneralSFMFactor.cpp │ │ │ ├── testGeneralSFMFactor_Cal3Bundler.cpp │ │ │ ├── testInitializePose.cpp │ │ │ ├── testInitializePose3.cpp │ │ │ ├── testKarcherMeanFactor.cpp │ │ │ ├── testLago.cpp │ │ │ ├── testOrientedPlane3Factor.cpp │ │ │ ├── testPoseRotationPrior.cpp │ │ │ ├── testPoseTranslationPrior.cpp │ │ │ ├── testPriorFactor.cpp │ │ │ ├── testProjectionFactor.cpp │ │ │ ├── testReferenceFrameFactor.cpp │ │ │ ├── testRegularImplicitSchurFactor.cpp │ │ │ ├── testRotateFactor.cpp │ │ │ ├── testSlamExpressions.cpp │ │ │ ├── testSmartFactorBase.cpp │ │ │ ├── testSmartProjectionFactor.cpp │ │ │ ├── testSmartProjectionPoseFactor.cpp │ │ │ ├── testStereoFactor.cpp │ │ │ └── testTriangulationFactor.cpp │ │ └── symbolic/ │ │ ├── CMakeLists.txt │ │ ├── SymbolicBayesNet.cpp │ │ ├── SymbolicBayesNet.h │ │ ├── SymbolicBayesTree.cpp │ │ ├── SymbolicBayesTree.h │ │ ├── SymbolicConditional.cpp │ │ ├── SymbolicConditional.h │ │ ├── SymbolicEliminationTree.cpp │ │ ├── SymbolicEliminationTree.h │ │ ├── SymbolicFactor-inst.h │ │ ├── SymbolicFactor.cpp │ │ ├── SymbolicFactor.h │ │ ├── SymbolicFactorGraph.cpp │ │ ├── SymbolicFactorGraph.h │ │ ├── SymbolicISAM.cpp │ │ ├── SymbolicISAM.h │ │ ├── SymbolicJunctionTree.cpp │ │ ├── SymbolicJunctionTree.h │ │ └── tests/ │ │ ├── CMakeLists.txt │ │ ├── symbolicExampleGraphs.h │ │ ├── testSerializationSymbolic.cpp │ │ ├── testSymbolicBayesNet.cpp │ │ ├── testSymbolicBayesTree.cpp │ │ ├── testSymbolicConditional.cpp │ │ ├── testSymbolicEliminationTree.cpp │ │ ├── testSymbolicFactor.cpp │ │ ├── testSymbolicFactorGraph.cpp │ │ ├── testSymbolicISAM.cpp │ │ ├── testSymbolicJunctionTree.cpp │ │ └── testVariableIndex.cpp │ ├── gtsam_extra.cmake.in │ ├── gtsam_unstable/ │ │ ├── CMakeLists.txt │ │ ├── base/ │ │ │ ├── BTree.h │ │ │ ├── CMakeLists.txt │ │ │ ├── DSF.h │ │ │ ├── Dummy.cpp │ │ │ ├── Dummy.h │ │ │ ├── FixedVector.h │ │ │ └── tests/ │ │ │ ├── CMakeLists.txt │ │ │ ├── testBTree.cpp │ │ │ ├── testDSF.cpp │ │ │ └── testFixedVector.cpp │ │ ├── discrete/ │ │ │ ├── AllDiff.cpp │ │ │ ├── AllDiff.h │ │ │ ├── BinaryAllDiff.h │ │ │ ├── CMakeLists.txt │ │ │ ├── CSP.cpp │ │ │ ├── CSP.h │ │ │ ├── Constraint.h │ │ │ ├── Domain.cpp │ │ │ ├── Domain.h │ │ │ ├── Scheduler.cpp │ │ │ ├── Scheduler.h │ │ │ ├── SingleValue.cpp │ │ │ ├── SingleValue.h │ │ │ ├── examples/ │ │ │ │ ├── CMakeLists.txt │ │ │ │ ├── Doodle.csv │ │ │ │ ├── Doodle.xls │ │ │ │ ├── Doodle2012.csv │ │ │ │ ├── Doodle2012.xls │ │ │ │ ├── Doodle2013.csv │ │ │ │ ├── Doodle2013.xls │ │ │ │ ├── intrusive.xlsx │ │ │ │ ├── schedulingExample.cpp │ │ │ │ ├── schedulingQuals12.cpp │ │ │ │ ├── schedulingQuals13.cpp │ │ │ │ └── small.csv │ │ │ └── tests/ │ │ │ ├── CMakeLists.txt │ │ │ ├── testCSP.cpp │ │ │ ├── testLoopyBelief.cpp │ │ │ ├── testScheduler.cpp │ │ │ └── testSudoku.cpp │ │ ├── dynamics/ │ │ │ ├── CMakeLists.txt │ │ │ ├── DynamicsPriors.h │ │ │ ├── FullIMUFactor.h │ │ │ ├── IMUFactor.h │ │ │ ├── Pendulum.h │ │ │ ├── PoseRTV.cpp │ │ │ ├── PoseRTV.h │ │ │ ├── SimpleHelicopter.cpp │ │ │ ├── SimpleHelicopter.h │ │ │ ├── VelocityConstraint.h │ │ │ ├── VelocityConstraint3.h │ │ │ └── tests/ │ │ │ ├── CMakeLists.txt │ │ │ ├── testIMUSystem.cpp │ │ │ ├── testPendulumFactors.cpp │ │ │ ├── testPoseRTV.cpp │ │ │ ├── testSimpleHelicopter.cpp │ │ │ ├── testVelocityConstraint.cpp │ │ │ └── testVelocityConstraint3.cpp │ │ ├── examples/ │ │ │ ├── CMakeLists.txt │ │ │ ├── ConcurrentCalibration.cpp │ │ │ ├── ConcurrentFilteringAndSmoothingExample.cpp │ │ │ ├── FixedLagSmootherExample.cpp │ │ │ ├── README.md │ │ │ ├── SmartProjectionFactorExample.cpp │ │ │ ├── SmartRangeExample_plaza1.cpp │ │ │ ├── SmartRangeExample_plaza2.cpp │ │ │ ├── SmartStereoProjectionFactorExample.cpp │ │ │ ├── TimeOfArrivalExample.cpp │ │ │ └── plotRangeResults.p │ │ ├── geometry/ │ │ │ ├── BearingS2.cpp │ │ │ ├── BearingS2.h │ │ │ ├── CMakeLists.txt │ │ │ ├── Event.cpp │ │ │ ├── Event.h │ │ │ ├── InvDepthCamera3.h │ │ │ ├── Pose3Upright.cpp │ │ │ ├── Pose3Upright.h │ │ │ ├── SimPolygon2D.cpp │ │ │ ├── SimPolygon2D.h │ │ │ ├── SimWall2D.cpp │ │ │ ├── SimWall2D.h │ │ │ ├── Similarity3.cpp │ │ │ ├── Similarity3.h │ │ │ └── tests/ │ │ │ ├── CMakeLists.txt │ │ │ ├── testBearingS2.cpp │ │ │ ├── testEvent.cpp │ │ │ ├── testInvDepthCamera3.cpp │ │ │ ├── testPose3Upright.cpp │ │ │ ├── testSimPolygon2D.cpp │ │ │ ├── testSimWall2D.cpp │ │ │ └── testSimilarity3.cpp │ │ ├── gtsam_unstable.i │ │ ├── linear/ │ │ │ ├── ActiveSetSolver-inl.h │ │ │ ├── ActiveSetSolver.h │ │ │ ├── CMakeLists.txt │ │ │ ├── EqualityFactorGraph.h │ │ │ ├── InequalityFactorGraph.h │ │ │ ├── InfeasibleInitialValues.h │ │ │ ├── InfeasibleOrUnboundedProblem.h │ │ │ ├── LP.h │ │ │ ├── LPInitSolver.cpp │ │ │ ├── LPInitSolver.h │ │ │ ├── LPSolver.cpp │ │ │ ├── LPSolver.h │ │ │ ├── LinearCost.h │ │ │ ├── LinearEquality.h │ │ │ ├── LinearInequality.h │ │ │ ├── QP.h │ │ │ ├── QPInitSolver.h │ │ │ ├── QPSParser.cpp │ │ │ ├── QPSParser.h │ │ │ ├── QPSParserE
Showing preview only (2,223K chars total). Download the full file or copy to clipboard to get everything.
SYMBOL INDEX (21087 symbols across 3376 files)
FILE: common/base/state.h
function namespace (line 12) | namespace common {
FILE: common/base/trajectory.h
function namespace (line 18) | namespace common {
FILE: common/frenet/frenet_state.h
function namespace (line 14) | namespace common {
type FrenetState (line 48) | struct FrenetState {
FILE: common/frenet/frenet_transform.cc
type common (line 14) | namespace common {
FILE: common/frenet/frenet_transform.h
function namespace (line 14) | namespace common {
FILE: common/geometry/box2d.cc
type common (line 10) | namespace common {
FILE: common/geometry/box2d.h
function namespace (line 15) | namespace common {
FILE: common/graph/dijkstra.hpp
type common (line 17) | namespace common {
class Dijkstra (line 20) | class Dijkstra {
type DijkstraVertex (line 21) | struct DijkstraVertex {
method DijkstraVertex (line 28) | DijkstraVertex() = default;
method DijkstraVertex (line 29) | DijkstraVertex(const T _index) : index(_index), parent(_index) {}
method Dijkstra (line 33) | Dijkstra() = default;
FILE: common/smoothing/affine_constraint.cc
type common (line 24) | namespace common {
FILE: common/smoothing/affine_constraint.h
function namespace (line 26) | namespace common {
FILE: common/smoothing/discrete_points_math.cc
type common (line 22) | namespace common {
FILE: common/smoothing/discrete_points_math.h
function namespace (line 22) | namespace common {
FILE: common/smoothing/osqp_spline1d_solver.cc
type common (line 25) | namespace common {
function Spline1dConstraint (line 38) | Spline1dConstraint* OsqpSpline1dSolver::mutable_constraint() {
function Spline1dKernel (line 42) | Spline1dKernel* OsqpSpline1dSolver::mutable_kernel() { return &kernel_; }
function Spline1d (line 44) | Spline1d* OsqpSpline1dSolver::mutable_spline() { return &spline_; }
function Spline1d (line 74) | const Spline1d& OsqpSpline1dSolver::spline() const { return spline_; }
FILE: common/smoothing/osqp_spline1d_solver.h
function namespace (line 23) | namespace common {
FILE: common/smoothing/osqp_spline2d_solver.cc
type common (line 25) | namespace common {
function Spline2dConstraint (line 38) | Spline2dConstraint* OsqpSpline2dSolver::mutable_constraint() {
function Spline2dKernel (line 42) | Spline2dKernel* OsqpSpline2dSolver::mutable_kernel() { return &kernel_; }
function Spline2d (line 44) | Spline2d* OsqpSpline2dSolver::mutable_spline() { return &spline_; }
function Spline2d (line 74) | const Spline2d& OsqpSpline2dSolver::spline() const { return spline_; }
FILE: common/smoothing/osqp_spline2d_solver.h
function namespace (line 23) | namespace common {
FILE: common/smoothing/polynomialxd.cc
type common (line 21) | namespace common {
function PolynomialXd (line 43) | PolynomialXd PolynomialXd::DerivedFrom(const PolynomialXd& base) {
function PolynomialXd (line 56) | PolynomialXd PolynomialXd::IntegratedFrom(const PolynomialXd& base,
FILE: common/smoothing/polynomialxd.h
function namespace (line 22) | namespace common {
FILE: common/smoothing/spline1d.cc
type common (line 19) | namespace common {
FILE: common/smoothing/spline1d.h
function namespace (line 25) | namespace common {
FILE: common/smoothing/spline1d_constraint.cc
type common (line 19) | namespace common {
function AffineConstraint (line 308) | const AffineConstraint& Spline1dConstraint::affine_constraint() const {
FILE: common/smoothing/spline1d_constraint.h
function namespace (line 27) | namespace common {
FILE: common/smoothing/spline1d_kernel.cc
type common (line 23) | namespace common {
FILE: common/smoothing/spline1d_kernel.h
function namespace (line 26) | namespace common {
FILE: common/smoothing/spline1d_kernel_helper.cc
type common (line 22) | namespace common {
function Spline1dKernelHelper (line 24) | Spline1dKernelHelper& Spline1dKernelHelper::Instance() {
FILE: common/smoothing/spline1d_kernel_helper.h
function namespace (line 23) | namespace common {
FILE: common/smoothing/spline1d_seg.cc
type common (line 19) | namespace common {
function PolynomialXd (line 52) | const PolynomialXd& Spline1dSeg::spline_func() const { return spline_f...
function PolynomialXd (line 54) | const PolynomialXd& Spline1dSeg::Derivative() const { return derivativ...
function PolynomialXd (line 56) | const PolynomialXd& Spline1dSeg::SecondOrderDerivative() const {
function PolynomialXd (line 60) | const PolynomialXd& Spline1dSeg::ThirdOrderDerivative() const {
FILE: common/smoothing/spline1d_seg.h
function namespace (line 23) | namespace common {
FILE: common/smoothing/spline1d_solver.h
function namespace (line 26) | namespace common {
FILE: common/smoothing/spline2d.cc
type common (line 21) | namespace common {
function Spline2dSeg (line 178) | const Spline2dSeg& Spline2d::smoothing_spline(const uint32_t index) co...
FILE: common/smoothing/spline2d.h
function namespace (line 26) | namespace common {
FILE: common/smoothing/spline2d_constraint.cc
type common (line 21) | namespace common {
function AffineConstraint (line 447) | const AffineConstraint& Spline2dConstraint::x_affine_constraint() {
function AffineConstraint (line 451) | const AffineConstraint& Spline2dConstraint::y_affine_constraint() {
FILE: common/smoothing/spline2d_constraint.h
function namespace (line 28) | namespace common {
FILE: common/smoothing/spline2d_kernel.cc
type common (line 21) | namespace common {
FILE: common/smoothing/spline2d_kernel.h
function namespace (line 26) | namespace common {
FILE: common/smoothing/spline2d_seg.cc
type common (line 19) | namespace common {
function PolynomialXd (line 91) | const PolynomialXd& Spline2dSeg::spline_func_x() const {
function PolynomialXd (line 95) | const PolynomialXd& Spline2dSeg::spline_func_y() const {
function PolynomialXd (line 99) | const PolynomialXd& Spline2dSeg::DerivativeX() const { return derivati...
function PolynomialXd (line 101) | const PolynomialXd& Spline2dSeg::DerivativeY() const { return derivati...
function PolynomialXd (line 103) | const PolynomialXd& Spline2dSeg::SecondDerivativeX() const {
function PolynomialXd (line 107) | const PolynomialXd& Spline2dSeg::SecondDerivativeY() const {
function PolynomialXd (line 111) | const PolynomialXd& Spline2dSeg::ThirdDerivativeX() const {
function PolynomialXd (line 115) | const PolynomialXd& Spline2dSeg::ThirdDerivativeY() const {
FILE: common/smoothing/spline2d_seg.h
function namespace (line 24) | namespace common {
FILE: common/smoothing/spline2d_solver.h
function namespace (line 26) | namespace common {
FILE: common/solver/osqp/osqp_interface.cc
type common (line 9) | namespace common {
FILE: common/solver/osqp/osqp_interface.h
function namespace (line 8) | namespace common {
FILE: common/solver/osqp/osqp_sparse_matrix.h
function namespace (line 8) | namespace common {
FILE: common/thirdparty/osqp/docs/conf.py
function setup (line 117) | def setup(app):
FILE: common/thirdparty/osqp/examples/osqp_demo.c
function main (line 4) | int main(int argc, char **argv) {
FILE: common/thirdparty/osqp/include/constants.h
type linsys_solver_type (line 36) | enum linsys_solver_type { QDLDL_SOLVER, MKL_PARDISO_SOLVER }
type osqp_error_type (line 43) | enum osqp_error_type {
FILE: common/thirdparty/osqp/include/error.h
type osqp_error_type (line 29) | enum osqp_error_type
FILE: common/thirdparty/osqp/include/glob_opts.h
type c_int (line 80) | typedef long long c_int;
type c_int (line 82) | typedef int c_int;
type c_float (line 87) | typedef double c_float;
type c_float (line 89) | typedef float c_float;
FILE: common/thirdparty/osqp/include/lin_sys.h
type linsys_solver_type (line 17) | enum linsys_solver_type
type linsys_solver_type (line 25) | enum linsys_solver_type
type linsys_solver_type (line 47) | enum linsys_solver_type
FILE: common/thirdparty/osqp/include/types.h
type csc (line 21) | typedef struct {
type LinSysSolver (line 35) | typedef struct linsys_solver LinSysSolver;
type OSQPTimer (line 40) | typedef struct OSQP_TIMER OSQPTimer;
type OSQPScaling (line 45) | typedef struct {
type OSQPSolution (line 57) | typedef struct {
type OSQPInfo (line 66) | typedef struct {
type OSQPPolish (line 99) | typedef struct {
type OSQPData (line 125) | typedef struct {
type OSQPSettings (line 139) | typedef struct {
type OSQPWorkspace (line 182) | typedef struct {
type linsys_solver (line 298) | struct linsys_solver {
FILE: common/thirdparty/osqp/include/util.h
type OSQP_TIMER (line 103) | struct OSQP_TIMER {
type OSQP_TIMER (line 115) | struct OSQP_TIMER {
type OSQP_TIMER (line 129) | struct OSQP_TIMER {
FILE: common/thirdparty/osqp/lin_sys/direct/pardiso/pardiso_interface.c
function free_linsys_solver_pardiso (line 38) | void free_linsys_solver_pardiso(pardiso_solver *s) {
function c_int (line 73) | c_int init_linsys_solver_pardiso(pardiso_solver ** sp, const csc * P, co...
function c_int (line 231) | c_int solve_linsys_pardiso(pardiso_solver * s, c_float * b) {
function c_int (line 262) | c_int update_linsys_solver_matrices_pardiso(pardiso_solver * s, const cs...
function c_int (line 281) | c_int update_linsys_solver_rho_vec_pardiso(pardiso_solver * s, const c_f...
FILE: common/thirdparty/osqp/lin_sys/direct/pardiso/pardiso_interface.h
type pardiso_solver (line 16) | typedef struct pardiso pardiso_solver;
type pardiso (line 18) | struct pardiso {
FILE: common/thirdparty/osqp/lin_sys/direct/pardiso/pardiso_loader.c
function pardiso (line 35) | void pardiso(void** pt, const c_int* maxfct, const c_int* mnum,
function c_int (line 54) | c_int mkl_set_interface_layer(c_int code) {
function c_int (line 58) | c_int mkl_get_max_threads() {
function c_int (line 63) | c_int lh_load_pardiso(const char* libname) {
function c_int (line 90) | c_int lh_unload_pardiso() {
FILE: common/thirdparty/osqp/lin_sys/direct/qdldl/amd/include/SuiteSparse_config.h
type SuiteSparse_config_struct (line 77) | struct SuiteSparse_config_struct
type SuiteSparse_config_struct (line 93) | struct SuiteSparse_config_struct
FILE: common/thirdparty/osqp/lin_sys/direct/qdldl/amd/src/SuiteSparse_config.c
type SuiteSparse_config_struct (line 57) | struct SuiteSparse_config_struct
function SuiteSparse_tic (line 227) | void SuiteSparse_tic
function SuiteSparse_tic (line 241) | void SuiteSparse_tic
function c_float (line 265) | c_float SuiteSparse_toc /* returns time in seconds since last tic */
function c_float (line 282) | c_float SuiteSparse_time /* returns current wall clock time in seconds */
function SuiteSparse_version (line 297) | int SuiteSparse_version
function c_float (line 332) | c_float SuiteSparse_hypot (c_float x, c_float y)
function SuiteSparse_divcomplex (line 382) | int SuiteSparse_divcomplex
FILE: common/thirdparty/osqp/lin_sys/direct/qdldl/amd/src/amd_1.c
function GLOBAL (line 29) | GLOBAL void AMD_1
FILE: common/thirdparty/osqp/lin_sys/direct/qdldl/amd/src/amd_2.c
function Int (line 22) | static Int clear_flag (Int wflg, Int wbig, Int W [ ], Int n)
function GLOBAL (line 42) | GLOBAL void AMD_2
FILE: common/thirdparty/osqp/lin_sys/direct/qdldl/amd/src/amd_aat.c
function GLOBAL (line 20) | GLOBAL size_t AMD_aat /* returns nz in A+A' */
FILE: common/thirdparty/osqp/lin_sys/direct/qdldl/amd/src/amd_control.c
function GLOBAL (line 18) | GLOBAL void AMD_control
FILE: common/thirdparty/osqp/lin_sys/direct/qdldl/amd/src/amd_defaults.c
function GLOBAL (line 21) | GLOBAL void AMD_defaults
FILE: common/thirdparty/osqp/lin_sys/direct/qdldl/amd/src/amd_info.c
function GLOBAL (line 19) | GLOBAL void AMD_info
FILE: common/thirdparty/osqp/lin_sys/direct/qdldl/amd/src/amd_order.c
function GLOBAL (line 21) | GLOBAL Int AMD_order
FILE: common/thirdparty/osqp/lin_sys/direct/qdldl/amd/src/amd_post_tree.c
function GLOBAL (line 15) | GLOBAL Int AMD_post_tree
FILE: common/thirdparty/osqp/lin_sys/direct/qdldl/amd/src/amd_postorder.c
function GLOBAL (line 15) | GLOBAL void AMD_postorder
FILE: common/thirdparty/osqp/lin_sys/direct/qdldl/amd/src/amd_preprocess.c
function GLOBAL (line 29) | GLOBAL void AMD_preprocess
FILE: common/thirdparty/osqp/lin_sys/direct/qdldl/amd/src/amd_valid.c
function GLOBAL (line 38) | GLOBAL Int AMD_valid
FILE: common/thirdparty/osqp/lin_sys/direct/qdldl/qdldl_interface.c
function free_linsys_solver_qdldl (line 17) | void free_linsys_solver_qdldl(qdldl_solver *s) {
function c_int (line 53) | static c_int LDL_factor(csc *A, qdldl_solver * p, c_int nvar){
function c_int (line 106) | static c_int permute_KKT(csc ** KKT, qdldl_solver * p, c_int Pnz, c_int ...
function c_int (line 177) | c_int init_linsys_solver_qdldl(qdldl_solver ** sp, const csc * P, const ...
function permute_x (line 329) | void permute_x(c_int n, c_float * x, const c_float * b, const c_int * P) {
function permutet_x (line 335) | void permutet_x(c_int n, c_float * x, const c_float * b, const c_int * P) {
function LDLSolve (line 341) | static void LDLSolve(c_float *x, c_float *b, const csc *L, const c_float...
function c_int (line 381) | c_int update_linsys_solver_matrices_qdldl(qdldl_solver * s, const csc *P...
function c_int (line 396) | c_int update_linsys_solver_rho_vec_qdldl(qdldl_solver * s, const c_float...
FILE: common/thirdparty/osqp/lin_sys/direct/qdldl/qdldl_interface.h
type qdldl_solver (line 14) | typedef struct qdldl qdldl_solver;
type qdldl (line 16) | struct qdldl {
FILE: common/thirdparty/osqp/lin_sys/direct/qdldl/qdldl_sources/examples/example.c
function main (line 17) | int main()
function print_line (line 153) | void print_line(void){
function print_arrayi (line 157) | void print_arrayi(const QDLDL_int* data, QDLDL_int n,char* varName){
function print_arrayf (line 168) | void print_arrayf(const QDLDL_float* data, QDLDL_int n, char* varName){
FILE: common/thirdparty/osqp/lin_sys/direct/qdldl/qdldl_sources/src/qdldl.c
function QDLDL_int (line 11) | QDLDL_int QDLDL_etree(const QDLDL_int n,
function QDLDL_int (line 72) | QDLDL_int QDLDL_factor(const QDLDL_int n,
function QDLDL_Lsolve (line 236) | void QDLDL_Lsolve(const QDLDL_int n,
function QDLDL_Ltsolve (line 252) | void QDLDL_Ltsolve(const QDLDL_int n,
function QDLDL_solve (line 269) | void QDLDL_solve(const QDLDL_int n,
FILE: common/thirdparty/osqp/lin_sys/direct/qdldl/qdldl_sources/tests/qdldl_tester.c
function QDLDL_float (line 49) | QDLDL_float vec_diff_norm(QDLDL_float* x, QDLDL_float* y, QDLDL_int len){
function ldl_factor_solve (line 63) | int ldl_factor_solve(QDLDL_int An,
function main (line 164) | int main(void) {
FILE: common/thirdparty/osqp/lin_sys/lib_handler.c
function soHandle_t (line 7) | soHandle_t lh_load_lib(const char *libName) {
function c_int (line 38) | c_int lh_unload_lib (soHandle_t h) {
type FARPROC (line 53) | typedef FARPROC symtype;
function symtype (line 66) | symtype lh_load_sym (soHandle_t h, const char *symName) {
FILE: common/thirdparty/osqp/lin_sys/lib_handler.h
type HINSTANCE (line 8) | typedef HINSTANCE soHandle_t;
FILE: common/thirdparty/osqp/src/auxil.c
function c_float (line 13) | c_float compute_rho_estimate(OSQPWorkspace *work) {
function c_int (line 54) | c_int adapt_rho(OSQPWorkspace *work) {
function set_rho_vec (line 76) | void set_rho_vec(OSQPWorkspace *work) {
function c_int (line 100) | c_int update_rho_vec(OSQPWorkspace *work) {
function swap_vectors (line 147) | void swap_vectors(c_float **a, c_float **b) {
function cold_start (line 155) | void cold_start(OSQPWorkspace *work) {
function compute_rhs (line 161) | static void compute_rhs(OSQPWorkspace *work) {
function update_xz_tilde (line 177) | void update_xz_tilde(OSQPWorkspace *work) {
function update_x (line 185) | void update_x(OSQPWorkspace *work) {
function update_z (line 200) | void update_z(OSQPWorkspace *work) {
function update_y (line 214) | void update_y(OSQPWorkspace *work) {
function c_float (line 227) | c_float compute_obj_val(OSQPWorkspace *work, c_float *x) {
function c_float (line 240) | c_float compute_pri_res(OSQPWorkspace *work, c_float *x, c_float *z) {
function c_float (line 256) | c_float compute_pri_tol(OSQPWorkspace *work, c_float eps_abs, c_float ep...
function c_float (line 287) | c_float compute_dua_res(OSQPWorkspace *work, c_float *x, c_float *y) {
function c_float (line 320) | c_float compute_dua_tol(OSQPWorkspace *work, c_float eps_abs, c_float ep...
function c_int (line 361) | c_int is_primal_infeasible(OSQPWorkspace *work, c_float eps_prim_inf) {
function c_int (line 426) | c_int is_dual_infeasible(OSQPWorkspace *work, c_float eps_dual_inf) {
function c_int (line 514) | c_int has_solution(OSQPInfo * info){
function store_solution (line 524) | void store_solution(OSQPWorkspace *work) {
function reset_info (line 632) | void reset_info(OSQPInfo *info) {
function else (line 672) | else if (status_val == OSQP_TIME_LIMIT_REACHED) c_strcpy(info->status,
function c_int (line 791) | c_int validate_data(const OSQPData *data) {
function c_int (line 881) | c_int validate_linsys_solver(c_int linsys_solver) {
function c_int (line 893) | c_int validate_settings(const OSQPSettings *settings) {
FILE: common/thirdparty/osqp/src/cs.c
function csc (line 12) | csc* csc_matrix(c_int m, c_int n, c_int nzmax, c_float *x, c_int *i, c_i...
function csc (line 28) | csc* csc_spalloc(c_int m, c_int n, c_int nzmax, c_int values, c_int trip...
function csc_spfree (line 46) | void csc_spfree(csc *A) {
function csc (line 55) | csc* triplet_to_csc(const csc *T, c_int *TtoC) {
function csc (line 90) | csc* triplet_to_csr(const csc *T, c_int *TtoC) {
function c_int (line 125) | c_int csc_cumsum(c_int *p, c_int *c, c_int n) {
function c_int (line 140) | c_int* csc_pinv(c_int const *p, c_int n) {
function csc (line 153) | csc* csc_symperm(const csc *A, const c_int *pinv, c_int *AtoC, c_int val...
function csc (line 208) | csc* copy_csc_mat(const csc *A) {
function prea_copy_csc_mat (line 220) | void prea_copy_csc_mat(const csc *A, csc *B) {
function csc (line 228) | csc* csc_done(csc *C, void *w, void *x, c_int ok) {
function csc (line 238) | csc* csc_to_triu(csc *M) {
FILE: common/thirdparty/osqp/src/ctrlc.c
function osqp_start_interrupt_listener (line 16) | void osqp_start_interrupt_listener(void) {
function osqp_end_interrupt_listener (line 20) | void osqp_end_interrupt_listener(void) {
function osqp_is_interrupted (line 24) | int osqp_is_interrupted(void) {
function BOOL (line 31) | static BOOL WINAPI handle_ctrlc(DWORD dwCtrlType) {
function osqp_start_interrupt_listener (line 38) | void osqp_start_interrupt_listener(void) {
function osqp_end_interrupt_listener (line 43) | void osqp_end_interrupt_listener(void) {
function osqp_is_interrupted (line 47) | int osqp_is_interrupted(void) {
type sigaction (line 55) | struct sigaction
function handle_ctrlc (line 56) | static void handle_ctrlc(int dummy) {
function osqp_start_interrupt_listener (line 60) | void osqp_start_interrupt_listener(void) {
function osqp_end_interrupt_listener (line 70) | void osqp_end_interrupt_listener(void) {
function osqp_is_interrupted (line 76) | int osqp_is_interrupted(void) {
FILE: common/thirdparty/osqp/src/error.c
function c_int (line 14) | c_int _osqp_error(enum osqp_error_type error_code,
FILE: common/thirdparty/osqp/src/kkt.c
function csc (line 6) | csc* form_KKT(const csc *P,
function update_KKT_P (line 184) | void update_KKT_P(csc *KKT,
function update_KKT_A (line 205) | void update_KKT_A(csc *KKT, const csc *A, const c_int *AtoKKT) {
function update_KKT_param2 (line 214) | void update_KKT_param2(csc *KKT, const c_float *param2,
FILE: common/thirdparty/osqp/src/lin_alg.c
function vec_add_scaled (line 7) | void vec_add_scaled(c_float *c,
function c_float (line 19) | c_float vec_scaled_norm_inf(const c_float *S, const c_float *v, c_int l) {
function c_float (line 32) | c_float vec_norm_inf(const c_float *v, c_int l) {
function c_float (line 45) | c_float vec_norm_inf_diff(const c_float *a, const c_float *b, c_int l) {
function c_float (line 57) | c_float vec_mean(const c_float *a, c_int n) {
function int_vec_set_scalar (line 69) | void int_vec_set_scalar(c_int *a, c_int sc, c_int n) {
function vec_set_scalar (line 77) | void vec_set_scalar(c_float *a, c_float sc, c_int n) {
function vec_add_scalar (line 85) | void vec_add_scalar(c_float *a, c_float sc, c_int n) {
function vec_mult_scalar (line 93) | void vec_mult_scalar(c_float *a, c_float sc, c_int n) {
function c_float (line 102) | c_float* vec_copy(c_float *a, c_int n) {
function prea_int_vec_copy (line 119) | void prea_int_vec_copy(const c_int *a, c_int *b, c_int n) {
function prea_vec_copy (line 127) | void prea_vec_copy(const c_float *a, c_float *b, c_int n) {
function vec_ew_recipr (line 135) | void vec_ew_recipr(const c_float *a, c_float *b, c_int n) {
function c_float (line 143) | c_float vec_prod(const c_float *a, const c_float *b, c_int n) {
function vec_ew_prod (line 154) | void vec_ew_prod(const c_float *a, const c_float *b, c_float *c, c_int n) {
function vec_ew_sqrt (line 163) | void vec_ew_sqrt(c_float *a, c_int n) {
function vec_ew_max (line 171) | void vec_ew_max(c_float *a, c_int n, c_float max_val) {
function vec_ew_min (line 179) | void vec_ew_min(c_float *a, c_int n, c_float min_val) {
function vec_ew_max_vec (line 187) | void vec_ew_max_vec(const c_float *a, const c_float *b, c_float *c, c_in...
function vec_ew_min_vec (line 195) | void vec_ew_min_vec(const c_float *a, const c_float *b, c_float *c, c_in...
function mat_mult_scalar (line 209) | void mat_mult_scalar(csc *A, c_float sc) {
function mat_premult_diag (line 219) | void mat_premult_diag(csc *A, const c_float *d) {
function mat_postmult_diag (line 230) | void mat_postmult_diag(csc *A, const c_float *d) {
function mat_vec (line 241) | void mat_vec(const csc *A, const c_float *x, c_float *y, c_int plus_eq) {
function mat_tpose_vec (line 273) | void mat_tpose_vec(const csc *A, const c_float *x, c_float *y,
function mat_inf_norm_cols (line 325) | void mat_inf_norm_cols(const csc *M, c_float *E) {
function mat_inf_norm_rows (line 341) | void mat_inf_norm_rows(const csc *M, c_float *E) {
function mat_inf_norm_cols_sym_triu (line 358) | void mat_inf_norm_cols_sym_triu(const csc *M, c_float *E) {
function c_float (line 387) | c_float quad_form(const csc *P, const c_float *x) {
FILE: common/thirdparty/osqp/src/lin_sys.c
function c_int (line 15) | c_int load_linsys_solver(enum linsys_solver_type linsys_solver) {
function c_int (line 35) | c_int unload_linsys_solver(enum linsys_solver_type linsys_solver) {
function c_int (line 56) | c_int init_linsys_solver(LinSysSolver **s,
FILE: common/thirdparty/osqp/src/osqp.c
function osqp_set_default_settings (line 24) | void osqp_set_default_settings(OSQPSettings *settings) {
function c_int (line 76) | c_int osqp_setup(OSQPWorkspace** workp, const OSQPData *data, const OSQP...
function c_int (line 288) | c_int osqp_solve(OSQPWorkspace *work) {
function c_int (line 646) | c_int osqp_cleanup(OSQPWorkspace *work) {
function c_int (line 752) | c_int osqp_update_lin_cost(OSQPWorkspace *work, const c_float *q_new) {
function c_int (line 784) | c_int osqp_update_bounds(OSQPWorkspace *work,
function c_int (line 835) | c_int osqp_update_lower_bound(OSQPWorkspace *work, const c_float *l_new) {
function c_int (line 882) | c_int osqp_update_upper_bound(OSQPWorkspace *work, const c_float *u_new) {
function c_int (line 929) | c_int osqp_warm_start(OSQPWorkspace *work, const c_float *x, const c_flo...
function c_int (line 954) | c_int osqp_warm_start_x(OSQPWorkspace *work, const c_float *x) {
function c_int (line 976) | c_int osqp_warm_start_y(OSQPWorkspace *work, const c_float *y) {
function c_int (line 999) | c_int osqp_update_P(OSQPWorkspace *work,
function c_int (line 1079) | c_int osqp_update_A(OSQPWorkspace *work,
function c_int (line 1158) | c_int osqp_update_P_A(OSQPWorkspace *work,
function c_int (line 1268) | c_int osqp_update_rho(OSQPWorkspace *work, c_float rho_new) {
function c_int (line 1326) | c_int osqp_update_max_iter(OSQPWorkspace *work, c_int max_iter_new) {
function c_int (line 1345) | c_int osqp_update_eps_abs(OSQPWorkspace *work, c_float eps_abs_new) {
function c_int (line 1364) | c_int osqp_update_eps_rel(OSQPWorkspace *work, c_float eps_rel_new) {
function c_int (line 1383) | c_int osqp_update_eps_prim_inf(OSQPWorkspace *work, c_float eps_prim_inf...
function c_int (line 1402) | c_int osqp_update_eps_dual_inf(OSQPWorkspace *work, c_float eps_dual_inf...
function c_int (line 1422) | c_int osqp_update_alpha(OSQPWorkspace *work, c_float alpha_new) {
function c_int (line 1441) | c_int osqp_update_warm_start(OSQPWorkspace *work, c_int warm_start_new) {
function c_int (line 1460) | c_int osqp_update_scaled_termination(OSQPWorkspace *work, c_int scaled_t...
function c_int (line 1479) | c_int osqp_update_check_termination(OSQPWorkspace *work, c_int check_ter...
function c_int (line 1500) | c_int osqp_update_delta(OSQPWorkspace *work, c_float delta_new) {
function c_int (line 1519) | c_int osqp_update_polish(OSQPWorkspace *work, c_int polish_new) {
function c_int (line 1544) | c_int osqp_update_polish_refine_iter(OSQPWorkspace *work, c_int polish_r...
function c_int (line 1563) | c_int osqp_update_verbose(OSQPWorkspace *work, c_int verbose_new) {
function c_int (line 1586) | c_int osqp_update_time_limit(OSQPWorkspace *work, c_float time_limit_new) {
FILE: common/thirdparty/osqp/src/polish.c
function c_int (line 19) | static c_int form_Ared(OSQPWorkspace *work) {
function form_rhs_red (line 105) | static void form_rhs_red(OSQPWorkspace *work, c_float *rhs) {
function c_int (line 134) | static c_int iterative_refinement(OSQPWorkspace *work,
function get_ypol_from_yred (line 188) | static void get_ypol_from_yred(OSQPWorkspace *work, c_float *yred) {
function c_int (line 212) | c_int polish(OSQPWorkspace *work) {
FILE: common/thirdparty/osqp/src/proj.c
function project (line 4) | void project(OSQPWorkspace *work, c_float *z) {
function project_normalcone (line 16) | void project_normalcone(OSQPWorkspace *work, c_float *z, c_float *y) {
FILE: common/thirdparty/osqp/src/scaling.c
function limit_scaling (line 7) | void limit_scaling(c_float *D, c_int n) {
function compute_inf_norm_cols_KKT (line 28) | void compute_inf_norm_cols_KKT(const csc *P, const csc *A,
function c_int (line 44) | c_int scale_data(OSQPWorkspace *work) {
function c_int (line 160) | c_int unscale_data(OSQPWorkspace *work) {
function c_int (line 177) | c_int unscale_solution(OSQPWorkspace *work) {
FILE: common/thirdparty/osqp/src/util.c
function c_strcpy (line 20) | void c_strcpy(char dest[], const char source[]) {
function print_line (line 33) | static void print_line(void) {
function print_header (line 42) | void print_header(void) {
function print_setup_header (line 58) | void print_setup_header(const OSQPWorkspace *work) {
function print_summary (line 152) | void print_summary(OSQPWorkspace *work) {
function print_polish (line 177) | void print_polish(OSQPWorkspace *work) {
function print_footer (line 208) | void print_footer(OSQPInfo *info, c_int polish) {
function OSQPSettings (line 243) | OSQPSettings* copy_settings(const OSQPSettings *settings) {
function osqp_tic (line 296) | void osqp_tic(OSQPTimer *t)
function c_float (line 302) | c_float osqp_toc(OSQPTimer *t)
function osqp_tic (line 311) | void osqp_tic(OSQPTimer *t)
function c_float (line 317) | c_float osqp_toc(OSQPTimer *t)
function osqp_tic (line 336) | void osqp_tic(OSQPTimer *t)
function c_float (line 342) | c_float osqp_toc(OSQPTimer *t)
function print_csc_matrix (line 372) | void print_csc_matrix(csc *M, const char *name)
function dump_csc_matrix (line 393) | void dump_csc_matrix(csc *M, const char *file_name) {
function print_trip_matrix (line 419) | void print_trip_matrix(csc *M, const char *name)
function print_dns_matrix (line 431) | void print_dns_matrix(c_float *M, c_int m, c_int n, const char *name)
function print_vec (line 455) | void print_vec(c_float *v, c_int n, const char *name) {
function dump_vec (line 459) | void dump_vec(c_float *v, c_int len, const char *file_name) {
function print_vec_int (line 474) | void print_vec_int(c_int *x, c_int n, const char *name) {
FILE: common/thirdparty/osqp/tests/custom_memory/custom_memory.c
function my_free (line 29) | void my_free(void *ptr) {
FILE: common/thirdparty/osqp/tests/osqp_tester.c
function main (line 42) | int main(void) {
FILE: common/thirdparty/osqp/tests/osqp_tester.h
function c_float (line 5) | c_float* csc_to_dns(csc *M)
function c_int (line 30) | c_int is_eq_csc(csc *A, csc *B, c_float tol) {
FILE: common/thirdparty/osqp/tests/utils/codegen_utils.py
function write_int (line 8) | def write_int(f, x, name, *args):
function write_float (line 17) | def write_float(f, x, name, *args):
function write_vec_int (line 26) | def write_vec_int(f, x, name, *args):
function write_vec_float (line 42) | def write_vec_float(f, x, name, *args):
function clean_vec (line 63) | def clean_vec(f, name, *args):
function write_mat_sparse (line 73) | def write_mat_sparse(f, A, name, *args):
function clean_mat (line 141) | def clean_mat(f, name, *args):
function generate_problem_data (line 172) | def generate_problem_data(P, q, A, l, u, problem_name, sols_data={}):
function generate_data (line 351) | def generate_data(problem_name, sols_data):
FILE: common/utils/boxcar_filter.h
function namespace (line 12) | namespace common {
FILE: common/utils/color_map.cc
type common (line 12) | namespace common {
function ColorRGBA (line 38) | ColorRGBA ColorMap::at(const Color color, const double a) {
FILE: common/utils/color_map.h
function namespace (line 14) | namespace common {
FILE: common/utils/common_visual.cc
type common (line 12) | namespace common {
FILE: common/utils/common_visual.h
function namespace (line 14) | namespace common {
FILE: common/utils/contains.hpp
type std_enhancement (line 7) | namespace std_enhancement {
function contains_impl (line 10) | inline auto contains_impl(const C& c, const T& x, int)
function contains_impl (line 16) | inline bool contains_impl(const C& v, const T& x, long) {
function contains (line 21) | auto contains(const C& c, const T& x) -> decltype(end(c), true) {
FILE: common/utils/io_utils.cc
type common (line 10) | namespace common {
function DotLog (line 12) | void DotLog(std::ofstream& os) { os << std::endl; }
FILE: common/utils/io_utils.h
function namespace (line 13) | namespace common {
FILE: common/utils/math.cc
type common (line 13) | namespace common {
function NormalizeAngle (line 15) | double NormalizeAngle(const double angle) {
function InterpolateAngle (line 24) | double InterpolateAngle(const double a0, const double t0, const double...
function RandomInt (line 43) | int RandomInt(const int size) {
function RandomDouble (line 50) | double RandomDouble(const double lb, const double ub) {
function Curvature (line 56) | double Curvature(const double dx, const double d2x, const double dy,
function CurvatureDerivative (line 66) | double CurvatureDerivative(const double dx, const double d2x, const do...
FILE: common/utils/math.h
function namespace (line 10) | namespace common {
FILE: common/utils/str_utils.h
function namespace (line 10) | namespace common {
FILE: common/utils/timer.h
function namespace (line 16) | namespace common {
FILE: gp_planner/gp/factors/gp_interpolate_kappa_limit_factor.cc
type planning (line 13) | namespace planning {
FILE: gp_planner/gp/factors/gp_interpolate_kappa_limit_factor.h
function namespace (line 15) | namespace planning {
FILE: gp_planner/gp/factors/gp_interpolate_obstacle_factor.cc
type planning (line 12) | namespace planning {
FILE: gp_planner/gp/factors/gp_interpolate_obstacle_factor.h
function namespace (line 15) | namespace planning {
FILE: gp_planner/gp/factors/gp_kappa_limit_factor.cc
type planning (line 13) | namespace planning {
FILE: gp_planner/gp/factors/gp_kappa_limit_factor.h
function namespace (line 14) | namespace planning {
FILE: gp_planner/gp/factors/gp_lat_acc_limit_factor.cc
type planning (line 10) | namespace planning {
FILE: gp_planner/gp/factors/gp_lat_acc_limit_factor.h
function namespace (line 12) | namespace planning {
FILE: gp_planner/gp/factors/gp_obstacle_factor.cc
type planning (line 12) | namespace planning {
FILE: gp_planner/gp/factors/gp_obstacle_factor.h
function namespace (line 13) | namespace planning {
FILE: gp_planner/gp/factors/gp_prior_factor.cc
type planning (line 10) | namespace planning {
FILE: gp_planner/gp/factors/gp_prior_factor.h
function namespace (line 13) | namespace planning {
FILE: gp_planner/gp/gp_incremental_path_planner.cc
type planning (line 25) | namespace planning {
type PathCandidate (line 44) | struct PathCandidate {
method Expand (line 51) | std::unique_ptr<PathCandidate> Expand(int selection) {
FILE: gp_planner/gp/gp_incremental_path_planner.h
function namespace (line 17) | namespace planning {
FILE: gp_planner/gp/interpolator/gp_interpolator.h
function namespace (line 14) | namespace planning {
FILE: gp_planner/gp/model/white_noise_on_acceleration_model_1d.h
function namespace (line 12) | namespace planning {
FILE: gp_planner/gp/model/white_noise_on_jerk_model_1d.h
function namespace (line 13) | namespace planning {
FILE: gp_planner/gp/utils/bounded_penalty_function.h
function namespace (line 13) | namespace planning {
FILE: gp_planner/gp/utils/curvature_utils.h
function namespace (line 12) | namespace planning {
FILE: gp_planner/gp/utils/gp_path.cc
type planning (line 13) | namespace planning {
FILE: gp_planner/gp/utils/gp_path.h
function namespace (line 16) | namespace planning {
FILE: gp_planner/gp/utils/gp_utils.cc
type planning (line 10) | namespace planning {
FILE: gp_planner/gp/utils/gp_utils.h
function namespace (line 13) | namespace planning {
FILE: gp_planner/gp/utils/penalty_function.h
function namespace (line 12) | namespace planning {
FILE: gp_planner/gp_planner.cc
type planning (line 21) | namespace planning {
FILE: gp_planner/gp_planner.h
function namespace (line 17) | namespace planning {
FILE: gp_planner/initializer/gp_initializer.cc
type planning (line 12) | namespace planning {
FILE: gp_planner/initializer/gp_initializer.h
function namespace (line 15) | namespace planning {
FILE: gp_planner/sdf/grid_map_2d.cc
type planning (line 10) | namespace planning {
class GridMap2D<int> (line 81) | class GridMap2D<int>
class GridMap2D<uint8_t> (line 82) | class GridMap2D<uint8_t>
FILE: gp_planner/sdf/grid_map_2d.h
function namespace (line 23) | namespace planning {
function std (line 57) | inline std::vector<T>* mutable_data() { return &map_data_; }
FILE: gp_planner/sdf/signed_distance_field_2d.cc
type planning (line 15) | namespace planning {
FILE: gp_planner/sdf/signed_distance_field_2d.h
function namespace (line 15) | namespace planning {
function set_origin (line 85) | inline void SignedDistanceField2D::set_origin(std::array<double, 2> orig...
function set_resolution (line 90) | inline void SignedDistanceField2D::set_resolution(const double map_resol...
function set_cell_num (line 97) | inline void SignedDistanceField2D::set_cell_num(std::array<int, 2> cell_...
FILE: gp_planner/st_plan/st_graph.cc
type planning (line 21) | namespace planning {
FILE: gp_planner/st_plan/st_graph.h
function namespace (line 18) | namespace planning {
FILE: gp_planner/st_plan/st_node.cc
type planning (line 13) | namespace planning {
FILE: gp_planner/st_plan/st_node.h
function namespace (line 12) | namespace planning {
FILE: gp_planner/thirdparty/gtsam-4.1rc/CppUnitLite/Failure.h
function class (line 28) | class Failure
FILE: gp_planner/thirdparty/gtsam-4.1rc/CppUnitLite/Test.cpp
function Test (line 33) | Test *Test::getNext() const
FILE: gp_planner/thirdparty/gtsam-4.1rc/CppUnitLite/Test.h
function class (line 30) | class Test
FILE: gp_planner/thirdparty/gtsam-4.1rc/CppUnitLite/TestRegistry.cpp
function TestRegistry (line 33) | TestRegistry& TestRegistry::instance ()
FILE: gp_planner/thirdparty/gtsam-4.1rc/CppUnitLite/TestRegistry.h
function class (line 29) | class TestRegistry
FILE: gp_planner/thirdparty/gtsam-4.1rc/CppUnitLite/TestResult.h
function class (line 26) | class TestResult
FILE: gp_planner/thirdparty/gtsam-4.1rc/cmake/example_cmake_find_gtsam/main.cpp
function main (line 63) | int main(int argc, char** argv) {
FILE: gp_planner/thirdparty/gtsam-4.1rc/cmake/example_project/SayGoodbye.cpp
function main (line 20) | int main(int argc, char *argv[]) {
FILE: gp_planner/thirdparty/gtsam-4.1rc/cmake/example_project/SayHello.cpp
function main (line 20) | int main(int argc, char *argv[]) {
FILE: gp_planner/thirdparty/gtsam-4.1rc/cmake/example_project/example.h
function namespace (line 23) | namespace example {
FILE: gp_planner/thirdparty/gtsam-4.1rc/cmake/example_project/example/PrintExamples.cpp
type example (line 22) | namespace example {
type internal (line 32) | namespace internal {
function getHelloString (line 34) | std::string getHelloString() {
function getGoodbyeString (line 38) | std::string getGoodbyeString() {
FILE: gp_planner/thirdparty/gtsam-4.1rc/cmake/example_project/example/PrintExamples.h
function namespace (line 23) | namespace example {
FILE: gp_planner/thirdparty/gtsam-4.1rc/cmake/example_project/tests/testExample.cpp
function TEST (line 26) | TEST(Example, HelloString) {
function TEST (line 31) | TEST(Example, GoodbyeString) {
function main (line 37) | int main() {
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/CCOLAMD/Demo/ccolamd_example.c
function main (line 47) | int main (void)
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/CCOLAMD/Demo/ccolamd_l_example.c
function main (line 47) | int main (void)
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/CCOLAMD/MATLAB/ccolamdmex.c
function mexFunction (line 33) | void mexFunction
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/CCOLAMD/MATLAB/ccolamdtestmex.c
function dump_matrix (line 60) | static void dump_matrix
function mexFunction (line 91) | void mexFunction
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/CCOLAMD/MATLAB/csymamdmex.c
function mexFunction (line 32) | void mexFunction
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/CCOLAMD/MATLAB/csymamdtestmex.c
function dump_matrix (line 46) | static void dump_matrix
function mexFunction (line 89) | void mexFunction
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/CCOLAMD/Source/ccolamd.c
type CColamd_Col (line 658) | typedef struct CColamd_Col_struct
type CColamd_Row (line 697) | typedef struct CColamd_Row_struct
function t_add (line 1016) | static size_t t_add (size_t a, size_t b, int *ok)
function t_mult (line 1023) | static size_t t_mult (size_t a, size_t k, int *ok)
function ccolamd_need (line 1047) | static size_t ccolamd_need (Int nnz, Int n_row, Int n_col, int *ok)
function PUBLIC (line 1083) | PUBLIC size_t CCOLAMD_recommended /* returns recommended value of Alen. */
function PUBLIC (line 1114) | PUBLIC void CCOLAMD_set_defaults
function PUBLIC (line 1144) | PUBLIC Int CSYMAMD_MAIN /* return TRUE if OK, FALSE otherwise */
function PUBLIC (line 1476) | PUBLIC Int CCOLAMD_MAIN
function PUBLIC (line 1505) | PUBLIC Int CCOLAMD_2 /* returns TRUE if successful, FALSE otherwise */
function PUBLIC (line 1972) | PUBLIC void CCOLAMD_report
function PUBLIC (line 1985) | PUBLIC void CSYMAMD_report
function PRIVATE (line 2014) | PRIVATE Int init_rows_cols /* returns TRUE if OK, or FALSE otherwise */
function PRIVATE (line 2259) | PRIVATE void init_scoring
function PRIVATE (line 2545) | PRIVATE Int find_ordering /* return the number of garbage collections */
function PRIVATE (line 3545) | PRIVATE Int garbage_collection /* returns the new value of pfree */
function PRIVATE (line 3677) | PRIVATE Int clear_mark /* return the new value for tag_mark */
function PRIVATE (line 3714) | PRIVATE void print_report
function GLOBAL (line 3872) | GLOBAL void CCOLAMD_apply_order
function GLOBAL (line 3909) | GLOBAL void CCOLAMD_fsize
function GLOBAL (line 3969) | GLOBAL void CCOLAMD_postorder
function GLOBAL (line 4156) | GLOBAL Int CCOLAMD_post_tree
function PRIVATE (line 4273) | PRIVATE void debug_structures
function PRIVATE (line 4363) | PRIVATE void debug_deg_lists
function PRIVATE (line 4439) | PRIVATE void debug_mark
function PRIVATE (line 4473) | PRIVATE void debug_matrix
function PRIVATE (line 4546) | PRIVATE void dump_super
function PRIVATE (line 4581) | PRIVATE void ccolamd_get_debug
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/Eigen/Eigen/src/Cholesky/LDLT.h
function namespace (line 16) | namespace Eigen {
function namespace (line 287) | namespace internal {
function Upper (line 454) | struct ldlt_inplace<Upper>
type TriangularView (line 474) | typedef const TriangularView<const typename
function MatrixL (line 475) | static inline MatrixL getL(const MatrixType& m) { return MatrixL(m); }
function MatrixU (line 476) | static inline MatrixU getU(const MatrixType& m) { return MatrixU(m.adjoi...
type TriangularView (line 482) | typedef const TriangularView<const MatrixType, UnitUpper> MatrixU;
function MatrixL (line 483) | static inline MatrixL getL(const MatrixType& m) { return MatrixL(m.adjoi...
function MatrixU (line 484) | static inline MatrixU getU(const MatrixType& m) { return MatrixU(m); }
type typename (line 535) | typedef typename TranspositionType::StorageIndex IndexType;
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/Eigen/Eigen/src/Cholesky/LLT.h
function namespace (line 13) | namespace Eigen {
function namespace (line 228) | namespace internal {
type typename (line 372) | typedef typename NumTraits<Scalar>::Real RealScalar;
type TriangularView (line 397) | typedef const TriangularView<const typename
function MatrixL (line 398) | static inline MatrixL getL(const MatrixType& m) { return MatrixL(m); }
function MatrixU (line 399) | static inline MatrixU getU(const MatrixType& m) { return MatrixU(m.adjoi...
function inplace_decomposition (line 400) | static bool inplace_decomposition(MatrixType& m)
type TriangularView (line 407) | typedef const TriangularView<const MatrixType, Upper> MatrixU;
function MatrixL (line 408) | static inline MatrixL getL(const MatrixType& m) { return MatrixL(m.adjoi...
function MatrixU (line 409) | static inline MatrixU getU(const MatrixType& m) { return MatrixU(m); }
function inplace_decomposition (line 410) | static bool inplace_decomposition(MatrixType& m)
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/Eigen/Eigen/src/Cholesky/LLT_LAPACKE.h
function namespace (line 36) | namespace Eigen {
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/Eigen/Eigen/src/CholmodSupport/CholmodSupport.h
function namespace (line 13) | namespace Eigen {
function cholmod_sparse (line 105) | cholmod_sparse viewAsCholmod(const SparseMatrix<_Scalar,_Options,_Index>...
function cholmod_sparse (line 112) | cholmod_sparse viewAsCholmod(const SparseVector<_Scalar,_Options,_Index>...
type typename (line 137) | typedef typename Derived::Scalar Scalar;
type CholmodMode (line 162) | enum CholmodMode {
type typename (line 182) | typedef typename MatrixType::Scalar Scalar;
type typename (line 183) | typedef typename MatrixType::RealScalar RealScalar;
type MatrixType (line 184) | typedef MatrixType CholMatrixType;
type typename (line 185) | typedef typename MatrixType::StorageIndex StorageIndex;
function StorageIndex (line 217) | inline StorageIndex cols() const { return internal::convert_index<Storag...
function analyzePattern (line 245) | void analyzePattern(const MatrixType& matrix)
function factorize (line 267) | void factorize(const MatrixType& matrix)
function Scalar (line 348) | Scalar determinant() const
function Base (line 445) | CholmodSimplicialLLT(const MatrixType& matrix) : Base()
function Base (line 496) | CholmodSimplicialLDLT(const MatrixType& matrix) : Base()
function Base (line 545) | CholmodSupernodalLLT(const MatrixType& matrix) : Base()
function Base (line 596) | CholmodDecomposition(const MatrixType& matrix) : Base()
function setMode (line 604) | void setMode(CholmodMode mode)
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/Eigen/Eigen/src/Core/Array.h
function namespace (line 13) | namespace Eigen {
function enum (line 51) | EIGEN_DENSE_PUBLIC_INTERFACE(Array)
function EIGEN_DEVICE_FUNC (line 141) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 151) | EIGEN_DEVICE_FUNC
function EIGEN_STRONG_INLINE (line 168) | EIGEN_STRONG_INLINE explicit Array(const T& x)
function EIGEN_STRONG_INLINE (line 176) | EIGEN_STRONG_INLINE Array(const T0& val0, const T1& val1)
function Base (line 228) | Array(const Array& other)
type PrivateType (line 233) | struct PrivateType {}
function EIGEN_STRONG_INLINE (line 239) | EIGEN_STRONG_INLINE Array(const EigenBase<OtherDerived> &other,
type internal (line 255) | struct internal
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/Eigen/Eigen/src/Core/ArrayBase.h
function namespace (line 13) | namespace Eigen {
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/Eigen/Eigen/src/Core/ArrayWrapper.h
function namespace (line 13) | namespace Eigen {
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/Eigen/Eigen/src/Core/Assign.h
function namespace (line 15) | namespace Eigen {
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/Eigen/Eigen/src/Core/AssignEvaluator.h
function namespace (line 15) | namespace Eigen {
type typename (line 347) | typedef typename Kernel::DstEvaluatorType::XprType DstXprType;
type unaligned_dense_assignment_loop (line 372) | struct unaligned_dense_assignment_loop
type typename (line 400) | typedef typename Kernel::Scalar Scalar;
type typename (line 401) | typedef typename Kernel::PacketType PacketType;
type typename (line 427) | typedef typename Kernel::DstEvaluatorType::XprType DstXprType;
type typename (line 428) | typedef typename Kernel::PacketType PacketType;
function run (line 451) | void run(Kernel &kernel)
type typename (line 467) | typedef typename Kernel::DstEvaluatorType::XprType DstXprType;
type typename (line 477) | typedef typename Kernel::DstEvaluatorType::XprType DstXprType;
type typename (line 478) | typedef typename Kernel::AssignmentTraits Traits;
type typename (line 506) | typedef typename Kernel::DstEvaluatorType::XprType DstXprType;
type typename (line 520) | typedef typename Kernel::Scalar Scalar;
type typename (line 521) | typedef typename Kernel::PacketType PacketType;
type typename (line 568) | typedef typename Kernel::DstEvaluatorType::XprType DstXprType;
type typename (line 569) | typedef typename Kernel::PacketType PacketType;
type typename (line 600) | typedef typename SrcEvaluatorTypeT::XprType SrcXprType;
type SrcEvaluatorTypeT (line 604) | typedef SrcEvaluatorTypeT SrcEvaluatorType;
type typename (line 605) | typedef typename DstEvaluatorType::Scalar Scalar;
type copy_using_evaluator_traits (line 606) | typedef copy_using_evaluator_traits<DstEvaluatorTypeT, SrcEvaluatorTypeT...
type typename (line 607) | typedef typename AssignmentTraits::PacketType PacketType;
function EIGEN_DEVICE_FUNC (line 625) | EIGEN_DEVICE_FUNC DstEvaluatorType& dstEvaluator() { return m_dst; }
function assignCoeff (line 629) | void assignCoeff(Index row, Index col)
function assignCoeff (line 635) | void assignCoeff(Index index)
function assignCoeffByOuterInner (line 641) | void assignCoeffByOuterInner(Index outer, Index inner)
function assignPacket (line 650) | void assignPacket(Index row, Index col)
function assignPacket (line 656) | void assignPacket(Index index)
function assignPacketByOuterInner (line 662) | void assignPacketByOuterInner(Index outer, Index inner)
function Index (line 669) | Index rowIndexByOuterInner(Index outer, Index inner)
function Index (line 678) | Index colIndexByOuterInner(Index outer, Index inner)
function EIGEN_DEVICE_FUNC (line 687) | EIGEN_DEVICE_FUNC const Scalar* dstDataPtr() const
function resize_if_allowed (line 706) | void resize_if_allowed(DstXprType &dst, const SrcXprType& src, const Fun...
type evaluator (line 728) | typedef evaluator<SrcXprType> SrcEvaluatorType;
type generic_dense_assignment_kernel (line 738) | typedef generic_dense_assignment_kernel<DstEvaluatorType,SrcEvaluatorTyp...
function call_dense_assignment_loop (line 745) | void call_dense_assignment_loop(DstXprType& dst, const SrcXprType& src)
type Dense2Dense (line 760) | struct Dense2Dense {}
type EigenBase2EigenBase (line 761) | struct EigenBase2EigenBase {}
type EigenBase2EigenBase (line 763) | typedef EigenBase2EigenBase Kind;
type AssignmentKind (line 764) | struct AssignmentKind
type Dense2Dense (line 764) | typedef Dense2Dense Kind;
function call_assignment (line 780) | void call_assignment(Dst& dst, const Src& src)
function call_assignment (line 786) | void call_assignment(const Dst& dst, const Src& src)
function call_assignment_no_alias (line 819) | void call_assignment_no_alias(Dst& dst, const Src& src, const Func& func)
function call_assignment_no_alias (line 840) | void call_assignment_no_alias(Dst& dst, const Src& src)
function call_assignment_no_alias_no_transpose (line 847) | void call_assignment_no_alias_no_transpose(Dst& dst, const Src& src, con...
function call_assignment_no_alias_no_transpose (line 858) | void call_assignment_no_alias_no_transpose(Dst& dst, const Src& src)
type Assignment (line 888) | struct Assignment
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/Eigen/Eigen/src/Core/Assign_MKL.h
function namespace (line 37) | namespace Eigen {
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/Eigen/Eigen/src/Core/BandMatrix.h
function namespace (line 13) | namespace Eigen {
type typename (line 103) | typedef typename internal::conditional<Conjugate,
function typename (line 115) | const typename DiagonalIntReturnType<N>::Type diagonal() const
function DenseMatrixType (line 145) | DenseMatrixType toDenseMatrix() const
type Dense (line 181) | typedef Dense StorageKind;
type Eigen (line 182) | typedef Eigen::Index StorageIndex;
type Matrix (line 195) | typedef Matrix<Scalar,DataRowsAtCompileTime,ColsAtCompileTime,Options
type typename (line 203) | typedef typename internal::traits<BandMatrix>::Scalar Scalar;
type typename (line 204) | typedef typename internal::traits<BandMatrix>::StorageIndex StorageIndex;
type typename (line 205) | typedef typename internal::traits<BandMatrix>::CoefficientsType Coeffici...
function CoefficientsType (line 226) | inline CoefficientsType& coeffs() { return m_coeffs; }
type typename (line 243) | typedef typename _CoefficientsType::StorageKind StorageKind;
type typename (line 244) | typedef typename _CoefficientsType::StorageIndex StorageIndex;
type _CoefficientsType (line 257) | typedef _CoefficientsType CoefficientsType;
type typename (line 266) | typedef typename internal::traits<BandMatrixWrapper>::CoefficientsType C...
type typename (line 267) | typedef typename internal::traits<BandMatrixWrapper>::StorageIndex Stora...
type typename (line 315) | typedef typename Base::StorageIndex StorageIndex;
type BandShape (line 331) | struct BandShape {}
type AssignmentKind (line 347) | struct AssignmentKind
type EigenBase2EigenBase (line 347) | typedef EigenBase2EigenBase Kind;
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/Eigen/Eigen/src/Core/Block.h
function namespace (line 14) | namespace Eigen {
function EIGEN_DEVICE_FUNC (line 117) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 127) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 138) | EIGEN_DEVICE_FUNC
type typename (line 158) | typedef typename XprType::StorageIndex StorageIndex;
function Impl (line 162) | inline BlockImpl(XprType& xpr, Index i) : Impl(xpr,i) {}
function EIGEN_DEVICE_FUNC (line 163) | EIGEN_DEVICE_FUNC inline BlockImpl(XprType& xpr, Index startRow, Index s...
function EIGEN_DEVICE_FUNC (line 164) | EIGEN_DEVICE_FUNC
function namespace (line 169) | namespace internal {
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/Eigen/Eigen/src/Core/BooleanRedux.h
function namespace (line 13) | namespace Eigen {
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/Eigen/Eigen/src/Core/CommaInitializer.h
function namespace (line 14) | namespace Eigen {
function EIGEN_DEVICE_FUNC (line 116) | EIGEN_DEVICE_FUNC
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/Eigen/Eigen/src/Core/ConditionEstimator.h
function namespace (line 13) | namespace Eigen {
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/Eigen/Eigen/src/Core/CoreEvaluators.h
function namespace (line 16) | namespace Eigen {
function EIGEN_DEVICE_FUNC (line 241) | EIGEN_DEVICE_FUNC evaluator() {}
function EIGEN_DEVICE_FUNC (line 243) | EIGEN_DEVICE_FUNC explicit evaluator(const XprType& m)
function EIGEN_DEVICE_FUNC (line 254) | EIGEN_DEVICE_FUNC evaluator() {}
function EIGEN_DEVICE_FUNC (line 256) | EIGEN_DEVICE_FUNC explicit evaluator(const XprType& m)
function EIGEN_DEVICE_FUNC (line 275) | EIGEN_DEVICE_FUNC explicit unary_evaluator(const XprType& t) : m_argImpl...
type typename (line 277) | typedef typename XprType::Scalar Scalar;
type typename (line 278) | typedef typename XprType::CoeffReturnType CoeffReturnType;
function CoeffReturnType (line 281) | CoeffReturnType coeff(Index row, Index col) const
function CoeffReturnType (line 287) | CoeffReturnType coeff(Index index) const
function typename (line 299) | typename XprType::Scalar& coeffRef(Index index)
function PacketType (line 306) | PacketType packet(Index row, Index col) const
function PacketType (line 313) | PacketType packet(Index index) const
function writePacket (line 320) | void writePacket(Index row, Index col, const PacketType& x)
function writePacket (line 327) | void writePacket(Index index, const PacketType& x)
function EIGEN_STRONG_INLINE (line 349) | EIGEN_STRONG_INLINE Scalar operator()(const NullaryOp& op, IndexType i) ...
function EIGEN_STRONG_INLINE (line 351) | EIGEN_STRONG_INLINE T packetOp(const NullaryOp& op, IndexType i, IndexTy...
function EIGEN_STRONG_INLINE (line 352) | EIGEN_STRONG_INLINE T packetOp(const NullaryOp& op, IndexType i) const {...
function EIGEN_STRONG_INLINE (line 382) | EIGEN_STRONG_INLINE T packetOp(const NullaryOp& op, IndexType i, IndexTy...
function EIGEN_STRONG_INLINE (line 388) | EIGEN_STRONG_INLINE Scalar operator()(const NullaryOp& op, IndexType i) ...
function EIGEN_STRONG_INLINE (line 390) | EIGEN_STRONG_INLINE T packetOp(const NullaryOp& op, IndexType i) const {...
function EIGEN_STRONG_INLINE (line 430) | EIGEN_STRONG_INLINE Scalar operator()(const NullaryOp& op, IndexType i) ...
function EIGEN_STRONG_INLINE (line 438) | EIGEN_STRONG_INLINE T packetOp(const NullaryOp& op, IndexType i, IndexTy...
function EIGEN_STRONG_INLINE (line 445) | EIGEN_STRONG_INLINE T packetOp(const NullaryOp& op, IndexType i) const {
type typename (line 459) | typedef typename internal::remove_all<PlainObjectType>::type PlainObject...
function EIGEN_DEVICE_FUNC (line 472) | EIGEN_DEVICE_FUNC explicit evaluator(const XprType& n)
type typename (line 478) | typedef typename XprType::CoeffReturnType CoeffReturnType;
function EIGEN_STRONG_INLINE (line 481) | EIGEN_STRONG_INLINE
function EIGEN_STRONG_INLINE (line 488) | EIGEN_STRONG_INLINE
function PacketType (line 496) | PacketType packet(IndexType row, IndexType col) const
function PacketType (line 503) | PacketType packet(IndexType index) const
function explicit (line 530) | explicit unary_evaluator(const XprType& op)
type typename (line 538) | typedef typename XprType::CoeffReturnType CoeffReturnType;
function CoeffReturnType (line 541) | CoeffReturnType coeff(Index row, Index col) const
function CoeffReturnType (line 547) | CoeffReturnType coeff(Index index) const
function PacketType (line 554) | PacketType packet(Index row, Index col) const
function PacketType (line 561) | PacketType packet(Index index) const
type ternary_evaluator (line 579) | typedef ternary_evaluator<CwiseTernaryOp<TernaryOp, Arg1, Arg2, Arg3> > ...
function EIGEN_DEVICE_FUNC (line 581) | EIGEN_DEVICE_FUNC explicit evaluator(const XprType& xpr) : Base(xpr) {}
type typename (line 622) | typedef typename XprType::CoeffReturnType CoeffReturnType;
function CoeffReturnType (line 625) | CoeffReturnType coeff(Index row, Index col) const
function CoeffReturnType (line 631) | CoeffReturnType coeff(Index index) const
function PacketType (line 638) | PacketType packet(Index row, Index col) const
function PacketType (line 647) | PacketType packet(Index index) const
type binary_evaluator (line 669) | typedef binary_evaluator<CwiseBinaryOp<BinaryOp, Lhs, Rhs> > Base;
function EIGEN_DEVICE_FUNC (line 671) | EIGEN_DEVICE_FUNC explicit evaluator(const XprType& xpr) : Base(xpr) {}
type typename (line 708) | typedef typename XprType::CoeffReturnType CoeffReturnType;
function CoeffReturnType (line 711) | CoeffReturnType coeff(Index row, Index col) const
function CoeffReturnType (line 717) | CoeffReturnType coeff(Index index) const
function PacketType (line 724) | PacketType packet(Index row, Index col) const
function PacketType (line 732) | PacketType packet(Index index) const
function EIGEN_DEVICE_FUNC (line 760) | EIGEN_DEVICE_FUNC explicit unary_evaluator(const XprType& op)
type typename (line 768) | typedef typename XprType::Scalar Scalar;
type typename (line 769) | typedef typename XprType::CoeffReturnType CoeffReturnType;
function CoeffReturnType (line 772) | CoeffReturnType coeff(Index row, Index col) const
function CoeffReturnType (line 778) | CoeffReturnType coeff(Index index) const
type Derived (line 810) | typedef Derived XprType;
type typename (line 811) | typedef typename XprType::PointerType PointerType;
type typename (line 812) | typedef typename XprType::Scalar Scalar;
type typename (line 813) | typedef typename XprType::CoeffReturnType CoeffReturnType;
function CoeffReturnType (line 832) | CoeffReturnType coeff(Index row, Index col) const
function CoeffReturnType (line 838) | CoeffReturnType coeff(Index index) const
function PacketType (line 857) | PacketType packet(Index row, Index col) const
function PacketType (line 865) | PacketType packet(Index index) const
function writePacket (line 872) | void writePacket(Index row, Index col, const PacketType& x)
function writePacket (line 880) | void writePacket(Index index, const PacketType& x)
type typename (line 900) | typedef typename XprType::Scalar Scalar;
type typename (line 902) | typedef typename packet_traits<Scalar>::type PacketScalar;
function EIGEN_DEVICE_FUNC (line 923) | EIGEN_DEVICE_FUNC explicit evaluator(const XprType& map)
function EIGEN_DEVICE_FUNC (line 941) | EIGEN_DEVICE_FUNC explicit evaluator(const XprType& ref)
type typename (line 956) | typedef typename XprType::Scalar Scalar;
type typename (line 958) | typedef typename packet_traits<Scalar>::type PacketScalar;
type block_evaluator (line 995) | typedef block_evaluator<ArgType, BlockRows, BlockCols, InnerPanel> block...
function EIGEN_DEVICE_FUNC (line 996) | EIGEN_DEVICE_FUNC explicit evaluator(const XprType& block) : block_evalu...
function EIGEN_DEVICE_FUNC (line 1009) | EIGEN_DEVICE_FUNC explicit block_evaluator(const XprType& block)
function CoeffReturnType (line 1036) | CoeffReturnType coeff(Index row, Index col) const
function CoeffReturnType (line 1042) | CoeffReturnType coeff(Index index) const
function PacketType (line 1067) | PacketType packet(Index row, Index col) const
function PacketType (line 1074) | PacketType packet(Index index) const
function writePacket (line 1085) | void writePacket(Index row, Index col, const PacketType& x)
function writePacket (line 1092) | void writePacket(Index index, const PacketType& x)
type typename (line 1118) | typedef typename XprType::Scalar Scalar;
type typename (line 1156) | typedef typename XprType::CoeffReturnType CoeffReturnType;
function CoeffReturnType (line 1159) | CoeffReturnType coeff(Index row, Index col) const
function CoeffReturnType (line 1168) | CoeffReturnType coeff(Index index) const
type typename (line 1190) | typedef typename XprType::CoeffReturnType CoeffReturnType;
type typename (line 1194) | typedef typename internal::nested_eval<ArgType,Factor>::type ArgTypeNested;
type typename (line 1195) | typedef typename internal::remove_all<ArgTypeNested>::type ArgTypeNested...
function CoeffReturnType (line 1227) | CoeffReturnType coeff(Index index) const
function PacketType (line 1239) | PacketType packet(Index row, Index col) const
function PacketType (line 1253) | PacketType packet(Index index) const
type typename (line 1277) | typedef typename internal::nested_eval<ArgType,1>::type ArgTypeNested;
type typename (line 1278) | typedef typename internal::remove_all<ArgTypeNested>::type ArgTypeNested...
type typename (line 1279) | typedef typename ArgType::Scalar InputScalar;
type typename (line 1280) | typedef typename XprType::Scalar Scalar;
type typename (line 1284) | typedef typename MemberOp::template Cost<InputScalar,int(TraversalSize)>...
function EIGEN_DEVICE_FUNC (line 1294) | EIGEN_DEVICE_FUNC explicit evaluator(const XprType xpr)
type typename (line 1301) | typedef typename XprType::CoeffReturnType CoeffReturnType;
function Scalar (line 1304) | const Scalar coeff(Index i, Index j) const
function Scalar (line 1313) | const Scalar coeff(Index index) const
type typename (line 1336) | typedef typename remove_all<typename XprType::NestedExpressionType>::typ...
function EIGEN_DEVICE_FUNC (line 1343) | EIGEN_DEVICE_FUNC explicit evaluator_wrapper_base(const ArgType& arg) : ...
type typename (line 1345) | typedef typename ArgType::Scalar Scalar;
type typename (line 1346) | typedef typename ArgType::CoeffReturnType CoeffReturnType;
function CoeffReturnType (line 1349) | CoeffReturnType coeff(Index row, Index col) const
function CoeffReturnType (line 1355) | CoeffReturnType coeff(Index index) const
function PacketType (line 1374) | PacketType packet(Index row, Index col) const
function PacketType (line 1381) | PacketType packet(Index index) const
function writePacket (line 1388) | void writePacket(Index row, Index col, const PacketType& x)
function writePacket (line 1395) | void writePacket(Index index, const PacketType& x)
function EIGEN_DEVICE_FUNC (line 1410) | EIGEN_DEVICE_FUNC explicit unary_evaluator(const XprType& wrapper)
function EIGEN_DEVICE_FUNC (line 1421) | EIGEN_DEVICE_FUNC explicit unary_evaluator(const XprType& wrapper)
type typename (line 1437) | typedef typename XprType::Scalar Scalar;
type typename (line 1438) | typedef typename XprType::CoeffReturnType CoeffReturnType;
function CoeffReturnType (line 1477) | CoeffReturnType coeff(Index index) const
function PacketType (line 1497) | PacketType packet(Index row, Index col) const
function PacketType (line 1512) | PacketType packet(Index index) const
function writePacket (line 1520) | void writePacket(Index row, Index col, const PacketType& x)
function writePacket (line 1537) | void writePacket(Index index, const PacketType& x)
function EIGEN_DEVICE_FUNC (line 1570) | EIGEN_DEVICE_FUNC explicit evaluator(const XprType& diagonal)
type typename (line 1575) | typedef typename XprType::Scalar Scalar;
type typename (line 1576) | typedef typename XprType::CoeffReturnType CoeffReturnType;
function CoeffReturnType (line 1579) | CoeffReturnType coeff(Index row, Index) const
function CoeffReturnType (line 1585) | CoeffReturnType coeff(Index index) const
function EvalToTemp (line 1634) | EIGEN_GENERIC_PUBLIC_INTERFACE(EvalToTemp)
type typename (line 1664) | typedef typename ArgType::PlainObject PlainObject;
type evaluator (line 1665) | typedef evaluator<PlainObject> Base;
function EIGEN_DEVICE_FUNC (line 1667) | EIGEN_DEVICE_FUNC explicit evaluator(const XprType& xpr)
function EIGEN_DEVICE_FUNC (line 1674) | EIGEN_DEVICE_FUNC evaluator(const ArgType& arg)
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/Eigen/Eigen/src/Core/CoreIterators.h
function namespace (line 13) | namespace Eigen {
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/Eigen/Eigen/src/Core/CwiseBinaryOp.h
function namespace (line 14) | namespace Eigen {
type typename (line 88) | typedef typename internal::remove_all<LhsType>::type Lhs;
type typename (line 89) | typedef typename internal::remove_all<RhsType>::type Rhs;
type typename (line 91) | typedef typename CwiseBinaryOpImpl<
type typename (line 99) | typedef typename internal::ref_selector<RhsType>::type RhsNested;
type typename (line 100) | typedef typename internal::remove_reference<LhsNested>::type _LhsNested;
type typename (line 101) | typedef typename internal::remove_reference<RhsNested>::type _RhsNested;
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/Eigen/Eigen/src/Core/CwiseNullaryOp.h
function namespace (line 13) | namespace Eigen {
function if (line 137) | EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
function namespace (line 739) | namespace internal {
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/Eigen/Eigen/src/Core/CwiseTernaryOp.h
function namespace (line 15) | namespace Eigen {
type typename (line 91) | typedef typename internal::remove_all<Arg2Type>::type Arg2;
type typename (line 92) | typedef typename internal::remove_all<Arg3Type>::type Arg3;
type typename (line 94) | typedef typename CwiseTernaryOpImpl<
type typename (line 100) | typedef typename internal::ref_selector<Arg2Type>::type Arg2Nested;
type typename (line 101) | typedef typename internal::ref_selector<Arg3Type>::type Arg3Nested;
type typename (line 102) | typedef typename internal::remove_reference<Arg1Nested>::type _Arg1Nested;
type typename (line 103) | typedef typename internal::remove_reference<Arg2Nested>::type _Arg2Nested;
type typename (line 104) | typedef typename internal::remove_reference<Arg3Nested>::type _Arg3Nested;
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/Eigen/Eigen/src/Core/CwiseUnaryOp.h
function namespace (line 14) | namespace Eigen {
type typename (line 62) | typedef typename internal::remove_all<XprType>::type NestedExpression;
function typename (line 84) | typename internal::remove_all<XprTypeNested>::type&
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/Eigen/Eigen/src/Core/CwiseUnaryView.h
function namespace (line 13) | namespace Eigen {
type typename (line 65) | typedef typename internal::remove_all<MatrixType>::type NestedExpression;
function explicit (line 67) | explicit inline CwiseUnaryView(MatrixType& mat, const ViewOp& func = Vie...
function typename (line 83) | typename internal::remove_reference<MatrixTypeNested>::type&
type typename (line 107) | typedef typename internal::dense_xpr_base< CwiseUnaryView<ViewOp, Matrix...
function EIGEN_INHERIT_ASSIGNMENT_OPERATORS (line 109) | EIGEN_DENSE_PUBLIC_INTERFACE(Derived)
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/Eigen/Eigen/src/Core/DenseBase.h
function namespace (line 16) | namespace internal {
type typename (line 55) | typedef typename internal::traits<Derived>::StorageKind StorageKind;
type typename (line 63) | typedef typename internal::traits<Derived>::StorageIndex StorageIndex;
type typename (line 66) | typedef typename internal::traits<Derived>::Scalar Scalar;
type Scalar (line 71) | typedef Scalar value_type;
type typename (line 73) | typedef typename NumTraits<Scalar>::Real RealScalar;
type DenseCoeffsBase (line 74) | typedef DenseCoeffsBase<Derived> Base;
type typename (line 96) | typedef typename Base::CoeffReturnType CoeffReturnType;
type typename (line 174) | typedef typename internal::find_best_packet<Scalar,SizeAtCompileTime>::t...
type Matrix (line 180) | typedef Matrix<typename
type Array (line 190) | typedef Array<typename
type typename (line 204) | typedef typename internal::conditional<internal::is_same<typename
function EIGEN_DEVICE_FUNC (line 240) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 251) | EIGEN_DEVICE_FUNC
type CwiseNullaryOp (line 262) | typedef CwiseNullaryOp<internal::scalar_constant_op<Scalar>,PlainObject>...
type CwiseNullaryOp (line 264) | typedef CwiseNullaryOp<internal::linspaced_op<Scalar,PacketScalar>,Plain...
type CwiseNullaryOp (line 266) | typedef CwiseNullaryOp<internal::linspaced_op<Scalar,PacketScalar>,Plain...
type Matrix (line 268) | typedef Matrix<typename
type Transpose (line 319) | typedef Transpose<Derived> TransposeReturnType;
type typename (line 322) | typedef typename internal::add_const<Transpose<const Derived> >::type Co...
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/Eigen/Eigen/src/Core/DenseCoeffsBase.h
function namespace (line 13) | namespace Eigen {
type typename (line 483) | typedef typename internal::traits<Derived>::Scalar Scalar;
type typename (line 484) | typedef typename NumTraits<Scalar>::Real RealScalar;
function Index (line 513) | inline Index stride() const
type typename (line 557) | typedef typename internal::traits<Derived>::Scalar Scalar;
type typename (line 558) | typedef typename NumTraits<Scalar>::Real RealScalar;
function Index (line 587) | inline Index stride() const
function EIGEN_DEVICE_FUNC (line 606) | EIGEN_DEVICE_FUNC
function Index (line 639) | inline Index first_aligned(const DenseBase<Derived>& m)
function Index (line 646) | inline Index first_default_aligned(const DenseBase<Derived>& m)
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/Eigen/Eigen/src/Core/DenseStorage.h
function namespace (line 21) | namespace Eigen {
function EIGEN_DEVICE_FUNC (line 125) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 132) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 144) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 151) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 162) | EIGEN_DEVICE_FUNC plain_array() {}
function EIGEN_DEVICE_FUNC (line 163) | EIGEN_DEVICE_FUNC plain_array(constructor_without_unaligned_array_assert...
function EIGEN_DEVICE_FUNC (line 193) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 203) | EIGEN_DEVICE_FUNC DenseStorage(Index size, Index rows, Index cols) {
function EIGEN_DEVICE_FUNC (line 211) | EIGEN_DEVICE_FUNC static Index rows(void) {return _Rows;}
function EIGEN_DEVICE_FUNC (line 212) | EIGEN_DEVICE_FUNC static Index cols(void) {return _Cols;}
function EIGEN_DEVICE_FUNC (line 213) | EIGEN_DEVICE_FUNC void conservativeResize(Index,Index,Index) {}
function EIGEN_DEVICE_FUNC (line 214) | EIGEN_DEVICE_FUNC void resize(Index,Index,Index) {}
function EIGEN_DEVICE_FUNC (line 215) | EIGEN_DEVICE_FUNC const T *data() const { return m_data.array; }
function EIGEN_DEVICE_FUNC (line 216) | EIGEN_DEVICE_FUNC T *data() { return m_data.array; }
function EIGEN_DEVICE_FUNC (line 223) | EIGEN_DEVICE_FUNC DenseStorage() {}
function EIGEN_DEVICE_FUNC (line 224) | EIGEN_DEVICE_FUNC explicit DenseStorage(internal::constructor_without_un...
function EIGEN_DEVICE_FUNC (line 225) | EIGEN_DEVICE_FUNC DenseStorage(const DenseStorage&) {}
function EIGEN_DEVICE_FUNC (line 227) | EIGEN_DEVICE_FUNC DenseStorage(Index,Index,Index) {}
function EIGEN_DEVICE_FUNC (line 268) | EIGEN_DEVICE_FUNC DenseStorage(Index, Index rows, Index cols) : m_rows(r...
function EIGEN_DEVICE_FUNC (line 273) | EIGEN_DEVICE_FUNC void conservativeResize(Index, Index rows, Index cols)...
function EIGEN_DEVICE_FUNC (line 274) | EIGEN_DEVICE_FUNC void resize(Index, Index rows, Index cols) { m_rows = ...
function EIGEN_DEVICE_FUNC (line 275) | EIGEN_DEVICE_FUNC const T *data() const { return m_data.array; }
function EIGEN_DEVICE_FUNC (line 276) | EIGEN_DEVICE_FUNC T *data() { return m_data.array; }
function EIGEN_DEVICE_FUNC (line 286) | EIGEN_DEVICE_FUNC explicit DenseStorage(internal::constructor_without_un...
function EIGEN_DEVICE_FUNC (line 288) | EIGEN_DEVICE_FUNC DenseStorage(const DenseStorage& other) : m_data(other...
function EIGEN_DEVICE_FUNC (line 298) | EIGEN_DEVICE_FUNC DenseStorage(Index, Index rows, Index) : m_rows(rows) {}
function EIGEN_DEVICE_FUNC (line 300) | EIGEN_DEVICE_FUNC Index rows(void) const {return m_rows;}
function EIGEN_DEVICE_FUNC (line 301) | EIGEN_DEVICE_FUNC Index cols(void) const {return _Cols;}
function EIGEN_DEVICE_FUNC (line 302) | EIGEN_DEVICE_FUNC void conservativeResize(Index, Index rows, Index) { m_...
function EIGEN_DEVICE_FUNC (line 303) | EIGEN_DEVICE_FUNC void resize(Index, Index rows, Index) { m_rows = rows; }
function EIGEN_DEVICE_FUNC (line 304) | EIGEN_DEVICE_FUNC const T *data() const { return m_data.array; }
function EIGEN_DEVICE_FUNC (line 305) | EIGEN_DEVICE_FUNC T *data() { return m_data.array; }
function EIGEN_DEVICE_FUNC (line 315) | EIGEN_DEVICE_FUNC explicit DenseStorage(internal::constructor_without_un...
function EIGEN_DEVICE_FUNC (line 317) | EIGEN_DEVICE_FUNC DenseStorage(const DenseStorage& other) : m_data(other...
function EIGEN_DEVICE_FUNC (line 327) | EIGEN_DEVICE_FUNC DenseStorage(Index, Index, Index cols) : m_cols(cols) {}
function EIGEN_DEVICE_FUNC (line 329) | EIGEN_DEVICE_FUNC Index rows(void) const {return _Rows;}
function EIGEN_DEVICE_FUNC (line 330) | EIGEN_DEVICE_FUNC Index cols(void) const {return m_cols;}
function conservativeResize (line 331) | void conservativeResize(Index, Index, Index cols) { m_cols = cols; }
function resize (line 332) | void resize(Index, Index, Index cols) { m_cols = cols; }
function EIGEN_DEVICE_FUNC (line 333) | EIGEN_DEVICE_FUNC const T *data() const { return m_data.array; }
function EIGEN_DEVICE_FUNC (line 334) | EIGEN_DEVICE_FUNC T *data() { return m_data.array; }
function EIGEN_DEVICE_FUNC (line 391) | EIGEN_DEVICE_FUNC ~DenseStorage() { internal::conditional_aligned_delete...
function EIGEN_DEVICE_FUNC (line 394) | EIGEN_DEVICE_FUNC Index rows(void) const {return m_rows;}
function EIGEN_DEVICE_FUNC (line 395) | EIGEN_DEVICE_FUNC Index cols(void) const {return m_cols;}
function conservativeResize (line 396) | void conservativeResize(Index size, Index rows, Index cols)
function EIGEN_DEVICE_FUNC (line 402) | EIGEN_DEVICE_FUNC void resize(Index size, Index rows, Index cols)
function EIGEN_DEVICE_FUNC (line 416) | EIGEN_DEVICE_FUNC const T *data() const { return m_data; }
function EIGEN_DEVICE_FUNC (line 417) | EIGEN_DEVICE_FUNC T *data() { return m_data; }
function explicit (line 427) | explicit DenseStorage(internal::constructor_without_unaligned_array_asse...
function EIGEN_DEVICE_FUNC (line 428) | EIGEN_DEVICE_FUNC DenseStorage(Index size, Index rows, Index cols) : m_d...
function EIGEN_DEVICE_FUNC (line 434) | EIGEN_DEVICE_FUNC DenseStorage(const DenseStorage& other)
function EIGEN_DEVICE_FUNC (line 451) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 468) | EIGEN_DEVICE_FUNC ~DenseStorage() { internal::conditional_aligned_delete...
function EIGEN_DEVICE_FUNC (line 470) | EIGEN_DEVICE_FUNC static Index rows(void) {return _Rows;}
function EIGEN_DEVICE_FUNC (line 471) | EIGEN_DEVICE_FUNC Index cols(void) const {return m_cols;}
function EIGEN_DEVICE_FUNC (line 472) | EIGEN_DEVICE_FUNC void conservativeResize(Index size, Index, Index cols)
function resize (line 477) | void resize(Index size, Index, Index cols)
function EIGEN_DEVICE_FUNC (line 490) | EIGEN_DEVICE_FUNC const T *data() const { return m_data; }
function EIGEN_DEVICE_FUNC (line 491) | EIGEN_DEVICE_FUNC T *data() { return m_data; }
function explicit (line 501) | explicit DenseStorage(internal::constructor_without_unaligned_array_asse...
function EIGEN_DEVICE_FUNC (line 502) | EIGEN_DEVICE_FUNC DenseStorage(Index size, Index rows, Index cols) : m_d...
function EIGEN_DEVICE_FUNC (line 508) | EIGEN_DEVICE_FUNC DenseStorage(const DenseStorage& other)
function EIGEN_DEVICE_FUNC (line 525) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 542) | EIGEN_DEVICE_FUNC ~DenseStorage() { internal::conditional_aligned_delete...
function EIGEN_DEVICE_FUNC (line 544) | EIGEN_DEVICE_FUNC Index rows(void) const {return m_rows;}
function EIGEN_DEVICE_FUNC (line 545) | EIGEN_DEVICE_FUNC static Index cols(void) {return _Cols;}
function conservativeResize (line 546) | void conservativeResize(Index size, Index rows, Index)
function resize (line 551) | void resize(Index size, Index rows, Index)
function EIGEN_DEVICE_FUNC (line 564) | EIGEN_DEVICE_FUNC const T *data() const { return m_data; }
function EIGEN_DEVICE_FUNC (line 565) | EIGEN_DEVICE_FUNC T *data() { return m_data; }
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/Eigen/Eigen/src/Core/Diagonal.h
function namespace (line 14) | namespace Eigen {
type typename (line 69) | typedef typename internal::dense_xpr_base<Diagonal>::type Base;
function explicit (line 73) | explicit inline Diagonal(MatrixType& matrix, Index a_index = DiagIndex) ...
type typename (line 102) | typedef typename internal::conditional<
function EIGEN_DEVICE_FUNC (line 108) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 110) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 113) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 120) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 126) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 132) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 139) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 145) | EIGEN_DEVICE_FUNC
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/Eigen/Eigen/src/Core/DiagonalMatrix.h
function namespace (line 14) | namespace Eigen {
function EIGEN_DEVICE_FUNC (line 138) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 142) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 146) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 150) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 154) | EIGEN_DEVICE_FUNC
function m_diagonal (line 160) | inline DiagonalMatrix(const DiagonalBase<OtherDerived>& other) : m_diago...
function m_diagonal (line 164) | inline DiagonalMatrix(const DiagonalMatrix& other) : m_diagonal(other.di...
function explicit (line 170) | explicit inline DiagonalMatrix(const MatrixBase<OtherDerived>& other) : ...
function EIGEN_DEVICE_FUNC (line 195) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 198) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 201) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 204) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 207) | EIGEN_DEVICE_FUNC
function namespace (line 225) | namespace internal {
type _DiagonalVectorType (line 250) | typedef _DiagonalVectorType DiagonalVectorType;
type DiagonalWrapper (line 251) | typedef DiagonalWrapper Nested;
function m_diagonal (line 256) | inline DiagonalWrapper(DiagonalVectorType& a_diagonal) : m_diagonal(a_di...
function namespace (line 309) | namespace internal {
function run (line 335) | static void run(DstXprType &dst, const SrcXprType &src, const internal::...
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/Eigen/Eigen/src/Core/DiagonalProduct.h
function namespace (line 14) | namespace Eigen {
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/Eigen/Eigen/src/Core/Dot.h
function namespace (line 13) | namespace Eigen {
type internal (line 78) | typedef internal::scalar_conj_product_op<Scalar,typename
type typename (line 126) | typedef typename internal::nested_eval<Derived,2>::type _Nested;
type typename (line 169) | typedef typename internal::nested_eval<Derived,3>::type _Nested;
function namespace (line 201) | namespace internal {
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/Eigen/Eigen/src/Core/EigenBase.h
function namespace (line 14) | namespace Eigen {
function evalTo (line 71) | inline void evalTo(Dest& dst) const
function addTo (line 77) | inline void addTo(Dest& dst) const
function subTo (line 89) | inline void subTo(Dest& dst) const
function applyThisOnTheRight (line 100) | inline void applyThisOnTheRight(Dest& dst) const
function applyThisOnTheLeft (line 109) | inline void applyThisOnTheLeft(Dest& dst) const
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/Eigen/Eigen/src/Core/ForceAlignedAccess.h
function namespace (line 13) | namespace Eigen {
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/Eigen/Eigen/src/Core/Fuzzy.h
function namespace (line 14) | namespace Eigen {
function typename (line 65) | typename Derived::RealScalar& prec)
function EIGEN_DEVICE_FUNC (line 74) | EIGEN_DEVICE_FUNC
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/Eigen/Eigen/src/Core/GeneralProduct.h
function namespace (line 14) | namespace Eigen {
type product_type_selector (line 93) | struct product_type_selector
type product_type_selector (line 94) | struct product_type_selector
type product_type_selector (line 95) | struct product_type_selector
type product_type_selector (line 96) | struct product_type_selector
type product_type_selector (line 97) | struct product_type_selector
type product_type_selector (line 98) | struct product_type_selector
type product_type_selector (line 99) | struct product_type_selector
type product_type_selector (line 100) | struct product_type_selector
type product_type_selector (line 101) | struct product_type_selector
type product_type_selector (line 102) | struct product_type_selector
type product_type_selector (line 103) | struct product_type_selector
type product_type_selector (line 104) | struct product_type_selector
type product_type_selector (line 105) | struct product_type_selector
type product_type_selector (line 106) | struct product_type_selector
type product_type_selector (line 107) | struct product_type_selector
type product_type_selector (line 108) | struct product_type_selector
type product_type_selector (line 109) | struct product_type_selector
type product_type_selector (line 110) | struct product_type_selector
type product_type_selector (line 111) | struct product_type_selector
type product_type_selector (line 112) | struct product_type_selector
function namespace (line 142) | namespace internal {
function namespace (line 149) | namespace internal {
function EIGEN_STRONG_INLINE (line 174) | EIGEN_STRONG_INLINE Scalar* data() { return m_data.array; }
function EIGEN_STRONG_INLINE (line 179) | EIGEN_STRONG_INLINE Scalar* data() {
type gemv_dense_selector (line 201) | struct gemv_dense_selector
function run (line 204) | inline void run(const Lhs &lhs, const Rhs &rhs, Dest& dest, const typena...
type gemv_dense_selector (line 295) | struct gemv_dense_selector
function run (line 298) | void run(const Lhs &lhs, const Rhs &rhs, Dest& dest, const typename Dest...
type gemv_dense_selector (line 348) | struct gemv_dense_selector
function run (line 351) | void run(const Lhs &lhs, const Rhs &rhs, Dest& dest, const typename Dest...
type gemv_dense_selector (line 362) | struct gemv_dense_selector
function run (line 365) | void run(const Lhs &lhs, const Rhs &rhs, Dest& dest, const typename Dest...
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/Eigen/Eigen/src/Core/GenericPacketMath.h
function namespace (line 14) | namespace Eigen {
function ptranspose (line 543) | inline void
function Packet (line 556) | inline Packet
function Packet (line 562) | inline Packet
function Packet (line 576) | inline Packet
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/Eigen/Eigen/src/Core/GlobalFunctions.h
function namespace (line 54) | namespace Eigen
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/Eigen/Eigen/src/Core/IO.h
function namespace (line 14) | namespace Eigen {
function namespace (line 112) | namespace internal {
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/Eigen/Eigen/src/Core/Inverse.h
function namespace (line 13) | namespace Eigen {
type typename (line 74) | typedef typename XprType::Scalar Scalar;
function namespace (line 81) | namespace internal {
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/Eigen/Eigen/src/Core/Map.h
function namespace (line 14) | namespace Eigen {
type PointerType (line 103) | typedef PointerType PointerArgType;
function EIGEN_DEVICE_FUNC (line 104) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 107) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 128) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 141) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 155) | EIGEN_DEVICE_FUNC
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/Eigen/Eigen/src/Core/MapBase.h
function namespace (line 18) | namespace Eigen {
type typename (line 227) | typedef typename Base::Scalar Scalar;
type typename (line 228) | typedef typename Base::PacketScalar PacketScalar;
type typename (line 229) | typedef typename Base::StorageIndex StorageIndex;
type typename (line 230) | typedef typename Base::PointerType PointerType;
type typename (line 244) | typedef typename internal::conditional<
function EIGEN_DEVICE_FUNC (line 250) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 252) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 255) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 261) | EIGEN_DEVICE_FUNC
function Base (line 283) | Base(dataPtr) {}
function EIGEN_DEVICE_FUNC (line 284) | EIGEN_DEVICE_FUNC inline MapBase(PointerType dataPtr, Index vecSize) : B...
function EIGEN_DEVICE_FUNC (line 285) | EIGEN_DEVICE_FUNC inline MapBase(PointerType dataPtr, Index rows, Index ...
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/Eigen/Eigen/src/Core/MathFunctions.h
function namespace (line 18) | namespace Eigen {
type Scalar (line 549) | typedef Scalar type;
function Scalar (line 562) | static inline Scalar run()
type typename (line 623) | typedef typename make_unsigned<Scalar>::type ScalarU;
type typename (line 627) | typedef typename conditional<(ScalarU(-1) > unsigned(-1)), ScalarU, unsi...
function Scalar (line 645) | static inline Scalar run()
function Scalar (line 668) | static inline Scalar run()
function isinf_impl (line 728) | bool>::type
function isinf_msvc_helper (line 760) | bool isinf_msvc_helper(T x)
function EIGEN_DEVICE_FUNC (line 766) | EIGEN_DEVICE_FUNC inline bool isnan_impl(const long double& x) { return ...
function EIGEN_DEVICE_FUNC (line 767) | EIGEN_DEVICE_FUNC inline bool isnan_impl(const double& x) { return ...
function EIGEN_DEVICE_FUNC (line 768) | EIGEN_DEVICE_FUNC inline bool isnan_impl(const float& x) { return ...
function EIGEN_DEVICE_FUNC (line 770) | EIGEN_DEVICE_FUNC inline bool isinf_impl(const long double& x) { return ...
function EIGEN_DEVICE_FUNC (line 771) | EIGEN_DEVICE_FUNC inline bool isinf_impl(const double& x) { return ...
function EIGEN_DEVICE_FUNC (line 772) | EIGEN_DEVICE_FUNC inline bool isinf_impl(const float& x) { return ...
function isnan_impl (line 784) | bool isnan_impl(const long double& x) { return __builtin_isnan(x); }
function isnan_impl (line 785) | bool isnan_impl(const double& x) { return __builtin_isnan(x); }
function isnan_impl (line 786) | bool isnan_impl(const float& x) { return __builtin_isnan(x); }
function isinf_impl (line 787) | bool isinf_impl(const double& x) { return __builtin_isinf(x); }
function isinf_impl (line 788) | bool isinf_impl(const float& x) { return __builtin_isinf(x); }
function isinf_impl (line 789) | bool isinf_impl(const long double& x) { return __builtin_isinf(x); }
function namespace (line 810) | namespace numext {
function floor (line 976) | float floor(const float &x) { return ::floorf(x); }
function floor (line 979) | double floor(const double &x) { return ::floor(x); }
function ceil (line 992) | float ceil(const float &x) { return ::ceilf(x); }
function ceil (line 995) | double ceil(const double &x) { return ::ceil(x); }
function log2 (line 1001) | inline int log2(int x)
function log (line 1040) | float log(const float &x) { return ::logf(x); }
function log (line 1043) | double log(const double &x) { return ::log(x); }
function typename (line 1056) | typename NumTraits<T>::Real>::type
function EIGEN_ALWAYS_INLINE (line 1062) | EIGEN_ALWAYS_INLINE float abs(float x) { return cl::sycl::fabs(x); }
function EIGEN_ALWAYS_INLINE (line 1063) | EIGEN_ALWAYS_INLINE double abs(double x) { return cl::sycl::fabs(x); }
function abs (line 1068) | float abs(const float &x) { return ::fabsf(x); }
function abs (line 1071) | double abs(const double &x) { return ::fabs(x); }
function exp (line 1093) | float exp(const float &x) { return ::expf(x); }
function exp (line 1096) | double exp(const double &x) { return ::exp(x); }
function cos (line 1108) | float cos(const float &x) { return ::cosf(x); }
function cos (line 1111) | double cos(const double &x) { return ::cos(x); }
function sin (line 1123) | float sin(const float &x) { return ::sinf(x); }
function sin (line 1126) | double sin(const double &x) { return ::sin(x); }
function tan (line 1138) | float tan(const float &x) { return ::tanf(x); }
function tan (line 1141) | double tan(const double &x) { return ::tan(x); }
function acos (line 1153) | float acos(const float &x) { return ::acosf(x); }
function acos (line 1156) | double acos(const double &x) { return ::acos(x); }
function asin (line 1168) | float asin(const float &x) { return ::asinf(x); }
function asin (line 1171) | double asin(const double &x) { return ::asin(x); }
function atan (line 1183) | float atan(const float &x) { return ::atanf(x); }
function atan (line 1186) | double atan(const double &x) { return ::atan(x); }
function cosh (line 1199) | float cosh(const float &x) { return ::coshf(x); }
function cosh (line 1202) | double cosh(const double &x) { return ::cosh(x); }
function sinh (line 1214) | float sinh(const float &x) { return ::sinhf(x); }
function sinh (line 1217) | double sinh(const double &x) { return ::sinh(x); }
function tanh (line 1229) | float tanh(float x) { return internal::generic_fast_tanh_float(x); }
function tanh (line 1234) | float tanh(const float &x) { return ::tanhf(x); }
function tanh (line 1237) | double tanh(const double &x) { return ::tanh(x); }
function fmod (line 1250) | float fmod(const float& a, const float& b) {
function fmod (line 1256) | double fmod(const double& a, const double& b) {
function namespace (line 1263) | namespace internal {
type typename (line 1316) | typedef typename NumTraits<Scalar>::Real RealScalar;
function isMuchSmallerThan (line 1318) | static inline bool isMuchSmallerThan(const Scalar& x, const Scalar&, con...
function EIGEN_DEVICE_FUNC (line 1322) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 1327) | EIGEN_DEVICE_FUNC
type typename (line 1337) | typedef typename NumTraits<Scalar>::Real RealScalar;
function isMuchSmallerThan (line 1339) | static inline bool isMuchSmallerThan(const Scalar& x, const OtherScalar&...
function EIGEN_DEVICE_FUNC (line 1343) | EIGEN_DEVICE_FUNC
function isMuchSmallerThan (line 1354) | bool isMuchSmallerThan(const Scalar& x, const OtherScalar& y,
function isApprox (line 1361) | bool isApprox(const Scalar& x, const Scalar& y,
function isApproxOrLessThan (line 1368) | bool isApproxOrLessThan(const Scalar& x, const Scalar& y,
function bool (line 1378) | struct random_impl<bool>
function bool (line 1386) | struct scalar_fuzzy_impl<bool>
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/Eigen/Eigen/src/Core/MathFunctionsImpl.h
function namespace (line 14) | namespace Eigen {
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/Eigen/Eigen/src/Core/Matrix.h
function namespace (line 14) | namespace Eigen {
type PlainObjectBase (line 186) | typedef PlainObjectBase<Matrix> Base;
function explicit (line 267) | explicit Matrix(internal::constructor_without_unaligned_array_assert)
function EIGEN_DEVICE_FUNC (line 272) | EIGEN_DEVICE_FUNC
function EIGEN_STRONG_INLINE (line 291) | EIGEN_STRONG_INLINE explicit Matrix(const T& x)
function EIGEN_STRONG_INLINE (line 299) | EIGEN_STRONG_INLINE Matrix(const T0& x, const T1& y)
function Base (line 368) | Matrix(const Matrix& other) : Base(other)
function EIGEN_STRONG_INLINE (line 376) | EIGEN_STRONG_INLINE Matrix(const EigenBase<OtherDerived> &other)
type internal (line 399) | struct internal
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/Eigen/Eigen/src/Core/MatrixBase.h
function namespace (line 14) | namespace Eigen {
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/Eigen/Eigen/src/Core/NestByValue.h
function namespace (line 14) | namespace Eigen {
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/Eigen/Eigen/src/Core/NoAlias.h
function namespace (line 13) | namespace Eigen {
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/Eigen/Eigen/src/Core/NumTraits.h
function namespace (line 13) | namespace Eigen {
type T (line 100) | typedef T Real;
type typename (line 101) | typedef typename internal::conditional<
type T (line 106) | typedef T Nested;
type T (line 107) | typedef T Literal;
function EIGEN_DEVICE_FUNC (line 109) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 115) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 121) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 129) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 134) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 139) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 144) | EIGEN_DEVICE_FUNC
type NumTraits (line 153) | struct NumTraits
function EIGEN_DEVICE_FUNC (line 156) | EIGEN_DEVICE_FUNC
type NumTraits (line 160) | struct NumTraits
function EIGEN_DEVICE_FUNC (line 162) | EIGEN_DEVICE_FUNC
type NumTraits (line 166) | struct NumTraits
function dummy_precision (line 169) | static inline long double dummy_precision() { return 1e-15l; }
type _Real (line 175) | typedef _Real Real;
type typename (line 176) | typedef typename NumTraits<_Real>::Literal Literal;
function EIGEN_DEVICE_FUNC (line 185) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 187) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 189) | EIGEN_DEVICE_FUNC
type typename (line 197) | typedef typename NumTraits<Scalar>::Real RealScalar;
type Array (line 198) | typedef Array<RealScalar, Rows, Cols, Options, MaxRows, MaxCols> Real;
type typename (line 199) | typedef typename NumTraits<Scalar>::NonInteger NonIntegerScalar;
type Array (line 200) | typedef Array<NonIntegerScalar, Rows, Cols, Options, MaxRows, MaxCols> N...
type ArrayType (line 201) | typedef ArrayType & Nested;
type typename (line 202) | typedef typename NumTraits<Scalar>::Literal Literal;
function EIGEN_DEVICE_FUNC (line 214) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 216) | EIGEN_DEVICE_FUNC
function digits10 (line 219) | static inline int digits10() { return NumTraits<Scalar>::digits10(); }
function string (line 222) | struct NumTraits<std::string>
function void (line 244) | struct NumTraits<void> {}
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/Eigen/Eigen/src/Core/PermutationMatrix.h
function namespace (line 14) | namespace Eigen {
function namespace (line 282) | namespace internal {
type internal (line 311) | typedef internal::traits<PermutationMatrix> Traits;
type typename (line 317) | typedef typename Traits::IndicesType IndicesType;
type typename (line 318) | typedef typename Traits::StorageIndex StorageIndex;
function explicit (line 326) | explicit inline PermutationMatrix(Index size) : m_indices(size)
function m_indices (line 339) | inline PermutationMatrix(const PermutationMatrix& other) : m_indices(oth...
function m_indices (line 350) | inline PermutationMatrix(const MatrixBase<Other>& indices) : m_indices(i...
function namespace (line 419) | namespace internal {
type internal (line 436) | typedef internal::traits<Map> Traits;
type typename (line 440) | typedef typename Traits::IndicesType IndicesType;
type typename (line 441) | typedef typename IndicesType::Scalar StorageIndex;
function m_indices (line 444) | inline Map(const StorageIndex* indicesPtr)
function namespace (line 484) | namespace internal {
type internal (line 517) | typedef internal::traits<PermutationWrapper> Traits;
type typename (line 521) | typedef typename Traits::IndicesType IndicesType;
function m_indices (line 524) | inline PermutationWrapper(const IndicesType& indices)
type internal (line 568) | typedef internal::traits<PermutationType> PermTraits;
type typename (line 576) | typedef typename PermutationType::DenseMatrixType DenseMatrixType;
function namespace (line 625) | namespace internal {
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/Eigen/Eigen/src/Core/PlainObjectBase.h
function namespace (line 25) | namespace Eigen {
function Scalar (line 160) | const Scalar& coeff(Index rowId, Index colId) const
function Scalar (line 173) | const Scalar& coeff(Index index) const
function Scalar (line 204) | const Scalar& coeffRef(Index rowId, Index colId) const
function Scalar (line 215) | const Scalar& coeffRef(Index index) const
function PacketScalar (line 222) | PacketScalar packet(Index rowId, Index colId) const
function PacketScalar (line 232) | PacketScalar packet(Index index) const
function writePacket (line 239) | void writePacket(Index rowId, Index colId, const PacketScalar& val)
function writePacket (line 249) | void writePacket(Index index, const PacketScalar& val)
function Scalar (line 255) | const Scalar *data() const
function Scalar (line 259) | Scalar *data()
function resize (line 279) | void resize(Index rows, Index cols)
function EIGEN_DEVICE_FUNC (line 308) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 333) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 347) | EIGEN_DEVICE_FUNC
function conservativeResize (line 390) | void conservativeResize(Index rows, Index cols)
function conservativeResize (line 403) | void conservativeResize(Index rows, NoChange_t)
function conservativeResize (line 417) | void conservativeResize(NoChange_t, Index cols)
function conservativeResize (line 432) | void conservativeResize(Index size)
function EIGEN_DEVICE_FUNC (line 493) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 502) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 521) | EIGEN_DEVICE_FUNC
function EIGEN_STRONG_INLINE (line 532) | EIGEN_STRONG_INLINE PlainObjectBase(const DenseBase<OtherDerived> &other)
function EIGEN_STRONG_INLINE (line 543) | EIGEN_STRONG_INLINE PlainObjectBase(const EigenBase<OtherDerived> &other)
function EIGEN_STRONG_INLINE (line 553) | EIGEN_STRONG_INLINE PlainObjectBase(const ReturnByValue<OtherDerived>& o...
function ConstMapType (line 587) | static inline ConstMapType Map(const Scalar* data)
function MapType (line 589) | static inline MapType Map(Scalar* data)
function ConstMapType (line 591) | static inline ConstMapType Map(const Scalar* data, Index size)
function MapType (line 593) | static inline MapType Map(Scalar* data, Index size)
function ConstMapType (line 595) | static inline ConstMapType Map(const Scalar* data, Index rows, Index cols)
function MapType (line 597) | static inline MapType Map(Scalar* data, Index rows, Index cols)
function ConstAlignedMapType (line 600) | static inline ConstAlignedMapType MapAligned(const Scalar* data)
function AlignedMapType (line 602) | static inline AlignedMapType MapAligned(Scalar* data)
function ConstAlignedMapType (line 604) | static inline ConstAlignedMapType MapAligned(const Scalar* data, Index s...
function AlignedMapType (line 606) | static inline AlignedMapType MapAligned(Scalar* data, Index size)
function ConstAlignedMapType (line 608) | static inline ConstAlignedMapType MapAligned(const Scalar* data, Index r...
function AlignedMapType (line 610) | static inline AlignedMapType MapAligned(Scalar* data, Index rows, Index ...
function _init2 (line 757) | void _init2(const Index& val0, const Index& val1,
function _init1 (line 795) | void _init1(const Index& val0,
function _init1 (line 808) | void _init1(const Scalar* data){
function _init1 (line 822) | void _init1(const Derived& other){
function EIGEN_STRONG_INLINE (line 843) | EIGEN_STRONG_INLINE void _init1(const RotationBase<OtherDerived,ColsAtCo...
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/Eigen/Eigen/src/Core/Product.h
function namespace (line 13) | namespace Eigen {
type _Rhs (line 79) | typedef _Rhs Rhs;
type typename (line 81) | typedef typename ProductImpl<
type typename (line 89) | typedef typename internal::ref_selector<Rhs>::type RhsNested;
type typename (line 90) | typedef typename internal::remove_all<LhsNested>::type LhsNestedCleaned;
type typename (line 91) | typedef typename internal::remove_all<RhsNested>::type RhsNestedCleaned;
function EIGEN_DEVICE_FUNC (line 93) | EIGEN_DEVICE_FUNC Product(const Lhs& lhs, const Rhs& rhs) : m_lhs(lhs), ...
function namespace (line 112) | namespace internal {
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/Eigen/Eigen/src/Core/ProductEvaluators.h
function namespace (line 16) | namespace Eigen {
type evaluator (line 56) | typedef evaluator<Product<EIGEN_SCALAR_BINARYOP_EXPR_RETURN_TYPE(Scalar1...
function explicit (line 58) | explicit evaluator(const XprType& xpr)
type evaluator (line 69) | typedef evaluator<Diagonal<const Product<Lhs, Rhs, LazyProduct>, DiagInd...
function explicit (line 71) | explicit evaluator(const XprType& xpr)
type typename (line 100) | typedef typename XprType::PlainObject PlainObject;
type evaluator (line 101) | typedef evaluator<PlainObject> Base;
function explicit (line 107) | explicit product_evaluator(const XprType& xpr)
type Product (line 157) | typedef Product<Lhs,Rhs,Options> SrcXprType;
type Product (line 172) | typedef Product<Lhs,Rhs,Options> SrcXprType;
type CwiseBinaryOp (line 190) | typedef CwiseBinaryOp<internal::scalar_product_op<ScalarBis,Scalar>,
function addTo (line 255) | void addTo(Dst& dst, const Lhs& lhs, const Rhs& rhs)
function subTo (line 261) | void subTo(Dst& dst, const Lhs& lhs, const Rhs& rhs)
type typename (line 489) | typedef typename find_best_packet<Scalar,RowsAtCompileTime>::type LhsVec...
type typename (line 490) | typedef typename find_best_packet<Scalar,ColsAtCompileTime>::type RhsVec...
function CoeffReturnType (line 550) | const CoeffReturnType coeff(Index row, Index col) const
function EIGEN_DEVICE_FUNC (line 559) | EIGEN_DEVICE_FUNC const CoeffReturnType coeff(Index index) const
function PacketType (line 567) | PacketType packet(Index row, Index col) const
function PacketType (line 578) | PacketType packet(Index index) const
type Product (line 600) | typedef Product<Lhs, Rhs, DefaultProduct> XprType;
type Product (line 601) | typedef Product<Lhs, Rhs, LazyProduct> BaseProduct;
type product_evaluator (line 602) | typedef product_evaluator<BaseProduct, CoeffBasedProductMode, DenseShape...
function EIGEN_DEVICE_FUNC (line 606) | EIGEN_DEVICE_FUNC explicit product_evaluator(const XprType& xpr)
function EIGEN_STRONG_INLINE (line 618) | static EIGEN_STRONG_INLINE void run(Index row, Index col, const Lhs& lhs...
function EIGEN_STRONG_INLINE (line 628) | static EIGEN_STRONG_INLINE void run(Index row, Index col, const Lhs& lhs...
function EIGEN_STRONG_INLINE (line 638) | static EIGEN_STRONG_INLINE void run(Index row, Index col, const Lhs& lhs...
function EIGEN_STRONG_INLINE (line 647) | static EIGEN_STRONG_INLINE void run(Index row, Index col, const Lhs& lhs...
function EIGEN_STRONG_INLINE (line 656) | static EIGEN_STRONG_INLINE void run(Index /*row*/, Index /*col*/, const ...
function EIGEN_STRONG_INLINE (line 665) | static EIGEN_STRONG_INLINE void run(Index /*row*/, Index /*col*/, const ...
function EIGEN_STRONG_INLINE (line 674) | static EIGEN_STRONG_INLINE void run(Index row, Index col, const Lhs& lhs...
function EIGEN_STRONG_INLINE (line 685) | static EIGEN_STRONG_INLINE void run(Index row, Index col, const Lhs& lhs...
type typename (line 706) | typedef typename Product<Lhs,Rhs>::Scalar Scalar;
type typename (line 720) | typedef typename Product<Lhs,Rhs>::Scalar Scalar;
type typename (line 741) | typedef typename Product<Lhs,Rhs>::Scalar Scalar;
type typename (line 754) | typedef typename Product<Lhs,Rhs>::Scalar Scalar;
type typename (line 772) | typedef typename ScalarBinaryOpTraits<typename MatrixType::Scalar, typename
function PacketType (line 812) | PacketType packet_impl(Index row, Index col, Index id, internal::true_ty...
function PacketType (line 819) | PacketType packet_impl(Index row, Index col, Index id, internal::false_t...
type typename (line 842) | typedef typename Base::Scalar Scalar;
type Product (line 844) | typedef Product<Lhs, Rhs, ProductKind> XprType;
type typename (line 845) | typedef typename XprType::PlainObject PlainObject;
function EIGEN_DEVICE_FUNC (line 851) | EIGEN_DEVICE_FUNC explicit product_evaluator(const XprType& xpr)
function Scalar (line 856) | const Scalar coeff(Index row, Index col) const
function PacketType (line 863) | PacketType packet(Index row, Index col) const
function PacketType (line 872) | PacketType packet(Index idx) const
type typename (line 888) | typedef typename Base::Scalar Scalar;
type Product (line 890) | typedef Product<Lhs, Rhs, ProductKind> XprType;
type typename (line 891) | typedef typename XprType::PlainObject PlainObject;
function EIGEN_DEVICE_FUNC (line 895) | EIGEN_DEVICE_FUNC explicit product_evaluator(const XprType& xpr)
function Scalar (line 900) | const Scalar coeff(Index row, Index col) const
function PacketType (line 907) | PacketType packet(Index row, Index col) const
function PacketType (line 914) | PacketType packet(Index idx) const
type typename (line 937) | typedef typename remove_all<MatrixType>::type MatrixTypeCleaned;
function run (line 940) | inline void run(Dest& dst, const PermutationType& perm, const Expression...
type typename (line 1044) | typedef typename nested_eval<ExpressionType, 1>::type MatrixType;
type typename (line 1045) | typedef typename remove_all<MatrixType>::type MatrixTypeCleaned;
function run (line 1048) | inline void run(Dest& dst, const TranspositionType& tr, const Expression...
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/Eigen/Eigen/src/Core/Random.h
function namespace (line 15) | namespace internal {
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/Eigen/Eigen/src/Core/Redux.h
function namespace (line 14) | namespace Eigen {
type typename (line 145) | typedef typename Derived::Scalar Scalar;
type typename (line 146) | typedef typename redux_traits<Func, Derived>::PacketType PacketScalar;
type typename (line 166) | typedef typename Derived::Scalar Scalar;
type typename (line 167) | typedef typename redux_traits<Func, Derived>::PacketType PacketScalar;
function Scalar (line 190) | Scalar run(const Derived &mat, const Func& func)
type typename (line 213) | typedef typename redux_traits<Func, Derived>::PacketType PacketScalar;
function Scalar (line 215) | static Scalar run(const Derived &mat, const Func& func)
type typename (line 272) | typedef typename redux_traits<Func, Derived>::PacketType PacketType;
function EIGEN_DEVICE_FUNC (line 274) | EIGEN_DEVICE_FUNC static Scalar run(const Derived &mat, const Func& func)
type typename (line 311) | typedef typename redux_traits<Func, Derived>::PacketType PacketScalar;
function Scalar (line 317) | Scalar run(const Derived &mat, const Func& func)
function EIGEN_DEVICE_FUNC (line 338) | EIGEN_DEVICE_FUNC explicit redux_evaluator(const XprType &xpr) : m_evalu...
type typename (line 340) | typedef typename XprType::Scalar Scalar;
type typename (line 341) | typedef typename XprType::CoeffReturnType CoeffReturnType;
type typename (line 342) | typedef typename XprType::PacketScalar PacketScalar;
type typename (line 343) | typedef typename XprType::PacketReturnType PacketReturnType;
function EIGEN_DEVICE_FUNC (line 363) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 367) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 379) | EIGEN_DEVICE_FUNC
function typename (line 410) | typename internal::traits<Derived>::Scalar
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/Eigen/Eigen/src/Core/Ref.h
function namespace (line 13) | namespace Eigen {
type typename (line 61) | typedef typename internal::traits<Derived>::PlainObjectType PlainObjectT...
type typename (line 62) | typedef typename internal::traits<Derived>::StrideType StrideType;
function Index (line 69) | inline Index innerStride() const
function EIGEN_DEVICE_FUNC (line 253) | EIGEN_DEVICE_FUNC inline Ref(const Ref& other) : Base(other) {
function construct (line 265) | void construct(const Expression& expr,internal::true_type)
function construct (line 271) | void construct(const Expression& expr, internal::false_type)
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/Eigen/Eigen/src/Core/Replicate.h
function namespace (line 13) | namespace Eigen {
type typename (line 64) | typedef typename internal::traits<Replicate>::MatrixTypeNested MatrixTyp...
type typename (line 65) | typedef typename internal::traits<Replicate>::_MatrixTypeNested _MatrixT...
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/Eigen/Eigen/src/Core/ReturnByValue.h
function namespace (line 14) | namespace Eigen {
type typename (line 56) | typedef typename internal::dense_xpr_base<ReturnByValue>::type Base;
function evalTo (line 61) | inline void evalTo(Dest& dst) const
function class (line 68) | class Unusable{
function namespace (line 88) | namespace internal {
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/Eigen/Eigen/src/Core/Reverse.h
function namespace (line 15) | namespace Eigen {
type internal (line 85) | typedef internal::reverse_packet_cond<PacketScalar,ReversePacket> revers...
function m_matrix (line 88) | inline Reverse(const MatrixType& matrix) : m_matrix(matrix) { }
function namespace (line 163) | namespace internal {
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/Eigen/Eigen/src/Core/Select.h
function namespace (line 13) | namespace Eigen {
function EIGEN_DEVICE_FUNC (line 73) | inline EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 82) | inline EIGEN_DEVICE_FUNC
function typename (line 139) | typename ThenDerived::Scalar& elseScalar) const
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/Eigen/Eigen/src/Core/SelfAdjointView.h
function namespace (line 13) | namespace Eigen {
type _MatrixType (line 54) | typedef _MatrixType MatrixType;
type TriangularBase (line 55) | typedef TriangularBase<SelfAdjointView> Base;
type typename (line 56) | typedef typename internal::traits<SelfAdjointView>::MatrixTypeNested Mat...
type typename (line 57) | typedef typename internal::traits<SelfAdjointView>::MatrixTypeNestedClea...
type MatrixTypeNestedCleaned (line 58) | typedef MatrixTypeNestedCleaned NestedExpression;
type typename (line 61) | typedef typename internal::traits<SelfAdjointView>::Scalar Scalar;
type typename (line 62) | typedef typename MatrixType::StorageIndex StorageIndex;
type typename (line 63) | typedef typename internal::remove_all<typename
type typename (line 70) | typedef typename MatrixType::PlainObject PlainObject;
function m_matrix (line 73) | inline SelfAdjointView(MatrixType& matrix) : m_matrix(matrix)
function EIGEN_DEVICE_FUNC (line 90) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 100) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 114) | EIGEN_DEVICE_FUNC
type SelfAdjointView (line 194) | typedef SelfAdjointView<const MatrixConjugateReturnType,UpLo> ConjugateR...
function EIGEN_DEVICE_FUNC (line 196) | EIGEN_DEVICE_FUNC
type typename (line 284) | typedef typename Base::DstXprType DstXprType;
type typename (line 285) | typedef typename Base::SrcXprType SrcXprType;
type typename (line 292) | typedef typename Base::SrcEvaluatorType SrcEvaluatorType;
type typename (line 293) | typedef typename Base::Scalar Scalar;
type typename (line 294) | typedef typename Base::AssignmentTraits AssignmentTraits;
function EIGEN_DEVICE_FUNC (line 297) | EIGEN_DEVICE_FUNC triangular_dense_assignment_kernel(DstEvaluatorType &d...
function EIGEN_DEVICE_FUNC (line 301) | EIGEN_DEVICE_FUNC void assignCoeff(Index row, Index col)
function EIGEN_DEVICE_FUNC (line 309) | EIGEN_DEVICE_FUNC void assignDiagonalCoeff(Index id)
function EIGEN_DEVICE_FUNC (line 314) | EIGEN_DEVICE_FUNC void assignOppositeCoeff(Index, Index)
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/Eigen/Eigen/src/Core/SelfCwiseBinaryOp.h
function namespace (line 13) | namespace Eigen {
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/Eigen/Eigen/src/Core/Solve.h
function namespace (line 13) | namespace Eigen {
type typename (line 66) | typedef typename internal::traits<Solve>::StorageIndex StorageIndex;
function namespace (line 110) | namespace internal {
type Solve (line 139) | typedef Solve<DecType,RhsType> SrcXprType;
function run (line 140) | static void run(DstXprType &dst, const SrcXprType &src, const internal::...
type Solve (line 155) | typedef Solve<Transpose<const DecType>,RhsType> SrcXprType;
function run (line 156) | static void run(DstXprType &dst, const SrcXprType &src, const internal::...
function run (line 173) | static void run(DstXprType &dst, const SrcXprType &src, const internal::...
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/Eigen/Eigen/src/Core/SolveTriangular.h
function namespace (line 13) | namespace Eigen {
function run (line 121) | static void run(const Lhs& lhs, Rhs& rhs)
function run (line 141) | static void run(const Lhs& lhs, Rhs& rhs)
type typename (line 177) | typedef typename internal::conditional<copy,
function namespace (line 197) | namespace internal {
type ReturnByValue (line 210) | typedef ReturnByValue<triangular_solve_retval> Base;
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/Eigen/Eigen/src/Core/SolverBase.h
function namespace (line 13) | namespace Eigen {
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/Eigen/Eigen/src/Core/StableNorm.h
function namespace (line 13) | namespace Eigen {
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/Eigen/Eigen/src/Core/Stride.h
function namespace (line 13) | namespace Eigen {
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/Eigen/Eigen/src/Core/Swap.h
function namespace (line 13) | namespace Eigen {
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/Eigen/Eigen/src/Core/Transpose.h
function namespace (line 14) | namespace Eigen {
function namespace (line 90) | namespace internal {
type typename (line 128) | typedef typename internal::conditional<
function EIGEN_DEVICE_FUNC (line 134) | EIGEN_DEVICE_FUNC inline ScalarWithConstIfNotLvalue* data() { return der...
function EIGEN_DEVICE_FUNC (line 135) | EIGEN_DEVICE_FUNC inline const Scalar* data() const { return derived().n...
function EIGEN_DEVICE_FUNC (line 138) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 144) | EIGEN_DEVICE_FUNC
function namespace (line 219) | namespace internal {
type typename (line 239) | typedef typename MatrixType::Scalar Scalar;
type typename (line 240) | typedef typename internal::packet_traits<typename
function namespace (line 324) | namespace internal {
function run (line 343) | static bool run(const Scalar* dest, const OtherDerived& src)
function run (line 372) | static void run(const Derived& dst, const OtherDerived& other)
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/Eigen/Eigen/src/Core/Transpositions.h
function namespace (line 13) | namespace Eigen {
type typename (line 164) | typedef typename Traits::IndicesType IndicesType;
type typename (line 165) | typedef typename IndicesType::Scalar StorageIndex;
function m_indices (line 177) | inline Transpositions(const Transpositions& other) : m_indices(other.ind...
function m_indices (line 182) | inline Transpositions(const MatrixBase<Other>& indices) : m_indices(indi...
function m_indices (line 205) | inline Transpositions(Index size) : m_indices(size)
function namespace (line 219) | namespace internal {
type typename (line 238) | typedef typename Traits::IndicesType IndicesType;
type typename (line 239) | typedef typename IndicesType::Scalar StorageIndex;
function explicit (line 241) | explicit inline Map(const StorageIndex* indicesPtr)
function namespace (line 278) | namespace internal {
type typename (line 295) | typedef typename Traits::IndicesType IndicesType;
type typename (line 296) | typedef typename IndicesType::Scalar StorageIndex;
function explicit (line 298) | explicit inline TranspositionsWrapper(IndicesType& indices)
function namespace (line 359) | namespace internal {
type TranspositionsDerived (line 371) | typedef TranspositionsDerived TranspositionType;
type typename (line 372) | typedef typename TranspositionType::IndicesType IndicesType;
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/Eigen/Eigen/src/Core/TriangularMatrix.h
function namespace (line 14) | namespace Eigen {
type typename (line 192) | typedef typename internal::traits<TriangularView>::Scalar Scalar;
type _MatrixType (line 193) | typedef _MatrixType MatrixType;
type typename (line 197) | typedef typename internal::traits<TriangularView>::MatrixTypeNestedNonRe...
type typename (line 199) | typedef typename internal::remove_all<typename
type typename (line 204) | typedef typename internal::traits<TriangularView>::MatrixTypeNestedClean...
function m_matrix (line 217) | inline TriangularView(MatrixType& matrix) : m_matrix(matrix)
function EIGEN_DEVICE_FUNC (line 236) | EIGEN_DEVICE_FUNC
type TriangularView (line 239) | typedef TriangularView<const MatrixConjugateReturnType,Mode> ConjugateRe...
function EIGEN_DEVICE_FUNC (line 241) | EIGEN_DEVICE_FUNC
type TriangularBase (line 339) | typedef TriangularBase<TriangularViewType> Base;
type typename (line 340) | typedef typename internal::traits<TriangularViewType>::Scalar Scalar;
type _MatrixType (line 342) | typedef _MatrixType MatrixType;
type typename (line 343) | typedef typename MatrixType::PlainObject DenseMatrixType;
type DenseMatrixType (line 344) | typedef DenseMatrixType PlainObject;
type typename (line 350) | typedef typename internal::traits<TriangularViewType>::StorageKind Stora...
function EIGEN_DEVICE_FUNC (line 389) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 392) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 396) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 399) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 405) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 415) | EIGEN_DEVICE_FUNC
function solveInPlace (line 510) | void solveInPlace(const MatrixBase<OtherDerived>& other) const
function swap (line 519) | void swap(TriangularBase<OtherDerived> const & other)
function namespace (line 699) | namespace internal {
type evaluator (line 717) | typedef evaluator<typename
function Base (line 718) | unary_evaluator(const XprType &xpr) : Base(xpr.nestedExpression()) {}
type Triangular2Triangular (line 722) | struct Triangular2Triangular {}
type Triangular2Dense (line 723) | struct Triangular2Dense {}
type Dense2Triangular (line 724) | struct Dense2Triangular {}
type typename (line 740) | typedef typename Base::DstXprType DstXprType;
type typename (line 741) | typedef typename Base::SrcXprType SrcXprType;
type typename (line 748) | typedef typename Base::SrcEvaluatorType SrcEvaluatorType;
type typename (line 749) | typedef typename Base::Scalar Scalar;
type typename (line 750) | typedef typename Base::AssignmentTraits AssignmentTraits;
function EIGEN_DEVICE_FUNC (line 753) | EIGEN_DEVICE_FUNC triangular_dense_assignment_kernel(DstEvaluatorType &d...
function EIGEN_DEVICE_FUNC (line 758) | EIGEN_DEVICE_FUNC void assignCoeff(Index row, Index col)
function EIGEN_DEVICE_FUNC (line 767) | EIGEN_DEVICE_FUNC void assignDiagonalCoeff(Index id)
function EIGEN_DEVICE_FUNC (line 774) | EIGEN_DEVICE_FUNC void assignOppositeCoeff(Index row, Index col)
type evaluator (line 786) | typedef evaluator<DstXprType> DstEvaluatorType;
type evaluator (line 787) | typedef evaluator<SrcXprType> SrcEvaluatorType;
type triangular_dense_assignment_kernel (line 797) | typedef triangular_dense_assignment_kernel< Mode
function Kernel (line 799) | Kernel kernel(dstEvaluator, srcEvaluator, func, dst.const_cast_derived());
type AssignmentKind (line 818) | struct AssignmentKind
type Triangular2Dense (line 818) | typedef Triangular2Dense Kind;
type AssignmentKind (line 819) | struct AssignmentKind
type Dense2Triangular (line 819) | typedef Dense2Triangular Kind;
type typename (line 857) | typedef typename DstEvaluatorType::XprType DstXprType;
type typename (line 864) | typedef typename Kernel::Scalar Scalar;
function namespace (line 939) | namespace internal {
function run (line 962) | static void run(DstXprType &dst, const SrcXprType &src, const internal::...
function run (line 973) | static void run(DstXprType &dst, const SrcXprType &src, const internal::...
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/Eigen/Eigen/src/Core/VectorBlock.h
function namespace (line 14) | namespace Eigen {
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/Eigen/Eigen/src/Core/VectorwiseOp.h
function namespace (line 14) | namespace Eigen {
function namespace (line 97) | namespace internal {
type typename (line 161) | typedef typename ExpressionType::RealScalar RealScalar;
type Eigen (line 162) | typedef Eigen::Index Index;
type typename (line 163) | typedef typename internal::ref_selector<ExpressionType>::non_const_type ...
type typename (line 164) | typedef typename internal::remove_all<ExpressionTypeNested>::type Expres...
type PartialReduxExpr (line 169) | typedef PartialReduxExpr<ExpressionType,
type PartialReduxExpr (line 177) | typedef PartialReduxExpr<ExpressionType,
function EIGEN_DEVICE_FUNC (line 195) | EIGEN_DEVICE_FUNC
type Replicate (line 208) | typedef Replicate<OtherDerived,
type Replicate (line 231) | typedef Replicate<OtherDerived,
function m_matrix (line 255) | inline VectorwiseOp(ExpressionType& matrix) : m_matrix(matrix) {}
function EIGEN_DEVICE_FUNC (line 258) | EIGEN_DEVICE_FUNC
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/Eigen/Eigen/src/Core/Visitor.h
function namespace (line 13) | namespace Eigen {
type typename (line 66) | typedef typename XprType::Scalar Scalar;
type typename (line 67) | typedef typename XprType::CoeffReturnType CoeffReturnType;
function EIGEN_DEVICE_FUNC (line 78) | EIGEN_DEVICE_FUNC CoeffReturnType coeff(Index row, Index col) const
type typename (line 109) | typedef typename internal::visitor_evaluator<Derived> ThisEvaluator;
function namespace (line 119) | namespace internal {
function typename (line 206) | typename internal::traits<Derived>::Scalar
function typename (line 224) | typename internal::traits<Derived>::Scalar
function typename (line 243) | typename internal::traits<Derived>::Scalar
function typename (line 261) | typename internal::traits<Derived>::Scalar
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/Eigen/Eigen/src/Core/arch/AVX/Complex.h
function namespace (line 13) | namespace Eigen {
function Packet4cf (line 124) | Packet4cf preverse(const Packet4cf& a) {
type conj_helper (line 174) | struct conj_helper
function EIGEN_STRONG_INLINE (line 176) | EIGEN_STRONG_INLINE Packet4cf pmadd(const Packet4cf& x, const Packet4cf&...
function EIGEN_STRONG_INLINE (line 179) | EIGEN_STRONG_INLINE Packet4cf pmul(const Packet4cf& a, const Packet4cf& ...
type conj_helper (line 185) | struct conj_helper
function EIGEN_STRONG_INLINE (line 187) | EIGEN_STRONG_INLINE Packet4cf pmadd(const Packet4cf& x, const Packet4cf&...
function EIGEN_STRONG_INLINE (line 190) | EIGEN_STRONG_INLINE Packet4cf pmul(const Packet4cf& a, const Packet4cf& ...
type conj_helper (line 196) | struct conj_helper
function EIGEN_STRONG_INLINE (line 198) | EIGEN_STRONG_INLINE Packet4cf pmadd(const Packet4cf& x, const Packet4cf&...
function EIGEN_STRONG_INLINE (line 201) | EIGEN_STRONG_INLINE Packet4cf pmul(const Packet4cf& a, const Packet4cf& ...
type Packet2cd (line 224) | struct Packet2cd
type packet_traits (line 231) | struct packet_traits
function default_packet_traits (line 231) | double> > : default_packet_traits
function Packet2cd (line 254) | struct unpacket_traits<Packet2cd> { typedef std::complex<double> type; e...
function Packet2cd (line 258) | Packet2cd pnegate(const Packet2cd& a) { return Packet2cd(pnegate(a.v)); }
function Packet2cd (line 259) | Packet2cd pconj(const Packet2cd& a)
function Packet2cd (line 319) | Packet2cd preverse(const Packet2cd& a) {
type conj_helper (line 354) | struct conj_helper
function EIGEN_STRONG_INLINE (line 356) | EIGEN_STRONG_INLINE Packet2cd pmadd(const Packet2cd& x, const Packet2cd&...
function EIGEN_STRONG_INLINE (line 359) | EIGEN_STRONG_INLINE Packet2cd pmul(const Packet2cd& a, const Packet2cd& ...
type conj_helper (line 365) | struct conj_helper
function EIGEN_STRONG_INLINE (line 367) | EIGEN_STRONG_INLINE Packet2cd pmadd(const Packet2cd& x, const Packet2cd&...
function EIGEN_STRONG_INLINE (line 370) | EIGEN_STRONG_INLINE Packet2cd pmul(const Packet2cd& a, const Packet2cd& ...
type conj_helper (line 376) | struct conj_helper
function EIGEN_STRONG_INLINE (line 378) | EIGEN_STRONG_INLINE Packet2cd pmadd(const Packet2cd& x, const Packet2cd&...
function EIGEN_STRONG_INLINE (line 381) | EIGEN_STRONG_INLINE Packet2cd pmul(const Packet2cd& a, const Packet2cd& ...
function Packet4cf (line 427) | Packet4cf pinsertfirst(const Packet4cf& a, std::complex<float> b)
function Packet2cd (line 432) | Packet2cd pinsertfirst(const Packet2cd& a, std::complex<double> b)
function Packet4cf (line 437) | Packet4cf pinsertlast(const Packet4cf& a, std::complex<float> b)
function Packet2cd (line 442) | Packet2cd pinsertlast(const Packet2cd& a, std::complex<double> b)
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/Eigen/Eigen/src/Core/arch/AVX/MathFunctions.h
function namespace (line 17) | namespace Eigen {
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/Eigen/Eigen/src/Core/arch/AVX/PacketMath.h
function namespace (line 13) | namespace Eigen {
function Packet8f (line 136) | Packet8f pnegate(const Packet8f& a)
function Packet4d (line 140) | Packet4d pnegate(const Packet4d& a)
function Packet8f (line 145) | Packet8f pconj(const Packet8f& a) { return a; }
function Packet4d (line 146) | Packet4d pconj(const Packet4d& a) { return a; }
function Packet8i (line 147) | Packet8i pconj(const Packet8i& a) { return a; }
function Index (line 285) | Index stride)
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/Eigen/Eigen/src/Core/arch/AVX/TypeCasting.h
function namespace (line 13) | namespace Eigen {
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/Eigen/Eigen/src/Core/arch/AVX512/MathFunctions.h
function namespace (line 13) | namespace Eigen {
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/Eigen/Eigen/src/Core/arch/AVX512/PacketMath.h
function namespace (line 13) | namespace Eigen {
function Packet16f (line 174) | Packet16f pnegate(const Packet16f& a) {
function Packet8d (line 178) | Packet8d pnegate(const Packet8d& a) {
function Packet16f (line 183) | Packet16f pconj(const Packet16f& a) {
function Packet8d (line 187) | Packet8d pconj(const Packet8d& a) {
function Packet16i (line 191) | Packet16i pconj(const Packet16i& a) {
function Packet16f (line 219) | Packet16f pmadd(const Packet16f& a, const Packet16f& b,
function Packet8d (line 224) | Packet8d pmadd(const Packet8d& a, const Packet8d& b,
function Packet16f (line 638) | Packet16f preverse(const Packet16f& a)
function Packet8d (line 643) | Packet8d preverse(const Packet8d& a)
function Packet16f (line 648) | Packet16f pabs(const Packet16f& a)
function Packet8d (line 654) | Packet8d pabs(const Packet8d& a) {
function Packet16f (line 1298) | Packet16f pblend(const Selector<16>& /*ifPacket*/,
function Packet8d (line 1305) | Packet8d pblend(const Selector<8>& /*ifPacket*/,
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/Eigen/Eigen/src/Core/arch/AltiVec/Complex.h
function namespace (line 14) | namespace Eigen {
function Packet2cf (line 100) | Packet2cf pnegate(const Packet2cf& a) { return Packet2cf(pnegate(a.v)); }
function Packet2cf (line 101) | Packet2cf pconj(const Packet2cf& a) { return Packet2cf(pxor<Packet4f>(a....
function Packet2cf (line 137) | Packet2cf preverse(const Packet2cf& a)
type conj_helper (line 194) | struct conj_helper
function EIGEN_STRONG_INLINE (line 196) | EIGEN_STRONG_INLINE Packet2cf pmadd(const Packet2cf& x, const Packet2cf&...
function EIGEN_STRONG_INLINE (line 199) | EIGEN_STRONG_INLINE Packet2cf pmul(const Packet2cf& a, const Packet2cf& ...
type conj_helper (line 205) | struct conj_helper
function EIGEN_STRONG_INLINE (line 207) | EIGEN_STRONG_INLINE Packet2cf pmadd(const Packet2cf& x, const Packet2cf&...
function EIGEN_STRONG_INLINE (line 210) | EIGEN_STRONG_INLINE Packet2cf pmul(const Packet2cf& a, const Packet2cf& ...
type conj_helper (line 216) | struct conj_helper
function EIGEN_STRONG_INLINE (line 218) | EIGEN_STRONG_INLINE Packet2cf pmadd(const Packet2cf& x, const Packet2cf&...
function EIGEN_STRONG_INLINE (line 221) | EIGEN_STRONG_INLINE Packet2cf pmul(const Packet2cf& a, const Packet2cf& ...
function Packet2cf (line 250) | Packet2cf pblend(const Selector<2>& ifPacket, const Packet2cf& thenPacke...
type Packet1cd (line 259) | struct Packet1cd
type packet_traits (line 266) | struct packet_traits
function default_packet_traits (line 266) | double> > : default_packet_traits
function Packet1cd (line 289) | struct unpacket_traits<Packet1cd> { typedef std::complex<double> type; e...
function Packet1cd (line 316) | Packet1cd pnegate(const Packet1cd& a) { return Packet1cd(pnegate(Packet2...
function Packet1cd (line 317) | Packet1cd pconj(const Packet1cd& a) { return Packet1cd(pxor(a.v, reinter...
function Packet1cd (line 354) | Packet1cd preverse(const Packet1cd& a) { return a; }
function EIGEN_STRONG_INLINE (line 373) | EIGEN_STRONG_INLINE Packet1cd pmadd(const Packet1cd& x, const Packet1cd&...
function EIGEN_STRONG_INLINE (line 376) | EIGEN_STRONG_INLINE Packet1cd pmul(const Packet1cd& a, const Packet1cd& ...
type conj_helper (line 382) | struct conj_helper
function EIGEN_STRONG_INLINE (line 384) | EIGEN_STRONG_INLINE Packet1cd pmadd(const Packet1cd& x, const Packet1cd&...
function EIGEN_STRONG_INLINE (line 387) | EIGEN_STRONG_INLINE Packet1cd pmul(const Packet1cd& a, const Packet1cd& ...
type conj_helper (line 393) | struct conj_helper
function EIGEN_STRONG_INLINE (line 395) | EIGEN_STRONG_INLINE Packet1cd pmadd(const Packet1cd& x, const Packet1cd&...
function EIGEN_STRONG_INLINE (line 398) | EIGEN_STRONG_INLINE Packet1cd pmul(const Packet1cd& a, const Packet1cd& ...
function EIGEN_STRONG_INLINE (line 414) | EIGEN_STRONG_INLINE Packet1cd pcplxflip/*<Packet1cd>*/(const Packet1cd& x)
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/Eigen/Eigen/src/Core/arch/AltiVec/MathFunctions.h
function namespace (line 19) | namespace Eigen {
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/Eigen/Eigen/src/Core/arch/AltiVec/PacketMath.h
function namespace (line 13) | namespace Eigen {
function Packet4f (line 355) | Packet4f pnegate(const Packet4f& a) { return p4f_ZERO - a; }
function Packet4i (line 356) | Packet4i pnegate(const Packet4i& a) { return p4i_ZERO - a; }
function Packet4f (line 358) | Packet4f pconj(const Packet4f& a) { return a; }
function Packet4i (line 359) | Packet4i pconj(const Packet4i& a) { return a; }
type __vector (line 774) | typedef __vector double Packet2d;
type Packet2ul (line 775) | typedef __vector unsigned long long Packet2ul;
type Packet2l (line 776) | typedef __vector long long Packet2l;
type Packet2ul (line 778) | typedef Packet2ul Packet2bl;
type __vector (line 780) | typedef __vector __bool
function default_packet_traits (line 807) | struct packet_traits<double> : default_packet_traits
function Packet2d (line 838) | struct unpacket_traits<Packet2d> { typedef double type; enum {size=2, al...
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/Eigen/Eigen/src/Core/arch/CUDA/Complex.h
function namespace (line 15) | namespace Eigen {
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/Eigen/Eigen/src/Core/arch/CUDA/Half.h
function namespace (line 46) | namespace Eigen {
function namespace (line 150) | namespace std {
function namespace (line 200) | namespace Eigen {
function namespace (line 649) | namespace Eigen {
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/Eigen/Eigen/src/Core/arch/CUDA/MathFunctions.h
function namespace (line 13) | namespace Eigen {
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/Eigen/Eigen/src/Core/arch/CUDA/PacketMath.h
function namespace (line 13) | namespace Eigen {
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/Eigen/Eigen/src/Core/arch/CUDA/PacketMathHalf.h
function namespace (line 14) | namespace Eigen {
function ptranspose (line 108) | void
type Packet16h (line 339) | typedef struct {
function Packet16h (line 344) | struct is_arithmetic<Packet16h> { enum { value = true }; }
function default_packet_traits (line 347) | struct packet_traits<half> : default_packet_traits {
function Packet16h (line 376) | struct unpacket_traits<Packet16h> { typedef Eigen::half type; enum {size...
function Packet16h (line 408) | Packet16h
function EIGEN_STRONG_INLINE (line 419) | EIGEN_STRONG_INLINE Packet16f half2float(const Packet16h& a) {
function EIGEN_STRONG_INLINE (line 447) | EIGEN_STRONG_INLINE Packet16h float2half(const Packet16f& a) {
type Packet8h (line 707) | typedef struct {
function Packet8h (line 712) | struct is_arithmetic<Packet8h> { enum { value = true }; }
function default_packet_traits (line 715) | struct packet_traits<Eigen::half> : default_packet_traits {
function Packet8h (line 744) | struct unpacket_traits<Packet8h> { typedef Eigen::half type; enum {size=...
function EIGEN_STRONG_INLINE (line 785) | EIGEN_STRONG_INLINE Packet8f half2float(const Packet8h& a) {
function EIGEN_STRONG_INLINE (line 804) | EIGEN_STRONG_INLINE Packet8h float2half(const Packet8f& a) {
function Packet8h (line 827) | Packet8h pconj(const Packet8h& a) { return a; }
type Packet4h (line 966) | typedef struct {
function Packet4h (line 971) | struct is_arithmetic<Packet4h> { enum { value = true }; }
function default_packet_traits (line 974) | struct packet_traits<Eigen::half> : default_packet_traits {
function Packet4h (line 1003) | struct unpacket_traits<Packet4h> { typedef Eigen::half type; enum {size=...
function Packet4h (line 1015) | Packet4h pconj(const Packet4h& a) { return a; }
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/Eigen/Eigen/src/Core/arch/CUDA/TypeCasting.h
function namespace (line 13) | namespace Eigen {
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/Eigen/Eigen/src/Core/arch/NEON/Complex.h
function namespace (line 14) | namespace Eigen {
function Packet2cf (line 154) | Packet2cf preverse(const Packet2cf& a)
type conj_helper (line 235) | struct conj_helper
function EIGEN_STRONG_INLINE (line 237) | EIGEN_STRONG_INLINE Packet2cf pmadd(const Packet2cf& x, const Packet2cf&...
function EIGEN_STRONG_INLINE (line 240) | EIGEN_STRONG_INLINE Packet2cf pmul(const Packet2cf& a, const Packet2cf& ...
type conj_helper (line 246) | struct conj_helper
function EIGEN_STRONG_INLINE (line 248) | EIGEN_STRONG_INLINE Packet2cf pmadd(const Packet2cf& x, const Packet2cf&...
function EIGEN_STRONG_INLINE (line 251) | EIGEN_STRONG_INLINE Packet2cf pmul(const Packet2cf& a, const Packet2cf& ...
type conj_helper (line 257) | struct conj_helper
function EIGEN_STRONG_INLINE (line 259) | EIGEN_STRONG_INLINE Packet2cf pmadd(const Packet2cf& x, const Packet2cf&...
function EIGEN_STRONG_INLINE (line 262) | EIGEN_STRONG_INLINE Packet2cf pmul(const Packet2cf& a, const Packet2cf& ...
type Packet1cd (line 301) | struct Packet1cd
type packet_traits (line 308) | struct packet_traits
function default_packet_traits (line 308) | double> > : default_packet_traits
function Packet1cd (line 331) | struct unpacket_traits<Packet1cd> { typedef std::complex<double> type; e...
function Packet1cd (line 341) | Packet1cd pnegate(const Packet1cd& a) { return Packet1cd(pnegate<Packet2...
function Packet1cd (line 342) | Packet1cd pconj(const Packet1cd& a) { return Packet1cd(vreinterpretq_f64...
function Packet1cd (line 410) | Packet1cd preverse(const Packet1cd& a) { return a; }
function EIGEN_STRONG_INLINE (line 430) | EIGEN_STRONG_INLINE Packet1cd pmadd(const Packet1cd& x, const Packet1cd&...
function EIGEN_STRONG_INLINE (line 433) | EIGEN_STRONG_INLINE Packet1cd pmul(const Packet1cd& a, const Packet1cd& ...
type conj_helper (line 439) | struct conj_helper
function EIGEN_STRONG_INLINE (line 441) | EIGEN_STRONG_INLINE Packet1cd pmadd(const Packet1cd& x, const Packet1cd&...
function EIGEN_STRONG_INLINE (line 444) | EIGEN_STRONG_INLINE Packet1cd pmul(const Packet1cd& a, const Packet1cd& ...
type conj_helper (line 450) | struct conj_helper
function EIGEN_STRONG_INLINE (line 452) | EIGEN_STRONG_INLINE Packet1cd pmadd(const Packet1cd& x, const Packet1cd&...
function EIGEN_STRONG_INLINE (line 455) | EIGEN_STRONG_INLINE Packet1cd pmul(const Packet1cd& a, const Packet1cd& ...
function EIGEN_STRONG_INLINE (line 473) | EIGEN_STRONG_INLINE Packet1cd pcplxflip/*<Packet1cd>*/(const Packet1cd& x)
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/Eigen/Eigen/src/Core/arch/NEON/MathFunctions.h
function namespace (line 15) | namespace Eigen {
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/Eigen/Eigen/src/Core/arch/NEON/PacketMath.h
function namespace (line 15) | namespace Eigen {
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/Eigen/Eigen/src/Core/arch/SSE/Complex.h
function namespace (line 13) | namespace Eigen {
function Packet2cf (line 148) | Packet2cf preverse(const Packet2cf& a) { return Packet2cf(_mm_castpd_ps(...
type conj_helper (line 178) | struct conj_helper
function EIGEN_STRONG_INLINE (line 180) | EIGEN_STRONG_INLINE Packet2cf pmadd(const Packet2cf& x, const Packet2cf&...
function EIGEN_STRONG_INLINE (line 183) | EIGEN_STRONG_INLINE Packet2cf pmul(const Packet2cf& a, const Packet2cf& ...
type conj_helper (line 196) | struct conj_helper
function EIGEN_STRONG_INLINE (line 198) | EIGEN_STRONG_INLINE Packet2cf pmadd(const Packet2cf& x, const Packet2cf&...
function EIGEN_STRONG_INLINE (line 201) | EIGEN_STRONG_INLINE Packet2cf pmul(const Packet2cf& a, const Packet2cf& ...
type conj_helper (line 214) | struct conj_helper
function EIGEN_STRONG_INLINE (line 216) | EIGEN_STRONG_INLINE Packet2cf pmadd(const Packet2cf& x, const Packet2cf&...
function EIGEN_STRONG_INLINE (line 219) | EIGEN_STRONG_INLINE Packet2cf pmul(const Packet2cf& a, const Packet2cf& ...
function EIGEN_STRONG_INLINE (line 242) | EIGEN_STRONG_INLINE Packet2cf pcplxflip/* <Packet2cf> */(const Packet2cf...
type Packet1cd (line 249) | struct Packet1cd
type packet_traits (line 259) | struct packet_traits
function default_packet_traits (line 259) | double> > : default_packet_traits
function Packet1cd (line 283) | struct unpacket_traits<Packet1cd> { typedef std::complex<double> type; e...
function Packet1cd (line 287) | Packet1cd pnegate(const Packet1cd& a) { return Packet1cd(pnegate(Packet2...
function Packet1cd (line 288) | Packet1cd pconj(const Packet1cd& a)
function Packet1cd (line 336) | Packet1cd preverse(const Packet1cd& a) { return a; }
function EIGEN_STRONG_INLINE (line 365) | EIGEN_STRONG_INLINE Packet1cd pmadd(const Packet1cd& x, const Packet1cd&...
function EIGEN_STRONG_INLINE (line 368) | EIGEN_STRONG_INLINE Packet1cd pmul(const Packet1cd& a, const Packet1cd& ...
type conj_helper (line 381) | struct conj_helper
function EIGEN_STRONG_INLINE (line 383) | EIGEN_STRONG_INLINE Packet1cd pmadd(const Packet1cd& x, const Packet1cd&...
function EIGEN_STRONG_INLINE (line 386) | EIGEN_STRONG_INLINE Packet1cd pmul(const Packet1cd& a, const Packet1cd& ...
type conj_helper (line 399) | struct conj_helper
function EIGEN_STRONG_INLINE (line 401) | EIGEN_STRONG_INLINE Packet1cd pmadd(const Packet1cd& x, const Packet1cd&...
function EIGEN_STRONG_INLINE (line 404) | EIGEN_STRONG_INLINE Packet1cd pmul(const Packet1cd& a, const Packet1cd& ...
function EIGEN_STRONG_INLINE (line 427) | EIGEN_STRONG_INLINE Packet1cd pcplxflip/* <Packet1cd> */(const Packet1cd...
function Packet2cf (line 442) | Packet2cf pblend(const Selector<2>& ifPacket, const Packet2cf& thenPacke...
function Packet2cf (line 447) | Packet2cf pinsertfirst(const Packet2cf& a, std::complex<float> b)
function Packet1cd (line 452) | Packet1cd pinsertfirst(const Packet1cd&, std::complex<double> b)
function Packet2cf (line 457) | Packet2cf pinsertlast(const Packet2cf& a, std::complex<float> b)
function Packet1cd (line 462) | Packet1cd pinsertlast(const Packet1cd&, std::complex<double> b)
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/Eigen/Eigen/src/Core/arch/SSE/MathFunctions.h
function namespace (line 18) | namespace Eigen {
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/Eigen/Eigen/src/Core/arch/SSE/PacketMath.h
function namespace (line 13) | namespace Eigen {
function Packet4f (line 441) | Packet4f preverse(const Packet4f& a)
function Packet2d (line 443) | Packet2d preverse(const Packet2d& a)
function Packet4i (line 445) | Packet4i preverse(const Packet4i& a)
function Packet4f (line 448) | Packet4f pabs(const Packet4f& a)
function Packet2d (line 453) | Packet2d pabs(const Packet2d& a)
function Packet4i (line 458) | Packet4i pabs(const Packet4i& a)
function EIGEN_STRONG_INLINE (line 500) | EIGEN_STRONG_INLINE void punpackp(Packet4f* vecs)
function Packet4i (line 802) | Packet4i pblend(const Selector<4>& ifPacket, const Packet4i& thenPacket,...
function Packet4f (line 812) | Packet4f pblend(const Selector<4>& ifPacket, const Packet4f& thenPacket,...
function Packet2d (line 822) | Packet2d pblend(const Selector<2>& ifPacket, const Packet2d& thenPacket,...
function Packet4f (line 833) | Packet4f pinsertfirst(const Packet4f& a, float b)
function Packet2d (line 842) | Packet2d pinsertfirst(const Packet2d& a, double b)
function Packet4f (line 851) | Packet4f pinsertlast(const Packet4f& a, float b)
function Packet2d (line 861) | Packet2d pinsertlast(const Packet2d& a, double b)
function pmadd (line 873) | float pmadd(const float& a, const float& b, const float& c) {
function pmadd (line 876) | double pmadd(const double& a, const double& b, const double& c) {
function __m128 (line 887) | static inline __m128 _mm_castpd_ps (__m128d x) { return reinterpret_c...
function __m128i (line 888) | static inline __m128i _mm_castpd_si128(__m128d x) { return reinterpret_c...
function __m128d (line 889) | static inline __m128d _mm_castps_pd (__m128 x) { return reinterpret_c...
function __m128i (line 890) | static inline __m128i _mm_castps_si128(__m128 x) { return reinterpret_c...
function __m128 (line 891) | static inline __m128 _mm_castsi128_ps(__m128i x) { return reinterpret_c...
function __m128d (line 892) | static inline __m128d _mm_castsi128_pd(__m128i x) { return reinterpret_c...
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/Eigen/Eigen/src/Core/arch/SSE/TypeCasting.h
function namespace (line 13) | namespace Eigen {
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/Eigen/Eigen/src/Core/arch/ZVector/Complex.h
function namespace (line 14) | namespace Eigen {
function Packet1cd (line 138) | Packet1cd pnegate(const Packet1cd& a) { return Packet1cd(pnegate(Packet2...
function Packet2cf (line 139) | Packet2cf pnegate(const Packet2cf& a) { return Packet2cf(pnegate(Packet4...
function Packet1cd (line 140) | Packet1cd pconj(const Packet1cd& a) { return Packet1cd((Packet2d)vec_xor...
function Packet2cf (line 141) | Packet2cf pconj(const Packet2cf& a)
function Packet1cd (line 204) | Packet1cd preverse(const Packet1cd& a) { return a; }
function Packet2cf (line 205) | Packet2cf preverse(const Packet2cf& a)
type conj_helper (line 273) | struct conj_helper
function EIGEN_STRONG_INLINE (line 275) | EIGEN_STRONG_INLINE Packet1cd pmadd(const Packet1cd& x, const Packet1cd&...
function EIGEN_STRONG_INLINE (line 278) | EIGEN_STRONG_INLINE Packet1cd pmul(const Packet1cd& a, const Packet1cd& ...
type conj_helper (line 284) | struct conj_helper
function EIGEN_STRONG_INLINE (line 286) | EIGEN_STRONG_INLINE Packet1cd pmadd(const Packet1cd& x, const Packet1cd&...
function EIGEN_STRONG_INLINE (line 289) | EIGEN_STRONG_INLINE Packet1cd pmul(const Packet1cd& a, const Packet1cd& ...
type conj_helper (line 295) | struct conj_helper
function EIGEN_STRONG_INLINE (line 297) | EIGEN_STRONG_INLINE Packet1cd pmadd(const Packet1cd& x, const Packet1cd&...
function EIGEN_STRONG_INLINE (line 300) | EIGEN_STRONG_INLINE Packet1cd pmul(const Packet1cd& a, const Packet1cd& ...
type conj_helper (line 306) | struct conj_helper
function EIGEN_STRONG_INLINE (line 308) | EIGEN_STRONG_INLINE Packet2cf pmadd(const Packet2cf& x, const Packet2cf&...
function EIGEN_STRONG_INLINE (line 311) | EIGEN_STRONG_INLINE Packet2cf pmul(const Packet2cf& a, const Packet2cf& ...
type conj_helper (line 317) | struct conj_helper
function EIGEN_STRONG_INLINE (line 319) | EIGEN_STRONG_INLINE Packet2cf pmadd(const Packet2cf& x, const Packet2cf&...
function EIGEN_STRONG_INLINE (line 322) | EIGEN_STRONG_INLINE Packet2cf pmul(const Packet2cf& a, const Packet2cf& ...
type conj_helper (line 328) | struct conj_helper
function EIGEN_STRONG_INLINE (line 330) | EIGEN_STRONG_INLINE Packet2cf pmadd(const Packet2cf& x, const Packet2cf&...
function EIGEN_STRONG_INLINE (line 333) | EIGEN_STRONG_INLINE Packet2cf pmul(const Packet2cf& a, const Packet2cf& ...
function EIGEN_STRONG_INLINE (line 359) | EIGEN_STRONG_INLINE Packet1cd pcplxflip/*<Packet1cd>*/(const Packet1cd& x)
function EIGEN_STRONG_INLINE (line 364) | EIGEN_STRONG_INLINE Packet2cf pcplxflip/*<Packet2cf>*/(const Packet2cf& x)
function Packet2cf (line 386) | Packet2cf pblend(const Selector<2>& ifPacket, const Packet2cf& thenPacke...
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/Eigen/Eigen/src/Core/arch/ZVector/MathFunctions.h
function namespace (line 19) | namespace Eigen {
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/Eigen/Eigen/src/Core/arch/ZVector/PacketMath.h
function namespace (line 15) | namespace Eigen {
function Packet4i (line 538) | Packet4i pnegate(const Packet4i& a) { return (-a); }
function Packet4f (line 539) | Packet4f pnegate(const Packet4f& a)
function Packet2d (line 546) | Packet2d pnegate(const Packet2d& a) { return (-a); }
function Packet4i (line 548) | Packet4i pconj(const Packet4i& a) { return a; }
function Packet4f (line 549) | Packet4f pconj(const Packet4f& a) { return a; }
function Packet2d (line 550) | Packet2d pconj(const Packet2d& a) { return a; }
function Packet4i (line 552) | Packet4i pmadd(const Packet4i& a, const Packet4i& b, const Packet4i& c) ...
function Packet4f (line 553) | Packet4f pmadd(const Packet4f& a, const Packet4f& b, const Packet4f& c)
function Packet2d (line 560) | Packet2d pmadd(const Packet2d& a, const Packet2d& b, const Packet2d& c) ...
function Packet4i (line 688) | Packet4i preverse(const Packet4i& a)
function Packet2d (line 693) | Packet2d preverse(const Packet2d& a)
function Packet4f (line 698) | Packet4f preverse(const Packet4f& a)
function Packet4i (line 918) | Packet4i pblend(const Selector<4>& ifPacket, const Packet4i& thenPacket,...
function Packet4f (line 924) | Packet4f pblend(const Selector<4>& ifPacket, const Packet4f& thenPacket,...
function Packet2d (line 935) | Packet2d pblend(const Selector<2>& ifPacket, const Packet2d& thenPacket,...
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/Eigen/Eigen/src/Core/functors/AssignmentFunctors.h
function namespace (line 13) | namespace Eigen {
function assignCoeff (line 70) | void assignCoeff(DstScalar& a, const SrcScalar& b) const { a -= b; }
function assignPacket (line 73) | void assignPacket(DstScalar* a, const Packet& b) const
function assignCoeff (line 92) | void assignCoeff(DstScalar& a, const SrcScalar& b) const { a *= b; }
function assignPacket (line 95) | void assignPacket(DstScalar* a, const Packet& b) const
function assignCoeff (line 113) | void assignCoeff(DstScalar& a, const SrcScalar& b) const { a /= b; }
function assignPacket (line 116) | void assignPacket(DstScalar* a, const Packet& b) const
function assignCoeff (line 145) | void assignCoeff(Scalar& a, const Scalar& b) const
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/Eigen/Eigen/src/Core/functors/BinaryFunctors.h
function namespace (line 13) | namespace Eigen {
type typename (line 116) | typedef typename ScalarBinaryOpTraits<LhsScalar,RhsScalar,scalar_conj_pr...
function EIGEN_STRONG_INLINE (line 119) | EIGEN_STRONG_INLINE const result_type operator() (const LhsScalar& a, co...
function Packet (line 123) | const Packet packetOp(const Packet& a, const Packet& b) const
type typename (line 142) | typedef typename ScalarBinaryOpTraits<LhsScalar,RhsScalar,scalar_min_op>...
function EIGEN_STRONG_INLINE (line 144) | EIGEN_STRONG_INLINE const result_type operator() (const LhsScalar& a, co...
function Packet (line 146) | const Packet packetOp(const Packet& a, const Packet& b) const
function result_type (line 149) | const result_type predux(const Packet& a) const
type typename (line 168) | typedef typename ScalarBinaryOpTraits<LhsScalar,RhsScalar,scalar_max_op>...
function EIGEN_STRONG_INLINE (line 170) | EIGEN_STRONG_INLINE const result_type operator() (const LhsScalar& a, co...
function Packet (line 172) | const Packet packetOp(const Packet& a, const Packet& b) const
function result_type (line 175) | const result_type predux(const Packet& a) const
function const (line 211) | bool operator()(const LhsScalar& a, const RhsScalar& b) const {return a=...
function const (line 218) | bool operator()(const LhsScalar& a, const RhsScalar& b) const {return a<b;}
function const (line 225) | bool operator()(const LhsScalar& a, const RhsScalar& b) const {return a<...
function const (line 232) | bool operator()(const LhsScalar& a, const RhsScalar& b) const {return a>b;}
function const (line 239) | bool operator()(const LhsScalar& a, const RhsScalar& b) const {return a>...
function const (line 246) | bool operator()(const LhsScalar& a, const RhsScalar& b) const {return !(...
function const (line 253) | bool operator()(const LhsScalar& a, const RhsScalar& b) const {return a!...
function Scalar (line 267) | const Scalar operator() (const Scalar &x, const Scalar &y) const
type typename (line 294) | typedef typename ScalarBinaryOpTraits<Scalar,Exponent,scalar_pow_op>::Re...
type Scalar (line 299) | typedef Scalar LhsScalar;
type Exponent (line 300) | typedef Exponent RhsScalar;
function EIGEN_DEVICE_FUNC (line 304) | EIGEN_DEVICE_FUNC
type typename (line 324) | typedef typename ScalarBinaryOpTraits<LhsScalar,RhsScalar,scalar_differe...
function result_type (line 332) | const result_type operator() (const LhsScalar& a, const RhsScalar& b) co...
function Packet (line 334) | const Packet packetOp(const Packet& a, const Packet& b) const
type typename (line 353) | typedef typename ScalarBinaryOpTraits<LhsScalar,RhsScalar,scalar_quotien...
function result_type (line 361) | const result_type operator() (const LhsScalar& a, const RhsScalar& b) co...
function Packet (line 363) | const Packet packetOp(const Packet& a, const Packet& b) const
type scalar_boolean_and_op (line 382) | struct scalar_boolean_and_op {
function scalar_boolean_and_op (line 386) | struct functor_traits<scalar_boolean_and_op> {
type scalar_boolean_or_op (line 398) | struct scalar_boolean_or_op {
function scalar_boolean_or_op (line 402) | struct functor_traits<scalar_boolean_or_op> {
type scalar_boolean_xor_op (line 414) | struct scalar_boolean_xor_op {
function scalar_boolean_xor_op (line 418) | struct functor_traits<scalar_boolean_xor_op> {
type typename (line 435) | typedef typename BinaryOp::first_argument_type first_argument_type;
type typename (line 436) | typedef typename BinaryOp::second_argument_type second_argument_type;
type typename (line 437) | typedef typename BinaryOp::result_type result_type;
function m_value (line 439) | bind1st_op(const first_argument_type &val) : m_value(val) {}
function result_type (line 441) | const result_type operator() (const second_argument_type& b) const { ret...
function Packet (line 444) | const Packet packetOp(const Packet& b) const
type typename (line 454) | typedef typename BinaryOp::first_argument_type first_argument_type;
type typename (line 455) | typedef typename BinaryOp::second_argument_type second_argument_type;
type typename (line 456) | typedef typename BinaryOp::result_type result_type;
function m_value (line 458) | bind2nd_op(const second_argument_type &val) : m_value(val) {}
function result_type (line 460) | const result_type operator() (const first_argument_type& a) const { retu...
function Packet (line 463) | const Packet packetOp(const Packet& a) const
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/Eigen/Eigen/src/Core/functors/NullaryFunctors.h
function namespace (line 13) | namespace Eigen {
function Scalar (line 136) | const Scalar operator() (IndexType i) const { return impl(i); }
function EIGEN_STRONG_INLINE (line 139) | EIGEN_STRONG_INLINE const Packet packetOp(IndexType i) const { return im...
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/Eigen/Eigen/src/Core/functors/StlFunctors.h
function namespace (line 13) | namespace Eigen {
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/Eigen/Eigen/src/Core/functors/TernaryFunctors.h
function namespace (line 13) | namespace Eigen {
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/Eigen/Eigen/src/Core/functors/UnaryFunctors.h
function namespace (line 13) | namespace Eigen {
function result_type (line 171) | result_type operator() (const Scalar& a) const { return numext::real(a); }
function result_type (line 187) | result_type operator() (const Scalar& a) const { return numext::imag(a); }
function Scalar (line 233) | inline const Scalar operator() (const Scalar& a) const { return numext::...
function Packet (line 235) | inline Packet packetOp(const Packet& a) const { return internal::pexp(a); }
function Scalar (line 273) | inline const Scalar operator() (const Scalar& a) const { return numext::...
function Packet (line 275) | inline Packet packetOp(const Packet& a) const { return internal::plog(a); }
function Scalar (line 304) | inline const Scalar operator() (const Scalar& a) const { return numext::...
function Packet (line 306) | inline Packet packetOp(const Packet& a) const { return internal::plog1p(...
function Scalar (line 324) | inline const Scalar operator() (const Scalar& a) const { EIGEN_USING_STD...
function Packet (line 326) | inline Packet packetOp(const Packet& a) const { return internal::plog10(...
function Scalar (line 338) | inline const Scalar operator() (const Scalar& a) const { return numext::...
function Packet (line 340) | inline Packet packetOp(const Packet& a) const { return internal::psqrt(a...
function Scalar (line 365) | inline const Scalar operator() (const Scalar& a) const { return Scalar(1...
function Packet (line 367) | inline Packet packetOp(const Packet& a) const { return internal::prsqrt(...
function Scalar (line 384) | inline Scalar operator() (const Scalar& a) const { return numext::cos(a); }
function Packet (line 386) | inline Packet packetOp(const Packet& a) const { return internal::pcos(a); }
function Scalar (line 403) | inline const Scalar operator() (const Scalar& a) const { return numext::...
function Packet (line 405) | inline Packet packetOp(const Packet& a) const { return internal::psin(a); }
function Scalar (line 423) | inline const Scalar operator() (const Scalar& a) const { return numext::...
function Packet (line 425) | inline Packet packetOp(const Packet& a) const { return internal::ptan(a); }
function Scalar (line 442) | inline const Scalar operator() (const Scalar& a) const { return numext::...
function Packet (line 444) | inline Packet packetOp(const Packet& a) const { return internal::pacos(a...
function Scalar (line 461) | inline const Scalar operator() (const Scalar& a) const { return numext::...
function Packet (line 463) | inline Packet packetOp(const Packet& a) const { return internal::pasin(a...
function Scalar (line 481) | inline const Scalar operator() (const Scalar& a) const { return numext::...
function Packet (line 483) | inline Packet packetOp(const Packet& a) const { return internal::patan(a...
function Scalar (line 501) | inline const Scalar operator()(const Scalar& a) const { return numext::t...
function Packet (line 503) | inline Packet packetOp(const Packet& x) const { return ptanh(x); }
function Scalar (line 537) | inline const Scalar operator() (const Scalar& a) const { return numext::...
function Packet (line 539) | inline Packet packetOp(const Packet& a) const { return internal::psinh(a...
function Scalar (line 556) | inline const Scalar operator() (const Scalar& a) const { return numext::...
function Packet (line 558) | inline Packet packetOp(const Packet& a) const { return internal::pcosh(a...
function Scalar (line 576) | inline Scalar operator() (const Scalar& a) const { return Scalar(1)/a; }
function Packet (line 578) | inline const Packet packetOp(const Packet& a) const
function Scalar (line 592) | inline Scalar operator() (const Scalar& a) const { return a*a; }
function Packet (line 594) | inline const Packet packetOp(const Packet& a) const
function Scalar (line 608) | inline Scalar operator() (const Scalar& a) const { return a*a*a; }
function Packet (line 610) | inline const Packet packetOp(const Packet& a) const
function EIGEN_STRONG_INLINE (line 623) | EIGEN_STRONG_INLINE const Scalar operator() (const Scalar& a) const { re...
function Packet (line 625) | inline Packet packetOp(const Packet& a) const { return internal::pround(...
function EIGEN_STRONG_INLINE (line 642) | EIGEN_STRONG_INLINE const Scalar operator() (const Scalar& a) const { re...
function Packet (line 644) | inline Packet packetOp(const Packet& a) const { return internal::pfloor(...
function EIGEN_STRONG_INLINE (line 661) | EIGEN_STRONG_INLINE const Scalar operator() (const Scalar& a) const { re...
function Packet (line 663) | inline Packet packetOp(const Packet& a) const { return internal::pceil(a...
function result_type (line 681) | result_type operator() (const Scalar& a) const { return (numext::isnan)(...
function result_type (line 699) | result_type operator() (const Scalar& a) const { return (numext::isinf)(...
function result_type (line 717) | result_type operator() (const Scalar& a) const { return (numext::isfinit...
function const (line 735) | bool operator() (const bool& a) const { return !a; }
function EIGEN_DEVICE_FUNC (line 753) | EIGEN_DEVICE_FUNC inline const Scalar operator() (const Scalar& a) const
function EIGEN_DEVICE_FUNC (line 764) | EIGEN_DEVICE_FUNC inline const Scalar operator() (const Scalar& a) const
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/Eigen/Eigen/src/Core/products/GeneralBlockPanelKernel.h
function namespace (line 14) | namespace Eigen {
function EIGEN_ALWAYS_INLINE (line 317) | EIGEN_ALWAYS_INLINE static void run(const CJ& cj, A& a, B& b, C& c, T& /...
function gebp_madd (line 331) | void gebp_madd(const CJ& cj, A& a, B& b, C& c, T& t)
type _RhsScalar (line 355) | typedef _RhsScalar RhsScalar;
type typename (line 356) | typedef typename ScalarBinaryOpTraits<LhsScalar, RhsScalar>::ReturnType ...
type typename (line 386) | typedef typename packet_traits<LhsScalar>::type _LhsPacket;
type typename (line 387) | typedef typename packet_traits<RhsScalar>::type _RhsPacket;
type typename (line 388) | typedef typename packet_traits<ResScalar>::type _ResPacket;
type typename (line 390) | typedef typename conditional<Vectorizable,_LhsPacket,LhsScalar>::type Lh...
type typename (line 391) | typedef typename conditional<Vectorizable,_RhsPacket,RhsScalar>::type Rh...
type typename (line 392) | typedef typename conditional<Vectorizable,_ResPacket,ResScalar>::type Re...
type ResPacket (line 394) | typedef ResPacket AccPacket;
function EIGEN_STRONG_INLINE (line 401) | EIGEN_STRONG_INLINE void broadcastRhs(const RhsScalar* b, RhsPacket& b0,...
function loadRhs (line 412) | void loadRhs(const RhsScalar* b, RhsPacketType& dest) const
function EIGEN_STRONG_INLINE (line 417) | EIGEN_STRONG_INLINE void loadRhsQuad(const RhsScalar* b, RhsPacket& dest...
function loadLhs (line 423) | void loadLhs(const LhsScalar* a, LhsPacketType& dest) const
function loadLhsUnaligned (line 429) | void loadLhsUnaligned(const LhsScalar* a, LhsPacketType& dest) const
function madd (line 435) | void madd(const LhsPacketType& a, const RhsPacketType& b, AccPacketType&...
function EIGEN_STRONG_INLINE (line 450) | EIGEN_STRONG_INLINE void acc(const AccPacket& c, const ResPacket& alpha,...
function acc (line 456) | void acc(const ResPacketHalf& c, const ResPacketHalf& alpha, ResPacketHa...
type RealScalar (line 468) | typedef RealScalar RhsScalar;
type typename (line 469) | typedef typename ScalarBinaryOpTraits<LhsScalar, RhsScalar>::ReturnType ...
type typename (line 492) | typedef typename packet_traits<LhsScalar>::type _LhsPacket;
type typename (line 493) | typedef typename packet_traits<RhsScalar>::type _RhsPacket;
type typename (line 494) | typedef typename packet_traits<ResScalar>::type _ResPacket;
type typename (line 496) | typedef typename conditional<Vectorizable,_LhsPacket,LhsScalar>::type Lh...
type typename (line 497) | typedef typename conditional<Vectorizable,_RhsPacket,RhsScalar>::type Rh...
type typename (line 498) | typedef typename conditional<Vectorizable,_ResPacket,ResScalar>::type Re...
type ResPacket (line 500) | typedef ResPacket AccPacket;
function EIGEN_STRONG_INLINE (line 507) | EIGEN_STRONG_INLINE void loadRhs(const RhsScalar* b, RhsPacket& dest) const
function EIGEN_STRONG_INLINE (line 512) | EIGEN_STRONG_INLINE void loadRhsQuad(const RhsScalar* b, RhsPacket& dest...
function EIGEN_STRONG_INLINE (line 517) | EIGEN_STRONG_INLINE void loadLhs(const LhsScalar* a, LhsPacket& dest) const
function EIGEN_STRONG_INLINE (line 522) | EIGEN_STRONG_INLINE void loadLhsUnaligned(const LhsScalar* a, LhsPacket&...
function EIGEN_STRONG_INLINE (line 527) | EIGEN_STRONG_INLINE void broadcastRhs(const RhsScalar* b, RhsPacket& b0,...
function EIGEN_STRONG_INLINE (line 537) | EIGEN_STRONG_INLINE void madd(const LhsPacket& a, const RhsPacket& b, Ac...
function EIGEN_STRONG_INLINE (line 542) | EIGEN_STRONG_INLINE void madd_impl(const LhsPacket& a, const RhsPacket& ...
function EIGEN_STRONG_INLINE (line 552) | EIGEN_STRONG_INLINE void madd_impl(const LhsScalar& a, const RhsScalar& ...
function EIGEN_STRONG_INLINE (line 557) | EIGEN_STRONG_INLINE void acc(const AccPacket& c, const ResPacket& alpha,...
type std (line 603) | typedef std::complex<RealScalar> LhsScalar;
type std (line 604) | typedef std::complex<RealScalar> RhsScalar;
type std (line 605) | typedef std::complex<RealScalar> ResScalar;
type typename (line 625) | typedef typename packet_traits<RealScalar>::type RealPacket;
type typename (line 626) | typedef typename packet_traits<Scalar>::type ScalarPacket;
type DoublePacket (line 627) | typedef DoublePacket<RealPacket> DoublePacketType;
type typename (line 629) | typedef typename conditional<Vectorizable,RealPacket, Scalar>::type Lhs...
type typename (line 630) | typedef typename conditional<Vectorizable,DoublePacketType,Scalar>::type...
type typename (line 631) | typedef typename conditional<Vectorizable,ScalarPacket,Scalar>::type Res...
type typename (line 632) | typedef typename conditional<Vectorizable,DoublePacketType,Scalar>::type...
function EIGEN_STRONG_INLINE (line 643) | EIGEN_STRONG_INLINE void loadRhs(const RhsScalar* b, ResPacket& dest) const
function EIGEN_STRONG_INLINE (line 649) | EIGEN_STRONG_INLINE void loadRhs(const RhsScalar* b, DoublePacketType& d...
function EIGEN_STRONG_INLINE (line 655) | EIGEN_STRONG_INLINE void loadRhsQuad(const RhsScalar* b, ResPacket& dest...
function EIGEN_STRONG_INLINE (line 659) | EIGEN_STRONG_INLINE void loadRhsQuad(const RhsScalar* b, DoublePacketTyp...
function EIGEN_STRONG_INLINE (line 665) | EIGEN_STRONG_INLINE void broadcastRhs(const RhsScalar* b, RhsPacket& b0,...
function EIGEN_STRONG_INLINE (line 675) | EIGEN_STRONG_INLINE void broadcastRhs(const RhsScalar* b, DoublePacketTy...
function EIGEN_STRONG_INLINE (line 683) | EIGEN_STRONG_INLINE void broadcastRhs(const RhsScalar* b, RhsScalar& b0,...
function EIGEN_STRONG_INLINE (line 691) | EIGEN_STRONG_INLINE void loadLhs(const LhsScalar* a, LhsPacket& dest) const
function EIGEN_STRONG_INLINE (line 696) | EIGEN_STRONG_INLINE void loadLhsUnaligned(const LhsScalar* a, LhsPacket&...
function EIGEN_STRONG_INLINE (line 701) | EIGEN_STRONG_INLINE void madd(const LhsPacket& a, const RhsPacket& b, Do...
function EIGEN_STRONG_INLINE (line 707) | EIGEN_STRONG_INLINE void madd(const LhsPacket& a, const RhsPacket& b, Re...
function EIGEN_STRONG_INLINE (line 712) | EIGEN_STRONG_INLINE void acc(const Scalar& c, const Scalar& alpha, Scala...
function EIGEN_STRONG_INLINE (line 714) | EIGEN_STRONG_INLINE void acc(const DoublePacketType& c, const ResPacket&...
type RealScalar (line 751) | typedef RealScalar LhsScalar;
type Scalar (line 752) | typedef Scalar RhsScalar;
type Scalar (line 753) | typedef Scalar ResScalar;
type typename (line 773) | typedef typename packet_traits<LhsScalar>::type _LhsPacket;
type typename (line 774) | typedef typename packet_traits<RhsScalar>::type _RhsPacket;
type typename (line 775) | typedef typename packet_traits<ResScalar>::type _ResPacket;
type typename (line 777) | typedef typename conditional<Vectorizable,_LhsPacket,LhsScalar>::type Lh...
type typename (line 778) | typedef typename conditional<Vectorizable,_RhsPacket,RhsScalar>::type Rh...
type typename (line 779) | typedef typename conditional<Vectorizable,_ResPacket,ResScalar>::type Re...
type ResPacket (line 781) | typedef ResPacket AccPacket;
function EIGEN_STRONG_INLINE (line 788) | EIGEN_STRONG_INLINE void loadRhs(const RhsScalar* b, RhsPacket& dest) const
function broadcastRhs (line 793) | void broadcastRhs(const RhsScalar* b, RhsPacket& b0, RhsPacket& b1, RhsP...
function EIGEN_STRONG_INLINE (line 805) | EIGEN_STRONG_INLINE void loadLhs(const LhsScalar* a, LhsPacket& dest) const
function EIGEN_STRONG_INLINE (line 810) | EIGEN_STRONG_INLINE void loadRhsQuad(const RhsScalar* b, RhsPacket& dest...
function EIGEN_STRONG_INLINE (line 816) | EIGEN_STRONG_INLINE void loadLhsUnaligned(const LhsScalar* a, LhsPacket&...
function EIGEN_STRONG_INLINE (line 821) | EIGEN_STRONG_INLINE void madd(const LhsPacket& a, const RhsPacket& b, Ac...
function EIGEN_STRONG_INLINE (line 826) | EIGEN_STRONG_INLINE void madd_impl(const LhsPacket& a, const RhsPacket& ...
function EIGEN_STRONG_INLINE (line 837) | EIGEN_STRONG_INLINE void madd_impl(const LhsScalar& a, const RhsScalar& ...
function EIGEN_STRONG_INLINE (line 842) | EIGEN_STRONG_INLINE void acc(const AccPacket& c, const ResPacket& alpha,...
type gebp_traits (line 861) | typedef gebp_traits<LhsScalar,RhsScalar,ConjugateLhs,ConjugateRhs> Traits;
type typename (line 862) | typedef typename Traits::ResScalar ResScalar;
type typename (line 863) | typedef typename Traits::LhsPacket LhsPacket;
type typename (line 864) | typedef typename Traits::RhsPacket RhsPacket;
type typename (line 865) | typedef typename Traits::ResPacket ResPacket;
type typename (line 866) | typedef typename Traits::AccPacket AccPacket;
type gebp_traits (line 868) | typedef gebp_traits<RhsScalar,LhsScalar,ConjugateRhs,ConjugateLhs> Swapp...
type typename (line 869) | typedef typename SwappedTraits::ResScalar SResScalar;
type typename (line 870) | typedef typename SwappedTraits::LhsPacket SLhsPacket;
type typename (line 871) | typedef typename SwappedTraits::RhsPacket SRhsPacket;
type typename (line 872) | typedef typename SwappedTraits::ResPacket SResPacket;
type typename (line 873) | typedef typename SwappedTraits::AccPacket SAccPacket;
type typename (line 875) | typedef typename DataMapper::LinearMapper LinearMapper;
type typename (line 1591) | typedef typename conditional<SwappedTraits::LhsProgress>=8,typename
type typename (line 1592) | typedef typename conditional<SwappedTraits::LhsProgress>=8,typename
type typename (line 1593) | typedef typename conditional<SwappedTraits::LhsProgress>=8,typename
type typename (line 1594) | typedef typename conditional<SwappedTraits::LhsProgress>=8,typename
type typename (line 1901) | typedef typename DataMapper::LinearMapper LinearMapper;
type typename (line 2025) | typedef typename DataMapper::LinearMapper LinearMapper;
function l1CacheSize (line 2118) | inline std::ptrdiff_t l1CacheSize()
function l2CacheSize (line 2127) | inline std::ptrdiff_t l2CacheSize()
function l3CacheSize (line 2137) | inline std::ptrdiff_t l3CacheSize()
function setCpuCacheSizes (line 2149) | inline void setCpuCacheSizes(std::ptrdiff_t l1, std::ptrdiff_t l2, std::...
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/Eigen/Eigen/src/Core/products/GeneralMatrixMatrix.h
function namespace (line 13) | namespace Eigen {
type typename (line 58) | typedef typename ScalarBinaryOpTraits<LhsScalar, RhsScalar>::ReturnType ...
type const_blas_data_mapper (line 68) | typedef const_blas_data_mapper<RhsScalar, Index, RhsStorageOrder> RhsMap...
type blas_data_mapper (line 69) | typedef blas_data_mapper<typename
function initParallelSession (line 215) | void initParallelSession(Index num_threads) const
type typename (line 233) | typedef typename Gemm::Traits Traits;
type _LhsScalar (line 249) | typedef _LhsScalar LhsScalar;
type _RhsScalar (line 250) | typedef _RhsScalar RhsScalar;
function LhsScalar (line 270) | inline LhsScalar* blockA() { return m_blockA; }
function RhsScalar (line 271) | inline RhsScalar* blockB() { return m_blockB; }
type typename (line 285) | typedef typename conditional<Transpose,_RhsScalar,_LhsScalar>::type LhsS...
type typename (line 286) | typedef typename conditional<Transpose,_LhsScalar,_RhsScalar>::type RhsS...
type gebp_traits (line 287) | typedef gebp_traits<LhsScalar,RhsScalar> Traits;
function initParallel (line 317) | void initParallel(Index, Index, Index, Index)
function allocateA (line 320) | inline void allocateA() {}
function allocateB (line 321) | inline void allocateB() {}
function allocateAll (line 322) | inline void allocateAll() {}
type typename (line 334) | typedef typename conditional<Transpose,_RhsScalar,_LhsScalar>::type LhsS...
type typename (line 335) | typedef typename conditional<Transpose,_LhsScalar,_RhsScalar>::type RhsS...
type gebp_traits (line 336) | typedef gebp_traits<LhsScalar,RhsScalar> Traits;
function initParallel (line 363) | void initParallel(Index rows, Index cols, Index depth, Index num_threads)
function allocateA (line 376) | void allocateA()
function allocateB (line 382) | void allocateB()
function allocateAll (line 388) | void allocateAll()
function namespace (line 403) | namespace internal {
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/Eigen/Eigen/src/Core/products/GeneralMatrixMatrixTriangular.h
function namespace (line 13) | namespace Eigen {
type gebp_traits (line 139) | typedef gebp_traits<LhsScalar,RhsScalar,ConjLhs,ConjRhs> Traits;
type typename (line 140) | typedef typename Traits::ResScalar ResScalar;
type blas_data_mapper (line 147) | typedef blas_data_mapper<ResScalar, Index, ColMajor> ResMapper;
type typename (line 206) | typedef typename internal::remove_all<typename
type internal (line 207) | typedef internal::blas_traits<Lhs> LhsBlasTraits;
type typename (line 208) | typedef typename LhsBlasTraits::DirectLinearAccessType ActualLhs;
type typename (line 209) | typedef typename internal::remove_all<ActualLhs>::type _ActualLhs;
type typename (line 212) | typedef typename internal::remove_all<typename
type internal (line 213) | typedef internal::blas_traits<Rhs> RhsBlasTraits;
type typename (line 214) | typedef typename RhsBlasTraits::DirectLinearAccessType ActualRhs;
type typename (line 215) | typedef typename internal::remove_all<ActualRhs>::type _ActualRhs;
type internal (line 253) | typedef internal::blas_traits<Lhs> LhsBlasTraits;
type typename (line 254) | typedef typename LhsBlasTraits::DirectLinearAccessType ActualLhs;
type typename (line 255) | typedef typename internal::remove_all<ActualLhs>::type _ActualLhs;
type typename (line 258) | typedef typename internal::remove_all<typename
type internal (line 259) | typedef internal::blas_traits<Rhs> RhsBlasTraits;
type typename (line 260) | typedef typename RhsBlasTraits::DirectLinearAccessType ActualRhs;
type typename (line 261) | typedef typename internal::remove_all<ActualRhs>::type _ActualRhs;
type internal (line 281) | typedef internal::gemm_blocking_space<IsRowMajor ? RowMajor : ColMajor,t...
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/Eigen/Eigen/src/Core/products/GeneralMatrixMatrixTriangular_BLAS.h
function namespace (line 36) | namespace Eigen {
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/Eigen/Eigen/src/Core/products/GeneralMatrixMatrix_BLAS.h
function namespace (line 38) | namespace internal {
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/Eigen/Eigen/src/Core/products/GeneralMatrixVector.h
function namespace (line 13) | namespace Eigen {
type typename (line 347) | typedef typename packet_traits<LhsScalar>::type _LhsPacket;
type typename (line 348) | typedef typename packet_traits<RhsScalar>::type _RhsPacket;
type typename (line 349) | typedef typename packet_traits<ResScalar>::type _ResPacket;
type typename (line 351) | typedef typename conditional<Vectorizable,_LhsPacket,LhsScalar>::type Lh...
type typename (line 352) | typedef typename conditional<Vectorizable,_RhsPacket,RhsScalar>::type Rh...
type typename (line 353) | typedef typename conditional<Vectorizable,_ResPacket,ResScalar>::type Re...
type typename (line 387) | typedef typename LhsMapper::VectorMapper LhsScalars;
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/Eigen/Eigen/src/Core/products/GeneralMatrixVector_BLAS.h
function namespace (line 36) | namespace Eigen {
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/Eigen/Eigen/src/Core/products/Parallelizer.h
function namespace (line 13) | namespace Eigen {
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/Eigen/Eigen/src/Core/products/SelfadjointMatrixMatrix.h
function namespace (line 13) | namespace Eigen {
type gebp_traits (line 332) | typedef gebp_traits<Scalar,Scalar> Traits;
type const_blas_data_mapper (line 334) | typedef const_blas_data_mapper<Scalar, Index, LhsStorageOrder> LhsMapper;
type const_blas_data_mapper (line 335) | typedef const_blas_data_mapper<Scalar, Index, (LhsStorageOrder == RowMaj...
type const_blas_data_mapper (line 336) | typedef const_blas_data_mapper<Scalar, Index, RhsStorageOrder> RhsMapper;
type blas_data_mapper (line 337) | typedef blas_data_mapper<typename
type gebp_traits (line 425) | typedef gebp_traits<Scalar,Scalar> Traits;
type const_blas_data_mapper (line 427) | typedef const_blas_data_mapper<Scalar, Index, LhsStorageOrder> LhsMapper;
type blas_data_mapper (line 428) | typedef blas_data_mapper<typename
function namespace (line 466) | namespace internal {
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/Eigen/Eigen/src/Core/products/SelfadjointMatrixVector.h
function namespace (line 13) | namespace Eigen {
function namespace (line 160) | namespace internal {
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/Eigen/Eigen/src/Core/products/SelfadjointMatrixVector_BLAS.h
function namespace (line 36) | namespace Eigen {
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/Eigen/Eigen/src/Core/products/SelfadjointProduct.h
function namespace (line 19) | namespace Eigen {
type internal (line 56) | typedef internal::blas_traits<OtherType> OtherBlasTraits;
type typename (line 57) | typedef typename OtherBlasTraits::DirectLinearAccessType ActualOtherType;
type typename (line 58) | typedef typename internal::remove_all<ActualOtherType>::type _ActualOthe...
type internal (line 88) | typedef internal::blas_traits<OtherType> OtherBlasTraits;
type typename (line 89) | typedef typename OtherBlasTraits::DirectLinearAccessType ActualOtherType;
type typename (line 90) | typedef typename internal::remove_all<ActualOtherType>::type _ActualOthe...
type internal (line 103) | typedef internal::gemm_blocking_space<IsRowMajor ? RowMajor : ColMajor,S...
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/Eigen/Eigen/src/Core/products/SelfadjointRank2Update.h
function namespace (line 13) | namespace Eigen {
type typename (line 64) | typedef typename UBlasTraits::DirectLinearAccessType ActualUType;
type typename (line 65) | typedef typename internal::remove_all<ActualUType>::type _ActualUType;
type internal (line 68) | typedef internal::blas_traits<DerivedV> VBlasTraits;
type typename (line 69) | typedef typename VBlasTraits::DirectLinearAccessType ActualVType;
type typename (line 70) | typedef typename internal::remove_all<ActualVType>::type _ActualVType;
type typename (line 82) | typedef typename internal::remove_all<typename
type typename (line 83) | typedef typename internal::remove_all<typename
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/Eigen/Eigen/src/Core/products/TriangularMatrixMatrix.h
function namespace (line 13) | namespace Eigen {
type const_blas_data_mapper (line 120) | typedef const_blas_data_mapper<Scalar, Index, LhsStorageOrder> LhsMapper;
type const_blas_data_mapper (line 121) | typedef const_blas_data_mapper<Scalar, Index, RhsStorageOrder> RhsMapper;
type blas_data_mapper (line 122) | typedef blas_data_mapper<typename
type const_blas_data_mapper (line 277) | typedef const_blas_data_mapper<Scalar, Index, LhsStorageOrder> LhsMapper;
type const_blas_data_mapper (line 278) | typedef const_blas_data_mapper<Scalar, Index, RhsStorageOrder> RhsMapper;
type blas_data_mapper (line 279) | typedef blas_data_mapper<typename
function namespace (line 397) | namespace internal {
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/Eigen/Eigen/src/Core/products/TriangularMatrixMatrix_BLAS.h
function namespace (line 36) | namespace Eigen {
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/Eigen/Eigen/src/Core/products/TriangularMatrixVector.h
function namespace (line 13) | namespace Eigen {
type Map (line 114) | typedef Map<const Matrix<LhsScalar,Dynamic,Dynamic,RowMajor>, 0, OuterSt...
function LhsMap (line 115) | const LhsMap lhs(_lhs,rows,cols,OuterStride<>(lhsStride));
function namespace (line 171) | namespace internal {
function namespace (line 200) | namespace internal {
function run (line 290) | void run(const Lhs &lhs, const Rhs &rhs, Dest& dest, const typename Dest...
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/Eigen/Eigen/src/Core/products/TriangularMatrixVector_BLAS.h
type VectorX (line 96) | typedef VectorX##EIGPREFIX VectorRhs;
type VectorX (line 185) | typedef VectorX##EIGPREFIX VectorRhs;
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/Eigen/Eigen/src/Core/products/TriangularSolverMatrix.h
function namespace (line 13) | namespace Eigen {
type const_blas_data_mapper (line 56) | typedef const_blas_data_mapper<Scalar, Index, TriStorageOrder> TriMapper;
type blas_data_mapper (line 57) | typedef blas_data_mapper<Scalar, Index, ColMajor> OtherMapper;
type gebp_traits (line 61) | typedef gebp_traits<Scalar,Scalar> Traits;
type typename (line 205) | typedef typename NumTraits<Scalar>::Real RealScalar;
type blas_data_mapper (line 207) | typedef blas_data_mapper<Scalar, Index, ColMajor> LhsMapper;
type const_blas_data_mapper (line 208) | typedef const_blas_data_mapper<Scalar, Index, TriStorageOrder> RhsMapper;
type gebp_traits (line 212) | typedef gebp_traits<Scalar,Scalar> Traits;
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/Eigen/Eigen/src/Core/products/TriangularSolverMatrix_BLAS.h
function namespace (line 36) | namespace Eigen {
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/Eigen/Eigen/src/Core/products/TriangularSolverVector.h
function namespace (line 13) | namespace Eigen {
type Map (line 38) | typedef Map<const Matrix<LhsScalar,Dynamic,Dynamic,RowMajor>, 0, OuterSt...
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/Eigen/Eigen/src/Core/util/BlasUtil.h
function namespace (line 16) | namespace Eigen {
function EIGEN_STRONG_INLINE (line 81) | EIGEN_STRONG_INLINE Scalar pmadd(const Scalar& x, const Scalar& y, const...
function EIGEN_STRONG_INLINE (line 84) | EIGEN_STRONG_INLINE Scalar pmul(const Scalar& x, const Scalar& y) const
function EIGEN_STRONG_INLINE (line 91) | EIGEN_STRONG_INLINE Scalar pmadd(const Scalar& x, const Scalar& y, const...
function EIGEN_STRONG_INLINE (line 94) | EIGEN_STRONG_INLINE Scalar pmul(const Scalar& x, const Scalar& y) const
function EIGEN_STRONG_INLINE (line 101) | EIGEN_STRONG_INLINE Scalar pmadd(const Scalar& x, const Scalar& y, const...
function EIGEN_STRONG_INLINE (line 104) | EIGEN_STRONG_INLINE Scalar pmul(const Scalar& x, const Scalar& y) const
type std (line 110) | typedef std::complex<RealScalar> Scalar;
function EIGEN_STRONG_INLINE (line 111) | EIGEN_STRONG_INLINE Scalar pmadd(const Scalar& x, const RealScalar& y, c...
function EIGEN_STRONG_INLINE (line 113) | EIGEN_STRONG_INLINE Scalar pmul(const Scalar& x, const RealScalar& y) const
type std (line 119) | typedef std::complex<RealScalar> Scalar;
function EIGEN_STRONG_INLINE (line 120) | EIGEN_STRONG_INLINE Scalar pmadd(const RealScalar& x, const Scalar& y, c...
function EIGEN_STRONG_INLINE (line 122) | EIGEN_STRONG_INLINE Scalar pmul(const RealScalar& x, const Scalar& y) const
function To (line 127) | To run(const From& x) { return To(x); }
function typename (line 132) | typename NumTraits<Scalar>::Real run(const Scalar& x) { return numext::r...
function m_data (line 139) | m_data(data) {}
function Scalar (line 141) | Scalar operator()(Index i) const {
function EIGEN_ALWAYS_INLINE (line 145) | EIGEN_ALWAYS_INLINE Packet load(Index i) const {
function aligned (line 150) | bool aligned(Index i) const {
type typename (line 162) | typedef typename packet_traits<Scalar>::half HalfPacket;
function m_data (line 164) | m_data(data) {}
function prefetch (line 166) | void prefetch(int i) const {
function Packet (line 174) | Packet loadPacket(Index i) const {
function HalfPacket (line 178) | HalfPacket loadHalfPacket(Index i) const {
function storePacket (line 182) | void storePacket(Index i, const Packet &p) const {
type typename (line 195) | typedef typename packet_traits<Scalar>::half HalfPacket;
type BlasLinearMapper (line 197) | typedef BlasLinearMapper<Scalar, Index, AlignmentType> LinearMapper;
type BlasVectorMapper (line 198) | typedef BlasVectorMapper<Scalar, Index> VectorMapper;
function EIGEN_DEVICE_FUNC (line 200) | EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE blas_data_mapper(Scalar* data, Ind...
function LinearMapper (line 207) | LinearMapper getLinearMapper(Index i, Index j) const {
function VectorMapper (line 211) | VectorMapper getVectorMapper(Index i, Index j) const {
function Packet (line 221) | Packet loadPacket(Index i, Index j) const {
function HalfPacket (line 225) | HalfPacket loadHalfPacket(Index i, Index j) const {
function scatterPacket (line 230) | void scatterPacket(Index i, Index j, const SubPacket &p) const {
function EIGEN_ALWAYS_INLINE (line 235) | EIGEN_ALWAYS_INLINE SubPacket gatherPacket(Index i, Index j) const {
function EIGEN_DEVICE_FUNC (line 240) | EIGEN_DEVICE_FUNC const Scalar* data() const { return m_data; }
function EIGEN_DEVICE_FUNC (line 242) | EIGEN_DEVICE_FUNC Index firstAligned(Index size) const {
type typename (line 271) | typedef typename traits<XprType>::Scalar Scalar;
type XprType (line 272) | typedef const XprType& ExtractType;
type XprType (line 273) | typedef XprType _ExtractType;
type typename (line 283) | typedef typename conditional<bool(HasUsableDirectAccess),
function ExtractType (line 287) | static inline ExtractType extract(const XprType& x) { return x; }
function Scalar (line 288) | static inline const Scalar extractScalarFactor(const XprType&) { return ...
type CwiseUnaryOp (line 297) | typedef CwiseUnaryOp<scalar_conjugate_op<Scalar>, NestedXpr> XprType;
type typename (line 298) | typedef typename Base::ExtractType ExtractType;
function ExtractType (line 304) | static inline ExtractType extract(const XprType& x) { return Base::extra...
function Scalar (line 305) | static inline Scalar extractScalarFactor(const XprType& x) { return conj...
type CwiseBinaryOp (line 314) | typedef CwiseBinaryOp<scalar_product_op<Scalar>, const
type typename (line 315) | typedef typename Base::ExtractType ExtractType;
function ExtractType (line 316) | static inline ExtractType extract(const XprType& x) { return Base::extra...
function Scalar (line 317) | static inline Scalar extractScalarFactor(const XprType& x)
type CwiseBinaryOp (line 325) | typedef CwiseBinaryOp<scalar_product_op<Scalar>, NestedXpr, const
type typename (line 326) | typedef typename Base::ExtractType ExtractType;
function ExtractType (line 327) | static inline ExtractType extract(const XprType& x) { return Base::extra...
function Scalar (line 328) | static inline Scalar extractScalarFactor(const XprType& x)
type CwiseUnaryOp (line 343) | typedef CwiseUnaryOp<scalar_opposite_op<Scalar>, NestedXpr> XprType;
type typename (line 344) | typedef typename Base::ExtractType ExtractType;
function ExtractType (line 345) | static inline ExtractType extract(const XprType& x) { return Base::extra...
function Scalar (line 346) | static inline Scalar extractScalarFactor(const XprType& x)
type typename (line 355) | typedef typename NestedXpr::Scalar Scalar;
type blas_traits (line 356) | typedef blas_traits<NestedXpr> Base;
type Transpose (line 357) | typedef Transpose<NestedXpr> XprType;
type Transpose (line 358) | typedef Transpose<const typename
type Transpose (line 359) | typedef Transpose<const typename
type typename (line 360) | typedef typename conditional<bool(Base::HasUsableDirectAccess),
function ExtractType (line 367) | static inline ExtractType extract(const XprType& x) { return ExtractType...
function Scalar (line 368) | static inline Scalar extractScalarFactor(const XprType& x) { return Base...
function typename (line 378) | static const typename T::Scalar* run(const T& m)
function typename (line 386) | static typename T::Scalar* run(const T&) { return 0; }
function typename (line 389) | typename T::Scalar* extract_data(const T& m)
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/Eigen/Eigen/src/Core/util/Constants.h
type UpLoType (line 202) | enum UpLoType {
type AlignmentType (line 227) | enum AlignmentType {
type CornerType (line 257) | enum CornerType { TopLeft, TopRight, BottomLeft, BottomRight }
type DirectionType (line 262) | enum DirectionType {
type TraversalType (line 276) | enum TraversalType {
type UnrollingType (line 298) | enum UnrollingType {
type SpecializedType (line 310) | enum SpecializedType {
type StorageOptions (line 318) | enum StorageOptions {
type SideType (line 331) | enum SideType {
type NoChange_t (line 350) | enum NoChange_t { NoChange }
type Sequential_t (line 351) | enum Sequential_t { Sequential }
type Default_t (line 352) | enum Default_t { Default }
type AmbiVectorMode (line 356) | enum AmbiVectorMode {
type AccessorLevels (line 364) | enum AccessorLevels {
type DecompositionOptions (line 377) | enum DecompositionOptions {
type QRPreconditioners (line 413) | enum QRPreconditioners {
type ComputationInfo (line 430) | enum ComputationInfo {
type TransformTraits (line 445) | enum TransformTraits {
function namespace (line 459) | namespace Architecture
type ProductImplType (line 483) | enum ProductImplType
type Action (line 488) | enum Action {GetAction, SetAction}
type Dense (line 491) | struct Dense {}
type Sparse (line 494) | struct Sparse {}
type SolverStorage (line 497) | struct SolverStorage {}
type PermutationStorage (line 500) | struct PermutationStorage {}
type TranspositionsStorage (line 503) | struct TranspositionsStorage {}
type MatrixXpr (line 506) | struct MatrixXpr {}
type ArrayXpr (line 509) | struct ArrayXpr {}
type HomogeneousShape (line 514) | struct HomogeneousShape { static std::string debugName() { return ...
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/Eigen/Eigen/src/Core/util/ForwardDeclarations.h
function namespace (line 14) | namespace Eigen {
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/Eigen/Eigen/src/Core/util/MKL_support.h
function namespace (line 116) | namespace Eigen {
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/Eigen/Eigen/src/Core/util/Macros.h
function namespace (line 544) | namespace Eigen {
function namespace (line 555) | namespace Eigen {
function namespace (line 613) | namespace Eigen {
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/Eigen/Eigen/src/Core/util/Memory.h
function namespace (line 62) | namespace Eigen {
function conditional_aligned_free (line 228) | inline void conditional_aligned_free(void *ptr)
function destruct_elements_of_array (line 255) | inline void destruct_elements_of_array(T *ptr, std::size_t size)
function T (line 265) | inline T* construct_elements_of_array(T *ptr, std::size_t size)
function check_size_for_overflow (line 286) | void check_size_for_overflow(std::size_t size)
function T (line 296) | inline T* aligned_new(std::size_t size)
function T (line 312) | inline T* conditional_aligned_new(std::size_t size)
function aligned_delete (line 331) | inline void aligned_delete(T *ptr, std::size_t size)
function conditional_aligned_delete (line 340) | inline void conditional_aligned_delete(T *ptr, std::size_t size)
function T (line 346) | inline T* conditional_aligned_realloc_new(T* pts, std::size_t new_size, ...
function T (line 369) | inline T* conditional_aligned_new_auto(std::size_t size)
function conditional_aligned_delete_auto (line 412) | inline void conditional_aligned_delete_auto(T *ptr, std::size_t size)
function Index (line 439) | inline Index first_aligned(const Scalar* array, Index size)
function Index (line 467) | inline Index first_default_aligned(const Scalar* array, Index size)
function Index (line 476) | Index first_multiple(Index size, Index base)
function smart_copy (line 485) | void smart_copy(const T* start, const T* end, T* target)
function EIGEN_DEVICE_FUNC (line 491) | EIGEN_DEVICE_FUNC static inline void run(const T* start, const T* end, T...
function EIGEN_DEVICE_FUNC (line 501) | EIGEN_DEVICE_FUNC static inline void run(const T* start, const T* end, T...
function run (line 514) | static inline void run(const T* start, const T* end, T* target)
function run (line 524) | static inline void run(const T* start, const T* end, T* target)
function T (line 596) | const T& operator[](std::ptrdiff_t i) const { return m_ptr[i]; }
function T (line 598) | const T* ptr() const { return m_ptr; }
function operator (line 599) | operator const T*() const { return m_ptr; }
function operator (line 682) | operator delete(void *ptr, const std::nothrow_t&) EIGEN_NO_THROW { \
type eigen_aligned_operator_new_marker_type (line 685) | typedef void eigen_aligned_operator_new_marker_type;
type T (line 726) | typedef T* pointer;
type T (line 727) | typedef const T* const_pointer;
type T (line 728) | typedef T& reference;
type T (line 729) | typedef const T& const_reference;
type T (line 730) | typedef T value_type;
type aligned_allocator (line 735) | typedef aligned_allocator<U> other;
function deallocate (line 761) | void deallocate(pointer p, size_type /*num*/)
function namespace (line 792) | namespace internal {
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/Eigen/Eigen/src/Core/util/Meta.h
function namespace (line 23) | namespace Eigen {
type T (line 140) | typedef const T type;
type T (line 141) | typedef T const& type;
type T (line 142) | typedef T const* type;
type T (line 143) | typedef T const* const type;
type T (line 144) | typedef T const* const type;
type any_conversion (line 151) | struct any_conversion
type yes (line 156) | struct yes {int a[1];}
type no (line 157) | struct no {int a[2];}
type T (line 187) | typedef T type;
function namespace (line 195) | namespace device {
function class (line 294) | class noncopyable
type typename (line 312) | typedef typename std::result_of<T>::type type1;
type typename (line 313) | typedef typename remove_all<type1>::type type;
type has_none (line 318) | struct has_none {int a[1];}
type has_std_result_type (line 319) | struct has_std_result_type {int a[2];}
type has_tr1_result (line 320) | struct has_tr1_result {int a[3];}
type typename (line 323) | typedef typename internal::remove_all<ArgType>::type type;
type typename (line 341) | typedef typename unary_result_of_select<Func, ArgType, FunctorType>::typ...
type typename (line 345) | typedef typename internal::remove_all<ArgType0>::type type;
type typename (line 365) | typedef typename binary_result_of_select<Func, ArgType0, ArgType1, Funct...
type typename (line 369) | typedef typename internal::remove_all<ArgType0>::type type;
type typename (line 389) | typedef typename ternary_result_of_select<Func, ArgType0, ArgType1, ArgT...
type meta_yes (line 393) | struct meta_yes { char a[1]; }
type meta_no (line 394) | struct meta_no { char a[2]; }
function meta_yes (line 411) | meta_yes testFunctor(C const *,typename enable_if<(sizeof(return_ptr<C>(...
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/Eigen/Eigen/src/Core/util/StaticAssert.h
function namespace (line 37) | namespace Eigen {
FILE: gp_planner/thirdparty/gtsam-4.1rc/gtsam/3rdparty/Eigen/Eigen/src/Core/util/XprHelper.h
function namespace (line 25) | namespace Eigen {
function class (line 89) | class no_assignment_operator
function EIGEN_STRONG_INLINE (line 110) | EIGEN_STRONG_INLINE explicit variable_if_dynamic(T v) { EIGEN_ONLY_USED_...
function T (line 111) | T value() { return T(Value); }
function setValue (line 112) | void setValue(T) {}
function EIGEN_DEVICE_FUNC (line 118) | EIGEN_DEVICE_FUNC variable_if_dynamic() { eigen_assert(false); }
function explicit (line 120) | explicit variable_if_dynamic(T value) : m_value(value) {}
function setValue (line 122) | void setValue(T value) { m_value = value; }
function EIGEN_STRONG_INLINE (line 131) | EIGEN_STRONG_INLINE explicit variable_if_dynamicindex(T v) { EIGEN_ONLY_...
function T (line 132) | T value() { return T(Value); }
function setValue (line 133) | void setValue(T) {}
function EIGEN_DEVICE_FUNC (line 139) | EIGEN_DEVICE_FUNC variable_if_dynamicindex() { eigen_assert(false); }
function explicit (line 141) | explicit variable_if_dynamicindex(T value) : m_value(value) {}
function setValue (line 143) | void setValue(T value) { m_value = value; }
type T (line 160) | typedef T type;
type T (line 161) | typedef T half;
type typename (line 188) | typedef typename find_best_packet_helper<Size,typename
type typename (line 279) | typedef typename plain_matrix_type_dense<T,typename
type typename (line 283) | typedef typename T::PlainObject type;
type typename (line 316) | typedef typename plain_matrix_type<T>::type type;
type typename (line 329) | typedef typename plain_matrix_type<T>::type type;
type typename (line 352) | typedef typename plain_matrix_type_dense<T,typename
type Matrix (line 365) | typedef Matrix<typename
type Matrix (line 383) | typedef Matrix<typename
type typename (line 398) | typedef typename conditional<
type typename (line 404) | typedef typename conditional<
type typename (line 415) | typedef typename conditional<
type typename (line 452) | typedef typename conditional<Evaluate, PlainObject, typename
function T (line 457) | inline T* const_cast_ptr(const T* ptr)
type typename (line 491) | typedef typename XprType::Scalar CurrentScalarType;
type typename (line 492) | typedef typename remove_all<CastType>::type _CastType;
type typename (line 493) | typedef typename _CastType::Scalar NewScalarType;
type typename (line 494) | typedef typename conditional<is_same<CurrentScalarType,NewScalarType>::v...
type A (line 502) | typedef A ret;
type A (line 506) | typedef A ret;
type A (line 510) | typedef A ret;
type Matrix (line 581) | typedef Matrix<Scalar, 1, ExpressionType::ColsAtCompileTime,
type Array (line 583) | typedef Array<Scalar, 1, ExpressionType::ColsAtCompileTime,
type typename (line 586) | typedef typename conditional<
type Matrix (line 596) | typedef Matrix<Scalar, ExpressionType::RowsAtCompileTime, 1,
type Array (line 598) | typedef Array<Scalar, ExpressionType::RowsAtCompileTime, 1,
type typename (line 601) | typedef typename conditional<
Copy disabled (too large)
Download .json
Condensed preview — 5806 files, each showing path, character count, and a content snippet. Download the .json file for the full structured content (110,845K chars).
[
{
"path": ".gitmodules",
"chars": 118,
"preview": "[submodule \"ros-bridge\"]\n\tpath = ros-bridge\n\turl = https://github.com/carla-simulator/ros-bridge.git\n\tbranch = master\n"
},
{
"path": "LICENSE",
"chars": 1066,
"preview": "MIT License\n\nCopyright (c) 2022 Jie Cheng\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\n"
},
{
"path": "README.md",
"chars": 3738,
"preview": "# GPIR\n\nThis is the project page of the paper \"Real-Time Trajectory Planning for Autonomous Driving with Gaussian Proces"
},
{
"path": "common/.gitignore",
"chars": 19,
"preview": "**/build\n**/install"
},
{
"path": "common/CMakeLists.txt",
"chars": 982,
"preview": "cmake_minimum_required(VERSION 3.13.0)\nproject(common CXX)\n\nif(NOT CMAKE_BUILD_TYPE)\n set(CMAKE_BUILD_TYPE Release)\nend"
},
{
"path": "common/base/state.h",
"chars": 1005,
"preview": "/**\n * Copyright (C) 2022, RAM-LAB, Hong Kong University of Science and Technology\n * This file is part of GPIR (https:/"
},
{
"path": "common/base/trajectory.h",
"chars": 2808,
"preview": "/**\n * Copyright (C) 2022, RAM-LAB, Hong Kong University of Science and Technology\n * This file is part of GPIR (https:/"
},
{
"path": "common/base/type.h",
"chars": 512,
"preview": "/**\n * Copyright (C) 2022, RAM-LAB, Hong Kong University of Science and Technology\n * This file is part of GPIR (https:/"
},
{
"path": "common/cmake/FindGlog.cmake",
"chars": 1450,
"preview": "# - Try to find Glog\n#\n# The following variables are optionally searched for defaults\n# GLOG_ROOT_DIR: Base "
},
{
"path": "common/frenet/CMakeLists.txt",
"chars": 192,
"preview": "add_library(common_frenet)\nadd_library(common::frenet ALIAS common_frenet)\n\ntarget_sources(common_frenet PRIVATE\n frene"
},
{
"path": "common/frenet/frenet_state.h",
"chars": 1795,
"preview": "/**\n * Copyright (C) 2022, RAM-LAB, Hong Kong University of Science and Technology\n * This file is part of GPIR (https:/"
},
{
"path": "common/frenet/frenet_transform.cc",
"chars": 5238,
"preview": "/**\n * Copyright (C) 2022, RAM-LAB, Hong Kong University of Science and Technology\n * This file is part of GPIR (https:/"
},
{
"path": "common/frenet/frenet_transform.h",
"chars": 1250,
"preview": "/**\n * Copyright (C) 2022, RAM-LAB, Hong Kong University of Science and Technology\n * This file is part of GPIR (https:/"
},
{
"path": "common/geometry/CMakeLists.txt",
"chars": 133,
"preview": "add_library(common_geometry)\nadd_library(common::geometry ALIAS common_geometry)\n\ntarget_sources(common_geometry PRIVATE"
},
{
"path": "common/geometry/box2d.cc",
"chars": 3510,
"preview": "/**\n * Copyright (C) 2022, RAM-LAB, Hong Kong University of Science and Technology\n * This file is part of GPIR (https:/"
},
{
"path": "common/geometry/box2d.h",
"chars": 1667,
"preview": "/**\n * Copyright (C) 2022, RAM-LAB, Hong Kong University of Science and Technology\n * This file is part of GPIR (https:/"
},
{
"path": "common/graph/dijkstra.hpp",
"chars": 3463,
"preview": "/**\n * Copyright (C) 2022, RAM-LAB, Hong Kong University of Science and Technology\n * This file is part of GPIR (https:/"
},
{
"path": "common/package.xml",
"chars": 409,
"preview": "<?xml version=\"1.0\"?>\n<package format=\"2\">\n <name>common</name>\n <version>0.0.0</version>\n <description>The common pa"
},
{
"path": "common/smoothing/CMakeLists.txt",
"chars": 522,
"preview": "add_library(common_smoothing)\nadd_library(common::smoothing ALIAS common_smoothing)\n\ntarget_sources(common_smoothing\n P"
},
{
"path": "common/smoothing/LICENSE",
"chars": 11424,
"preview": "Copyright (c) 2018 Apollo Authors. All Rights Reserved\n\n Apache License\n "
},
{
"path": "common/smoothing/README.md",
"chars": 235,
"preview": "The code in this folder is a practice re-implementation of the original [Apollo](https://github.com/ApolloAuto/apollo/tr"
},
{
"path": "common/smoothing/affine_constraint.cc",
"chars": 3511,
"preview": "/******************************************************************************\n * Copyright 2017 The Apollo Authors. Al"
},
{
"path": "common/smoothing/affine_constraint.h",
"chars": 1801,
"preview": "/******************************************************************************\n * Copyright 2017 The Apollo Authors. Al"
},
{
"path": "common/smoothing/discrete_points_math.cc",
"chars": 6544,
"preview": "/******************************************************************************\n * Copyright 2017 The Apollo Authors. Al"
},
{
"path": "common/smoothing/discrete_points_math.h",
"chars": 1179,
"preview": "/******************************************************************************\n * Copyright 2017 The Apollo Authors. Al"
},
{
"path": "common/smoothing/osqp_spline1d_solver.cc",
"chars": 2559,
"preview": "/******************************************************************************\n * Copyright 2017 The Apollo Authors. Al"
},
{
"path": "common/smoothing/osqp_spline1d_solver.h",
"chars": 1423,
"preview": "/******************************************************************************\n * Copyright 2017 The Apollo Authors. Al"
},
{
"path": "common/smoothing/osqp_spline2d_solver.cc",
"chars": 2559,
"preview": "/******************************************************************************\n * Copyright 2017 The Apollo Authors. Al"
},
{
"path": "common/smoothing/osqp_spline2d_solver.h",
"chars": 1417,
"preview": "/******************************************************************************\n * Copyright 2017 The Apollo Authors. Al"
},
{
"path": "common/smoothing/polynomialxd.cc",
"chars": 2489,
"preview": "/******************************************************************************\n * Copyright 2017 The Apollo Authors. Al"
},
{
"path": "common/smoothing/polynomialxd.h",
"chars": 1620,
"preview": "/******************************************************************************\n * Copyright 2017 The Apollo Authors. Al"
},
{
"path": "common/smoothing/spline1d.cc",
"chars": 3033,
"preview": "/******************************************************************************\n * Copyright 2017 The Apollo Authors. Al"
},
{
"path": "common/smoothing/spline1d.h",
"chars": 1633,
"preview": "/******************************************************************************\n * Copyright 2017 The Apollo Authors. Al"
},
{
"path": "common/smoothing/spline1d_constraint.cc",
"chars": 12059,
"preview": "/******************************************************************************\n * Copyright 2017 The Apollo Authors. Al"
},
{
"path": "common/smoothing/spline1d_constraint.h",
"chars": 3116,
"preview": "/******************************************************************************\n * Copyright 2017 The Apollo Authors. Al"
},
{
"path": "common/smoothing/spline1d_kernel.cc",
"chars": 6002,
"preview": "/******************************************************************************\n * Copyright 2017 The Apollo Authors. Al"
},
{
"path": "common/smoothing/spline1d_kernel.h",
"chars": 2235,
"preview": "/******************************************************************************\n * Copyright 2017 The Apollo Authors. Al"
},
{
"path": "common/smoothing/spline1d_kernel_helper.cc",
"chars": 5987,
"preview": "/******************************************************************************\n * Copyright 2017 The Apollo Authors. Al"
},
{
"path": "common/smoothing/spline1d_kernel_helper.h",
"chars": 2464,
"preview": "/******************************************************************************\n * Copyright 2017 The Apollo Authors. Al"
},
{
"path": "common/smoothing/spline1d_seg.cc",
"chars": 2203,
"preview": "/******************************************************************************\n * Copyright 2017 The Apollo Authors. Al"
},
{
"path": "common/smoothing/spline1d_seg.h",
"chars": 1750,
"preview": "/******************************************************************************\n * Copyright 2017 The Apollo Authors. Al"
},
{
"path": "common/smoothing/spline1d_solver.h",
"chars": 1730,
"preview": "/******************************************************************************\n * Copyright 2017 The Apollo Authors. Al"
},
{
"path": "common/smoothing/spline2d.cc",
"chars": 6180,
"preview": "/******************************************************************************\n * Copyright 2017 The Apollo Authors. Al"
},
{
"path": "common/smoothing/spline2d.h",
"chars": 3060,
"preview": "/******************************************************************************\n * Copyright 2017 The Apollo Authors. Al"
},
{
"path": "common/smoothing/spline2d_constraint.cc",
"chars": 17171,
"preview": "/******************************************************************************\n * Copyright 2017 The Apollo Authors. Al"
},
{
"path": "common/smoothing/spline2d_constraint.h",
"chars": 4877,
"preview": "/******************************************************************************\n * Copyright 2017 The Apollo Authors. Al"
},
{
"path": "common/smoothing/spline2d_kernel.cc",
"chars": 7748,
"preview": "/******************************************************************************\n * Copyright 2017 The Apollo Authors. Al"
},
{
"path": "common/smoothing/spline2d_kernel.h",
"chars": 2458,
"preview": "/******************************************************************************\n * Copyright 2017 The Apollo Authors. Al"
},
{
"path": "common/smoothing/spline2d_seg.cc",
"chars": 4209,
"preview": "/******************************************************************************\n * Copyright 2017 The Apollo Authors. Al"
},
{
"path": "common/smoothing/spline2d_seg.h",
"chars": 2384,
"preview": "/******************************************************************************\n * Copyright 2017 The Apollo Authors. Al"
},
{
"path": "common/smoothing/spline2d_solver.h",
"chars": 1752,
"preview": "/******************************************************************************\n * Copyright 2017 The Apollo Authors. Al"
},
{
"path": "common/solver/CMakeLists.txt",
"chars": 417,
"preview": "set(osqp_DIR ${PROJECT_SOURCE_DIR}/thirdparty/osqp/install/lib/cmake/osqp)\n\nfind_package(osqp REQUIRED)\n\nadd_library(com"
},
{
"path": "common/solver/osqp/osqp_interface.cc",
"chars": 3938,
"preview": "#include \"common/solver/osqp/osqp_interface.h\"\n\n#include <glog/logging.h>\n\n#include <iostream>\n\n#include \"common/solver/"
},
{
"path": "common/solver/osqp/osqp_interface.h",
"chars": 1456,
"preview": "#pragma once\n\n#include <osqp/osqp.h>\n\n#include <Eigen/Dense>\n#include <Eigen/Sparse>\n\nnamespace common {\n\nusing ColSpars"
},
{
"path": "common/solver/osqp/osqp_sparse_matrix.h",
"chars": 2862,
"preview": "#pragma once\n\n#include <glog/logging.h>\n#include <osqp/cs.h>\n\n#include <Eigen/Sparse>\n\nnamespace common {\n\ntemplate <typ"
},
{
"path": "common/thirdparty/osqp/.bumpversion.cfg",
"chars": 629,
"preview": "[bumpversion]\ncurrent_version = 0.6.2\ncommit = True\ntag = True\nparse = (?P<major>\\d+)\\.(?P<minor>\\d+)\\.(?P<patch>\\d+)(\\."
},
{
"path": "common/thirdparty/osqp/.editorconfig",
"chars": 274,
"preview": "# https://editorconfig.org\n\nroot = true\n\n[*.{c, h, cpp, hpp}]\ncharset = utf-8\nindent_style = space\nindent_size = 2\nend_o"
},
{
"path": "common/thirdparty/osqp/.gitattributes",
"chars": 40,
"preview": "* text=auto\n*.c text\n*.h text\n*.cpp text"
},
{
"path": "common/thirdparty/osqp/.gitignore",
"chars": 2700,
"preview": "# C language\n# -------------------------------------------------------------------\n# Compile commands for cquery\ncompile"
},
{
"path": "common/thirdparty/osqp/.gitmodules",
"chars": 142,
"preview": "[submodule \"lin_sys/direct/qdldl/qdldl_sources\"]\n\tpath = lin_sys/direct/qdldl/qdldl_sources\n\turl = https://github.com/ox"
},
{
"path": "common/thirdparty/osqp/.travis.yml",
"chars": 2991,
"preview": "language: C\n\nmatrix:\n include:\n - os: linux\n dist: xenial\n - os: osx\n # Specify version to avoid bug (h"
},
{
"path": "common/thirdparty/osqp/.valgrind-suppress.supp",
"chars": 1137,
"preview": "{\n ignore_get_max_threads_intel\n Memcheck:Param\n sched_setaffinity(mask)\n fun:syscall\n fun:__kmp_affinity_dete"
},
{
"path": "common/thirdparty/osqp/CHANGELOG.md",
"chars": 4897,
"preview": "Version 0.6.2 (6 January 2021)\n------------------------------\n* Fix segfault python multithreading\n* Compatibility pytho"
},
{
"path": "common/thirdparty/osqp/CMakeLists.txt",
"chars": 14003,
"preview": "# Minimum version required\ncmake_minimum_required (VERSION 3.2)\n\n# Project name\nproject (osqp)\n\n# Export compile command"
},
{
"path": "common/thirdparty/osqp/LICENSE",
"chars": 11391,
"preview": " Apache License\n Version 2.0, January 2004\n "
},
{
"path": "common/thirdparty/osqp/NOTICE",
"chars": 418,
"preview": "OSQP\nCopyright (c) 2019 Bartolomeo Stellato, Goran Banjac, Paul Goulart, Stephen Boyd\n\nThis product includes software de"
},
{
"path": "common/thirdparty/osqp/README.md",
"chars": 2245,
"preview": "# The Operator Splitting QP Solver\n\n[![Build status of the master branch on Linux/OSX](https://img.shields.io/travis/oxf"
},
{
"path": "common/thirdparty/osqp/ROADMAP.md",
"chars": 60,
"preview": "## TODO\n- [ ] Add GPU solver\n- [ ] Add indirect solver\n\n"
},
{
"path": "common/thirdparty/osqp/appveyor.yml",
"chars": 946,
"preview": "# Not a .NET project. We build it in the install script\nbuild: false\n\nplatform:\n - x64\n - x86\n\nenvironment:\n BINTRAY_"
},
{
"path": "common/thirdparty/osqp/ci/appveyor/deploy.cmd",
"chars": 1825,
"preview": "@echo on\n\nREM Needed to enable to define OSQP_BIN within the file\n@setlocal enabledelayedexpansion\n\nIF \"%APPVEYOR_REPO_T"
},
{
"path": "common/thirdparty/osqp/ci/appveyor/install.cmd",
"chars": 1521,
"preview": "@echo on\n\n:: Make sure all the submodules are updated correctly\ncd %APPVEYOR_BUILD_FOLDER%\ngit submodule update --init -"
},
{
"path": "common/thirdparty/osqp/ci/appveyor/script.cmd",
"chars": 1266,
"preview": "@echo on\n\n\n:: Perform C Tests with standard configuration\n:: -----------------------------------------------------\ncd %A"
},
{
"path": "common/thirdparty/osqp/ci/travis/deploy.sh",
"chars": 2118,
"preview": "#!/bin/bash\nset -e\necho \"Creating Bintray shared library package...\"\n\nif [[ ${OSQP_VERSION} == *\"dev\"* ]]; then\n # Us"
},
{
"path": "common/thirdparty/osqp/ci/travis/docs.sh",
"chars": 1116,
"preview": "#!/bin/bash\n\necho \"Deploying docs to website osqp.org...\"\n\n# Update variables from install\n\n# Anaconda\nexport PATH=${DEP"
},
{
"path": "common/thirdparty/osqp/ci/travis/install.sh",
"chars": 1141,
"preview": "#!/bin/bash\n\n# Create deps dir\nmkdir ${DEPS_DIR}\ncd ${DEPS_DIR}\n\n# Install lcov and valgrind on linux\nif [[ \"$TRAVIS_OS_"
},
{
"path": "common/thirdparty/osqp/ci/travis/script.sh",
"chars": 3760,
"preview": "#!/bin/bash\nset -e\n\n# Add MKL shared libraries to the path\n# This unfortunately does not work in travis OSX if I put the"
},
{
"path": "common/thirdparty/osqp/configure/cmake/FindPythonModule.cmake",
"chars": 3768,
"preview": "# Find python module and version\n#\n# It sets the variables (given module called MODULE)\n# unless MODULE is __FUTURE__. I"
},
{
"path": "common/thirdparty/osqp/configure/cmake/FindR.cmake",
"chars": 980,
"preview": "# CMake module to find R\n# - Try to find R. If found, defines:\n#\n# R_FOUND - system has R\n# R_EXEC - t"
},
{
"path": "common/thirdparty/osqp/configure/cmake/Utils.cmake",
"chars": 168,
"preview": "# Clears variables from list\n# Usage:\n# osqp_clear_vars(<variables_list>)\nmacro(osqp_clear_vars)\n foreach(_var ${ARGN"
},
{
"path": "common/thirdparty/osqp/configure/cmake/cmake_uninstall.cmake.in",
"chars": 1002,
"preview": "if(NOT EXISTS \"@CMAKE_BINARY_DIR@/install_manifest.txt\")\n message(FATAL_ERROR \"Cannot find install manifest: @CMAKE_BIN"
},
{
"path": "common/thirdparty/osqp/configure/osqp_configure.h.in",
"chars": 741,
"preview": "#ifndef OSQP_CONFIGURE_H\n# define OSQP_CONFIGURE_H\n\n# ifdef __cplusplus\nextern \"C\" {\n# endif /* ifdef __cplusplus */\n\n/*"
},
{
"path": "common/thirdparty/osqp/docs/Makefile",
"chars": 604,
"preview": "# Minimal makefile for Sphinx documentation\n#\n\n# You can set these variables from the command line.\nSPHINXOPTS =\nSPHI"
},
{
"path": "common/thirdparty/osqp/docs/_static/css/osqp_theme.css",
"chars": 4131,
"preview": "/* Default header fonts are ugly */\n@import url(https://fonts.googleapis.com/css?family=Open+Sans:400,400i,600,600i,700,"
},
{
"path": "common/thirdparty/osqp/docs/_templates/layout.html",
"chars": 909,
"preview": "{% extends '!layout.html' %}\n\n{% block extrahead %}\n<meta name=\"twitter:card\" content=\"summary_large_image\" >\n<meta name"
},
{
"path": "common/thirdparty/osqp/docs/citing/index.rst",
"chars": 3693,
"preview": ".. _citing :\n\nCiting OSQP\n===========\n\nIf you use OSQP for published work, we encourage you to put a star on `GitHub <ht"
},
{
"path": "common/thirdparty/osqp/docs/codegen/index.rst",
"chars": 1399,
"preview": "Code generation\n===============\n\nOSQP can generate tailored C code that compiles into a fast and reliable solver\nfor the"
},
{
"path": "common/thirdparty/osqp/docs/codegen/matlab.rst",
"chars": 6933,
"preview": "Matlab\n======\n\nBefore generating code for a parametric problem, the problem should be first\nspecified in the setup phase"
},
{
"path": "common/thirdparty/osqp/docs/codegen/python.rst",
"chars": 6851,
"preview": "Python\n======\n\nBefore generating code for a parametric problem, the problem should be first\nspecified in the setup phase"
},
{
"path": "common/thirdparty/osqp/docs/conf.py",
"chars": 5973,
"preview": "#!/usr/bin/env python3\n# -*- coding: utf-8 -*-\n#\n# OSQP documentation build configuration file, created by\n# sphinx-quic"
},
{
"path": "common/thirdparty/osqp/docs/contributing/index.rst",
"chars": 4213,
"preview": "Contributing\n=============\n\nOSQP is an open-source project open to any academic or commercial applications.\nContribution"
},
{
"path": "common/thirdparty/osqp/docs/doxygen.conf",
"chars": 107534,
"preview": "# Doxyfile 1.8.13\n\n# This file describes the settings to be used by the documentation system\n# doxygen (www.doxygen.org)"
},
{
"path": "common/thirdparty/osqp/docs/examples/huber.rst",
"chars": 3806,
"preview": "Huber fitting\n=============\n\n*Huber fitting* or the *robust least-squares problem* performs linear regression under the "
},
{
"path": "common/thirdparty/osqp/docs/examples/index.rst",
"chars": 274,
"preview": "Examples\n========\n\n\nDemo\n----\n\n.. toctree::\n :maxdepth: 1\n\n setup-and-solve.rst\n update-vectors.rst\n update-matr"
},
{
"path": "common/thirdparty/osqp/docs/examples/lasso.rst",
"chars": 4799,
"preview": "Lasso\n=====\n\n\nLasso is a well known technique for sparse linear regression.\nIt is obtained by adding an :math:`\\ell_1` r"
},
{
"path": "common/thirdparty/osqp/docs/examples/least-squares.rst",
"chars": 2536,
"preview": "Least-squares\n=============\n\nConsider the following constrained least-squares problem\n\n.. math::\n \\begin{array}{ll}\n "
},
{
"path": "common/thirdparty/osqp/docs/examples/mpc.rst",
"chars": 14569,
"preview": "Model predictive control (MPC)\n==============================\n\nWe consider the problem of controlling a linear time-inva"
},
{
"path": "common/thirdparty/osqp/docs/examples/portfolio.rst",
"chars": 3904,
"preview": "Portfolio optimization\n======================\n\n\nPortfolio optimization seeks to allocate assets in a way that maximizes "
},
{
"path": "common/thirdparty/osqp/docs/examples/setup-and-solve.rst",
"chars": 3999,
"preview": "Setup and solve\n===============\n\n\nConsider the following QP\n\n\n.. math::\n \\begin{array}{ll}\n \\mbox{minimize} & \\frac{"
},
{
"path": "common/thirdparty/osqp/docs/examples/svm.rst",
"chars": 3950,
"preview": "Support vector machine (SVM)\n============================\n\n*Support vector machine* seeks an affine function that approx"
},
{
"path": "common/thirdparty/osqp/docs/examples/update-matrices.rst",
"chars": 5903,
"preview": "Update matrices\n===============\n\n\nConsider the following QP\n\n\n.. math::\n \\begin{array}{ll}\n \\mbox{minimize} & \\frac{"
},
{
"path": "common/thirdparty/osqp/docs/examples/update-vectors.rst",
"chars": 5283,
"preview": "Update vectors\n==============\n\n\nConsider the following QP\n\n\n.. math::\n \\begin{array}{ll}\n \\mbox{minimize} & \\frac{1}"
},
{
"path": "common/thirdparty/osqp/docs/get_started/CC++.rst",
"chars": 1601,
"preview": ".. _install_osqp_libs:\n\nCC++\n=====\n\nBinaries\n--------\n\nPrecompiled platform-dependent shared and static libraries are av"
},
{
"path": "common/thirdparty/osqp/docs/get_started/cutest.rst",
"chars": 528,
"preview": "CUTEst\n=======\n\nTo be able to use OSQP and `CUTEst <https://github.com/ralna/CUTEst/wiki>`_ you need to\n\n* Install `CUTE"
},
{
"path": "common/thirdparty/osqp/docs/get_started/index.rst",
"chars": 296,
"preview": "Get started\n===============\n\nTo get started simply choose your language interface and follow the easy installation instr"
},
{
"path": "common/thirdparty/osqp/docs/get_started/julia.rst",
"chars": 218,
"preview": "Julia\n======\n\nJulia interface can be directly installed from Julia package manager by running\n\n.. code:: julia\n\n ] add"
},
{
"path": "common/thirdparty/osqp/docs/get_started/linear_system_solvers.rst",
"chars": 3776,
"preview": ".. _linear_system_solvers_installation :\n\nLinear System Solvers\n======================\n\nThe linear system solver is a co"
},
{
"path": "common/thirdparty/osqp/docs/get_started/matlab.rst",
"chars": 1345,
"preview": "Matlab\n======\nOSQP Matlab interface requires Matlab 2015b or newer.\n\n\nBinaries\n--------\n\nPrecompiled platform-dependent "
},
{
"path": "common/thirdparty/osqp/docs/get_started/python.rst",
"chars": 955,
"preview": "Python\n======\n\nPython interface supports Python 2.7 and 3.5 or newer.\n\nPip\n----\n\n.. code:: bash\n\n pip install osqp\n\n\nA"
},
{
"path": "common/thirdparty/osqp/docs/get_started/r.rst",
"chars": 1307,
"preview": "R\n======\n\nBinaries\n--------\n\nA pre-compiled version of the OSQP R interface can be installed directly from within R. N"
},
{
"path": "common/thirdparty/osqp/docs/get_started/sources.rst",
"chars": 3893,
"preview": ".. _build_from_sources:\n\n\nBuild from sources\n==================\n\nInstall GCC and CMake\n----------------------\n\nThe main "
},
{
"path": "common/thirdparty/osqp/docs/index.rst",
"chars": 4223,
"preview": "OSQP solver documentation\n==========================\n**Join our** `forum <https://osqp.discourse.group/>`_ **for any\nque"
},
{
"path": "common/thirdparty/osqp/docs/interfaces/CC++.rst",
"chars": 2205,
"preview": ".. _c_interface:\n\nC\n=====\n\n\n\n\n.. _C_main_API:\n\nMain solver API\n---------------\n\nThe main C API is imported from the head"
},
{
"path": "common/thirdparty/osqp/docs/interfaces/cutest.rst",
"chars": 1001,
"preview": ".. _cutest_interface:\n\nCUTEst\n======\n\nThe command to solve a problem in SIF format contained in the file\nprobname.SIF is"
},
{
"path": "common/thirdparty/osqp/docs/interfaces/eigen_google.rst",
"chars": 184,
"preview": ".. _eigen_google:\n\nC++ Eigen interface (osqp-cpp)\n================================\n\nThe Eigen interface developed at Goo"
},
{
"path": "common/thirdparty/osqp/docs/interfaces/eigen_robotology.rst",
"chars": 223,
"preview": ".. _eigen_robotology:\n\nC++ Eigen interface (osqp-eigen)\n================================\n\nThe Eigen interface by Robotol"
},
{
"path": "common/thirdparty/osqp/docs/interfaces/fortran.rst",
"chars": 252,
"preview": ".. _fortran_interface:\n\n\nFortran\n========\n\nThe interface is still experimental.\nYou can find a demo of how it works in t"
},
{
"path": "common/thirdparty/osqp/docs/interfaces/index.rst",
"chars": 8192,
"preview": "Interfaces\n============\n\nOSQP has several interfaces. The information about settings, status values and how to assign di"
},
{
"path": "common/thirdparty/osqp/docs/interfaces/julia.rst",
"chars": 6152,
"preview": ".. _julia_interface:\n\nJulia\n======\n\nLoad the module\n---------------\nThe OSQP module can be load with\n\n.. code:: julia\n\n "
},
{
"path": "common/thirdparty/osqp/docs/interfaces/linear_systems_solvers.rst",
"chars": 1014,
"preview": ".. _linear_system_solvers_setting :\n\nLinear Systems Solvers\n-----------------------\nThe settings parameter :code:`linsys"
},
{
"path": "common/thirdparty/osqp/docs/interfaces/matlab.rst",
"chars": 6289,
"preview": ".. _matlab_interface:\n\nMatlab\n======\n\n.. _matlab_setup:\n\nSetup\n-----\nThe solver is initialized by creating an OSQP objec"
},
{
"path": "common/thirdparty/osqp/docs/interfaces/python.rst",
"chars": 6308,
"preview": ".. _python_interface:\n\nPython\n======\n\nImport\n------\nThe OSQP module can be imported with\n\n.. code:: python\n\n import o"
},
{
"path": "common/thirdparty/osqp/docs/interfaces/rlang.rst",
"chars": 139,
"preview": ".. _rlang_interface:\n\n\nR\n==\n\nThe R interface is officially on CRAN and documented `here <https://cran.r-project.org/web/"
},
{
"path": "common/thirdparty/osqp/docs/interfaces/ruby.rst",
"chars": 152,
"preview": ".. _ruby_interface:\n\n\nRuby\n========\n\nThe ruby interface can be installed as a Ruby gem and is documented `here <https://"
},
{
"path": "common/thirdparty/osqp/docs/interfaces/rust.rst",
"chars": 100,
"preview": ".. _rust_interface:\n\nRust\n======\n\nThe Rust interface is documented `here <https://docs.rs/osqp/>`_.\n"
},
{
"path": "common/thirdparty/osqp/docs/interfaces/solver_settings.rst",
"chars": 9152,
"preview": ".. _solver_settings :\n\nSolver settings\n---------------\n\nThe solver settings are displayed in the following table. The se"
},
{
"path": "common/thirdparty/osqp/docs/interfaces/status_values.rst",
"chars": 4916,
"preview": ".. _status_values :\n\n\n\nStatus values and errors\n========================\n\nStatus values\n-------------\n\nThese are the exi"
},
{
"path": "common/thirdparty/osqp/docs/make.bat",
"chars": 772,
"preview": "@ECHO OFF\n\npushd %~dp0\n\nREM Command file for Sphinx documentation\n\nif \"%SPHINXBUILD%\" == \"\" (\n\tset SPHINXBUILD=sphinx-bu"
},
{
"path": "common/thirdparty/osqp/docs/parsers/cvxpy.rst",
"chars": 426,
"preview": "CVXPY\n=====\n\n`CVXPY <http://www.cvxpy.org/>`_ 1.0 supports the OSQP solver by default. After defining your problem, you "
},
{
"path": "common/thirdparty/osqp/docs/parsers/index.rst",
"chars": 96,
"preview": "Parsers\n=======\n\n.. toctree::\n :maxdepth: 1\n :glob:\n\n yalmip.rst\n cvxpy.rst\n jump.rst\n"
},
{
"path": "common/thirdparty/osqp/docs/parsers/jump.rst",
"chars": 732,
"preview": "JuMP\n=====\n\n`JuMP <https://github.com/JuliaOpt/JuMP.jl>`_ supports the OSQP solver using the `MathOptInterface interface"
},
{
"path": "common/thirdparty/osqp/docs/parsers/yalmip.rst",
"chars": 310,
"preview": "YALMIP\n======\n\n`YALMIP <https://yalmip.github.io/>`_ support the OSQP solver. You can easily define problems in high-lev"
},
{
"path": "common/thirdparty/osqp/docs/requirements.txt",
"chars": 8,
"preview": "breathe\n"
},
{
"path": "common/thirdparty/osqp/docs/solver/index.rst",
"chars": 6643,
"preview": "The solver\n==========\n\nProblem statement\n-----------------\n\nOSQP solves convex quadratic programs (QPs) of the form\n\n.. "
},
{
"path": "common/thirdparty/osqp/examples/osqp_demo.c",
"chars": 1375,
"preview": "#include \"osqp.h\"\n\n\nint main(int argc, char **argv) {\n // Load problem data\n c_float P_x[3] = { 4.0, 1.0, 2.0, };\n c_"
},
{
"path": "common/thirdparty/osqp/include/.gitignore",
"chars": 64,
"preview": "# Ignore Cmake-generated osqp_configure.h file\nosqp_configure.h\n"
},
{
"path": "common/thirdparty/osqp/include/CMakeLists.txt",
"chars": 1272,
"preview": "# Add the OSQP headers\nset(\n osqp_headers\n \"${CMAKE_CURRENT_SOURCE_DIR}/auxil.h\"\n \"${CMAKE_CURRENT_SOURCE_DIR}/"
},
{
"path": "common/thirdparty/osqp/include/auxil.h",
"chars": 3901,
"preview": "#ifndef AUXIL_H\n# define AUXIL_H\n\n# ifdef __cplusplus\nextern \"C\" {\n# endif // ifdef __cplusplus\n\n# include \"types.h\"\n\n\n/"
},
{
"path": "common/thirdparty/osqp/include/constants.h",
"chars": 3739,
"preview": "#ifndef CONSTANTS_H\n# define CONSTANTS_H\n\n# ifdef __cplusplus\nextern \"C\" {\n# endif // ifdef __cplusplus\n\n\n/*************"
},
{
"path": "common/thirdparty/osqp/include/cs.h",
"chars": 4996,
"preview": "#ifndef CS_H\n# define CS_H\n\n# ifdef __cplusplus\nextern \"C\" {\n# endif // ifdef __cplusplus\n\n# include \"types.h\" // CSC "
},
{
"path": "common/thirdparty/osqp/include/ctrlc.h",
"chars": 1032,
"preview": "/*\n * Interface for OSQP signal handling.\n */\n\n#ifndef CTRLC_H\n# define CTRLC_H\n\n# ifdef __cplusplus\nextern \"C\" {\n# endi"
},
{
"path": "common/thirdparty/osqp/include/error.h",
"chars": 760,
"preview": "#ifndef ERROR_H\n# define ERROR_H\n\n/* OSQP error handling */\n\n# ifdef __cplusplus\nextern \"C\" {\n# endif // ifdef __cpluspl"
},
{
"path": "common/thirdparty/osqp/include/glob_opts.h",
"chars": 4686,
"preview": "#ifndef GLOB_OPTS_H\n# define GLOB_OPTS_H\n\n# ifdef __cplusplus\nextern \"C\" {\n# endif /* ifdef __cplusplus */\n\n/*\n Define"
},
{
"path": "common/thirdparty/osqp/include/kkt.h",
"chars": 3266,
"preview": "#ifndef KKT_H\n# define KKT_H\n\n# ifdef __cplusplus\nextern \"C\" {\n# endif // ifdef __cplusplus\n\n# include \"types.h\"\n\n# ifnd"
},
{
"path": "common/thirdparty/osqp/include/lin_alg.h",
"chars": 5678,
"preview": "#ifndef LIN_ALG_H\n# define LIN_ALG_H\n\n\n# ifdef __cplusplus\nextern \"C\" {\n# endif // ifdef __cplusplus\n\n# include \"types.h"
},
{
"path": "common/thirdparty/osqp/include/lin_sys.h",
"chars": 1621,
"preview": "#ifndef LIN_SYS_H\n# define LIN_SYS_H\n\n/* KKT linear system definition and solution */\n\n# ifdef __cplusplus\nextern \"C\" {\n"
},
{
"path": "common/thirdparty/osqp/include/osqp.h",
"chars": 11814,
"preview": "#ifndef OSQP_H\n# define OSQP_H\n\n# ifdef __cplusplus\nextern \"C\" {\n# endif // ifdef __cplusplus\n\n/* Includes */\n# include "
},
{
"path": "common/thirdparty/osqp/include/polish.h",
"chars": 434,
"preview": "/* Solution polish based on assuming the active set */\n#ifndef POLISH_H\n# define POLISH_H\n\n# ifdef __cplusplus\nextern \"C"
},
{
"path": "common/thirdparty/osqp/include/proj.h",
"chars": 726,
"preview": "#ifndef PROJ_H\n# define PROJ_H\n\n# ifdef __cplusplus\nextern \"C\" {\n# endif // ifdef __cplusplus\n\n# include \"types.h\"\n\n\n/* "
},
{
"path": "common/thirdparty/osqp/include/scaling.h",
"chars": 778,
"preview": "#ifndef SCALING_H\n# define SCALING_H\n\n# ifdef __cplusplus\nextern \"C\" {\n# endif // ifdef __cplusplus\n\n// Functions to sca"
},
{
"path": "common/thirdparty/osqp/include/types.h",
"chars": 10256,
"preview": "#ifndef OSQP_TYPES_H\n# define OSQP_TYPES_H\n\n# ifdef __cplusplus\nextern \"C\" {\n# endif // ifdef __cplusplus\n\n# include \"gl"
},
{
"path": "common/thirdparty/osqp/include/util.h",
"chars": 4109,
"preview": "#ifndef UTIL_H\n# define UTIL_H\n\n# ifdef __cplusplus\nextern \"C\" {\n# endif // ifdef __cplusplus\n\n# include \"types.h\"\n# inc"
},
{
"path": "common/thirdparty/osqp/lin_sys/CMakeLists.txt",
"chars": 773,
"preview": "# Add subdirectory for each linear systems solver\n\nif (NOT DEFINED EMBEDDED)\n# Include this directory for library handle"
},
{
"path": "common/thirdparty/osqp/lin_sys/direct/CMakeLists.txt",
"chars": 1499,
"preview": "# Add direct linear systems solvers\n\n# QDLDL (Default)\n# -------------------------\nadd_subdirectory(qdldl)\n\n# Need to ad"
},
{
"path": "common/thirdparty/osqp/lin_sys/direct/pardiso/CMakeLists.txt",
"chars": 338,
"preview": "set(pardiso_includes\n ${CMAKE_CURRENT_SOURCE_DIR}\n PARENT_SCOPE\n)\n\n# Set source files\nset(\n pardiso_sources\n "
},
{
"path": "common/thirdparty/osqp/lin_sys/direct/pardiso/pardiso_interface.c",
"chars": 9844,
"preview": "#include \"pardiso_interface.h\"\n\n#define MKL_INT c_int\n\n// Single Dynamic library interface\n#define MKL_INTERFACE_LP64 0"
},
{
"path": "common/thirdparty/osqp/lin_sys/direct/pardiso/pardiso_interface.h",
"chars": 4102,
"preview": "#ifndef PARDISO_H\n#define PARDISO_H\n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n\n#include \"lin_alg.h\"\n#include \"kkt.h\"\n\n/**\n"
},
{
"path": "common/thirdparty/osqp/lin_sys/direct/pardiso/pardiso_loader.c",
"chars": 3126,
"preview": "#include \"lib_handler.h\"\n#include \"pardiso_loader.h\"\n\n#include \"glob_opts.h\"\n#include \"constants.h\"\n\n#ifdef IS_WINDOWS\n#"
},
{
"path": "common/thirdparty/osqp/lin_sys/direct/pardiso/pardiso_loader.h",
"chars": 645,
"preview": "#ifndef PARDISOLOADER_H\n#define PARDISOLOADER_H\n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n\n\n\n/**\n * Tries to load a shared"
},
{
"path": "common/thirdparty/osqp/lin_sys/direct/qdldl/CMakeLists.txt",
"chars": 1448,
"preview": "# Add qdldl\nadd_subdirectory(qdldl_sources)\n\n\nif(NOT DEFINED EMBEDDED)\nset(\n amd_sources\n ${CMAKE_CURRENT_SOURCE_D"
},
{
"path": "common/thirdparty/osqp/lin_sys/direct/qdldl/amd/LICENSE",
"chars": 1924,
"preview": "AMD, Copyright (c), 1996-2015, Timothy A. Davis,\nPatrick R. Amestoy, and Iain S. Duff. All Rights Reserved.\n\nAvailabili"
},
{
"path": "common/thirdparty/osqp/lin_sys/direct/qdldl/amd/include/SuiteSparse_config.h",
"chars": 8987,
"preview": "/* ========================================================================== */\n/* === SuiteSparse_config ============="
},
{
"path": "common/thirdparty/osqp/lin_sys/direct/qdldl/amd/include/amd.h",
"chars": 17829,
"preview": "/* ========================================================================= */\n/* === AMD: approximate minimum degree "
},
{
"path": "common/thirdparty/osqp/lin_sys/direct/qdldl/amd/include/amd_internal.h",
"chars": 8239,
"preview": "/* ========================================================================= */\n/* === amd_internal.h =================="
},
{
"path": "common/thirdparty/osqp/lin_sys/direct/qdldl/amd/src/SuiteSparse_config.c",
"chars": 12237,
"preview": "/* ========================================================================== */\n/* === SuiteSparse_config ============="
},
{
"path": "common/thirdparty/osqp/lin_sys/direct/qdldl/amd/src/amd_1.c",
"chars": 5712,
"preview": "/* ========================================================================= */\n/* === AMD_1 ==========================="
},
{
"path": "common/thirdparty/osqp/lin_sys/direct/qdldl/amd/src/amd_2.c",
"chars": 64841,
"preview": "/* ========================================================================= */\n/* === AMD_2 ==========================="
},
{
"path": "common/thirdparty/osqp/lin_sys/direct/qdldl/amd/src/amd_aat.c",
"chars": 4854,
"preview": "/* ========================================================================= */\n/* === AMD_aat ========================="
},
{
"path": "common/thirdparty/osqp/lin_sys/direct/qdldl/amd/src/amd_control.c",
"chars": 1870,
"preview": "/* ========================================================================= */\n/* === AMD_control ====================="
},
{
"path": "common/thirdparty/osqp/lin_sys/direct/qdldl/amd/src/amd_defaults.c",
"chars": 1255,
"preview": "/* ========================================================================= */\n/* === AMD_defaults ===================="
},
{
"path": "common/thirdparty/osqp/lin_sys/direct/qdldl/amd/src/amd_info.c",
"chars": 4295,
"preview": "/* ========================================================================= */\n/* === AMD_info ========================"
},
{
"path": "common/thirdparty/osqp/lin_sys/direct/qdldl/amd/src/amd_order.c",
"chars": 6037,
"preview": "/* ========================================================================= */\n/* === AMD_order ======================="
},
{
"path": "common/thirdparty/osqp/lin_sys/direct/qdldl/amd/src/amd_post_tree.c",
"chars": 3703,
"preview": "/* ========================================================================= */\n/* === AMD_post_tree ==================="
},
{
"path": "common/thirdparty/osqp/lin_sys/direct/qdldl/amd/src/amd_postorder.c",
"chars": 5509,
"preview": "/* ========================================================================= */\n/* === AMD_postorder ==================="
},
{
"path": "common/thirdparty/osqp/lin_sys/direct/qdldl/amd/src/amd_preprocess.c",
"chars": 3808,
"preview": "/* ========================================================================= */\n/* === AMD_preprocess =================="
},
{
"path": "common/thirdparty/osqp/lin_sys/direct/qdldl/amd/src/amd_valid.c",
"chars": 2980,
"preview": "/* ========================================================================= */\n/* === AMD_valid ======================="
},
{
"path": "common/thirdparty/osqp/lin_sys/direct/qdldl/qdldl_interface.c",
"chars": 11867,
"preview": "#include \"glob_opts.h\"\n\n#include \"qdldl.h\"\n#include \"qdldl_interface.h\"\n\n#ifndef EMBEDDED\n#include \"amd.h\"\n#endif\n\n#if E"
},
{
"path": "common/thirdparty/osqp/lin_sys/direct/qdldl/qdldl_interface.h",
"chars": 3729,
"preview": "#ifndef QDLDL_INTERFACE_H\n#define QDLDL_INTERFACE_H\n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n\n#include \"types.h\"\n#include"
},
{
"path": "common/thirdparty/osqp/lin_sys/direct/qdldl/qdldl_sources/.editorconfig",
"chars": 164,
"preview": "# https://editorconfig.org\n\nroot = true\n\n[*.{c, h, cpp, hpp}]\ncharset = utf-8\nindent_style = space\nindent_size = 2\nend_o"
},
{
"path": "common/thirdparty/osqp/lin_sys/direct/qdldl/qdldl_sources/.gitignore",
"chars": 502,
"preview": "# Prerequisites\n*.d\n\n# Object files\n*.o\n*.ko\n*.obj\n*.elf\n\n# Linker output\n*.ilk\n*.map\n*.exp\n\n# Precompiled Headers\n*.gch"
},
{
"path": "common/thirdparty/osqp/lin_sys/direct/qdldl/qdldl_sources/.travis.yml",
"chars": 1176,
"preview": "language: C\n\nmatrix:\n include:\n - os: linux\n - os: osx\n # Specify version to avoid bug (https://github.com/t"
},
{
"path": "common/thirdparty/osqp/lin_sys/direct/qdldl/qdldl_sources/CHANGELOG.md",
"chars": 886,
"preview": "Version 0.1.4 (6 September 2019)\n---------------------------------\n* Fix to cmake when building `qdldl::qdldlstatic` \n"
},
{
"path": "common/thirdparty/osqp/lin_sys/direct/qdldl/qdldl_sources/CMakeLists.txt",
"chars": 6222,
"preview": "# Minimum version required\ncmake_minimum_required (VERSION 3.2)\n\n# Project name\nproject (qdldl)\n\n# Set the output folder"
},
{
"path": "common/thirdparty/osqp/lin_sys/direct/qdldl/qdldl_sources/LICENSE",
"chars": 11357,
"preview": " Apache License\n Version 2.0, January 2004\n "
},
{
"path": "common/thirdparty/osqp/lin_sys/direct/qdldl/qdldl_sources/README.md",
"chars": 5725,
"preview": "# QDLDL\nA free LDL factorisation routine for quasi-definite linear systems: `Ax=b`\n\n[![Build Status](https://travis-ci.o"
},
{
"path": "common/thirdparty/osqp/lin_sys/direct/qdldl/qdldl_sources/appveyor.yml",
"chars": 996,
"preview": "# Not a .NET project. We build it in the test script\nbuild: false\n\nplatform:\n - x64\n - x86\n\nenvironment:\n CMAKE_PROJE"
},
{
"path": "common/thirdparty/osqp/lin_sys/direct/qdldl/qdldl_sources/configure/cmake/cmake_uninstall.cmake.in",
"chars": 1003,
"preview": "if(NOT EXISTS \"@CMAKE_BINARY_DIR@/install_manifest.txt\")\n message(FATAL_ERROR \"Cannot find install manifest: @CMAKE_BIN"
},
{
"path": "common/thirdparty/osqp/lin_sys/direct/qdldl/qdldl_sources/configure/qdldl_types.h.in",
"chars": 571,
"preview": "#ifndef QDLDL_TYPES_H\n# define QDLDL_TYPES_H\n\n# ifdef __cplusplus\nextern \"C\" {\n# endif /* ifdef __cplusplus */\n\n#include"
},
{
"path": "common/thirdparty/osqp/lin_sys/direct/qdldl/qdldl_sources/examples/example.c",
"chars": 4513,
"preview": "#include \"qdldl.h\"\n#include <stdlib.h>\n#include <stdio.h>\n\nvoid print_arrayi(const QDLDL_int* data, QDLDL_int n,char* va"
},
{
"path": "common/thirdparty/osqp/lin_sys/direct/qdldl/qdldl_sources/include/.gitignore",
"chars": 14,
"preview": "qdldl_types.h\n"
},
{
"path": "common/thirdparty/osqp/lin_sys/direct/qdldl/qdldl_sources/include/qdldl.h",
"chars": 6397,
"preview": "#ifndef QDLDL_H\n#define QDLDL_H\n\n// Include qdldl type options\n#include \"qdldl_types.h\"\n\n# ifdef __cplusplus\nextern \"C\" "
},
{
"path": "common/thirdparty/osqp/lin_sys/direct/qdldl/qdldl_sources/src/qdldl.c",
"chars": 7683,
"preview": "#include \"qdldl.h\"\n\n#define QDLDL_UNKNOWN (-1)\n#define QDLDL_USED (1)\n#define QDLDL_UNUSED (0)\n\n/* Compute the eliminati"
},
{
"path": "common/thirdparty/osqp/lin_sys/direct/qdldl/qdldl_sources/tests/CMakeLists.txt",
"chars": 550,
"preview": "set(test_headers\n\t${CMAKE_CURRENT_SOURCE_DIR}/test_basic.h\n\t${CMAKE_CURRENT_SOURCE_DIR}/test_identity.h\n\t${CMAKE_CURRENT"
},
{
"path": "common/thirdparty/osqp/lin_sys/direct/qdldl/qdldl_sources/tests/minunit.h",
"chars": 438,
"preview": "/* QDLDL TESTER MODULE */\n\n/* THE CODE FOR MINIMAL UNIT TESTING HAS BEEN TAKEN FROM\n http://www.jera.com/techinfo/jtns"
},
{
"path": "common/thirdparty/osqp/lin_sys/direct/qdldl/qdldl_sources/tests/qdldl_tester.c",
"chars": 4495,
"preview": "/* QDLDL TESTER MODULE */\n\n/* THE CODE FOR MINIMAL UNIT TESTING HAS BEEN TAKEN FROM\n http://www.jera.com/techinfo/jtns"
},
{
"path": "common/thirdparty/osqp/lin_sys/direct/qdldl/qdldl_sources/tests/test_basic.h",
"chars": 871,
"preview": "static char* test_basic()\n{\n //A matrix data\n QDLDL_int Ap[] = {0, 1, 2, 4, 5, 6, 8, 10, 12, 14, 17};\n QDLDL_int Ai["
},
{
"path": "common/thirdparty/osqp/lin_sys/direct/qdldl/qdldl_sources/tests/test_identity.h",
"chars": 511,
"preview": "static char* test_identity()\n{\n //A matrix data\n QDLDL_int Ap[] = {0, 1, 2, 3, 4};\n QDLDL_int Ai[] = {0, 1, 2, 3};\n"
},
{
"path": "common/thirdparty/osqp/lin_sys/direct/qdldl/qdldl_sources/tests/test_osqp_kkt.h",
"chars": 1030,
"preview": "static char* test_osqp_kkt()\n{\n // Unordered A\n QDLDL_int Ap[] = {0, 1, 2, 5, 6, 7, 8, 12};\n QDLDL_int Ai[] = {0, 1"
},
{
"path": "common/thirdparty/osqp/lin_sys/direct/qdldl/qdldl_sources/tests/test_rank_deficient.h",
"chars": 401,
"preview": "static char* test_rank_deficient()\n{\n //A matrix data\n QDLDL_int Ap[] = {0, 1, 3};\n QDLDL_int Ai[] = {0, 0, 1};\n Q"
},
{
"path": "common/thirdparty/osqp/lin_sys/direct/qdldl/qdldl_sources/tests/test_singleton.h",
"chars": 470,
"preview": "static char* test_singleton()\n{\n //A matrix data\n QDLDL_int Ap[] = {0, 1};\n QDLDL_int Ai[] = {0};\n QDLDL_float Ax["
},
{
"path": "common/thirdparty/osqp/lin_sys/direct/qdldl/qdldl_sources/tests/test_sym_structure.h",
"chars": 388,
"preview": "static char* test_sym_structure()\n{\n //A matrix data\n QDLDL_int Ap[] = {0, 2, 4};\n QDLDL_int Ai[] = {0, 1, 0, 1};\n "
}
]
// ... and 5606 more files (download for full content)
About this extraction
This page contains the full source code of the jchengai/gpir GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 5806 files (136.6 MB), approximately 26.6M tokens, and a symbol index with 21087 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.