Copy disabled (too large)
Download .txt
Showing preview only (57,569K chars total). Download the full file to get everything.
Repository: byangw/PCT_planner
Branch: main
Commit: 35cd73fd82bc
Files: 4732
Total size: 53.7 MB
Directory structure:
gitextract_x6z1z4d3/
├── .gitignore
├── LICENSE
├── NOTICE
├── README.md
├── planner/
│ ├── build.sh
│ ├── build_thirdparty.sh
│ ├── config/
│ │ ├── __init__.py
│ │ └── param.py
│ ├── lib/
│ │ ├── 3rdparty/
│ │ │ ├── gtsam-4.1.1/
│ │ │ │ ├── .github/
│ │ │ │ │ ├── ISSUE_TEMPLATE/
│ │ │ │ │ │ ├── bug-report.md
│ │ │ │ │ │ ├── feature-request.md
│ │ │ │ │ │ └── questions-help-support.md
│ │ │ │ │ ├── scripts/
│ │ │ │ │ │ ├── boost.sh
│ │ │ │ │ │ ├── python.sh
│ │ │ │ │ │ └── unix.sh
│ │ │ │ │ └── workflows/
│ │ │ │ │ ├── build-linux.yml
│ │ │ │ │ ├── build-macos.yml
│ │ │ │ │ ├── build-python.yml
│ │ │ │ │ ├── build-special.yml
│ │ │ │ │ ├── build-windows.yml
│ │ │ │ │ └── trigger-python.yml
│ │ │ │ ├── .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
│ │ │ │ │ ├── FindEigen3.cmake
│ │ │ │ │ ├── FindGooglePerfTools.cmake
│ │ │ │ │ ├── FindMKL.cmake
│ │ │ │ │ ├── FindNumPy.cmake
│ │ │ │ │ ├── FindTBB.cmake
│ │ │ │ │ ├── GTSAMCMakeToolsConfig.cmake
│ │ │ │ │ ├── GtsamAddPch.cmake
│ │ │ │ │ ├── GtsamBuildTypes.cmake
│ │ │ │ │ ├── GtsamMakeConfigFile.cmake
│ │ │ │ │ ├── GtsamPrinting.cmake
│ │ │ │ │ ├── GtsamTesting.cmake
│ │ │ │ │ ├── HandleAllocators.cmake
│ │ │ │ │ ├── HandleBoost.cmake
│ │ │ │ │ ├── HandleCCache.cmake
│ │ │ │ │ ├── HandleCPack.cmake
│ │ │ │ │ ├── HandleEigen.cmake
│ │ │ │ │ ├── HandleFinalChecks.cmake
│ │ │ │ │ ├── HandleGeneralOptions.cmake
│ │ │ │ │ ├── HandleGlobalBuildFlags.cmake
│ │ │ │ │ ├── HandleMKL.cmake
│ │ │ │ │ ├── HandleMetis.cmake
│ │ │ │ │ ├── HandleOpenMP.cmake
│ │ │ │ │ ├── HandlePerfTools.cmake
│ │ │ │ │ ├── HandlePrintConfiguration.cmake
│ │ │ │ │ ├── HandlePython.cmake
│ │ │ │ │ ├── HandleTBB.cmake
│ │ │ │ │ ├── HandleUninstall.cmake
│ │ │ │ │ ├── README.html
│ │ │ │ │ ├── README.md
│ │ │ │ │ ├── cmake_uninstall.cmake.in
│ │ │ │ │ ├── dllexport.h.in
│ │ │ │ │ ├── example_cmake_find_gtsam/
│ │ │ │ │ │ ├── CMakeLists.txt
│ │ │ │ │ │ └── main.cpp
│ │ │ │ │ └── obsolete/
│ │ │ │ │ ├── FindCppUnitLite.cmake
│ │ │ │ │ ├── FindWrap.cmake
│ │ │ │ │ └── GtsamTestingObsolete.cmake
│ │ │ │ ├── doc/
│ │ │ │ │ ├── .gitignore
│ │ │ │ │ ├── CMakeLists.txt
│ │ │ │ │ ├── Code/
│ │ │ │ │ │ ├── LocalizationExample2.cpp
│ │ │ │ │ │ ├── LocalizationFactor.cpp
│ │ │ │ │ │ ├── LocalizationOutput5.txt
│ │ │ │ │ │ ├── OdometryExample.cpp
│ │ │ │ │ │ ├── OdometryMarginals.cpp
│ │ │ │ │ │ ├── OdometryOptimize.cpp
│ │ │ │ │ │ ├── OdometryOutput1.txt
│ │ │ │ │ │ ├── OdometryOutput2.txt
│ │ │ │ │ │ ├── OdometryOutput3.txt
│ │ │ │ │ │ ├── PlanarSLAMExample.m
│ │ │ │ │ │ ├── PlanarSLAMExample.txt
│ │ │ │ │ │ ├── Pose2SLAMExample-graph.m
│ │ │ │ │ │ ├── Pose2SLAMExample.cpp
│ │ │ │ │ │ ├── Pose2SLAMExample.m
│ │ │ │ │ │ ├── Pose3SLAMExample-graph.m
│ │ │ │ │ │ ├── SFMExample.m
│ │ │ │ │ │ ├── VisualISAMExample.cpp
│ │ │ │ │ │ ├── calls.txt
│ │ │ │ │ │ ├── print.txt
│ │ │ │ │ │ └── whos.txt
│ │ │ │ │ ├── CodingGuidelines.docx
│ │ │ │ │ ├── CodingGuidelines.lyx
│ │ │ │ │ ├── Doxyfile.in
│ │ │ │ │ ├── DoxygenLayout.xml
│ │ │ │ │ ├── ImuFactor.lyx
│ │ │ │ │ ├── LieGroups.lyx
│ │ │ │ │ ├── Mathematica/
│ │ │ │ │ │ ├── CalibratedCamera.nb
│ │ │ │ │ │ ├── CalibratedStereoCamera.nb
│ │ │ │ │ │ ├── Quaternion-Logmap.nb
│ │ │ │ │ │ ├── Rot3.nb
│ │ │ │ │ │ ├── StereoCamera.nb
│ │ │ │ │ │ └── dexpInvL_SE2.nb
│ │ │ │ │ ├── cholesky.lyx
│ │ │ │ │ ├── common_macros.tex
│ │ │ │ │ ├── gtsam-coordinate-frames.lyx
│ │ │ │ │ ├── gtsam.bib
│ │ │ │ │ ├── gtsam.lyx
│ │ │ │ │ ├── images/
│ │ │ │ │ │ └── gtsam-structure.graffle
│ │ │ │ │ ├── macros.lyx
│ │ │ │ │ ├── math.lyx
│ │ │ │ │ ├── refs.bib
│ │ │ │ │ ├── stats.html
│ │ │ │ │ ├── trustregion.bib
│ │ │ │ │ └── trustregion.lyx
│ │ │ │ ├── docker/
│ │ │ │ │ ├── README.md
│ │ │ │ │ ├── ubuntu-boost-tbb/
│ │ │ │ │ │ ├── Dockerfile
│ │ │ │ │ │ └── build.sh
│ │ │ │ │ ├── ubuntu-gtsam/
│ │ │ │ │ │ ├── Dockerfile
│ │ │ │ │ │ └── build.sh
│ │ │ │ │ ├── ubuntu-gtsam-python/
│ │ │ │ │ │ ├── Dockerfile
│ │ │ │ │ │ └── build.sh
│ │ │ │ │ └── ubuntu-gtsam-python-vnc/
│ │ │ │ │ ├── Dockerfile
│ │ │ │ │ ├── bootstrap.sh
│ │ │ │ │ ├── build.sh
│ │ │ │ │ └── vnc.sh
│ │ │ │ ├── examples/
│ │ │ │ │ ├── CMakeLists.txt
│ │ │ │ │ ├── CameraResectioning.cpp
│ │ │ │ │ ├── CombinedImuFactorsExample.cpp
│ │ │ │ │ ├── CreateSFMExampleData.cpp
│ │ │ │ │ ├── Data/
│ │ │ │ │ │ ├── .gitignore
│ │ │ │ │ │ ├── Balbianello.out
│ │ │ │ │ │ ├── HS21.QPS
│ │ │ │ │ │ ├── HS268.QPS
│ │ │ │ │ │ ├── HS35.QPS
│ │ │ │ │ │ ├── HS35MOD.QPS
│ │ │ │ │ │ ├── HS51.QPS
│ │ │ │ │ │ ├── HS52.QPS
│ │ │ │ │ │ ├── Klaus3.g2o
│ │ │ │ │ │ ├── Plaza1_.mat
│ │ │ │ │ │ ├── Plaza2_.mat
│ │ │ │ │ │ ├── QPExample.QPS
│ │ │ │ │ │ ├── QPTEST.QPS
│ │ │ │ │ │ ├── example.graph
│ │ │ │ │ │ ├── example_with_vertices.g2o
│ │ │ │ │ │ ├── imuAndGPSdata.csv
│ │ │ │ │ │ ├── quadraped_imu_data.csv
│ │ │ │ │ │ ├── randomGrid3D.xml
│ │ │ │ │ │ ├── sphere_smallnoise.graph
│ │ │ │ │ │ ├── toy3D.xml
│ │ │ │ │ │ ├── toyExample.g2o
│ │ │ │ │ │ ├── w100.graph
│ │ │ │ │ │ └── w10000.graph
│ │ │ │ │ ├── DiscreteBayesNetExample.cpp
│ │ │ │ │ ├── DiscreteBayesNet_FG.cpp
│ │ │ │ │ ├── FisheyeExample.cpp
│ │ │ │ │ ├── HMMExample.cpp
│ │ │ │ │ ├── IMUKittiExampleGPS.cpp
│ │ │ │ │ ├── ISAM2Example_SmartFactor.cpp
│ │ │ │ │ ├── ImuFactorsExample.cpp
│ │ │ │ │ ├── ImuFactorsExample2.cpp
│ │ │ │ │ ├── InverseKinematicsExampleExpressions.cpp
│ │ │ │ │ ├── LocalizationExample.cpp
│ │ │ │ │ ├── METISOrderingExample.cpp
│ │ │ │ │ ├── OdometryExample.cpp
│ │ │ │ │ ├── PlanarSLAMExample.cpp
│ │ │ │ │ ├── Pose2SLAMExample.cpp
│ │ │ │ │ ├── Pose2SLAMExampleExpressions.cpp
│ │ │ │ │ ├── Pose2SLAMExample_g2o.cpp
│ │ │ │ │ ├── Pose2SLAMExample_graph.cpp
│ │ │ │ │ ├── Pose2SLAMExample_graphviz.cpp
│ │ │ │ │ ├── Pose2SLAMExample_lago.cpp
│ │ │ │ │ ├── Pose2SLAMStressTest.cpp
│ │ │ │ │ ├── Pose2SLAMwSPCG.cpp
│ │ │ │ │ ├── Pose3Localization.cpp
│ │ │ │ │ ├── Pose3SLAMExampleExpressions_BearingRangeWithTransform.cpp
│ │ │ │ │ ├── Pose3SLAMExample_changeKeys.cpp
│ │ │ │ │ ├── Pose3SLAMExample_g2o.cpp
│ │ │ │ │ ├── Pose3SLAMExample_initializePose3Chordal.cpp
│ │ │ │ │ ├── Pose3SLAMExample_initializePose3Gradient.cpp
│ │ │ │ │ ├── README.md
│ │ │ │ │ ├── RangeISAMExample_plaza2.cpp
│ │ │ │ │ ├── SFMExample.cpp
│ │ │ │ │ ├── SFMExampleExpressions.cpp
│ │ │ │ │ ├── SFMExampleExpressions_bal.cpp
│ │ │ │ │ ├── SFMExample_SmartFactor.cpp
│ │ │ │ │ ├── SFMExample_SmartFactorPCG.cpp
│ │ │ │ │ ├── SFMExample_bal.cpp
│ │ │ │ │ ├── SFMExample_bal_COLAMD_METIS.cpp
│ │ │ │ │ ├── SFMdata.h
│ │ │ │ │ ├── SelfCalibrationExample.cpp
│ │ │ │ │ ├── ShonanAveragingCLI.cpp
│ │ │ │ │ ├── SimpleRotation.cpp
│ │ │ │ │ ├── SolverComparer.cpp
│ │ │ │ │ ├── StereoVOExample.cpp
│ │ │ │ │ ├── StereoVOExample_large.cpp
│ │ │ │ │ ├── TimeTBB.cpp
│ │ │ │ │ ├── UGM_chain.cpp
│ │ │ │ │ ├── UGM_small.cpp
│ │ │ │ │ ├── VisualISAM2Example.cpp
│ │ │ │ │ ├── VisualISAMExample.cpp
│ │ │ │ │ ├── easyPoint2KalmanFilter.cpp
│ │ │ │ │ └── elaboratePoint2KalmanFilter.cpp
│ │ │ │ ├── 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
│ │ │ │ │ │ │ │ │ ├── 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
│ │ │ │ │ │ │ │ │ └── obj/
│ │ │ │ │ │ │ │ │ └── x86/
│ │ │ │ │ │ │ │ │ └── Debug/
│ │ │ │ │ │ │ │ │ ├── .NETFramework,Version=v4.0,Profile=Client.AssemblyAttributes.cs
│ │ │ │ │ │ │ │ │ └── Projections.csproj.AssemblyReference.cache
│ │ │ │ │ │ │ │ └── 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
│ │ │ │ │ │ ├── base.i
│ │ │ │ │ │ ├── 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
│ │ │ │ │ │ └── utilities.h
│ │ │ │ │ ├── basis/
│ │ │ │ │ │ ├── Basis.h
│ │ │ │ │ │ ├── BasisFactors.h
│ │ │ │ │ │ ├── CMakeLists.txt
│ │ │ │ │ │ ├── Chebyshev.cpp
│ │ │ │ │ │ ├── Chebyshev.h
│ │ │ │ │ │ ├── Chebyshev2.cpp
│ │ │ │ │ │ ├── Chebyshev2.h
│ │ │ │ │ │ ├── FitBasis.h
│ │ │ │ │ │ ├── Fourier.h
│ │ │ │ │ │ ├── ParameterMatrix.h
│ │ │ │ │ │ ├── basis.i
│ │ │ │ │ │ └── tests/
│ │ │ │ │ │ ├── CMakeLists.txt
│ │ │ │ │ │ ├── testChebyshev.cpp
│ │ │ │ │ │ ├── testChebyshev2.cpp
│ │ │ │ │ │ ├── testFourier.cpp
│ │ │ │ │ │ └── testParameterMatrix.cpp
│ │ │ │ │ ├── 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
│ │ │ │ │ │ ├── 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
│ │ │ │ │ │ ├── Cal3.cpp
│ │ │ │ │ │ ├── Cal3.h
│ │ │ │ │ │ ├── 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
│ │ │ │ │ │ ├── Similarity3.cpp
│ │ │ │ │ │ ├── Similarity3.h
│ │ │ │ │ │ ├── SimpleCamera.cpp
│ │ │ │ │ │ ├── SimpleCamera.h
│ │ │ │ │ │ ├── StereoCamera.cpp
│ │ │ │ │ │ ├── StereoCamera.h
│ │ │ │ │ │ ├── StereoPoint2.cpp
│ │ │ │ │ │ ├── StereoPoint2.h
│ │ │ │ │ │ ├── Unit3.cpp
│ │ │ │ │ │ ├── Unit3.h
│ │ │ │ │ │ ├── concepts.h
│ │ │ │ │ │ ├── geometry.i
│ │ │ │ │ │ ├── tests/
│ │ │ │ │ │ │ ├── CMakeLists.txt
│ │ │ │ │ │ │ ├── testBearingRange.cpp
│ │ │ │ │ │ │ ├── testCal3Bundler.cpp
│ │ │ │ │ │ │ ├── testCal3DFisheye.cpp
│ │ │ │ │ │ │ ├── testCal3DS2.cpp
│ │ │ │ │ │ │ ├── testCal3Unified.cpp
│ │ │ │ │ │ │ ├── testCal3_S2.cpp
│ │ │ │ │ │ │ ├── testCal3_S2Stereo.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
│ │ │ │ │ │ │ ├── testSimilarity3.cpp
│ │ │ │ │ │ │ ├── testSimpleCamera.cpp
│ │ │ │ │ │ │ ├── testStereoCamera.cpp
│ │ │ │ │ │ │ ├── testStereoPoint2.cpp
│ │ │ │ │ │ │ ├── testTriangulation.cpp
│ │ │ │ │ │ │ ├── testUnit3.cpp
│ │ │ │ │ │ │ └── testUtilities.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/
│ │ │ │ │ │ ├── AcceleratedPowerMethod.h
│ │ │ │ │ │ ├── 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
│ │ │ │ │ │ ├── PowerMethod.h
│ │ │ │ │ │ ├── Preconditioner.cpp
│ │ │ │ │ │ ├── Preconditioner.h
│ │ │ │ │ │ ├── RegularHessianFactor.h
│ │ │ │ │ │ ├── RegularJacobianFactor.h
│ │ │ │ │ │ ├── Sampler.cpp
│ │ │ │ │ │ ├── Sampler.h
│ │ │ │ │ │ ├── Scatter.cpp
│ │ │ │ │ │ ├── Scatter.h
│ │ │ │ │ │ ├── SparseEigen.h
│ │ │ │ │ │ ├── SubgraphBuilder.cpp
│ │ │ │ │ │ ├── SubgraphBuilder.h
│ │ │ │ │ │ ├── SubgraphPreconditioner.cpp
│ │ │ │ │ │ ├── SubgraphPreconditioner.h
│ │ │ │ │ │ ├── SubgraphSolver.cpp
│ │ │ │ │ │ ├── SubgraphSolver.h
│ │ │ │ │ │ ├── VectorValues.cpp
│ │ │ │ │ │ ├── VectorValues.h
│ │ │ │ │ │ ├── iterative-inl.h
│ │ │ │ │ │ ├── iterative.cpp
│ │ │ │ │ │ ├── iterative.h
│ │ │ │ │ │ ├── linear.i
│ │ │ │ │ │ ├── linearAlgorithms-inst.h
│ │ │ │ │ │ ├── linearExceptions.cpp
│ │ │ │ │ │ ├── linearExceptions.h
│ │ │ │ │ │ └── tests/
│ │ │ │ │ │ ├── CMakeLists.txt
│ │ │ │ │ │ ├── powerMethodExample.h
│ │ │ │ │ │ ├── testAcceleratedPowerMethod.cpp
│ │ │ │ │ │ ├── testErrors.cpp
│ │ │ │ │ │ ├── testGaussianBayesNet.cpp
│ │ │ │ │ │ ├── testGaussianBayesTree.cpp
│ │ │ │ │ │ ├── testGaussianConditional.cpp
│ │ │ │ │ │ ├── testGaussianDensity.cpp
│ │ │ │ │ │ ├── testGaussianFactorGraph.cpp
│ │ │ │ │ │ ├── testHessianFactor.cpp
│ │ │ │ │ │ ├── testJacobianFactor.cpp
│ │ │ │ │ │ ├── testKalmanFilter.cpp
│ │ │ │ │ │ ├── testNoiseModel.cpp
│ │ │ │ │ │ ├── testPowerMethod.cpp
│ │ │ │ │ │ ├── testRegularHessianFactor.cpp
│ │ │ │ │ │ ├── testRegularJacobianFactor.cpp
│ │ │ │ │ │ ├── testSampler.cpp
│ │ │ │ │ │ ├── testScatter.cpp
│ │ │ │ │ │ ├── testSerializationLinear.cpp
│ │ │ │ │ │ ├── testSparseEigen.cpp
│ │ │ │ │ │ └── testVectorValues.cpp
│ │ │ │ │ ├── mainpage.dox
│ │ │ │ │ ├── navigation/
│ │ │ │ │ │ ├── .gitignore
│ │ │ │ │ │ ├── AHRSFactor.cpp
│ │ │ │ │ │ ├── AHRSFactor.h
│ │ │ │ │ │ ├── AttitudeFactor.cpp
│ │ │ │ │ │ ├── AttitudeFactor.h
│ │ │ │ │ │ ├── CMakeLists.txt
│ │ │ │ │ │ ├── CombinedImuFactor.cpp
│ │ │ │ │ │ ├── CombinedImuFactor.h
│ │ │ │ │ │ ├── ConstantVelocityFactor.h
│ │ │ │ │ │ ├── GPSFactor.cpp
│ │ │ │ │ │ ├── GPSFactor.h
│ │ │ │ │ │ ├── ImuBias.cpp
│ │ │ │ │ │ ├── ImuBias.h
│ │ │ │ │ │ ├── ImuFactor.cpp
│ │ │ │ │ │ ├── ImuFactor.h
│ │ │ │ │ │ ├── MagFactor.h
│ │ │ │ │ │ ├── MagPoseFactor.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
│ │ │ │ │ │ ├── navigation.i
│ │ │ │ │ │ └── tests/
│ │ │ │ │ │ ├── CMakeLists.txt
│ │ │ │ │ │ ├── imuFactorTesting.h
│ │ │ │ │ │ ├── testAHRSFactor.cpp
│ │ │ │ │ │ ├── testAttitudeFactor.cpp
│ │ │ │ │ │ ├── testCombinedImuFactor.cpp
│ │ │ │ │ │ ├── testConstantVelocityFactor.cpp
│ │ │ │ │ │ ├── testGPSFactor.cpp
│ │ │ │ │ │ ├── testGeographicLib.cpp
│ │ │ │ │ │ ├── testImuBias.cpp
│ │ │ │ │ │ ├── testImuFactor.cpp
│ │ │ │ │ │ ├── testImuFactorSerialization.cpp
│ │ │ │ │ │ ├── testMagFactor.cpp
│ │ │ │ │ │ ├── testMagPoseFactor.cpp
│ │ │ │ │ │ ├── testManifoldPreintegration.cpp
│ │ │ │ │ │ ├── testNavExpressions.cpp
│ │ │ │ │ │ ├── testNavState.cpp
│ │ │ │ │ │ ├── testPoseVelocityBias.cpp
│ │ │ │ │ │ ├── testScenario.cpp
│ │ │ │ │ │ ├── testScenarioRunner.cpp
│ │ │ │ │ │ └── testTangentPreintegration.cpp
│ │ │ │ │ ├── nonlinear/
│ │ │ │ │ │ ├── AdaptAutoDiff.h
│ │ │ │ │ │ ├── CMakeLists.txt
│ │ │ │ │ │ ├── CustomFactor.cpp
│ │ │ │ │ │ ├── CustomFactor.h
│ │ │ │ │ │ ├── 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
│ │ │ │ │ │ ├── GncOptimizer.h
│ │ │ │ │ │ ├── GncParams.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
│ │ │ │ │ │ ├── nonlinear.i
│ │ │ │ │ │ ├── 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
│ │ │ │ │ │ ├── sam.i
│ │ │ │ │ │ └── tests/
│ │ │ │ │ │ ├── CMakeLists.txt
│ │ │ │ │ │ ├── testBearingFactor.cpp
│ │ │ │ │ │ ├── testBearingRangeFactor.cpp
│ │ │ │ │ │ └── testRangeFactor.cpp
│ │ │ │ │ ├── sfm/
│ │ │ │ │ │ ├── BinaryMeasurement.h
│ │ │ │ │ │ ├── CMakeLists.txt
│ │ │ │ │ │ ├── MFAS.cpp
│ │ │ │ │ │ ├── MFAS.h
│ │ │ │ │ │ ├── ShonanAveraging.cpp
│ │ │ │ │ │ ├── ShonanAveraging.h
│ │ │ │ │ │ ├── ShonanFactor.cpp
│ │ │ │ │ │ ├── ShonanFactor.h
│ │ │ │ │ │ ├── ShonanGaugeFactor.h
│ │ │ │ │ │ ├── TranslationFactor.h
│ │ │ │ │ │ ├── TranslationRecovery.cpp
│ │ │ │ │ │ ├── TranslationRecovery.h
│ │ │ │ │ │ ├── sfm.i
│ │ │ │ │ │ └── tests/
│ │ │ │ │ │ ├── CMakeLists.txt
│ │ │ │ │ │ ├── testBinaryMeasurement.cpp
│ │ │ │ │ │ ├── testMFAS.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
│ │ │ │ │ │ ├
================================================
FILE CONTENTS
================================================
================================================
FILE: .gitignore
================================================
*.stl
*.obj
*.ply
*.pcd
*.npy
*.pyc
*.pickle
*.so
__pycache__/
build/
install/
================================================
FILE: LICENSE
================================================
GNU GENERAL PUBLIC LICENSE
Version 2, June 1991
Copyright (C) 1989, 1991 Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.
Preamble
The licenses for most software are designed to take away your
freedom to share and change it. By contrast, the GNU General Public
License is intended to guarantee your freedom to share and change free
software--to make sure the software is free for all its users. This
General Public License applies to most of the Free Software
Foundation's software and to any other program whose authors commit to
using it. (Some other Free Software Foundation software is covered by
the GNU Lesser General Public License instead.) You can apply it to
your programs, too.
When we speak of free software, we are referring to freedom, not
price. Our General Public Licenses are designed to make sure that you
have the freedom to distribute copies of free software (and charge for
this service if you wish), that you receive source code or can get it
if you want it, that you can change the software or use pieces of it
in new free programs; and that you know you can do these things.
To protect your rights, we need to make restrictions that forbid
anyone to deny you these rights or to ask you to surrender the rights.
These restrictions translate to certain responsibilities for you if you
distribute copies of the software, or if you modify it.
For example, if you distribute copies of such a program, whether
gratis or for a fee, you must give the recipients all the rights that
you have. You must make sure that they, too, receive or can get the
source code. And you must show them these terms so they know their
rights.
We protect your rights with two steps: (1) copyright the software, and
(2) offer you this license which gives you legal permission to copy,
distribute and/or modify the software.
Also, for each author's protection and ours, we want to make certain
that everyone understands that there is no warranty for this free
software. If the software is modified by someone else and passed on, we
want its recipients to know that what they have is not the original, so
that any problems introduced by others will not reflect on the original
authors' reputations.
Finally, any free program is threatened constantly by software
patents. We wish to avoid the danger that redistributors of a free
program will individually obtain patent licenses, in effect making the
program proprietary. To prevent this, we have made it clear that any
patent must be licensed for everyone's free use or not licensed at all.
The precise terms and conditions for copying, distribution and
modification follow.
GNU GENERAL PUBLIC LICENSE
TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
0. This License applies to any program or other work which contains
a notice placed by the copyright holder saying it may be distributed
under the terms of this General Public License. The "Program", below,
refers to any such program or work, and a "work based on the Program"
means either the Program or any derivative work under copyright law:
that is to say, a work containing the Program or a portion of it,
either verbatim or with modifications and/or translated into another
language. (Hereinafter, translation is included without limitation in
the term "modification".) Each licensee is addressed as "you".
Activities other than copying, distribution and modification are not
covered by this License; they are outside its scope. The act of
running the Program is not restricted, and the output from the Program
is covered only if its contents constitute a work based on the
Program (independent of having been made by running the Program).
Whether that is true depends on what the Program does.
1. You may copy and distribute verbatim copies of the Program's
source code as you receive it, in any medium, provided that you
conspicuously and appropriately publish on each copy an appropriate
copyright notice and disclaimer of warranty; keep intact all the
notices that refer to this License and to the absence of any warranty;
and give any other recipients of the Program a copy of this License
along with the Program.
You may charge a fee for the physical act of transferring a copy, and
you may at your option offer warranty protection in exchange for a fee.
2. You may modify your copy or copies of the Program or any portion
of it, thus forming a work based on the Program, and copy and
distribute such modifications or work under the terms of Section 1
above, provided that you also meet all of these conditions:
a) You must cause the modified files to carry prominent notices
stating that you changed the files and the date of any change.
b) You must cause any work that you distribute or publish, that in
whole or in part contains or is derived from the Program or any
part thereof, to be licensed as a whole at no charge to all third
parties under the terms of this License.
c) If the modified program normally reads commands interactively
when run, you must cause it, when started running for such
interactive use in the most ordinary way, to print or display an
announcement including an appropriate copyright notice and a
notice that there is no warranty (or else, saying that you provide
a warranty) and that users may redistribute the program under
these conditions, and telling the user how to view a copy of this
License. (Exception: if the Program itself is interactive but
does not normally print such an announcement, your work based on
the Program is not required to print an announcement.)
These requirements apply to the modified work as a whole. If
identifiable sections of that work are not derived from the Program,
and can be reasonably considered independent and separate works in
themselves, then this License, and its terms, do not apply to those
sections when you distribute them as separate works. But when you
distribute the same sections as part of a whole which is a work based
on the Program, the distribution of the whole must be on the terms of
this License, whose permissions for other licensees extend to the
entire whole, and thus to each and every part regardless of who wrote it.
Thus, it is not the intent of this section to claim rights or contest
your rights to work written entirely by you; rather, the intent is to
exercise the right to control the distribution of derivative or
collective works based on the Program.
In addition, mere aggregation of another work not based on the Program
with the Program (or with a work based on the Program) on a volume of
a storage or distribution medium does not bring the other work under
the scope of this License.
3. You may copy and distribute the Program (or a work based on it,
under Section 2) in object code or executable form under the terms of
Sections 1 and 2 above provided that you also do one of the following:
a) Accompany it with the complete corresponding machine-readable
source code, which must be distributed under the terms of Sections
1 and 2 above on a medium customarily used for software interchange; or,
b) Accompany it with a written offer, valid for at least three
years, to give any third party, for a charge no more than your
cost of physically performing source distribution, a complete
machine-readable copy of the corresponding source code, to be
distributed under the terms of Sections 1 and 2 above on a medium
customarily used for software interchange; or,
c) Accompany it with the information you received as to the offer
to distribute corresponding source code. (This alternative is
allowed only for noncommercial distribution and only if you
received the program in object code or executable form with such
an offer, in accord with Subsection b above.)
The source code for a work means the preferred form of the work for
making modifications to it. For an executable work, complete source
code means all the source code for all modules it contains, plus any
associated interface definition files, plus the scripts used to
control compilation and installation of the executable. However, as a
special exception, the source code distributed need not include
anything that is normally distributed (in either source or binary
form) with the major components (compiler, kernel, and so on) of the
operating system on which the executable runs, unless that component
itself accompanies the executable.
If distribution of executable or object code is made by offering
access to copy from a designated place, then offering equivalent
access to copy the source code from the same place counts as
distribution of the source code, even though third parties are not
compelled to copy the source along with the object code.
4. You may not copy, modify, sublicense, or distribute the Program
except as expressly provided under this License. Any attempt
otherwise to copy, modify, sublicense or distribute the Program is
void, and will automatically terminate your rights under this License.
However, parties who have received copies, or rights, from you under
this License will not have their licenses terminated so long as such
parties remain in full compliance.
5. You are not required to accept this License, since you have not
signed it. However, nothing else grants you permission to modify or
distribute the Program or its derivative works. These actions are
prohibited by law if you do not accept this License. Therefore, by
modifying or distributing the Program (or any work based on the
Program), you indicate your acceptance of this License to do so, and
all its terms and conditions for copying, distributing or modifying
the Program or works based on it.
6. Each time you redistribute the Program (or any work based on the
Program), the recipient automatically receives a license from the
original licensor to copy, distribute or modify the Program subject to
these terms and conditions. You may not impose any further
restrictions on the recipients' exercise of the rights granted herein.
You are not responsible for enforcing compliance by third parties to
this License.
7. If, as a consequence of a court judgment or allegation of patent
infringement or for any other reason (not limited to patent issues),
conditions are imposed on you (whether by court order, agreement or
otherwise) that contradict the conditions of this License, they do not
excuse you from the conditions of this License. If you cannot
distribute so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you
may not distribute the Program at all. For example, if a patent
license would not permit royalty-free redistribution of the Program by
all those who receive copies directly or indirectly through you, then
the only way you could satisfy both it and this License would be to
refrain entirely from distribution of the Program.
If any portion of this section is held invalid or unenforceable under
any particular circumstance, the balance of the section is intended to
apply and the section as a whole is intended to apply in other
circumstances.
It is not the purpose of this section to induce you to infringe any
patents or other property right claims or to contest validity of any
such claims; this section has the sole purpose of protecting the
integrity of the free software distribution system, which is
implemented by public license practices. Many people have made
generous contributions to the wide range of software distributed
through that system in reliance on consistent application of that
system; it is up to the author/donor to decide if he or she is willing
to distribute software through any other system and a licensee cannot
impose that choice.
This section is intended to make thoroughly clear what is believed to
be a consequence of the rest of this License.
8. If the distribution and/or use of the Program is restricted in
certain countries either by patents or by copyrighted interfaces, the
original copyright holder who places the Program under this License
may add an explicit geographical distribution limitation excluding
those countries, so that distribution is permitted only in or among
countries not thus excluded. In such case, this License incorporates
the limitation as if written in the body of this License.
9. The Free Software Foundation may publish revised and/or new versions
of the General Public License from time to time. Such new versions will
be similar in spirit to the present version, but may differ in detail to
address new problems or concerns.
Each version is given a distinguishing version number. If the Program
specifies a version number of this License which applies to it and "any
later version", you have the option of following the terms and conditions
either of that version or of any later version published by the Free
Software Foundation. If the Program does not specify a version number of
this License, you may choose any version ever published by the Free Software
Foundation.
10. If you wish to incorporate parts of the Program into other free
programs whose distribution conditions are different, write to the author
to ask for permission. For software which is copyrighted by the Free
Software Foundation, write to the Free Software Foundation; we sometimes
make exceptions for this. Our decision will be guided by the two goals
of preserving the free status of all derivatives of our free software and
of promoting the sharing and reuse of software generally.
NO WARRANTY
11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN
OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS
TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE
PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
REPAIR OR CORRECTION.
12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
POSSIBILITY OF SUCH DAMAGES.
END OF TERMS AND CONDITIONS
How to Apply These Terms to Your New Programs
If you develop a new program, and you want it to be of the greatest
possible use to the public, the best way to achieve this is to make it
free software which everyone can redistribute and change under these terms.
To do so, attach the following notices to the program. It is safest
to attach them to the start of each source file to most effectively
convey the exclusion of warranty; and each file should have at least
the "copyright" line and a pointer to where the full notice is found.
<one line to give the program's name and a brief idea of what it does.>
Copyright (C) <year> <name of author>
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program 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. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License along
with this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
Also add information on how to contact you by electronic and paper mail.
If the program is interactive, make it output a short notice like this
when it starts in an interactive mode:
Gnomovision version 69, Copyright (C) year name of author
Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
This is free software, and you are welcome to redistribute it
under certain conditions; type `show c' for details.
The hypothetical commands `show w' and `show c' should show the appropriate
parts of the General Public License. Of course, the commands you use may
be called something other than `show w' and `show c'; they could even be
mouse-clicks or menu items--whatever suits your program.
You should also get your employer (if you work as a programmer) or your
school, if any, to sign a "copyright disclaimer" for the program, if
necessary. Here is a sample; alter the names:
Yoyodyne, Inc., hereby disclaims all copyright interest in the program
`Gnomovision' (which makes passes at compilers) written by James Hacker.
<signature of Ty Coon>, 1 April 1989
Ty Coon, President of Vice
This General Public License does not permit incorporating your program into
proprietary programs. If your program is a subroutine library, you may
consider it more useful to permit linking proprietary applications with the
library. If this is what you want to do, use the GNU Lesser General
Public License instead of this License.
================================================
FILE: NOTICE
================================================
Copyright (c) 2024 Bowen Yang <byangar@connect.ust.hk>, Jie Cheng <jchengai@connect.ust.hk>
PCT_planner contains several third party libraries, with documentation of licensing
and modifications as follows:
- gtsam 4.1.1: Georgia Tech Smoothing and Mapping Library
- Removed unused cmake files and example data
- Licenced under BSD, provided in PCT_planner/planner/lib/3rdparty/gtsam-4.1.1/LICENSE.BSD
- osqp: The Operator Splitting QP Solver
- Modified osqp/include/constants.h, osqp/include/osqp_configure.h
- Licenced under Apache License v 2.0, provided in PCT_planner/planner/lib/3rdparty/osqp/LICENSE
- pybind11: Seamless operability between C++11 and Python
- Licenced provided in PCT_planner/planner/lib/3rdparty/pybind11/LICENSE
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program 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. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License along
with this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
================================================
FILE: README.md
================================================
# PCT Planner
## Overview
This is an implementation of paper **Efficient Global Navigational Planning in 3-D Structures Based on Point Cloud Tomography** (accepted by TMECH).
It provides a highly efficient and extensible global navigation framework based on a tomographic understanding of the environment to navigate ground robots in multi-layer structures.
**Demonstrations**: [pct_planner](https://byangw.github.io/projects/tmech2024/)
## Citing
If you use PCT Planner, please cite the following paper:
[Efficient Global Navigational Planning in 3-D Structures Based on Point Cloud Tomography](https://ieeexplore.ieee.org/document/10531813)
```bibtex
@ARTICLE{yang2024efficient,
author={Yang, Bowen and Cheng, Jie and Xue, Bohuan and Jiao, Jianhao and Liu, Ming},
journal={IEEE/ASME Transactions on Mechatronics},
title={Efficient Global Navigational Planning in 3-D Structures Based on Point Cloud Tomography},
year={2024},
volume={},
number={},
pages={1-12}
}
```
## Prerequisites
### Environment
- Ubuntu >= 20.04
- ROS >= Noetic with ros-desktop-full installation
- CUDA >= 11.7
### Python
- Python >= 3.8
- [CuPy](https://docs.cupy.dev/en/stable/install.html) with CUDA >= 11.7
- Open3d
## Build & Install
Inside the package, there are two modules: the point cloud tomography module for tomogram reconstruction (in **tomography/**) and the planner module for path planning and optimization (in **planner/**).
You only need to build the planner module before use.
In **planner/**, run **build_thirdparty.sh** first and then run **build.sh**.
```bash
cd planner/
./build_thirdparty.sh
./build.sh
```
## Run Examples
Three example scenarios are provided: **"Spiral"**, **"Building"**, and **"Plaza"**.
- **"Spiral"**: A spiral overpass scenario released in the [3D2M planner](https://github.com/ZJU-FAST-Lab/3D2M-planner).
- **"Building"**: A multi-layer indoor scenario with various stairs, slopes, overhangs and obstacles.
- **"Plaza"**: A complex outdoor plaza for repeated trajectory generation evaluation.
### Tomogram Construction
To plan in a scenario, first you need to construct the scene tomogram using the pcd file.
- Unzip the pcd files in **rsc/pcd/pcd_files.zip** to **rsc/pcd/**.
- For scene **"Spiral"**, you can download the pcd file from [3D2M planner spiral0.3_2.pcd](https://github.com/ZJU-FAST-Lab/3D2M-planner/tree/main/planner/src/read_pcd/PCDFiles).
- Run **roscore**, start **RViz** with the provided config (**rsc/rviz/pct_ros.rviz**).
- In **tomography/scripts/**, run **tomography.py** with the **--scene** argument:
```bash
cd tomography/scripts/
python3 tomography.py --scene Spiral
```
- The generated tomogram is visualized as ROS PointCloud2 message in RViz and saved in **rsc/tomogram/**.
### Trajectory Generation
After the tomogram is constructed, you can run the trajectory generation example.
- In **planner/scripts/**, run **plan.py** with the **--scene** argument:
```bash
export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/YOUR/DIRECTORY/TO/PCT_planner/planner/lib/3rdparty/gtsam-4.1.1/install/lib
cd planner/scripts/
python3 plan.py --scene Spiral
```
- The generated trajectory is visualized as ROS Path message in RViz.
## License
The source code is released under [GPLv2](http://www.gnu.org/licenses/) license.
For commercial use, please contact Bowen Yang [byangar@connect.ust.hk](mailto:byangar@connect.ust.hk).
================================================
FILE: planner/build.sh
================================================
#!/bin/bash
ROOT_DIR=$(cd $(dirname "$0"); pwd)
# echo "ROOT_DIR: ${ROOT_DIR}"
cd lib
# rm -rf build
mkdir build
cd build
cmake ../ -DCMAKE_BUILD_TYPE=Release
make -j6
cp ./src/a_star/a_star*.so ../
cp ./src/trajectory_optimization/traj_opt*.so ../
cp ./src/ele_planner/ele_planner*.so ../
cp ./src/map_manager/py_map_manager*.so ../
cp ./src/common/smoothing/libcommon_smoothing.so ../
cd ..
# # optional
export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:${ROOT_DIR}/lib/3rdparty/gtsam-4.1.1/install/lib
export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:${ROOT_DIR}/lib/build/src/common/smoothing
export PYTHONPATH=$PYTHONPATH:${ROOT_DIR}/lib
# pybind11-stubgen -o ./ a_star
# pybind11-stubgen -o ./ traj_opt
# pybind11-stubgen -o ./ ele_planner
# pybind11-stubgen -o ./ py_map_manager
# cp ./a_star-stubs/__init__.pyi ./a_star.pyi
# cp ./traj_opt-stubs/__init__.pyi ./traj_opt.pyi
# cp ./ele_planner-stubs/__init__.pyi ./ele_planner.pyi
# cp ./py_map_manager-stubs/__init__.pyi ./py_map_manager.pyi
================================================
FILE: planner/build_thirdparty.sh
================================================
ROOT_DIR=$(cd $(dirname "$0"); pwd)
# build gtsam
cd ${ROOT_DIR}/lib/3rdparty/gtsam-4.1.1
rm -rf build install
mkdir build install
cd build
cmake .. -DCMAKE_INSTALL_PREFIX="../install" -DCMAKE_BUILD_TYPE=Release -DGTSAM_USE_SYSTEM_EIGEN=ON
make -j6 && make install
# build osqp
cd ${ROOT_DIR}/lib/3rdparty/osqp
rm -rf build install
mkdir build && cd build
cmake .. -DCMAKE_INSTALL_PREFIX="../install" -DCMAKE_BUILD_TYPE=Release
make -j4 && make install
================================================
FILE: planner/config/__init__.py
================================================
from .param import Config
================================================
FILE: planner/config/param.py
================================================
class ConfigPlanner():
use_quintic = True
max_heading_rate = 10
class ConfigWrapper():
tomo_dir = '/rsc/tomogram/'
class Config():
planner = ConfigPlanner()
wrapper = ConfigWrapper()
================================================
FILE: planner/lib/3rdparty/gtsam-4.1.1/.github/ISSUE_TEMPLATE/bug-report.md
================================================
---
name: "Bug Report"
about: Submit a bug report to help us improve GTSAM
---
<!--Please only submit issues/bug reports that come with enough information to reproduce them, ideally a unit test that fails, and possible ideas on what might be wrong. -->
<!-- Even better yet, fix the bug and/or documentation, add a unit test, and create a pull request! -->
<!-- This is a channel to report bugs/issues, not a support channel to help install/use/debug your own code. We'd love to help, but just don't have the bandwidth. Please post questions in the GTSAM Google group (https://groups.google.com/forum/#!forum/gtsam-users) -->
## Description
<!-- A clear description of the bug -->
## Steps to reproduce
1.
2.
<!-- If you have a code sample, unit test, error messages, stack traces, etc., please provide it here as well -->
## Expected behavior
<!-- A clear and concise description of what you expected to happen. -->
## Environment
<!-- Please provide information about your code environment, things such as OS, language of use (C++, Matlab or Python), version of dependent libraries if using a custom build etc., anything to provide us more information. -->
<!-- The more the information, the faster we can help resolve the issue -->
## Additional information
<!-- Add any other infor or context about the problem here. -->
================================================
FILE: planner/lib/3rdparty/gtsam-4.1.1/.github/ISSUE_TEMPLATE/feature-request.md
================================================
---
name: "Feature Request"
about: Submit a proposal/request for a new GTSAM feature
---
## Feature
<!-- A clear and concise description of the feature proposal -->
## Motivation
<!-- Please outline the motivation for the proposal. Is your feature request related to a problem? e.g., I'm always frustrated when [...]. If this is related to another GitHub issue, please link here too. -->
## Pitch
<!-- A clear and concise description of what you want to happen. -->
## Alternatives
<!-- A clear and concise description of any alternative solutions or features you've considered, if any. -->
## Additional context
<!-- Add any other context or screenshots about the feature request here. -->
================================================
FILE: planner/lib/3rdparty/gtsam-4.1.1/.github/ISSUE_TEMPLATE/questions-help-support.md
================================================
---
name: "Questions/Help/Support"
---
Please post questions and support requests in the [GTSAM Google group](https://groups.google.com/forum/#!forum/gtsam-users) and not on Github.
================================================
FILE: planner/lib/3rdparty/gtsam-4.1.1/.github/scripts/boost.sh
================================================
### Script to install Boost
BOOST_FOLDER=boost_${BOOST_VERSION//./_}
# Download Boost
wget https://boostorg.jfrog.io/artifactory/main/release/${BOOST_VERSION}/source/${BOOST_FOLDER}.tar.gz
# Unzip
tar -zxf ${BOOST_FOLDER}.tar.gz
# Bootstrap
cd ${BOOST_FOLDER}/
./bootstrap.sh --with-libraries=serialization,filesystem,thread,system,atomic,date_time,timer,chrono,program_options,regex
# Build and install
sudo ./b2 -j$(nproc) install
# Rebuild ld cache
sudo ldconfig
================================================
FILE: planner/lib/3rdparty/gtsam-4.1.1/.github/scripts/python.sh
================================================
#!/bin/bash
##########################################################
# Build and test the GTSAM Python wrapper.
##########################################################
set -x -e
# install TBB with _debug.so files
function install_tbb()
{
TBB_BASEURL=https://github.com/oneapi-src/oneTBB/releases/download
TBB_VERSION=4.4.5
TBB_DIR=tbb44_20160526oss
TBB_SAVEPATH="/tmp/tbb.tgz"
if [ "$(uname)" == "Linux" ]; then
OS_SHORT="lin"
TBB_LIB_DIR="intel64/gcc4.4"
SUDO="sudo"
elif [ "$(uname)" == "Darwin" ]; then
OS_SHORT="osx"
TBB_LIB_DIR=""
SUDO=""
fi
wget "${TBB_BASEURL}/${TBB_VERSION}/${TBB_DIR}_${OS_SHORT}.tgz" -O $TBB_SAVEPATH
tar -C /tmp -xf $TBB_SAVEPATH
TBBROOT=/tmp/$TBB_DIR
# Copy the needed files to the correct places.
# This works correctly for CI builds, instead of setting path variables.
# This is what Homebrew does to install TBB on Macs
$SUDO cp -R $TBBROOT/lib/$TBB_LIB_DIR/* /usr/local/lib/
$SUDO cp -R $TBBROOT/include/ /usr/local/include/
}
if [ -z ${PYTHON_VERSION+x} ]; then
echo "Please provide the Python version to build against!"
exit 127
fi
PYTHON="python${PYTHON_VERSION}"
if [[ $(uname) == "Darwin" ]]; then
brew install wget
else
# Install a system package required by our library
sudo apt-get install -y wget libicu-dev python3-pip python3-setuptools
fi
PATH=$PATH:$($PYTHON -c "import site; print(site.USER_BASE)")/bin
[ "${GTSAM_WITH_TBB:-OFF}" = "ON" ] && install_tbb
BUILD_PYBIND="ON"
sudo $PYTHON -m pip install -r $GITHUB_WORKSPACE/python/requirements.txt
mkdir $GITHUB_WORKSPACE/build
cd $GITHUB_WORKSPACE/build
cmake $GITHUB_WORKSPACE -DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE} \
-DGTSAM_BUILD_TESTS=OFF \
-DGTSAM_BUILD_UNSTABLE=${GTSAM_BUILD_UNSTABLE:-ON} \
-DGTSAM_USE_QUATERNIONS=OFF \
-DGTSAM_WITH_TBB=${GTSAM_WITH_TBB:-OFF} \
-DGTSAM_BUILD_EXAMPLES_ALWAYS=OFF \
-DGTSAM_BUILD_WITH_MARCH_NATIVE=OFF \
-DGTSAM_BUILD_PYTHON=${BUILD_PYBIND} \
-DGTSAM_UNSTABLE_BUILD_PYTHON=${GTSAM_BUILD_UNSTABLE:-ON} \
-DGTSAM_PYTHON_VERSION=$PYTHON_VERSION \
-DPYTHON_EXECUTABLE:FILEPATH=$(which $PYTHON) \
-DGTSAM_ALLOW_DEPRECATED_SINCE_V41=OFF \
-DCMAKE_INSTALL_PREFIX=$GITHUB_WORKSPACE/gtsam_install
# Set to 2 cores so that Actions does not error out during resource provisioning.
make -j2 install
cd $GITHUB_WORKSPACE/build/python
$PYTHON setup.py install --user --prefix=
cd $GITHUB_WORKSPACE/python/gtsam/tests
$PYTHON -m unittest discover -v
================================================
FILE: planner/lib/3rdparty/gtsam-4.1.1/.github/scripts/unix.sh
================================================
#!/bin/bash
##########################################################
# Build and test GTSAM for *nix based systems.
# Specifically Linux and macOS.
##########################################################
# install TBB with _debug.so files
function install_tbb()
{
TBB_BASEURL=https://github.com/oneapi-src/oneTBB/releases/download
TBB_VERSION=4.4.5
TBB_DIR=tbb44_20160526oss
TBB_SAVEPATH="/tmp/tbb.tgz"
if [ "$(uname)" == "Linux" ]; then
OS_SHORT="lin"
TBB_LIB_DIR="intel64/gcc4.4"
SUDO="sudo"
elif [ "$(uname)" == "Darwin" ]; then
OS_SHORT="osx"
TBB_LIB_DIR=""
SUDO=""
fi
wget "${TBB_BASEURL}/${TBB_VERSION}/${TBB_DIR}_${OS_SHORT}.tgz" -O $TBB_SAVEPATH
tar -C /tmp -xf $TBB_SAVEPATH
TBBROOT=/tmp/$TBB_DIR
# Copy the needed files to the correct places.
# This works correctly for CI builds, instead of setting path variables.
# This is what Homebrew does to install TBB on Macs
$SUDO cp -R $TBBROOT/lib/$TBB_LIB_DIR/* /usr/local/lib/
$SUDO cp -R $TBBROOT/include/ /usr/local/include/
}
# common tasks before either build or test
function configure()
{
set -e # Make sure any error makes the script to return an error code
set -x # echo
SOURCE_DIR=$GITHUB_WORKSPACE
BUILD_DIR=$GITHUB_WORKSPACE/build
#env
rm -fr $BUILD_DIR || true
mkdir $BUILD_DIR && cd $BUILD_DIR
[ "${GTSAM_WITH_TBB:-OFF}" = "ON" ] && install_tbb
if [ ! -z "$GCC_VERSION" ]; then
export CC=gcc-$GCC_VERSION
export CXX=g++-$GCC_VERSION
fi
# GTSAM_BUILD_WITH_MARCH_NATIVE=OFF: to avoid crashes in builder VMs
cmake $SOURCE_DIR \
-DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE:-Debug} \
-DGTSAM_BUILD_TESTS=${GTSAM_BUILD_TESTS:-OFF} \
-DGTSAM_BUILD_UNSTABLE=${GTSAM_BUILD_UNSTABLE:-ON} \
-DGTSAM_WITH_TBB=${GTSAM_WITH_TBB:-OFF} \
-DGTSAM_BUILD_EXAMPLES_ALWAYS=${GTSAM_BUILD_EXAMPLES_ALWAYS:-ON} \
-DGTSAM_ALLOW_DEPRECATED_SINCE_V41=${GTSAM_ALLOW_DEPRECATED_SINCE_V41:-OFF} \
-DGTSAM_USE_QUATERNIONS=${GTSAM_USE_QUATERNIONS:-OFF} \
-DGTSAM_ROT3_EXPMAP=${GTSAM_ROT3_EXPMAP:-ON} \
-DGTSAM_POSE3_EXPMAP=${GTSAM_POSE3_EXPMAP:-ON} \
-DGTSAM_USE_SYSTEM_EIGEN=${GTSAM_USE_SYSTEM_EIGEN:-OFF} \
-DGTSAM_USE_SYSTEM_METIS=${GTSAM_USE_SYSTEM_METIS:-OFF} \
-DGTSAM_BUILD_WITH_MARCH_NATIVE=OFF \
-DBOOST_ROOT=$BOOST_ROOT \
-DBoost_NO_SYSTEM_PATHS=ON \
-DBoost_ARCHITECTURE=-x64
}
# common tasks after either build or test
function finish ()
{
# Print ccache stats
[ -x "$(command -v ccache)" ] && ccache -s
cd $SOURCE_DIR
}
# compile the code with the intent of populating the cache
function build ()
{
export GTSAM_BUILD_EXAMPLES_ALWAYS=ON
export GTSAM_BUILD_TESTS=OFF
configure
if [ "$(uname)" == "Linux" ]; then
make -j$(nproc)
elif [ "$(uname)" == "Darwin" ]; then
make -j$(sysctl -n hw.physicalcpu)
fi
finish
}
# run the tests
function test ()
{
export GTSAM_BUILD_EXAMPLES_ALWAYS=OFF
export GTSAM_BUILD_TESTS=ON
configure
# Actual testing
if [ "$(uname)" == "Linux" ]; then
make -j$(nproc) check
elif [ "$(uname)" == "Darwin" ]; then
make -j$(sysctl -n hw.physicalcpu) check
fi
finish
}
# select between build or test
case $1 in
-b)
build
;;
-t)
test
;;
esac
================================================
FILE: planner/lib/3rdparty/gtsam-4.1.1/.github/workflows/build-linux.yml
================================================
name: Linux CI
on: [push, pull_request]
jobs:
build:
name: ${{ matrix.name }} ${{ matrix.build_type }}
runs-on: ${{ matrix.os }}
env:
CTEST_OUTPUT_ON_FAILURE: ON
CTEST_PARALLEL_LEVEL: 2
CMAKE_BUILD_TYPE: ${{ matrix.build_type }}
GTSAM_BUILD_UNSTABLE: ${{ matrix.build_unstable }}
BOOST_VERSION: 1.67.0
strategy:
fail-fast: false
matrix:
# Github Actions requires a single row to be added to the build matrix.
# See https://help.github.com/en/articles/workflow-syntax-for-github-actions.
name: [
ubuntu-18.04-gcc-5,
ubuntu-18.04-gcc-9,
ubuntu-18.04-clang-9,
]
build_type: [Debug, Release]
build_unstable: [ON]
include:
- name: ubuntu-18.04-gcc-5
os: ubuntu-18.04
compiler: gcc
version: "5"
- name: ubuntu-18.04-gcc-9
os: ubuntu-18.04
compiler: gcc
version: "9"
- name: ubuntu-18.04-clang-9
os: ubuntu-18.04
compiler: clang
version: "9"
steps:
- name: Checkout
uses: actions/checkout@v2
- name: Install Dependencies
run: |
# LLVM (clang) 9 is not in Bionic's repositories so we add the official LLVM repository.
if [ "${{ matrix.compiler }}" = "clang" ] && [ "${{ matrix.version }}" = "9" ]; then
# (ipv4|ha).pool.sks-keyservers.net is the SKS GPG global keyserver pool
# ipv4 avoids potential timeouts because of crappy IPv6 infrastructure
# 15CF4D18AF4F7421 is the GPG key for the LLVM apt repository
# This key is not in the keystore by default for Ubuntu so we need to add it.
LLVM_KEY=15CF4D18AF4F7421
gpg --keyserver keyserver.ubuntu.com --recv-key $LLVM_KEY || gpg --keyserver hkp://keyserver.ubuntu.com:80 --recv-key $LLVM_KEY
gpg -a --export $LLVM_KEY | sudo apt-key add -
sudo add-apt-repository "deb http://apt.llvm.org/bionic/ llvm-toolchain-bionic-9 main"
fi
sudo apt-get -y update
sudo apt-get -y install cmake build-essential pkg-config libpython-dev python-numpy libicu-dev
if [ "${{ matrix.compiler }}" = "gcc" ]; then
sudo apt-get install -y g++-${{ matrix.version }} g++-${{ matrix.version }}-multilib
echo "CC=gcc-${{ matrix.version }}" >> $GITHUB_ENV
echo "CXX=g++-${{ matrix.version }}" >> $GITHUB_ENV
else
sudo apt-get install -y clang-${{ matrix.version }} g++-multilib
echo "CC=clang-${{ matrix.version }}" >> $GITHUB_ENV
echo "CXX=clang++-${{ matrix.version }}" >> $GITHUB_ENV
fi
- name: Install Boost
run: |
bash .github/scripts/boost.sh
- name: Build and Test
run: bash .github/scripts/unix.sh -t
================================================
FILE: planner/lib/3rdparty/gtsam-4.1.1/.github/workflows/build-macos.yml
================================================
name: macOS CI
on: [pull_request]
jobs:
build:
name: ${{ matrix.name }} ${{ matrix.build_type }}
runs-on: ${{ matrix.os }}
env:
CTEST_OUTPUT_ON_FAILURE: ON
CTEST_PARALLEL_LEVEL: 2
CMAKE_BUILD_TYPE: ${{ matrix.build_type }}
GTSAM_BUILD_UNSTABLE: ${{ matrix.build_unstable }}
strategy:
fail-fast: false
matrix:
# Github Actions requires a single row to be added to the build matrix.
# See https://help.github.com/en/articles/workflow-syntax-for-github-actions.
name: [
macOS-10.15-xcode-11.3.1,
]
build_type: [Debug, Release]
build_unstable: [ON]
include:
- name: macOS-10.15-xcode-11.3.1
os: macOS-10.15
compiler: xcode
version: "11.3.1"
steps:
- name: Checkout
uses: actions/checkout@v2
- name: Install Dependencies
run: |
brew install cmake ninja
brew install boost
if [ "${{ matrix.compiler }}" = "gcc" ]; then
brew install gcc@${{ matrix.version }}
echo "CC=gcc-${{ matrix.version }}" >> $GITHUB_ENV
echo "CXX=g++-${{ matrix.version }}" >> $GITHUB_ENV
else
sudo xcode-select -switch /Applications/Xcode_${{ matrix.version }}.app
echo "CC=clang" >> $GITHUB_ENV
echo "CXX=clang++" >> $GITHUB_ENV
fi
- name: Build and Test
run: bash .github/scripts/unix.sh -t
================================================
FILE: planner/lib/3rdparty/gtsam-4.1.1/.github/workflows/build-python.yml
================================================
name: Python CI
on: [pull_request]
jobs:
build:
name: ${{ matrix.name }} ${{ matrix.build_type }} Python ${{ matrix.python_version }}
runs-on: ${{ matrix.os }}
env:
CTEST_OUTPUT_ON_FAILURE: ON
CTEST_PARALLEL_LEVEL: 2
CMAKE_BUILD_TYPE: ${{ matrix.build_type }}
PYTHON_VERSION: ${{ matrix.python_version }}
strategy:
fail-fast: false
matrix:
# Github Actions requires a single row to be added to the build matrix.
# See https://help.github.com/en/articles/workflow-syntax-for-github-actions.
name: [
ubuntu-18.04-gcc-5,
ubuntu-18.04-gcc-9,
ubuntu-18.04-clang-9,
macOS-10.15-xcode-11.3.1,
ubuntu-18.04-gcc-5-tbb,
]
build_type: [Debug, Release]
python_version: [3]
include:
- name: ubuntu-18.04-gcc-5
os: ubuntu-18.04
compiler: gcc
version: "5"
- name: ubuntu-18.04-gcc-9
os: ubuntu-18.04
compiler: gcc
version: "9"
- name: ubuntu-18.04-clang-9
os: ubuntu-18.04
compiler: clang
version: "9"
# NOTE temporarily added this as it is a required check.
- name: ubuntu-18.04-clang-9
os: ubuntu-18.04
compiler: clang
version: "9"
build_type: Debug
python_version: "3"
- name: macOS-10.15-xcode-11.3.1
os: macOS-10.15
compiler: xcode
version: "11.3.1"
- name: ubuntu-18.04-gcc-5-tbb
os: ubuntu-18.04
compiler: gcc
version: "5"
flag: tbb
steps:
- name: Checkout
uses: actions/checkout@v2
- name: Install (Linux)
if: runner.os == 'Linux'
run: |
if [ "${{ matrix.compiler }}" = "clang" ] && [ "${{ matrix.version }}" = "9" ]; then
# (ipv4|ha).pool.sks-keyservers.net is the SKS GPG global keyserver pool
# ipv4 avoids potential timeouts because of crappy IPv6 infrastructure
# 15CF4D18AF4F7421 is the GPG key for the LLVM apt repository
# This key is not in the keystore by default for Ubuntu so we need to add it.
LLVM_KEY=15CF4D18AF4F7421
gpg --keyserver keyserver.ubuntu.com --recv-key $LLVM_KEY || gpg --keyserver hkp://keyserver.ubuntu.com:80 --recv-key $LLVM_KEY
gpg -a --export $LLVM_KEY | sudo apt-key add -
sudo add-apt-repository "deb http://apt.llvm.org/bionic/ llvm-toolchain-bionic-9 main"
fi
sudo apt-get -y update
sudo apt-get -y install cmake build-essential pkg-config libpython-dev python-numpy libboost-all-dev
if [ "${{ matrix.compiler }}" = "gcc" ]; then
sudo apt-get install -y g++-${{ matrix.version }} g++-${{ matrix.version }}-multilib
echo "CC=gcc-${{ matrix.version }}" >> $GITHUB_ENV
echo "CXX=g++-${{ matrix.version }}" >> $GITHUB_ENV
else
sudo apt-get install -y clang-${{ matrix.version }} g++-multilib
echo "CC=clang-${{ matrix.version }}" >> $GITHUB_ENV
echo "CXX=clang++-${{ matrix.version }}" >> $GITHUB_ENV
fi
- name: Install (macOS)
if: runner.os == 'macOS'
run: |
brew tap ProfFan/robotics
brew install cmake ninja
brew install boost
if [ "${{ matrix.compiler }}" = "gcc" ]; then
brew install gcc@${{ matrix.version }}
echo "CC=gcc-${{ matrix.version }}" >> $GITHUB_ENV
echo "CXX=g++-${{ matrix.version }}" >> $GITHUB_ENV
else
sudo xcode-select -switch /Applications/Xcode_${{ matrix.version }}.app
echo "CC=clang" >> $GITHUB_ENV
echo "CXX=clang++" >> $GITHUB_ENV
fi
- name: Set GTSAM_WITH_TBB Flag
if: matrix.flag == 'tbb'
run: |
echo "GTSAM_WITH_TBB=ON" >> $GITHUB_ENV
echo "GTSAM Uses TBB"
- name: Build (Linux)
if: runner.os == 'Linux'
run: |
bash .github/scripts/python.sh
- name: Build (macOS)
if: runner.os == 'macOS'
run: |
bash .github/scripts/python.sh
================================================
FILE: planner/lib/3rdparty/gtsam-4.1.1/.github/workflows/build-special.yml
================================================
name: Special Cases CI
on: [pull_request]
jobs:
build:
name: ${{ matrix.name }} ${{ matrix.build_type }}
runs-on: ${{ matrix.os }}
env:
CTEST_OUTPUT_ON_FAILURE: ON
CTEST_PARALLEL_LEVEL: 2
CMAKE_BUILD_TYPE: ${{ matrix.build_type }}
GTSAM_BUILD_UNSTABLE: ON
BOOST_VERSION: 1.67.0
strategy:
fail-fast: false
matrix:
# Github Actions requires a single row to be added to the build matrix.
# See https://help.github.com/en/articles/workflow-syntax-for-github-actions.
name:
[
ubuntu-gcc-deprecated,
ubuntu-gcc-quaternions,
ubuntu-gcc-tbb,
ubuntu-cayleymap,
]
build_type: [Debug, Release]
include:
- name: ubuntu-gcc-deprecated
os: ubuntu-18.04
compiler: gcc
version: "9"
flag: deprecated
- name: ubuntu-gcc-quaternions
os: ubuntu-18.04
compiler: gcc
version: "9"
flag: quaternions
- name: ubuntu-gcc-tbb
os: ubuntu-18.04
compiler: gcc
version: "9"
flag: tbb
- name: ubuntu-cayleymap
os: ubuntu-18.04
compiler: gcc
version: "9"
flag: cayley
- name: ubuntu-system-libs
os: ubuntu-18.04
compiler: gcc
version: "9"
flag: system-libs
steps:
- name: Checkout
uses: actions/checkout@v2
- name: Install (Linux)
if: runner.os == 'Linux'
run: |
# LLVM 9 is not in Bionic's repositories so we add the official LLVM repository.
if [ "${{ matrix.compiler }}" = "clang" ] && [ "${{ matrix.version }}" = "9" ]; then
gpg --keyserver keyserver.ubuntu.com --recv-key $LLVM_KEY || gpg --keyserver hkp://keyserver.ubuntu.com:80 --recv-key $LLVM_KEY
gpg -a --export 15CF4D18AF4F7421 | sudo apt-key add -
sudo add-apt-repository "deb http://apt.llvm.org/bionic/ llvm-toolchain-bionic-9 main"
fi
sudo apt-get -y update
sudo apt-get -y install cmake build-essential pkg-config libpython-dev python-numpy libicu-dev
if [ "${{ matrix.compiler }}" = "gcc" ]; then
sudo apt-get install -y g++-${{ matrix.version }} g++-${{ matrix.version }}-multilib
echo "CC=gcc-${{ matrix.version }}" >> $GITHUB_ENV
echo "CXX=g++-${{ matrix.version }}" >> $GITHUB_ENV
else
sudo apt-get install -y clang-${{ matrix.version }} g++-multilib
echo "CC=clang-${{ matrix.version }}" >> $GITHUB_ENV
echo "CXX=clang++-${{ matrix.version }}" >> $GITHUB_ENV
fi
- name: Install Boost
if: runner.os == 'Linux'
run: |
bash .github/scripts/boost.sh
- name: Install (macOS)
if: runner.os == 'macOS'
run: |
brew install cmake ninja boost
if [ "${{ matrix.compiler }}" = "gcc" ]; then
brew install gcc@${{ matrix.version }}
echo "CC=gcc-${{ matrix.version }}" >> $GITHUB_ENV
echo "CXX=g++-${{ matrix.version }}" >> $GITHUB_ENV
else
sudo xcode-select -switch /Applications/Xcode_${{ matrix.version }}.app
echo "CC=clang" >> $GITHUB_ENV
echo "CXX=clang++" >> $GITHUB_ENV
fi
- name: Set Allow Deprecated Flag
if: matrix.flag == 'deprecated'
run: |
echo "GTSAM_ALLOW_DEPRECATED_SINCE_V41=ON" >> $GITHUB_ENV
echo "Allow deprecated since version 4.1"
- name: Set Use Quaternions Flag
if: matrix.flag == 'quaternions'
run: |
echo "GTSAM_USE_QUATERNIONS=ON" >> $GITHUB_ENV
echo "Use Quaternions for rotations"
- name: Set GTSAM_WITH_TBB Flag
if: matrix.flag == 'tbb'
run: |
echo "GTSAM_WITH_TBB=ON" >> $GITHUB_ENV
echo "GTSAM Uses TBB"
- name: Use Cayley Transform for Rot3
if: matrix.flag == 'cayley'
run: |
echo "GTSAM_POSE3_EXPMAP=OFF" >> $GITHUB_ENV
echo "GTSAM_ROT3_EXPMAP=OFF" >> $GITHUB_ENV
echo "GTSAM Uses Cayley map for Rot3"
- name: Use system versions of 3rd party libraries
if: matrix.flag == 'system'
run: |
echo "GTSAM_USE_SYSTEM_EIGEN=ON" >> $GITHUB_ENV
echo "GTSAM_USE_SYSTEM_METIS=ON" >> $GITHUB_ENV
- name: Build & Test
run: |
bash .github/scripts/unix.sh -t
================================================
FILE: planner/lib/3rdparty/gtsam-4.1.1/.github/workflows/build-windows.yml
================================================
name: Windows CI
on: [pull_request]
jobs:
build:
name: ${{ matrix.name }} ${{ matrix.build_type }}
runs-on: ${{ matrix.os }}
env:
CTEST_OUTPUT_ON_FAILURE: ON
CTEST_PARALLEL_LEVEL: 2
CMAKE_BUILD_TYPE: ${{ matrix.build_type }}
GTSAM_BUILD_UNSTABLE: ${{ matrix.build_unstable }}
BOOST_VERSION: 1.72.0
BOOST_EXE: boost_1_72_0-msvc-14.2
strategy:
fail-fast: false
matrix:
# Github Actions requires a single row to be added to the build matrix.
# See https://help.github.com/en/articles/workflow-syntax-for-github-actions.
name: [
#TODO This build fails, need to understand why.
# windows-2016-cl,
windows-2019-cl,
]
build_type: [Debug, Release]
build_unstable: [ON]
include:
#TODO This build fails, need to understand why.
# - name: windows-2016-cl
# os: windows-2016
# compiler: cl
# platform: 32
- name: windows-2019-cl
os: windows-2019
compiler: cl
platform: 64
steps:
- name: Install Dependencies
shell: powershell
run: |
Invoke-Expression (New-Object System.Net.WebClient).DownloadString('https://get.scoop.sh')
scoop install cmake --global # So we don't get issues with CMP0074 policy
scoop install ninja --global
if ("${{ matrix.compiler }}".StartsWith("clang")) {
scoop install llvm --global
}
if ("${{ matrix.compiler }}" -eq "gcc") {
# Chocolatey GCC is broken on the windows-2019 image.
# See: https://github.com/DaanDeMeyer/doctest/runs/231595515
# See: https://github.community/t5/GitHub-Actions/Something-is-wrong-with-the-chocolatey-installed-version-of-gcc/td-p/32413
scoop install gcc --global
echo "CC=gcc" >> $GITHUB_ENV
echo "CXX=g++" >> $GITHUB_ENV
} elseif ("${{ matrix.compiler }}" -eq "clang") {
echo "CC=clang" >> $GITHUB_ENV
echo "CXX=clang++" >> $GITHUB_ENV
} else {
echo "CC=${{ matrix.compiler }}" >> $env:GITHUB_ENV
echo "CXX=${{ matrix.compiler }}" >> $env:GITHUB_ENV
}
# Scoop modifies the PATH so we make the modified PATH global.
echo "$env:PATH" >> $env:GITHUB_PATH
- name: Install Boost
shell: powershell
run: |
# Snippet from: https://github.com/actions/virtual-environments/issues/2667
$BOOST_PATH = "C:\hostedtoolcache\windows\Boost\$env:BOOST_VERSION\x86_64"
# Use the prebuilt binary for Windows
$Url = "https://sourceforge.net/projects/boost/files/boost-binaries/$env:BOOST_VERSION/$env:BOOST_EXE-${{matrix.platform}}.exe"
(New-Object System.Net.WebClient).DownloadFile($Url, "$env:TEMP\boost.exe")
Start-Process -Wait -FilePath "$env:TEMP\boost.exe" "/SILENT","/SP-","/SUPPRESSMSGBOXES","/DIR=$BOOST_PATH"
# Set the BOOST_ROOT variable
echo "BOOST_ROOT=$BOOST_PATH" >> $env:GITHUB_ENV
- name: Checkout
uses: actions/checkout@v2
- name: Build
run: |
cmake -E remove_directory build
cmake -B build -S . -DGTSAM_BUILD_EXAMPLES_ALWAYS=OFF -DBOOST_ROOT="${env:BOOST_ROOT}" -DBOOST_INCLUDEDIR="${env:BOOST_ROOT}\boost\include" -DBOOST_LIBRARYDIR="${env:BOOST_ROOT}\lib"
cmake --build build --config ${{ matrix.build_type }} --target gtsam
cmake --build build --config ${{ matrix.build_type }} --target gtsam_unstable
cmake --build build --config ${{ matrix.build_type }} --target wrap
cmake --build build --config ${{ matrix.build_type }} --target check.base
cmake --build build --config ${{ matrix.build_type }} --target check.base_unstable
cmake --build build --config ${{ matrix.build_type }} --target check.linear
================================================
FILE: planner/lib/3rdparty/gtsam-4.1.1/.github/workflows/trigger-python.yml
================================================
# This triggers Python builds on `gtsam-manylinux-build`
name: Trigger Python Builds
on:
push:
branches:
- develop
jobs:
triggerPython:
runs-on: ubuntu-latest
steps:
- name: Repository Dispatch
uses: ProfFan/repository-dispatch@master
with:
token: ${{ secrets.PYTHON_CI_REPO_ACCESS_TOKEN }}
repository: borglab/gtsam-manylinux-build
event-type: python-wrapper
client-payload: '{"ref": "${{ github.ref }}", "sha": "${{ github.sha }}"}'
================================================
FILE: planner/lib/3rdparty/gtsam-4.1.1/.gitignore
================================================
/build*
/debug*
.idea
*.pyc
*.DS_Store
*.swp
/examples/Data/dubrovnik-3-7-pre-rewritten.txt
/examples/Data/pose2example-rewritten.txt
/examples/Data/pose3example-rewritten.txt
*.txt.user
*.txt.user.6d59f0c
*.pydevproject
.vscode
.env
/.vs/
/CMakeSettings.json
# for QtCreator:
CMakeLists.txt.user*
xcode/
================================================
FILE: planner/lib/3rdparty/gtsam-4.1.1/.project
================================================
<?xml version="1.0" encoding="UTF-8"?>
<projectDescription>
<name>gtsam</name>
<comment></comment>
<projects>
</projects>
<buildSpec>
<buildCommand>
<name>org.eclipse.cdt.managedbuilder.core.genmakebuilder</name>
<triggers>clean,full,incremental,</triggers>
<arguments>
<dictionary>
<key>?name?</key>
<value></value>
</dictionary>
<dictionary>
<key>org.eclipse.cdt.make.core.append_environment</key>
<value>true</value>
</dictionary>
<dictionary>
<key>org.eclipse.cdt.make.core.autoBuildTarget</key>
<value>all</value>
</dictionary>
<dictionary>
<key>org.eclipse.cdt.make.core.buildArguments</key>
<value>-j4</value>
</dictionary>
<dictionary>
<key>org.eclipse.cdt.make.core.buildCommand</key>
<value>make</value>
</dictionary>
<dictionary>
<key>org.eclipse.cdt.make.core.buildLocation</key>
<value>${ProjDirPath}/build</value>
</dictionary>
<dictionary>
<key>org.eclipse.cdt.make.core.cleanBuildTarget</key>
<value>clean</value>
</dictionary>
<dictionary>
<key>org.eclipse.cdt.make.core.contents</key>
<value>org.eclipse.cdt.make.core.activeConfigSettings</value>
</dictionary>
<dictionary>
<key>org.eclipse.cdt.make.core.enableAutoBuild</key>
<value>false</value>
</dictionary>
<dictionary>
<key>org.eclipse.cdt.make.core.enableCleanBuild</key>
<value>true</value>
</dictionary>
<dictionary>
<key>org.eclipse.cdt.make.core.enableFullBuild</key>
<value>true</value>
</dictionary>
<dictionary>
<key>org.eclipse.cdt.make.core.fullBuildTarget</key>
<value>all</value>
</dictionary>
<dictionary>
<key>org.eclipse.cdt.make.core.stopOnError</key>
<value>true</value>
</dictionary>
<dictionary>
<key>org.eclipse.cdt.make.core.useDefaultBuildCmd</key>
<value>true</value>
</dictionary>
</arguments>
</buildCommand>
<buildCommand>
<name>org.eclipse.cdt.managedbuilder.core.ScannerConfigBuilder</name>
<arguments>
</arguments>
</buildCommand>
</buildSpec>
<natures>
<nature>org.eclipse.cdt.core.cnature</nature>
<nature>org.eclipse.cdt.core.ccnature</nature>
<nature>org.eclipse.cdt.managedbuilder.core.managedBuildNature</nature>
<nature>org.eclipse.cdt.managedbuilder.core.ScannerConfigNature</nature>
</natures>
</projectDescription>
================================================
FILE: planner/lib/3rdparty/gtsam-4.1.1/.settings/.gitignore
================================================
/org.eclipse.cdt.codan.core.prefs
================================================
FILE: planner/lib/3rdparty/gtsam-4.1.1/.settings/org.eclipse.cdt.core.prefs
================================================
eclipse.preferences.version=1
environment/project/cdt.managedbuild.toolchain.gnu.macosx.base.1359703544/PATH/delimiter=\:
environment/project/cdt.managedbuild.toolchain.gnu.macosx.base.1359703544/PATH/operation=append
environment/project/cdt.managedbuild.toolchain.gnu.macosx.base.1359703544/PATH/value=$PATH\:/opt/local/bin
environment/project/cdt.managedbuild.toolchain.gnu.macosx.base.1359703544/append=true
environment/project/cdt.managedbuild.toolchain.gnu.macosx.base.1359703544/appendContributed=true
================================================
FILE: planner/lib/3rdparty/gtsam-4.1.1/CMakeLists.txt
================================================
project(GTSAM CXX C)
cmake_minimum_required(VERSION 3.0)
# new feature to Cmake Version > 2.8.12
# Mac ONLY. Define Relative Path on Mac OS
if(NOT DEFINED CMAKE_MACOSX_RPATH)
set(CMAKE_MACOSX_RPATH 0)
endif()
# Set the version number for the library
set (GTSAM_VERSION_MAJOR 4)
set (GTSAM_VERSION_MINOR 1)
set (GTSAM_VERSION_PATCH 1)
math (EXPR GTSAM_VERSION_NUMERIC "10000 * ${GTSAM_VERSION_MAJOR} + 100 * ${GTSAM_VERSION_MINOR} + ${GTSAM_VERSION_PATCH}")
set (GTSAM_VERSION_STRING "${GTSAM_VERSION_MAJOR}.${GTSAM_VERSION_MINOR}.${GTSAM_VERSION_PATCH}")
set (CMAKE_PROJECT_VERSION ${GTSAM_VERSION_STRING})
set (CMAKE_PROJECT_VERSION_MAJOR ${GTSAM_VERSION_MAJOR})
set (CMAKE_PROJECT_VERSION_MINOR ${GTSAM_VERSION_MINOR})
set (CMAKE_PROJECT_VERSION_PATCH ${GTSAM_VERSION_PATCH})
###############################################################################
# Gather information, perform checks, set defaults
set(CMAKE_MODULE_PATH "${CMAKE_MODULE_PATH}" "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
include(GtsamMakeConfigFile)
include(GNUInstallDirs)
# Load build type flags and default to Debug mode
include(GtsamBuildTypes)
# Use macros for creating tests/timing scripts
include(GtsamTesting)
include(GtsamPrinting)
# guard against in-source builds
if(${GTSAM_SOURCE_DIR} STREQUAL ${GTSAM_BINARY_DIR})
message(FATAL_ERROR "In-source builds not allowed. Please make a new directory (called a build directory) and run CMake from there. You may need to remove CMakeCache.txt. ")
endif()
include(cmake/HandleGeneralOptions.cmake) # CMake build options
# Libraries:
include(cmake/HandleBoost.cmake) # Boost
include(cmake/HandleCCache.cmake) # ccache
include(cmake/HandleCPack.cmake) # CPack
include(cmake/HandleEigen.cmake) # Eigen3
include(cmake/HandleMetis.cmake) # metis
include(cmake/HandleMKL.cmake) # MKL
include(cmake/HandleOpenMP.cmake) # OpenMP
include(cmake/HandlePerfTools.cmake) # Google perftools
include(cmake/HandlePython.cmake) # Python options and commands
include(cmake/HandleTBB.cmake) # TBB
include(cmake/HandleUninstall.cmake) # for "make uninstall"
include(cmake/HandleAllocators.cmake) # Must be after tbb, pertools
include(cmake/HandleGlobalBuildFlags.cmake) # Build flags
###############################################################################
# Add components
# Build CppUnitLite
add_subdirectory(CppUnitLite)
# Build GTSAM library
add_subdirectory(gtsam)
# Build Tests
add_subdirectory(tests)
# Build examples
add_subdirectory(examples)
# Build timing
add_subdirectory(timing)
# Build gtsam_unstable
if (GTSAM_BUILD_UNSTABLE)
add_subdirectory(gtsam_unstable)
endif()
# This is the new wrapper
if(GTSAM_BUILD_PYTHON OR GTSAM_INSTALL_MATLAB_TOOLBOX)
# Need to set this for the wrap package so we don't use the default value.
set(WRAP_PYTHON_VERSION ${GTSAM_PYTHON_VERSION}
CACHE STRING "The Python version to use for wrapping")
# Set the include directory for matlab.h
set(GTWRAP_INCLUDE_NAME "wrap")
add_subdirectory(wrap)
list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_LIST_DIR}/wrap/cmake")
endif()
# Python toolbox
if(GTSAM_BUILD_PYTHON)
add_subdirectory(python)
endif()
# Matlab toolbox
if(GTSAM_INSTALL_MATLAB_TOOLBOX)
add_subdirectory(matlab)
endif()
# Install config and export files
GtsamMakeConfigFile(GTSAM "${CMAKE_CURRENT_SOURCE_DIR}/gtsam_extra.cmake.in")
export(TARGETS ${GTSAM_EXPORTED_TARGETS} FILE GTSAM-exports.cmake)
if (GTSAM_BUILD_UNSTABLE)
GtsamMakeConfigFile(GTSAM_UNSTABLE "${CMAKE_CURRENT_SOURCE_DIR}/gtsam_extra.cmake.in")
export(TARGETS ${GTSAM_UNSTABLE_EXPORTED_TARGETS} FILE GTSAM_UNSTABLE-exports.cmake)
endif()
# Check for doxygen availability - optional dependency
find_package(Doxygen)
# Doxygen documentation - enabling options in subfolder
if (DOXYGEN_FOUND)
add_subdirectory(doc)
endif()
# CMake Tools
add_subdirectory(cmake)
# Print configuration variables
include(cmake/HandlePrintConfiguration.cmake)
# Print warnings at the end
include(cmake/HandleFinalChecks.cmake)
# Include CPack *after* all flags
include(CPack)
================================================
FILE: planner/lib/3rdparty/gtsam-4.1.1/CppUnitLite/CMakeLists.txt
================================================
# Build/install CppUnitLite
file(GLOB cppunitlite_headers "*.h")
file(GLOB cppunitlite_src "*.cpp")
add_library(CppUnitLite STATIC ${cppunitlite_src} ${cppunitlite_headers})
list(APPEND GTSAM_EXPORTED_TARGETS CppUnitLite)
set(GTSAM_EXPORTED_TARGETS "${GTSAM_EXPORTED_TARGETS}" PARENT_SCOPE)
target_link_libraries(CppUnitLite PUBLIC Boost::boost) # boost/lexical_cast.h
gtsam_assign_source_folders("${cppunitlite_headers};${cppunitlite_src}") # MSVC project structure
option(GTSAM_INSTALL_CPPUNITLITE "Enable/Disable installation of CppUnitLite library" ON)
if (GTSAM_INSTALL_CPPUNITLITE)
install(FILES ${cppunitlite_headers} DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/CppUnitLite)
install(TARGETS CppUnitLite EXPORT GTSAM-exports ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR})
endif(GTSAM_INSTALL_CPPUNITLITE)
================================================
FILE: planner/lib/3rdparty/gtsam-4.1.1/CppUnitLite/Failure.h
================================================
/* ----------------------------------------------------------------------------
* GTSAM Copyright 2010, Georgia Tech Research Corporation,
* Atlanta, Georgia 30332-0415
* All Rights Reserved
* Authors: Frank Dellaert, et al. (see THANKS for the full author list)
* See LICENSE for the license information
* -------------------------------------------------------------------------- */
///////////////////////////////////////////////////////////////////////////////
//
// FAILURE.H
//
// Failure is a class which holds information pertaining to a specific
// test failure. The stream insertion operator is overloaded to allow easy
// display.
//
///////////////////////////////////////////////////////////////////////////////
#pragma once
#include <string>
class Failure
{
public:
Failure (const std::string& theTestName,
const std::string& theFileName,
long theLineNumber,
const std::string& theCondition)
: message (theCondition),
testName (theTestName),
fileName (theFileName),
lineNumber (theLineNumber)
{
}
Failure (const std::string& theTestName,
const std::string& theFileName,
const std::string& theCondition)
: message (theCondition),
testName (theTestName),
fileName (theFileName),
lineNumber (-1)
{
}
Failure (const std::string& theTestName,
const std::string& theFileName,
long theLineNumber,
const std::string& expected,
const std::string& actual)
: message("expected " + expected + " but was: " + actual),
testName (theTestName),
fileName (theFileName),
lineNumber (theLineNumber)
{
}
std::string message;
std::string testName;
std::string fileName;
long lineNumber;
};
================================================
FILE: planner/lib/3rdparty/gtsam-4.1.1/CppUnitLite/Test.cpp
================================================
/* ----------------------------------------------------------------------------
* GTSAM Copyright 2010, Georgia Tech Research Corporation,
* Atlanta, Georgia 30332-0415
* All Rights Reserved
* Authors: Frank Dellaert, et al. (see THANKS for the full author list)
* See LICENSE for the license information
* -------------------------------------------------------------------------- */
#include "Test.h"
#include "TestRegistry.h"
#include "TestResult.h"
#include "Failure.h"
#include <boost/lexical_cast.hpp>
Test::Test (const std::string& testName)
: name_ (testName), next_(0), lineNumber_(-1), safeCheck_(true)
{
TestRegistry::addTest (this);
}
Test::Test (const std::string& testName, const std::string& filename, long lineNumber, bool safeCheck)
: name_(testName), next_(0), filename_(filename), lineNumber_(lineNumber), safeCheck_(safeCheck)
{
TestRegistry::addTest (this);
}
Test *Test::getNext() const
{
return next_;
}
void Test::setNext(Test *test)
{
next_ = test;
}
bool Test::check(long expected, long actual, TestResult& result, const std::string& fileName, long lineNumber)
{
if (expected == actual)
return true;
result.addFailure (
Failure (
name_,
boost::lexical_cast<std::string> (__FILE__),
__LINE__,
boost::lexical_cast<std::string> (expected),
boost::lexical_cast<std::string> (actual)));
return false;
}
bool Test::check(const std::string& expected, const std::string& actual, TestResult& result, const std::string& fileName, long lineNumber)
{
if (expected == actual)
return true;
result.addFailure (
Failure (
name_,
boost::lexical_cast<std::string> (__FILE__),
__LINE__,
expected,
actual));
return false;
}
================================================
FILE: planner/lib/3rdparty/gtsam-4.1.1/CppUnitLite/Test.h
================================================
/* ----------------------------------------------------------------------------
* GTSAM Copyright 2010, Georgia Tech Research Corporation,
* Atlanta, Georgia 30332-0415
* All Rights Reserved
* Authors: Frank Dellaert, et al. (see THANKS for the full author list)
* See LICENSE for the license information
* -------------------------------------------------------------------------- */
///////////////////////////////////////////////////////////////////////////////
//
// TEST.H
//
// This file contains the Test class along with the macros which make effective
// in the harness.
//
///////////////////////////////////////////////////////////////////////////////
#ifndef TEST_H
#define TEST_H
#include <cmath>
#include <boost/lexical_cast.hpp>
class TestResult;
class Test
{
public:
Test (const std::string& testName);
Test (const std::string& testName, const std::string& filename, long lineNumber, bool safeCheck);
virtual ~Test() {};
virtual void run (TestResult& result) = 0;
void setNext(Test *test);
Test *getNext () const;
std::string getName() const {return name_;}
std::string getFilename() const {return filename_;}
long getLineNumber() const {return lineNumber_;}
bool safe() const {return safeCheck_;}
protected:
bool check (long expected, long actual, TestResult& result, const std::string& fileName, long lineNumber);
bool check (const std::string& expected, const std::string& actual, TestResult& result, const std::string& fileName, long lineNumber);
std::string name_;
Test *next_;
std::string filename_;
long lineNumber_; /// This is the line line number of the test, rather than the a single check
bool safeCheck_;
};
/**
* Normal test will wrap execution in a try/catch block to catch exceptions more effectively
*/
#define TEST(testGroup, testName)\
class testGroup##testName##Test : public Test \
{ public: testGroup##testName##Test () : Test (#testName "Test", __FILE__, __LINE__, true) {} \
virtual ~testGroup##testName##Test () {};\
void run (TestResult& result_) override;} \
testGroup##testName##Instance; \
void testGroup##testName##Test::run (TestResult& result_)
/**
* Declare friend in a class to test its private methods
*/
#define FRIEND_TEST(testGroup, testName) \
friend class testGroup##testName##Test;
/**
* For debugging only: use TEST_UNSAFE to allow debuggers to have access to exceptions, as this
* will not wrap execution with a try/catch block
*/
#define TEST_UNSAFE(testGroup, testName)\
class testGroup##testName##Test : public Test \
{ public: testGroup##testName##Test () : Test (#testName "Test", __FILE__, __LINE__, false) {} \
virtual ~testGroup##testName##Test () {};\
void run (TestResult& result_) override;} \
testGroup##testName##Instance; \
void testGroup##testName##Test::run (TestResult& result_)
/**
* Use this to disable unwanted tests without commenting them out.
*/
#define TEST_DISABLED(testGroup, testName)\
void testGroup##testName##Test(TestResult& result_, const std::string& name_)
/*
* Convention for tests:
* - "EXPECT" is a test that will not end execution of the series of tests
* - Otherwise, upon a failure, the test will end
*
* Usage:
* EXPECT is useful when checking several different parts of an condition so
* that a failure of one check won't hide another failure.
*
* Note: Exception tests are not available in a EXPECT form, as exceptions rarely
* fit the criteria of an assertion that does not need to be true to continue
*/
/* True ASSERTs: tests end at first failure */
#define CHECK(condition)\
{ if (!(condition)) \
{ result_.addFailure (Failure (name_, __FILE__,__LINE__, #condition)); return; } }
#define THROWS_EXCEPTION(condition)\
{ try { condition; \
result_.addFailure (Failure (name_, __FILE__,__LINE__, std::string("Didn't throw: ") + boost::lexical_cast<std::string>(#condition))); \
return; } \
catch (...) {} }
#define CHECK_EXCEPTION(condition, exception_name)\
{ try { condition; \
result_.addFailure (Failure (name_, __FILE__,__LINE__, std::string("Didn't throw: ") + boost::lexical_cast<std::string>(#condition))); \
return; } \
catch (exception_name&) {} \
catch (...) { \
result_.addFailure (Failure (name_, __FILE__,__LINE__, std::string("Wrong exception: ") + boost::lexical_cast<std::string>(#condition) + boost::lexical_cast<std::string>(", expected: ") + boost::lexical_cast<std::string>(#exception_name))); \
return; } }
#define EQUALITY(expected,actual)\
{ if (!assert_equal(expected,actual)) \
result_.addFailure(Failure(name_, __FILE__, __LINE__, #expected, #actual)); }
#define CHECK_EQUAL(expected,actual)\
{ if ((expected) == (actual)) return; result_.addFailure(Failure(name_, __FILE__, __LINE__, boost::lexical_cast<std::string>(expected), boost::lexical_cast<std::string>(actual))); }
#define LONGS_EQUAL(expected,actual)\
{ long actualTemp = actual; \
long expectedTemp = expected; \
if ((expectedTemp) != (actualTemp)) \
{ result_.addFailure (Failure (name_, __FILE__, __LINE__, boost::lexical_cast<std::string>(expectedTemp), \
boost::lexical_cast<std::string>(actualTemp))); return; } }
#define DOUBLES_EQUAL(expected,actual,threshold)\
{ double actualTemp = actual; \
double expectedTemp = expected; \
if (!std::isfinite(actualTemp) || !std::isfinite(expectedTemp) || fabs ((expectedTemp)-(actualTemp)) > threshold) \
{ result_.addFailure (Failure (name_, __FILE__, __LINE__, \
boost::lexical_cast<std::string>((double)expectedTemp), boost::lexical_cast<std::string>((double)actualTemp))); return; } }
/* EXPECTs: tests will continue running after a failure */
#define EXPECT(condition)\
{ if (!(condition)) \
{ result_.addFailure (Failure (name_, __FILE__,__LINE__, #condition)); } }
#define EXPECT_LONGS_EQUAL(expected,actual)\
{ long actualTemp = actual; \
long expectedTemp = expected; \
if ((expectedTemp) != (actualTemp)) \
{ result_.addFailure (Failure (name_, __FILE__, __LINE__, boost::lexical_cast<std::string>(expectedTemp), \
boost::lexical_cast<std::string>(actualTemp))); } }
#define EXPECT_DOUBLES_EQUAL(expected,actual,threshold)\
{ double actualTemp = actual; \
double expectedTemp = expected; \
if (!std::isfinite(actualTemp) || !std::isfinite(expectedTemp) || fabs ((expectedTemp)-(actualTemp)) > threshold) \
{ result_.addFailure (Failure (name_, __FILE__, __LINE__, \
boost::lexical_cast<std::string>((double)expectedTemp), boost::lexical_cast<std::string>((double)actualTemp))); } }
#define FAIL(text) \
{ result_.addFailure (Failure (name_, __FILE__, __LINE__,(text))); return; }
#endif
================================================
FILE: planner/lib/3rdparty/gtsam-4.1.1/CppUnitLite/TestHarness.h
================================================
/* ----------------------------------------------------------------------------
* GTSAM Copyright 2010, Georgia Tech Research Corporation,
* Atlanta, Georgia 30332-0415
* All Rights Reserved
* Authors: Frank Dellaert, et al. (see THANKS for the full author list)
* See LICENSE for the license information
* -------------------------------------------------------------------------- */
///////////////////////////////////////////////////////////////////////////////
//
// TESTHARNESS.H
//
// The primary include file for the framework.
//
///////////////////////////////////////////////////////////////////////////////
#ifndef TESTHARNESS_H
#define TESTHARNESS_H
#include "Test.h"
#include "TestResult.h"
#include "Failure.h"
#include "TestRegistry.h"
#endif
================================================
FILE: planner/lib/3rdparty/gtsam-4.1.1/CppUnitLite/TestRegistry.cpp
================================================
/* ----------------------------------------------------------------------------
* GTSAM Copyright 2010, Georgia Tech Research Corporation,
* Atlanta, Georgia 30332-0415
* All Rights Reserved
* Authors: Frank Dellaert, et al. (see THANKS for the full author list)
* See LICENSE for the license information
* -------------------------------------------------------------------------- */
#include <exception>
#include "Test.h"
#include "Failure.h"
#include "TestResult.h"
#include "TestRegistry.h"
void TestRegistry::addTest (Test *test)
{
instance ().add (test);
}
int TestRegistry::runAllTests (TestResult& result)
{
return instance ().run (result);
}
TestRegistry& TestRegistry::instance ()
{
static TestRegistry registry;
return registry;
}
void TestRegistry::add (Test *test)
{
if (tests == 0) {
test->setNext(0);
tests = test;
lastTest = test;
return;
}
test->setNext (0);
lastTest->setNext(test);
lastTest = test;
}
int TestRegistry::run (TestResult& result)
{
result.testsStarted ();
for (Test *test = tests; test != 0; test = test->getNext ()) {
if (test->safe()) {
try {
test->run (result);
} catch (std::exception& e) {
// catch standard exceptions and derivatives
result.addFailure(
Failure(test->getName(), test->getFilename(), test->getLineNumber(),
std::string("Exception: ") + std::string(e.what())));
} catch (...) {
// catch all other exceptions
result.addFailure(
Failure(test->getName(), test->getFilename(), test->getLineNumber(),
"ExceptionThrown!"));
}
}
else {
test->run (result);
}
}
result.testsEnded ();
return result.getFailureCount();
}
================================================
FILE: planner/lib/3rdparty/gtsam-4.1.1/CppUnitLite/TestRegistry.h
================================================
/* ----------------------------------------------------------------------------
* GTSAM Copyright 2010, Georgia Tech Research Corporation,
* Atlanta, Georgia 30332-0415
* All Rights Reserved
* Authors: Frank Dellaert, et al. (see THANKS for the full author list)
* See LICENSE for the license information
* -------------------------------------------------------------------------- */
///////////////////////////////////////////////////////////////////////////////
//
// TESTREGISTRY.H
//
// TestRegistry is a singleton collection of all the tests to run in a system.
//
///////////////////////////////////////////////////////////////////////////////
#ifndef TESTREGISTRY_H
#define TESTREGISTRY_H
class Test;
class TestResult;
class TestRegistry
{
public:
static void addTest (Test *test);
static int runAllTests (TestResult& result);
private:
static TestRegistry& instance ();
void add (Test *test);
int run (TestResult& result);
Test *tests;
Test *lastTest;
};
#endif
================================================
FILE: planner/lib/3rdparty/gtsam-4.1.1/CppUnitLite/TestResult.cpp
================================================
/* ----------------------------------------------------------------------------
* GTSAM Copyright 2010, Georgia Tech Research Corporation,
* Atlanta, Georgia 30332-0415
* All Rights Reserved
* Authors: Frank Dellaert, et al. (see THANKS for the full author list)
* See LICENSE for the license information
* -------------------------------------------------------------------------- */
#include "TestResult.h"
#include "Failure.h"
#include <stdio.h>
TestResult::TestResult ()
: failureCount (0)
{
}
void TestResult::testsStarted ()
{
}
void TestResult::addFailure (const Failure& failure)
{
if (failure.lineNumber < 0) // allow for no line number
fprintf (stdout, "%s%s%s%s\n",
"Failure: \"",
failure.message.c_str (),
"\" in ",
failure.fileName.c_str ());
else
fprintf (stdout, "%s%s%ld%s%s%s\n",
failure.fileName.c_str(), // Format matches Eclipse error flagging
":",
failure.lineNumber,
": Failure: \"",
failure.message.c_str(),
"\" ");
failureCount++;
}
void TestResult::testsEnded ()
{
if (failureCount > 0)
fprintf (stdout, "There were %d failures\n", failureCount);
else
fprintf (stdout, "There were no test failures\n");
}
================================================
FILE: planner/lib/3rdparty/gtsam-4.1.1/CppUnitLite/TestResult.h
================================================
/* ----------------------------------------------------------------------------
* GTSAM Copyright 2010, Georgia Tech Research Corporation,
* Atlanta, Georgia 30332-0415
* All Rights Reserved
* Authors: Frank Dellaert, et al. (see THANKS for the full author list)
* See LICENSE for the license information
* -------------------------------------------------------------------------- */
///////////////////////////////////////////////////////////////////////////////
//
// TESTRESULT.H
//
// A TestResult is a collection of the history of some test runs. Right now
// it just collects failures.
//
///////////////////////////////////////////////////////////////////////////////
#ifndef TESTRESULT_H
#define TESTRESULT_H
class Failure;
class TestResult
{
public:
TestResult ();
virtual ~TestResult() {};
virtual void testsStarted ();
virtual void addFailure (const Failure& failure);
virtual void testsEnded ();
int getFailureCount() {return failureCount;}
private:
int failureCount;
};
#endif
================================================
FILE: planner/lib/3rdparty/gtsam-4.1.1/DEVELOP.md
================================================
# Information for Developers
### Coding Conventions
* Classes are Uppercase, methods and functions lowerMixedCase.
* We use a modified K&R Style, with 2-space tabs, inserting spaces for tabs.
* Use meaningful variable names, e.g. `measurement` not `msm`.
### Windows
On Windows it is necessary to explicitly export all functions from the library which should be externally accessible. To do this, include the macro `GTSAM_EXPORT` in your class or function definition.
For example:
```cpp
class GTSAM_EXPORT MyClass { ... };
GTSAM_EXPORT myFunction();
```
More details [here](Using-GTSAM-EXPORT.md).
================================================
FILE: planner/lib/3rdparty/gtsam-4.1.1/GTSAM-Concepts.md
================================================
GTSAM Concepts
==============
As discussed in [Generic Programming Techniques](http://www.boost.org/community/generic_programming.html), concepts define
* associated types
* valid expressions, like functions and values
* invariants
* complexity guarantees
Below we discuss the most important concepts use in GTSAM, and after that we discuss how they are implemented/used/enforced.
Manifold
--------
To optimize over continuous types, we assume they are manifolds. This is central to GTSAM and hence discussed in some more detail below.
[Manifolds](http://en.wikipedia.org/wiki/Manifold#Charts.2C_atlases.2C_and_transition_maps) and [charts](http://en.wikipedia.org/wiki/Manifold#Charts.2C_atlases.2C_and_transition_maps) are intimately linked concepts. We are only interested here in [differentiable manifolds](http://en.wikipedia.org/wiki/Differentiable_manifold#Definition), continuous spaces that can be locally approximated *at any point* using a local vector space, called the [tangent space](http://en.wikipedia.org/wiki/Tangent_space). A *chart* is an invertible map from the manifold to that tangent space.
In GTSAM, all properties and operations needed to use a type must be defined through template specialization of the struct `gtsam::traits`. Concept checks are used to check that all required functions are implemented.
In detail, we ask that the following items are defined in the traits object (although, not all are needed for optimization):
* values:
* `enum { dimension = D};`, an enum that indicates the dimensionality *n* of the manifold. In Eigen-fashion, we also support manifolds whose dimensionality is only defined at runtime, by specifying the value -1.
* types:
* `TangentVector`, type that lives in tangent space. This will almost always be an `Eigen::Matrix<double,n,1>`.
* `ChartJacobian`, a typedef for `OptionalJacobian<dimension, dimension>`.
* `ManifoldType`, a pointer back to the type.
* `structure_category`, a tag type that defines what requirements the type fulfills, and therefore what requirements this traits class must fulfill. It should be defined to be one of the following:
* `gtsam::traits::manifold_tag` -- Everything in this list is expected
* `gtsam::traits::group_tag` -- The functions defined under **Groups** below.
* `gtsam::traits::lie_group_tag` -- Everything in this list is expected, plus the functions defined under **Groups**, and **Lie Groups** below.
* `gtsam::traits::vector_space_tag` -- Everything in this list is expected, plus the functions defined under **Groups**, and **Lie Groups** below.
* valid expressions:
* `size_t dim = traits<T>::GetDimension(p);` static function should be defined. This is mostly useful if the size is not known at compile time.
* `v = traits<T>::Local(p,q)`, the chart, from manifold to tangent space, think of it as *q (-) p*, where *p* and *q* are elements of the manifold and the result, *v* is an element of the vector space.
* `p = traits<T>::Retract(p,v)`, the inverse chart, from tangent space to manifold, think of it as *p (+) v*, where *p* is an element of the manifold and the result, *v* is an element of the vector space.
* invariants
* `Retract(p, Local(p,q)) == q`
* `Local(p, Retract(p, v)) == v`
Group
-----
A [group]("http://en.wikipedia.org/wiki/Group_(mathematics)"") should be well known from grade school :-), and provides a type with a composition operation that is closed, associative, has an identity element, and an inverse for each element. The following should be added to the traits class for a group:
* valid expressions:
* `r = traits<T>::Compose(p,q)`, where *p*, *q*, and *r* are elements of the manifold.
* `q = traits<T>::Inverse(p)`, where *p* and*q* are elements of the manifold.
* `r = traits<T>::Between(p,q)`, where *p*, *q*, and *r* are elements of the manifold.
* static members:
* `traits<T>::Identity`, a static const member that represents the group's identity element.
* invariants:
* `Compose(p,Inverse(p)) == Identity`
* `Compose(p,Between(p,q)) == q`
* `Between(p,q) == Compose(Inverse(p),q)`
The `gtsam::group::traits` namespace defines the following:
* values:
* `traits<T>::Identity` -- The identity element for this group stored as a static const.
* `traits<T>::group_flavor` -- the flavor of this group's `compose()` operator, either:
* `gtsam::traits::group_multiplicative_tag` for multiplicative operator syntax ,or
* `gtsam::traits::group_additive_tag` for additive operator syntax.
We do *not* at this time support more than one composition operator per type. Although mathematically possible, it is hardly ever needed, and the machinery to support it would be burdensome and counter-intuitive.
Also, a type should provide either multiplication or addition operators depending on the flavor of the operation. To distinguish between the two, we will use a tag (see below).
Lie Group
---------
A Lie group is both a manifold *and* a group. Hence, a LIE_GROUP type should implements both MANIFOLD and GROUP concepts.
However, we now also need to be able to evaluate the derivatives of compose and inverse.
Hence, we have the following extra valid static functions defined in the struct `gtsam::traits<T>`:
* `r = traits<T>::Compose(p,q,Hp,Hq)`
* `q = traits<T>::Inverse(p,Hp)`
* `r = traits<T>::Between(p,q,Hp,Hq)`
where above the *H* arguments stand for optional Jacobian arguments.
That makes it possible to create factors implementing priors (PriorFactor) or relations between two instances of a Lie group type (BetweenFactor).
In addition, a Lie group has a Lie algebra, which affords two extra valid expressions:
* `v = traits<T>::Logmap(p,Hp)`, the log map, with optional Jacobian
* `p = traits<T>::Expmap(v,Hv)`, the exponential map, with optional Jacobian
Note that in the Lie group case, the usual valid expressions for Retract and Local can be generated automatically, e.g.
```
T Retract(p,v,Hp,Hv) {
T q = Expmap(v,Hqv);
T r = Compose(p,q,Hrp,Hrq);
Hv = Hrq * Hqv; // chain rule
return r;
}
```
For Lie groups, the `exponential map` above is the most obvious mapping: it
associates straight lines in the tangent space with geodesics on the manifold
(and it's inverse, the log map). However, there are several cases in which we deviate from this:
However, the exponential map is unnecessarily expensive for use in optimization. Hence, in GTSAM there is the option to provide a cheaper chart by means of the `ChartAtOrigin` struct in a class. This is done for *SE(2)*, *SO(3)* and *SE(3)* (see `Pose2`, `Rot3`, `Pose3`)
Most Lie groups we care about are *Matrix groups*, continuous sub-groups of *GL(n)*, the group of *n x n* invertible matrices. In this case, a lot of the derivatives calculations needed can be standardized, and this is done by the `LieGroup` superclass. You only need to provide an `AdjointMap` method.
A CRTP helper class `LieGroup` is available that can take a class and create some of the Lie group methods automatically. The class needs:
* operator* : implements group operator
* inverse: implements group inverse
* AdjointMap: maps tangent vectors according to group element
* Expmap/Logmap: exponential map and its inverse
* ChartAtOrigin: struct where you define Retract/Local at origin
To use, simply derive, but also say `using LieGroup<Class,N>::inverse` so you get an inverse with a derivative.
Finally, to create the traits automatically you can use `internal::LieGroupTraits<Class>`
Vector Space
------------
While vector spaces are in principle also manifolds, it is overkill to think about charts etc. Really, we should simply think about vector addition and subtraction. I.e.where
* `Identity == 0`
* `Inverse(p) == -p`
* `Compose(p,q) == p+q`
* `Between(p,q) == q-p`
* `Local(q) == p-q`
* `Retract(v) == p+v`
This considerably simplifies certain operations. A `VectorSpace` superclass is available to implement the traits. Types that are vector space models include `Matrix`, `Vector`, any fixed or dynamic Eigen Matrix, `Point2`, and `Point3`.
Testable
--------
Unit tests heavily depend on the following two functions being defined for all types that need to be tested:
* valid expressions:
* `Print(p,s)` where s is an optional string
* `Equals(p,q,tol)` where tol is an optional (double) tolerance
Implementation
==============
GTSAM Types start with Uppercase, e.g., `gtsam::Point2`, and are models of the
TESTABLE, MANIFOLD, GROUP, LIE_GROUP, and VECTOR_SPACE concepts.
`gtsam::traits` is our way to associate these concepts with types,
and we also define a limited number of `gtsam::tags` to select the correct implementation
of certain functions at compile time (tag dispatching).
Traits
------
However, a base class is not a good way to implement/check the other concepts, as we would like these
to apply equally well to types that are outside GTSAM control, e.g., `Eigen::VectorXd`. This is where
[traits](http://www.boost.org/doc/libs/1_57_0/libs/type_traits/doc/html/boost_typetraits/background.html) come in.
We use Eigen-style or STL-style traits, that define *many* properties at once.
Note that not everything that makes a concept is defined by traits. Valid expressions such as traits<T>::Compose are
defined simply as static functions within the traits class.
Finally, for GTSAM types, it is perfectly acceptable (and even desired) to define associated types as internal types,
rather than having to use traits internally.
Concept Checks
--------------
Boost provides a nice way to check whether a given type satisfies a concept. For example, the following
BOOST_CONCEPT_ASSERT(IsVectorSpace<Point2>)
asserts that Point2 indeed is a model for the VectorSpace concept.
Future Concepts
===============
Group Action
------------
Group actions are concepts in and of themselves that can be concept checked (see below).
In particular, a group can *act* on another space.
For example, the [cyclic group of order 6](http://en.wikipedia.org/wiki/Cyclic_group) can rotate 2D vectors around the origin:
q = R(i)*p
where R(i) = R(60)^i, where R(60) rotates by 60 degrees
Hence, we formalize by the following extension of the concept:
* valid expressions:
* `q = traits<T>::Act(g,p)`, for some instance, *p*, of a space *S*, that can be acted upon by the group element *g* to produce *q* in *S*.
* `q = traits<T>::Act(g,p,Hp)`, if the space acted upon is a continuous differentiable manifold. *
In the latter case, if *S* is an n-dimensional manifold, *Hp* is an output argument that should be
filled with the *nxn* Jacobian matrix of the action with respect to a change in *p*. It typically depends
on the group element *g*, but in most common example will *not* depend on the value of *p*. For example, in
the cyclic group example above, we simply have
Hp = R(i)
Note there is no derivative of the action with respect to a change in g. That will only be defined
for Lie groups, which we introduce now.
Lie Group Action
----------------
When a Lie group acts on a space, we have two derivatives to care about:
* `gtasm::manifold::traits<T>::act(g,p,Hg,Hp)`, if the space acted upon is a continuous differentiable manifold.
An example is a *similarity transform* in 3D, which can act on 3D space, like
q = s*R*p + t
Note that again the derivative in *p*, *Hp* is simply *s R*, which depends on *g* but not on *p*.
The derivative in *g*, *Hg*, is in general more complex.
For now, we won't care about Lie groups acting on non-manifolds.
================================================
FILE: planner/lib/3rdparty/gtsam-4.1.1/INSTALL.md
================================================
# Quickstart
In the root library folder execute:
```sh
$ mkdir build
$ cd build
$ cmake ..
$ make check # (optional, runs unit tests)
$ make install
```
## Important Installation Notes
1. GTSAM requires the following libraries to be installed on your system:
- BOOST version 1.65 or greater (install through Linux repositories or MacPorts). Please see [Boost Notes](#boost-notes).
- Cmake version 3.0 or higher
- Support for XCode 4.3 command line tools on Mac requires CMake 2.8.8 or higher
Optional dependent libraries:
- If TBB is installed and detectable by CMake GTSAM will use it automatically.
Ensure that CMake prints "Use Intel TBB : Yes". To disable the use of TBB,
disable the CMake flag `GTSAM_WITH_TBB` (enabled by default) by providing
the argument `-DGTSAM_WITH_TBB=OFF` to `cmake`. On Ubuntu, TBB may be
installed from the Ubuntu repositories, and for other platforms it may be
downloaded from https://www.threadingbuildingblocks.org/
- GTSAM may be configured to use MKL by toggling `GTSAM_WITH_EIGEN_MKL` and
`GTSAM_WITH_EIGEN_MKL_OPENMP` to `ON`; however, best performance is usually
achieved with MKL disabled. We therefore advise you to benchmark your problem
before using MKL.
Tested compilers:
- GCC 4.2-7.3
- OS X Clang 2.9-10.0
- OS X GCC 4.2
- MSVC 2010, 2012, 2017
Tested systems:
- Ubuntu 16.04 - 18.04
- MacOS 10.6 - 10.14
- Windows 7, 8, 8.1, 10
2. GTSAM makes extensive use of debug assertions, and we highly recommend you work
in Debug mode while developing (enabled by default). Likewise, it is imperative
that you switch to release mode when running finished code and for timing. GTSAM
will run up to 10x faster in Release mode! See the end of this document for
additional debugging tips.
3. GTSAM has Doxygen documentation. To generate, run 'make doc' from your
build directory.
4. The instructions below install the library to the default system install path and
build all components. From a terminal, starting in the root library folder,
execute commands as follows for an out-of-source build:
```sh
$ mkdir build
$ cd build
$ cmake ..
$ make check (optional, runs unit tests)
$ make install
```
This will build the library and unit tests, run all of the unit tests,
and then install the library itself.
## Boost Notes
Versions of Boost prior to 1.65 have a known bug that prevents proper "deep" serialization of objects, which means that objects encapsulated inside other objects don't get serialized.
This is particularly seen when using `clang` as the C++ compiler.
For this reason we require Boost>=1.65, and recommend installing it through alternative channels when it is not available through your operating system's primary package manager.
## Known Issues
- MSVC 2013 is not yet supported because it cannot build the serialization module of Boost 1.55 (or earlier).
# Windows Installation
This section details how to build a GTSAM `.sln` file using Visual Studio.
### Prerequisites
- Visual Studio with C++ CMake tools for Windows
- All the other pre-requisites listed above.
### Steps
1. Open Visual Studio.
2. Select `Open a local folder` and select the GTSAM source directory.
3. Go to `Project -> CMake Settings`.
- (Optional) Set `Configuration name`.
- (Optional) Set `Configuration type`.
- Set the `Toolset` to `msvc_x64_x64`. If you know what toolset you require, then skip this step.
- Update the `Build root` to `${projectDir}\build\${name}`.
- You can optionally create a new configuration for a `Release` build.
- Set the necessary CMake variables for your use case.
- Click on `Show advanced settings`.
- For `CMake generator`, select a version which matches `Visual Studio <Version> <Year> Win64`, e.g. `Visual Studio 16 2019 Win64`.
- Save the settings (Ctrl + S).
4. Click on `Project -> Generate Cache`. This will generate the CMake build files (as seen in the Output window).
5. The last step will generate a `GTSAM.sln` file in the `build` directory. At this point, GTSAM can be used as a regular Visual Studio project.
# CMake Configuration Options and Details
GTSAM has a number of options that can be configured, which is best done with
one of the following:
- ccmake the curses GUI for cmake
- cmake-gui a real GUI for cmake
## Important Options:
#### CMAKE_BUILD_TYPE
We support several build configurations for GTSAM (case insensitive)
```cmake -DCMAKE_BUILD_TYPE=[Option] ..```
- Debug (default) All error checking options on, no optimization. Use for development.
- Release Optimizations turned on, no debug symbols.
- Timing Adds ENABLE_TIMING flag to provide statistics on operation
- Profiling Standard configuration for use during profiling
- RelWithDebInfo Same as Release, but with the -g flag for debug symbols
#### CMAKE_INSTALL_PREFIX
The install folder. The default is typically `/usr/local/`.
To configure to install to your home directory, you could execute:
```cmake -DCMAKE_INSTALL_PREFIX:PATH=$HOME ..```
#### GTSAM_TOOLBOX_INSTALL_PATH
The Matlab toolbox will be installed in a subdirectory
of this folder, called 'gtsam'.
```cmake -DGTSAM_TOOLBOX_INSTALL_PATH:PATH=$HOME/toolbox ..```
#### GTSAM_BUILD_CONVENIENCE_LIBRARIES
This is a build option to allow for tests in subfolders to be linked against convenience libraries rather than the full libgtsam.
Set with the command line as follows:
```cmake -DGTSAM_BUILD_CONVENIENCE_LIBRARIES:OPTION=ON ..```
- ON (Default): This builds convenience libraries and links tests against them. This option is suggested for gtsam developers, as it is possible to build and run tests without first building the rest of the library, and speeds up compilation for a single test. The downside of this option is that it will build the entire library again to build the full libgtsam library, so build/install will be slower.
- OFF: This will build all of libgtsam before any of the tests, and then link all of the tests at once. This option is best for users of GTSAM, as it avoids rebuilding the entirety of gtsam an extra time.
#### GTSAM_BUILD_UNSTABLE
Enable build and install for libgtsam_unstable library.
Set with the command line as follows:
```cmake -DGTSAM_BUILD_UNSTABLE:OPTION=ON ..```
ON: When enabled, libgtsam_unstable will be built and installed with the same options as libgtsam. In addition, if tests are enabled, the unit tests will be built as well. The Matlab toolbox will also be generated if the matlab toolbox is enabled, installing into a folder called `gtsam_unstable`.
OFF (Default) If disabled, no `gtsam_unstable` code will be included in build or install.
## Check
`make check` will build and run all of the tests. Note that the tests will only be
built when using the "check" targets, to prevent `make install` from building the tests
unnecessarily. You can also run `make timing` to build all of the timing scripts.
To run check on a particular module only, run `make check.[subfolder]`, so to run
just the geometry tests, run `make check.geometry`. Individual tests can be run by
appending `.run` to the name of the test, for example, to run testMatrix, run
`make testMatrix.run`.
MEX_COMMAND: Path to the mex compiler. Defaults to assume the path is included in your shell's PATH environment variable. mex is installed with matlab at `$MATLABROOT/bin/mex`
$MATLABROOT can be found by executing the command `matlabroot` in MATLAB
## Performance
Here are some tips to get the best possible performance out of GTSAM.
1. Build in `Release` mode. GTSAM will run up to 10x faster compared to `Debug` mode.
2. Enable TBB. On modern processors with multiple cores, this can easily speed up
optimization by 30-50%. Please note that this may not be true for very small
problems where the overhead of dispatching work to multiple threads outweighs
the benefit. We recommend that you benchmark your problem with/without TBB.
3. Add `-march=native` to `GTSAM_CMAKE_CXX_FLAGS`. A performance gain of
25-30% can be expected on modern processors. Note that this affects the portability
of your executable. It may not run when copied to another system with older/different
processor architecture.
Also note that all dependent projects *must* be compiled with the same flag, or
seg-faults and other undefined behavior may result.
4. Possibly enable MKL. Please note that our benchmarks have shown that this helps only
in very limited cases, and actually hurts performance in the usual case. We therefore
recommend that you do *not* enable MKL, unless you have benchmarked it on
your problem and have verified that it improves performance.
## Debugging tips
Another useful debugging symbol is _GLIBCXX_DEBUG, which enables debug checks and safe containers in the standard C++ library and makes problems much easier to find.
NOTE: The native Snow Leopard g++ compiler/library contains a bug that makes it impossible to use _GLIBCXX_DEBUG. MacPorts g++ compilers do work with it though.
NOTE: If _GLIBCXX_DEBUG is used to compile gtsam, anything that links against gtsam will need to be compiled with _GLIBCXX_DEBUG as well, due to the use of header-only Eigen.
## Installing MKL on Linux
Intel has a guide for installing MKL on Linux through APT repositories at <https://software.intel.com/en-us/articles/installing-intel-free-libs-and-python-apt-repo>.
After following the instructions, add the following to your `~/.bashrc` (and afterwards, open a new terminal before compiling GTSAM):
`LD_PRELOAD` need only be set if you are building the python wrapper to use GTSAM from python.
```sh
source /opt/intel/mkl/bin/mklvars.sh intel64
export LD_PRELOAD="$LD_PRELOAD:/opt/intel/mkl/lib/intel64/libmkl_core.so:/opt/intel/mkl/lib/intel64/libmkl_sequential.so"
```
To use MKL in GTSAM pass the flag `-DGTSAM_WITH_EIGEN_MKL=ON` to cmake.
The `LD_PRELOAD` fix seems to be related to a well known problem with MKL which leads to lots of undefined symbol errors, for example:
- <https://software.intel.com/en-us/forums/intel-math-kernel-library/topic/300857>
- <https://software.intel.com/en-us/forums/intel-distribution-for-python/topic/628976>
- <https://groups.google.com/a/continuum.io/forum/#!topic/anaconda/J3YGoef64z8>
Failing to specify `LD_PRELOAD` may lead to errors such as:
`ImportError: /opt/intel/mkl/lib/intel64/libmkl_vml_avx2.so: undefined symbol: mkl_serv_getenv`
or
`Intel MKL FATAL ERROR: Cannot load libmkl_avx2.so or libmkl_def.so.`
when importing GTSAM using the python wrapper.
================================================
FILE: planner/lib/3rdparty/gtsam-4.1.1/LICENSE
================================================
GTSAM is released under the simplified BSD license, reproduced in the file
LICENSE.BSD in this directory.
GTSAM contains several third party libraries, with documentation of licensing
and modifications as follows:
- CCOLAMD 2.9.6: Tim Davis' constrained column approximate minimum degree
ordering library
- Included unmodified in gtsam/3rdparty/CCOLAMD and
gtsam/3rdparty/SuiteSparse_config
- http://faculty.cse.tamu.edu/davis/suitesparse.html
- Licenced under BSD-3, provided in gtsam/3rdparty/CCOLAMD/Doc/License.txt
- ceres: Google's nonlinear least-squares optimization library
- Includes only auto-diff/jet code, with minor modifications to includes
- http://ceres-solver.org/license.html
- Eigen 3.3.7: General C++ matrix and linear algebra library
- Licenced under MPL2, provided in gtsam/3rdparty/Eigen/COPYING.README
- Some code that is 3rd-party to Eigen is BSD and LGPL
- GeographicLib 1.35: Charles Karney's geographic conversion utility library
- Included unmodified in gtsam/3rdparty/GeographicLib
- Licenced under MIT, provided in gtsam/3rdparty/GeographicLib/LICENSE.txt
- METIS 5.1.0: Graph partitioning and fill-reducing matrix ordering library
- Included unmodified in gtsam/3rdparty/metis
- Licenced under Apache License v 2.0, provided in
gtsam/3rdparty/metis/LICENSE.txt
- Spectra v0.9.0: Sparse Eigenvalue Computation Toolkit as a Redesigned ARPACK.
- Licenced under MPL2, provided at https://github.com/yixuan/spectra
================================================
FILE: planner/lib/3rdparty/gtsam-4.1.1/LICENSE.BSD
================================================
Copyright (c) 2010, Georgia Tech Research Corporation
Atlanta, Georgia 30332-0415
All Rights Reserved
Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
================================================
FILE: planner/lib/3rdparty/gtsam-4.1.1/README.md
================================================
# README - Georgia Tech Smoothing and Mapping Library
**Important Note**
As of August 1 2020, the `develop` branch is officially in "Pre 4.1" mode, and features deprecated in 4.0 have been removed. Please use the last [4.0.3 release](https://github.com/borglab/gtsam/releases/tag/4.0.3) if you need those features.
However, most are easily converted and can be tracked down (in 4.0.3) by disabling the cmake flag `GTSAM_ALLOW_DEPRECATED_SINCE_V4`.
## What is GTSAM?
GTSAM is a C++ library that implements smoothing and
mapping (SAM) in robotics and vision, using Factor Graphs and Bayes
Networks as the underlying computing paradigm rather than sparse
matrices.
The current support matrix is:
| Platform | Compiler | Build Status |
|:------------:|:---------:|:-------------:|
| Ubuntu 18.04 | gcc/clang |  |
| macOS | clang |  |
| Windows | MSVC |  |
On top of the C++ library, GTSAM includes [wrappers for MATLAB & Python](#wrappers).
## Quickstart
In the root library folder execute:
```sh
#!bash
$ mkdir build
$ cd build
$ cmake ..
$ make check (optional, runs unit tests)
$ make install
```
Prerequisites:
- [Boost](http://www.boost.org/users/download/) >= 1.65 (Ubuntu: `sudo apt-get install libboost-all-dev`)
- [CMake](http://www.cmake.org/cmake/resources/software.html) >= 3.0 (Ubuntu: `sudo apt-get install cmake`)
- A modern compiler, i.e., at least gcc 4.7.3 on Linux.
Optional prerequisites - used automatically if findable by CMake:
- [Intel Threaded Building Blocks (TBB)](http://www.threadingbuildingblocks.org/) (Ubuntu: `sudo apt-get install libtbb-dev`)
- [Intel Math Kernel Library (MKL)](http://software.intel.com/en-us/intel-mkl) (Ubuntu: [installing using APT](https://software.intel.com/en-us/articles/installing-intel-free-libs-and-python-apt-repo))
- See [INSTALL.md](INSTALL.md) for more installation information
- Note that MKL may not provide a speedup in all cases. Make sure to benchmark your problem with and without MKL.
## GTSAM 4 Compatibility
GTSAM 4 introduces several new features, most notably Expressions and a Python toolbox. It also introduces traits, a C++ technique that allows optimizing with non-GTSAM types. That opens the door to retiring geometric types such as Point2 and Point3 to pure Eigen types, which we also do. A significant change which will not trigger a compile error is that zero-initializing of Point2 and Point3 is deprecated, so please be aware that this might render functions using their default constructor incorrect.
GTSAM 4 also deprecated some legacy functionality and wrongly named methods. If you are on a 4.0.X release, you can define the flag `GTSAM_ALLOW_DEPRECATED_SINCE_V4` to use the deprecated methods.
GTSAM 4.1 added a new pybind wrapper, and **removed** the deprecated functionality. There is a flag `GTSAM_ALLOW_DEPRECATED_SINCE_V41` for newly deprecated methods since the 4.1 release, which is on by default, allowing anyone to just pull version 4.1 and compile.
## Wrappers
We provide support for [MATLAB](matlab/README.md) and [Python](python/README.md) wrappers for GTSAM. Please refer to the linked documents for more details.
## The Preintegrated IMU Factor
GTSAM includes a state of the art IMU handling scheme based on
- Todd Lupton and Salah Sukkarieh, _"Visual-Inertial-Aided Navigation for High-Dynamic Motion in Built Environments Without Initial Conditions"_, TRO, 28(1):61-76, 2012. [[link]](https://ieeexplore.ieee.org/document/6092505)
Our implementation improves on this using integration on the manifold, as detailed in
- Luca Carlone, Zsolt Kira, Chris Beall, Vadim Indelman, and Frank Dellaert, _"Eliminating conditionally independent sets in factor graphs: a unifying perspective based on smart factors"_, Int. Conf. on Robotics and Automation (ICRA), 2014. [[link]](https://ieeexplore.ieee.org/abstract/document/6907483)
- Christian Forster, Luca Carlone, Frank Dellaert, and Davide Scaramuzza, "IMU Preintegration on Manifold for Efficient Visual-Inertial Maximum-a-Posteriori Estimation", Robotics: Science and Systems (RSS), 2015. [[link]](http://www.roboticsproceedings.org/rss11/p06.pdf)
If you are using the factor in academic work, please cite the publications above.
In GTSAM 4 a new and more efficient implementation, based on integrating on the NavState tangent space and detailed in [this document](doc/ImuFactor.pdf), is enabled by default. To switch to the RSS 2015 version, set the flag `GTSAM_TANGENT_PREINTEGRATION` to OFF.
## Additional Information
There is a [`GTSAM users Google group`](https://groups.google.com/forum/#!forum/gtsam-users) for general discussion.
Read about important [`GTSAM-Concepts`](GTSAM-Concepts.md) here. A primer on GTSAM Expressions,
which support (superfast) automatic differentiation,
can be found on the [GTSAM wiki on BitBucket](https://bitbucket.org/gtborg/gtsam/wiki/Home).
See the [`INSTALL`](INSTALL.md) file for more detailed installation instructions.
GTSAM is open source under the BSD license, see the [`LICENSE`](LICENSE) and [`LICENSE.BSD`](LICENSE.BSD) files.
Please see the [`examples/`](examples) directory and the [`USAGE`](USAGE.md) file for examples on how to use GTSAM.
GTSAM was developed in the lab of [Frank Dellaert](http://www.cc.gatech.edu/~dellaert) at the [Georgia Institute of Technology](http://www.gatech.edu), with the help of many contributors over the years, see [THANKS](THANKS.md).
================================================
FILE: planner/lib/3rdparty/gtsam-4.1.1/THANKS.md
================================================
GTSAM was made possible by the efforts of many collaborators at Georgia Tech, listed below with their current afffiliation, if they left Tech:
* Jeremy Aguilon, Facebook
* Sungtae An
* Doru Balcan, Bank of America
* Chris Beall
* Luca Carlone
* Alex Cunningham, U Michigan
* Jing Dong
* Alireza Fathi, Stanford
* Eohan George
* Alex Hagiopol
* Viorela Ila, Czeck Republic
* Vadim Indelman, the Technion
* David Jensen, GTRI
* Yong-Dian Jian, Baidu
* Michael Kaess, Carnegie Mellon
* Zhaoyang Lv
* Andrew Melim, Oculus Rift
* Kai Ni, Baidu
* Carlos Nieto
* Duy-Nguyen Ta
* Manohar Paluri, Facebook
* Christian Potthast, USC
* Richard Roberts, Google X
* Grant Schindler, Consultant
* Natesh Srinivasan
* Alex Trevor
* Stephen Williams, BossaNova
* Matthew Broadway
at ETH, Zurich
* Paul Furgale
* Mike Bosse
* Hannes Sommer
* Thomas Schneider
at Uni Zurich:
* Christian Forster
at LAAS-CNRS
* Ellon Paiva
Many thanks for your hard work!!!!
Frank Dellaert
================================================
FILE: planner/lib/3rdparty/gtsam-4.1.1/USAGE.md
================================================
# GTSAM USAGE
This file explains how to make use of the library for common SLAM tasks, using a visual SLAM implementation as an example.
## Getting Started
### Install
Follow the installation instructions in the README file to build and install gtsam, as well as running tests to ensure the library is working properly.
### Compiling/Linking with GTSAM
The installation creates a binary `libgtsam` at the installation prefix, and an include folder `gtsam`. These are the only required includes, but the library has also been designed to make use of XML serialization through the `Boost.serialization` library, which requires the the Boost.serialization headers and binaries to be linked.
If you use CMake for your project, you can use the CMake scripts in the cmake folder for finding `GTSAM`, `CppUnitLite`, and `Wrap`.
### Examples
To see how the library works, examine the unit tests provided.
## Overview
The GTSAM library has three primary components necessary for the construction of factor graph representation and optimization which users will need to adapt to their particular problem.
* FactorGraph
A factor graph contains a set of variables to solve for (i.e., robot poses, landmark poses, etc.) and a set of constraints between these variables, which make up factors.
* Values:
Values is a single object containing labeled values for all of the variables. Currently, all variables are labeled with strings, but the type or organization of the variables can change.
* Factors
A nonlinear factor expresses a constraint between variables, which in the SLAM example, is a measurement such as a visual reading on a landmark or odometry.
The library is organized according to the following directory structure:
3rdparty local copies of third party libraries e.g. Eigen3 and CCOLAMD
base provides some base Math and data structures, as well as test-related utilities
geometry points, poses, tensors, etc
inference core graphical model inference such as factor graphs, junction trees, Bayes nets, Bayes trees
linear inference specialized to Gaussian linear case, GaussianFactorGraph etc...
nonlinear non-linear factor graphs and non-linear optimization
slam SLAM and visual SLAM application code
================================================
FILE: planner/lib/3rdparty/gtsam-4.1.1/Using-GTSAM-EXPORT.md
================================================
# Using GTSAM_EXPORT
To create a DLL in windows, the `GTSAM_EXPORT` keyword has been created and needs to be applied to different methods and classes in the code to expose this code outside of the DLL. However, there are several intricacies that make this more difficult than it sounds. In general, if you follow the following three rules, GTSAM_EXPORT should work properly. The rest of the document also describes (1) the common error message encountered when you are not following these rules and (2) the reasoning behind these usage rules.
## Usage Rules
1. Put `GTSAM_EXPORT` in front of any function that you want exported in the DLL _if and only if_ that function is declared in a .cpp file, not just a .h file.
2. Use `GTSAM_EXPORT` in a class definition (i.e. `class GSTAM_EXPORT MyClass {...}`) only if:
* At least one of the functions inside that class is declared in a .cpp file and not just the .h file.
* You can `GTSAM_EXPORT` any class it inherits from as well. (Note that this implictly requires the class does not derive from a "header-only" class. Note that Eigen is a "header-only" library, so if your class derives from Eigen, _do not_ use `GTSAM_EXPORT` in the class definition!)
3. If you have defined a class using `GTSAM_EXPORT`, do not use `GTSAM_EXPORT` in any of its individual function declarations. (Note that you _can_ put `GTSAM_EXPORT` in the definition of individual functions within a class as long as you don't put `GTSAM_EXPORT` in the class definition.)
## When is GTSAM_EXPORT being used incorrectly
Unfortunately, using `GTSAM_EXPORT` incorrectly often does not cause a compiler or linker error in the library that is being compiled, but only when you try to use that DLL in a different library. For example, an error in `gtsam/base` will often show up when compiling the `check_base_program` or the MATLAB wrapper, but not when compiling/linking gtsam itself. The most common errors will say something like:
```
Error LNK2019 unresolved external symbol "public: void __cdecl gtsam::SO3::print(class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > const &)const " (?print@SO3@gtsam@@QEBAXAEBV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@@Z) referenced in function "public: static void __cdecl gtsam::Testable<class gtsam::SO3>::Print(class gtsam::SO3 const &,class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > const &)" (?Print@?$Testable@VSO3@gtsam@@@gtsam@@SAXAEBVSO3@2@AEBV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@@Z) check_geometry_program C:\AFIT\lib\gtsam\build\gtsam\geometry\tests\testSO3.obj
```
Let's analyze this error statement. First, there is an unresolved symbol `gtsam::SO3::print`. This can occur because _either_ `GTSAM_EXPORT` was not added to the print function definition when it should have been, _OR_ because `GTSAM_EXPORT` was added to the print function definition when it is fully declared in the header. This error was detected while compiling `check_geometry_program` and pulling in `...\testSO3.obj`. Specifically, within the function call `gtsam::Testable<class gtsam::SO3>::Print (...)`. Note that this error did _not_ occur when compiling the library that actually has SO3 inside of it.
## But Why?
I believe that how the compiler/linker interacts with GTSAM_EXPORT can be explained by understanding the rules that MSVC operates under.
But first, we need to understand exactly what `GTSAM_EXPORT` is. `GTSAM_EXPORT` is a `#define` macro that is created by CMAKE when GTSAM is being compiled on a Windows machine. Inside the GTSAM project, GTSAM export will be set to a "dllexport" command. A "dllexport" command tells the compiler that this function should go into the DLL and be visible externally. In any other library, `GTSAM_EXPORT` will be set to a "dllimport" command, telling the linker it should find this function in a DLL somewhere. This leads to the first rule the compiler uses. (Note that I say "compiler rules" when the rules may actually be in the linker, but I am conflating the two terms here when I speak of the "compiler rules".)
***Compiler Rule #1*** If a `dllimport` command is used in defining a function or class, that function or class _must_ be found in a DLL.
Rule #1 doesn't seem very bad, until you combine it with rule #2
***Compiler Rule #2*** Anything declared in a header file is not included in a DLL.
When these two rules are combined, you get some very confusing results. For example, a class which is completely defined in a header (e.g. LieMatrix) cannot use `GTSAM_EXPORT` in its definition. If LieMatrix is defined with `GTSAM_EXPORT`, then the compiler _must_ find LieMatrix in a DLL. Because LieMatrix is a header-only class, however, it can't find it, leading to a very confusing "I can't find this symbol" type of error. Note that the linker says it can't find the symbol even though the compiler found the header file that completely defines the class.
Also note that when a class that you want to export inherits from another class that is not exportable, this can cause significant issues. According to this [MSVC Warning page](https://docs.microsoft.com/en-us/cpp/error-messages/compiler-warnings/compiler-warning-level-2-c4275?view=vs-2019), it may not strictly be a rule, but we have seen several linker errors when a class that is defined with `GTSAM_EXPORT` extended an Eigen class. In general, it appears that any inheritance of non-exportable class by an exportable class is a bad idea.
## Conclusion
Hopefully, this little document clarifies when `GTSAM_EXPORT` should and should not be used whenever future GTSAM code is being written. Following the usage rules above, we have been able to get all of the libraries, together with their test and wrapping libraries, to compile/link successfully.
================================================
FILE: planner/lib/3rdparty/gtsam-4.1.1/cmake/CMakeLists.txt
================================================
# This file installs the scripts from this directory that may be used in other
# projects. See README.txt in this directory for documentation.
# Set the install directory depending on the platform so it will be found by
# find_package(GTSAMCMakeTools)
if(WIN32 AND NOT CYGWIN)
set(SCRIPT_INSTALL_DIR "${CMAKE_INSTALL_PREFIX}/CMake")
else()
set(SCRIPT_INSTALL_DIR "${CMAKE_INSTALL_PREFIX}/lib/cmake")
endif()
# Install scripts
install(FILES
GTSAMCMakeToolsConfig.cmake
Config.cmake.in
dllexport.h.in
GtsamBuildTypes.cmake
GtsamMakeConfigFile.cmake
GtsamTesting.cmake
GtsamPrinting.cmake
FindNumPy.cmake
README.html
DESTINATION "${SCRIPT_INSTALL_DIR}/GTSAMCMakeTools")
================================================
FILE: planner/lib/3rdparty/gtsam-4.1.1/cmake/Config.cmake.in
================================================
# - Config file for @CMAKE_PROJECT_NAME@
# It defines the following variables
# @PACKAGE_NAME@_INCLUDE_DIR - include directories for @CMAKE_PROJECT_NAME@
# Compute paths
get_filename_component(OUR_CMAKE_DIR "${CMAKE_CURRENT_LIST_FILE}" PATH)
if(EXISTS "${OUR_CMAKE_DIR}/CMakeCache.txt")
# In build tree
set(@PACKAGE_NAME@_INCLUDE_DIR @GTSAM_SOURCE_DIR@ CACHE PATH "@PACKAGE_NAME@ include directory")
else()
# Find installed library
set(@PACKAGE_NAME@_INCLUDE_DIR "${OUR_CMAKE_DIR}/@CONF_REL_INCLUDE_DIR@" CACHE PATH "@PACKAGE_NAME@ include directory")
endif()
# Find dependencies, required by cmake exported targets:
include(CMakeFindDependencyMacro)
# Allow using cmake < 3.8
if(${CMAKE_VERSION} VERSION_LESS "3.8.0")
find_package(Boost @BOOST_FIND_MINIMUM_VERSION@ COMPONENTS @BOOST_FIND_MINIMUM_COMPONENTS@)
else()
find_dependency(Boost @BOOST_FIND_MINIMUM_VERSION@ COMPONENTS @BOOST_FIND_MINIMUM_COMPONENTS@)
endif()
# Load exports
include(${OUR_CMAKE_DIR}/@PACKAGE_NAME@-exports.cmake)
# Load project-specific flags, if present
if(EXISTS "${OUR_CMAKE_DIR}/@EXTRA_FILE@")
include("${OUR_CMAKE_DIR}/@EXTRA_FILE@")
endif()
message(STATUS "@CMAKE_PROJECT_NAME@ include directory: ${@CMAKE_PROJECT_NAME@_INCLUDE_DIR}")
================================================
FILE: planner/lib/3rdparty/gtsam-4.1.1/cmake/FindBoost.cmake
================================================
# Distributed under the OSI-approved BSD 3-Clause License. See accompanying
# file Copyright.txt or https://cmake.org/licensing for details.
#[=======================================================================[.rst:
FindBoost
---------
Find Boost include dirs and libraries
Use this module by invoking find_package with the form::
find_package(Boost
[version] [EXACT] # Minimum or EXACT version e.g. 1.67.0
[REQUIRED] # Fail with error if Boost is not found
[COMPONENTS <libs>...] # Boost libraries by their canonical name
# e.g. "date_time" for "libboost_date_time"
[OPTIONAL_COMPONENTS <libs>...]
# Optional Boost libraries by their canonical name)
) # e.g. "date_time" for "libboost_date_time"
This module finds headers and requested component libraries OR a CMake
package configuration file provided by a "Boost CMake" build. For the
latter case skip to the "Boost CMake" section below. For the former
case results are reported in variables::
Boost_FOUND - True if headers and requested libraries were found
Boost_INCLUDE_DIRS - Boost include directories
Boost_LIBRARY_DIRS - Link directories for Boost libraries
Boost_LIBRARIES - Boost component libraries to be linked
Boost_<C>_FOUND - True if component <C> was found (<C> is upper-case)
Boost_<C>_LIBRARY - Libraries to link for component <C> (may include
target_link_libraries debug/optimized keywords)
Boost_VERSION_MACRO - BOOST_VERSION value from boost/version.hpp
Boost_VERSION_STRING - Boost version number in x.y.z format
Boost_VERSION - if CMP0093 NEW => same as Boost_VERSION_STRING
if CMP0093 OLD or unset => same as Boost_VERSION_MACRO
Boost_LIB_VERSION - Version string appended to library filenames
Boost_VERSION_MAJOR - Boost major version number (X in X.y.z)
alias: Boost_MAJOR_VERSION
Boost_VERSION_MINOR - Boost minor version number (Y in x.Y.z)
alias: Boost_MINOR_VERSION
Boost_VERSION_PATCH - Boost subminor version number (Z in x.y.Z)
alias: Boost_SUBMINOR_VERSION
Boost_VERSION_COUNT - Amount of version components (3)
Boost_LIB_DIAGNOSTIC_DEFINITIONS (Windows)
- Pass to add_definitions() to have diagnostic
information about Boost's automatic linking
displayed during compilation
Note that Boost Python components require a Python version suffix
(Boost 1.67 and later), e.g. ``python36`` or ``python27`` for the
versions built against Python 3.6 and 2.7, respectively. This also
applies to additional components using Python including
``mpi_python`` and ``numpy``. Earlier Boost releases may use
distribution-specific suffixes such as ``2``, ``3`` or ``2.7``.
These may also be used as suffixes, but note that they are not
portable.
This module reads hints about search locations from variables::
BOOST_ROOT - Preferred installation prefix
(or BOOSTROOT)
BOOST_INCLUDEDIR - Preferred include directory e.g. <prefix>/include
BOOST_LIBRARYDIR - Preferred library directory e.g. <prefix>/lib
Boost_NO_SYSTEM_PATHS - Set to ON to disable searching in locations not
specified by these hint variables. Default is OFF.
Boost_ADDITIONAL_VERSIONS
- List of Boost versions not known to this module
(Boost install locations may contain the version)
and saves search results persistently in CMake cache entries::
Boost_INCLUDE_DIR - Directory containing Boost headers
Boost_LIBRARY_DIR_RELEASE - Directory containing release Boost libraries
Boost_LIBRARY_DIR_DEBUG - Directory containing debug Boost libraries
Boost_<C>_LIBRARY_DEBUG - Component <C> library debug variant
Boost_<C>_LIBRARY_RELEASE - Component <C> library release variant
The following :prop_tgt:`IMPORTED` targets are also defined::
Boost::headers - Target for header-only dependencies
(Boost include directory)
alias: Boost::boost
Boost::<C> - Target for specific component dependency
(shared or static library); <C> is lower-
case
Boost::diagnostic_definitions - interface target to enable diagnostic
information about Boost's automatic linking
during compilation (adds BOOST_LIB_DIAGNOSTIC)
Boost::disable_autolinking - interface target to disable automatic
linking with MSVC (adds BOOST_ALL_NO_LIB)
Boost::dynamic_linking - interface target to enable dynamic linking
linking with MSVC (adds BOOST_ALL_DYN_LINK)
Implicit dependencies such as ``Boost::filesystem`` requiring
``Boost::system`` will be automatically detected and satisfied, even
if system is not specified when using :command:`find_package` and if
``Boost::system`` is not added to :command:`target_link_libraries`. If using
``Boost::thread``, then ``Threads::Threads`` will also be added automatically.
It is important to note that the imported targets behave differently
than variables created by this module: multiple calls to
:command:`find_package(Boost)` in the same directory or sub-directories with
different options (e.g. static or shared) will not override the
values of the targets created by the first call.
Users may set these hints or results as ``CACHE`` entries. Projects
should not read these entries directly but instead use the above
result variables. Note that some hint names start in upper-case
"BOOST". One may specify these as environment variables if they are
not specified as CMake variables or cache entries.
This module first searches for the ``Boost`` header files using the above
hint variables (excluding ``BOOST_LIBRARYDIR``) and saves the result in
``Boost_INCLUDE_DIR``. Then it searches for requested component libraries
using the above hints (excluding ``BOOST_INCLUDEDIR`` and
``Boost_ADDITIONAL_VERSIONS``), "lib" directories near ``Boost_INCLUDE_DIR``,
and the library name configuration settings below. It saves the
library directories in ``Boost_LIBRARY_DIR_DEBUG`` and
``Boost_LIBRARY_DIR_RELEASE`` and individual library
locations in ``Boost_<C>_LIBRARY_DEBUG`` and ``Boost_<C>_LIBRARY_RELEASE``.
When one changes settings used by previous searches in the same build
tree (excluding environment variables) this module discards previous
search results affected by the changes and searches again.
Boost libraries come in many variants encoded in their file name.
Users or projects may tell this module which variant to find by
setting variables::
Boost_USE_DEBUG_LIBS - Set to ON or OFF to specify whether to search
and use the debug libraries. Default is ON.
Boost_USE_RELEASE_LIBS - Set to ON or OFF to specify whether to search
and use the release libraries. Default is ON.
Boost_USE_MULTITHREADED - Set to OFF to use the non-multithreaded
libraries ('mt' tag). Default is ON.
Boost_USE_STATIC_LIBS - Set to ON to force the use of the static
libraries. Default is OFF.
Boost_USE_STATIC_RUNTIME - Set to ON or OFF to specify whether to use
libraries linked statically to the C++ runtime
('s' tag). Default is platform dependent.
Boost_USE_DEBUG_RUNTIME - Set to ON or OFF to specify whether to use
libraries linked to the MS debug C++ runtime
('g' tag). Default is ON.
Boost_USE_DEBUG_PYTHON - Set to ON to use libraries compiled with a
debug Python build ('y' tag). Default is OFF.
Boost_USE_STLPORT - Set to ON to use libraries compiled with
STLPort ('p' tag). Default is OFF.
Boost_USE_STLPORT_DEPRECATED_NATIVE_IOSTREAMS
- Set to ON to use libraries compiled with
STLPort deprecated "native iostreams"
('n' tag). Default is OFF.
Boost_COMPILER - Set to the compiler-specific library suffix
(e.g. "-gcc43"). Default is auto-computed
for the C++ compiler in use. A list may be
used if multiple compatible suffixes should
be tested for, in decreasing order of
preference.
Boost_ARCHITECTURE - Set to the architecture-specific library suffix
(e.g. "-x64"). Default is auto-computed for the
C++ compiler in use.
Boost_THREADAPI - Suffix for "thread" component library name,
such as "pthread" or "win32". Names with
and without this suffix will both be tried.
Boost_NAMESPACE - Alternate namespace used to build boost with
e.g. if set to "myboost", will search for
myboost_thread instead of boost_thread.
Other variables one may set to control this module are::
Boost_DEBUG - Set to ON to enable debug output from FindBoost.
Please enable this before filing any bug report.
Boost_REALPATH - Set to ON to resolve symlinks for discovered
libraries to assist with packaging. For example,
the "system" component library may be resolved to
"/usr/lib/libboost_system.so.1.67.0" instead of
"/usr/lib/libboost_system.so". This does not
affect linking and should not be enabled unless
the user needs this information.
Boost_LIBRARY_DIR - Default value for Boost_LIBRARY_DIR_RELEASE and
Boost_LIBRARY_DIR_DEBUG.
On Visual Studio and Borland compilers Boost headers request automatic
linking to corresponding libraries. This requires matching libraries
to be linked explicitly or available in the link library search path.
In this case setting ``Boost_USE_STATIC_LIBS`` to ``OFF`` may not achieve
dynamic linking. Boost automatic linking typically requests static
libraries with a few exceptions (such as ``Boost.Python``). Use::
add_definitions(${Boost_LIB_DIAGNOSTIC_DEFINITIONS})
to ask Boost to report information about automatic linking requests.
Example to find Boost headers only::
find_package(Boost 1.36.0)
if(Boost_FOUND)
include_directories(${Boost_INCLUDE_DIRS})
add_executable(foo foo.cc)
endif()
Example to find Boost libraries and use imported targets::
find_package(Boost 1.56 REQUIRED COMPONENTS
date_time filesystem iostreams)
add_executable(foo foo.cc)
target_link_libraries(foo Boost::date_time Boost::filesystem
Boost::iostreams)
Example to find Boost Python 3.6 libraries and use imported targets::
find_package(Boost 1.67 REQUIRED COMPONENTS
python36 numpy36)
add_executable(foo foo.cc)
target_link_libraries(foo Boost::python36 Boost::numpy36)
Example to find Boost headers and some *static* (release only) libraries::
set(Boost_USE_STATIC_LIBS ON) # only find static libs
set(Boost_USE_DEBUG_LIBS OFF) # ignore debug libs and
set(Boost_USE_RELEASE_LIBS ON) # only find release libs
set(Boost_USE_MULTITHREADED ON)
set(Boost_USE_STATIC_RUNTIME OFF)
find_package(Boost 1.66.0 COMPONENTS date_time filesystem system ...)
if(Boost_FOUND)
include_directories(${Boost_INCLUDE_DIRS})
add_executable(foo foo.cc)
target_link_libraries(foo ${Boost_LIBRARIES})
endif()
Boost CMake
^^^^^^^^^^^
If Boost was built using the boost-cmake project or from Boost 1.70.0 on
it provides a package configuration file for use with find_package's config mode.
This module looks for the package configuration file called
``BoostConfig.cmake`` or ``boost-config.cmake`` and stores the result in
``CACHE`` entry "Boost_DIR". If found, the package configuration file is loaded
and this module returns with no further action. See documentation of
the Boost CMake package configuration for details on what it provides.
Set ``Boost_NO_BOOST_CMAKE`` to ``ON``, to disable the search for boost-cmake.
#]=======================================================================]
# The FPHSA helper provides standard way of reporting final search results to
# the user including the version and component checks.
# Patch for GTSAM:
#include(${CMAKE_CURRENT_LIST_DIR}/FindPackageHandleStandardArgs.cmake)
include(FindPackageHandleStandardArgs)
# Save project's policies
cmake_policy(PUSH)
cmake_policy(SET CMP0057 NEW) # if IN_LIST
function(_boost_get_existing_target component target_var)
set(names "${component}")
if(component MATCHES "^([a-z_]*)(python|numpy)([1-9])\\.?([0-9])?$")
# handle pythonXY and numpyXY versioned components and also python X.Y, mpi_python etc.
list(APPEND names
"${CMAKE_MATCH_1}${CMAKE_MATCH_2}" # python
"${CMAKE_MATCH_1}${CMAKE_MATCH_2}${CMAKE_MATCH_3}" # pythonX
"${CMAKE_MATCH_1}${CMAKE_MATCH_2}${CMAKE_MATCH_3}${CMAKE_MATCH_4}" #pythonXY
)
endif()
# https://github.com/boost-cmake/boost-cmake uses boost::file_system etc.
# So handle similar constructions of target names
string(TOLOWER "${component}" lower_component)
list(APPEND names "${lower_component}")
foreach(prefix Boost boost)
foreach(name IN LISTS names)
if(TARGET "${prefix}::${name}")
# The target may be an INTERFACE library that wraps around a single other
# target for compatibility. Unwrap this layer so we can extract real info.
if("${name}" MATCHES "^(python|numpy|mpi_python)([1-9])([0-9])$")
set(name_nv "${CMAKE_MATCH_1}")
if(TARGET "${prefix}::${name_nv}")
get_property(type TARGET "${prefix}::${name}" PROPERTY TYPE)
if(type STREQUAL "INTERFACE_LIBRARY")
get_property(lib TARGET "${prefix}::${name}" PROPERTY INTERFACE_LINK_LIBRARIES)
if("${lib}" STREQUAL "${prefix}::${name_nv}")
set(${target_var} "${prefix}::${name_nv}" PARENT_SCOPE)
return()
endif()
endif()
endif()
endif()
set(${target_var} "${prefix}::${name}" PARENT_SCOPE)
return()
endif()
endforeach()
endforeach()
set(${target_var} "" PARENT_SCOPE)
endfunction()
function(_boost_get_canonical_target_name component target_var)
string(TOLOWER "${component}" component)
if(component MATCHES "^([a-z_]*)(python|numpy)([1-9])\\.?([0-9])?$")
# handle pythonXY and numpyXY versioned components and also python X.Y, mpi_python etc.
set(${target_var} "Boost::${CMAKE_MATCH_1}${CMAKE_MATCH_2}" PARENT_SCOPE)
else()
set(${target_var} "Boost::${component}" PARENT_SCOPE)
endif()
endfunction()
macro(_boost_set_in_parent_scope name value)
# Set a variable in parent scope and make it visibile in current scope
set(${name} "${value}" PARENT_SCOPE)
set(${name} "${value}")
endmacro()
macro(_boost_set_if_unset name value)
if(NOT ${name})
_boost_set_in_parent_scope(${name} "${value}")
endif()
endmacro()
macro(_boost_set_cache_if_unset name value)
if(NOT ${name})
set(${name} "${value}" CACHE STRING "" FORCE)
endif()
endmacro()
macro(_boost_append_include_dir target)
get_target_property(inc "${target}" INTERFACE_INCLUDE_DIRECTORIES)
if(inc)
list(APPEND include_dirs "${inc}")
endif()
endmacro()
function(_boost_set_legacy_variables_from_config)
# Set legacy variables for compatibility if not set
set(include_dirs "")
set(library_dirs "")
set(libraries "")
# Header targets Boost::headers or Boost::boost
foreach(comp headers boost)
_boost_get_existing_target(${comp} target)
if(target)
_boost_append_include_dir("${target}")
endif()
endforeach()
# Library targets
foreach(comp IN LISTS Boost_FIND_COMPONENTS)
string(TOUPPER ${comp} uppercomp)
# Overwrite if set
_boost_set_in_parent_scope(Boost_${uppercomp}_FOUND "${Boost_${comp}_FOUND}")
if(Boost_${comp}_FOUND)
_boost_get_existing_target(${comp} target)
if(NOT target)
if(Boost_DEBUG OR Boost_VERBOSE)
message(WARNING "Could not find imported target for required component '${comp}'. Legacy variables for this component might be missing. Refer to the documentation of your Boost installation for help on variables to use.")
endif()
continue()
endif()
_boost_append_include_dir("${target}")
_boost_set_if_unset(Boost_${uppercomp}_LIBRARY "${target}")
_boost_set_if_unset(Boost_${uppercomp}_LIBRARIES "${target}") # Very old legacy variable
list(APPEND libraries "${target}")
get_property(type TARGET "${target}" PROPERTY TYPE)
if(NOT type STREQUAL "INTERFACE_LIBRARY")
foreach(cfg RELEASE DEBUG)
get_target_property(lib ${target} IMPORTED_LOCATION_${cfg})
if(lib)
get_filename_component(lib_dir "${lib}" DIRECTORY)
list(APPEND library_dirs ${lib_dir})
_boost_set_cache_if_unset(Boost_${uppercomp}_LIBRARY_${cfg} "${lib}")
endif()
endforeach()
elseif(Boost_DEBUG OR Boost_VERBOSE)
# For projects using only the Boost::* targets this warning can be safely ignored.
message(WARNING "Imported target '${target}' for required component '${comp}' has no artifact. Legacy variables for this component might be missing. Refer to the documentation of your Boost installation for help on variables to use.")
endif()
_boost_get_canonical_target_name("${comp}" canonical_target)
if(NOT TARGET "${canonical_target}")
add_library("${canonical_target}" INTERFACE IMPORTED)
target_link_libraries("${canonical_target}" INTERFACE "${target}")
endif()
endif()
endforeach()
list(REMOVE_DUPLICATES include_dirs)
list(REMOVE_DUPLICATES library_dirs)
_boost_set_if_unset(Boost_INCLUDE_DIRS "${include_dirs}")
_boost_set_if_unset(Boost_LIBRARY_DIRS "${library_dirs}")
_boost_set_if_unset(Boost_LIBRARIES "${libraries}")
_boost_set_if_unset(Boost_VERSION_STRING "${Boost_VERSION_MAJOR}.${Boost_VERSION_MINOR}.${Boost_VERSION_PATCH}")
find_path(Boost_INCLUDE_DIR
NAMES boost/version.hpp boost/config.hpp
HINTS ${Boost_INCLUDE_DIRS}
NO_DEFAULT_PATH
)
if(NOT Boost_VERSION_MACRO OR NOT Boost_LIB_VERSION)
set(version_file ${Boost_INCLUDE_DIR}/boost/version.hpp)
if(EXISTS "${version_file}")
file(STRINGS "${version_file}" contents REGEX "#define BOOST_(LIB_)?VERSION ")
if(contents MATCHES "#define BOOST_VERSION ([0-9]+)")
_boost_set_if_unset(Boost_VERSION_MACRO "${CMAKE_MATCH_1}")
endif()
if(contents MATCHES "#define BOOST_LIB_VERSION \"([0-9_]+)\"")
_boost_set_if_unset(Boost_LIB_VERSION "${CMAKE_MATCH_1}")
endif()
endif()
endif()
_boost_set_if_unset(Boost_MAJOR_VERSION ${Boost_VERSION_MAJOR})
_boost_set_if_unset(Boost_MINOR_VERSION ${Boost_VERSION_MINOR})
_boost_set_if_unset(Boost_SUBMINOR_VERSION ${Boost_VERSION_PATCH})
if(WIN32)
_boost_set_if_unset(Boost_LIB_DIAGNOSTIC_DEFINITIONS "-DBOOST_LIB_DIAGNOSTIC")
endif()
if(NOT TARGET Boost::headers)
add_library(Boost::headers INTERFACE IMPORTED)
target_include_directories(Boost::headers INTERFACE ${Boost_INCLUDE_DIRS})
endif()
# Legacy targets w/o functionality as all handled by defined targets
foreach(lib diagnostic_definitions disable_autolinking dynamic_linking)
if(NOT TARGET Boost::${lib})
add_library(Boost::${lib} INTERFACE IMPORTED)
endif()
endforeach()
if(NOT TARGET Boost::boost)
add_library(Boost::boost INTERFACE IMPORTED)
target_link_libraries(Boost::boost INTERFACE Boost::headers)
endif()
endfunction()
#-------------------------------------------------------------------------------
# Before we go searching, check whether a boost cmake package is available, unless
# the user specifically asked NOT to search for one.
#
# If Boost_DIR is set, this behaves as any find_package call would. If not,
# it looks at BOOST_ROOT and BOOSTROOT to find Boost.
#
if (NOT Boost_NO_BOOST_CMAKE)
# If Boost_DIR is not set, look for BOOSTROOT and BOOST_ROOT as alternatives,
# since these are more conventional for Boost.
if ("$ENV{Boost_DIR}" STREQUAL "")
if (NOT "$ENV{BOOST_ROOT}" STREQUAL "")
set(ENV{Boost_DIR} $ENV{BOOST_ROOT})
elseif (NOT "$ENV{BOOSTROOT}" STREQUAL "")
set(ENV{Boost_DIR} $ENV{BOOSTROOT})
endif()
endif()
# Do the same find_package call but look specifically for the CMake version.
# Note that args are passed in the Boost_FIND_xxxxx variables, so there is no
# need to delegate them to this find_package call.
find_package(Boost QUIET NO_MODULE)
mark_as_advanced(Boost_DIR)
# If we found a boost cmake package, then we're done. Print out what we found.
# Otherwise let the rest of the module try to find it.
if(Boost_FOUND)
# Convert component found variables to standard variables if required
# Necessary for legacy boost-cmake and 1.70 builtin BoostConfig
if(Boost_FIND_COMPONENTS)
foreach(_comp IN LISTS Boost_FIND_COMPONENTS)
if(DEFINED Boost_${_comp}_FOUND)
continue()
endif()
string(TOUPPER ${_comp} _uppercomp)
if(DEFINED Boost${_comp}_FOUND) # legacy boost-cmake project
set(Boost_${_comp}_FOUND ${Boost${_comp}_FOUND})
elseif(DEFINED Boost_${_uppercomp}_FOUND) # Boost 1.70
set(Boost_${_comp}_FOUND ${Boost_${_uppercomp}_FOUND})
endif()
endforeach()
endif()
find_package_handle_standard_args(Boost HANDLE_COMPONENTS CONFIG_MODE)
_boost_set_legacy_variables_from_config()
# Restore project's policies
cmake_policy(POP)
return()
endif()
endif()
#-------------------------------------------------------------------------------
# FindBoost functions & macros
#
#
# Print debug text if Boost_DEBUG is set.
# Call example:
# _Boost_DEBUG_PRINT("${CMAKE_CURRENT_LIST_FILE}" "${CMAKE_CURRENT_LIST_LINE}" "debug message")
#
function(_Boost_DEBUG_PRINT file line text)
if(Boost_DEBUG)
message(STATUS "[ ${file}:${line} ] ${text}")
endif()
endfunction()
#
# _Boost_DEBUG_PRINT_VAR(file line variable_name [ENVIRONMENT]
# [SOURCE "short explanation of origin of var value"])
#
# ENVIRONMENT - look up environment variable instead of CMake variable
#
# Print variable name and its value if Boost_DEBUG is set.
# Call example:
# _Boost_DEBUG_PRINT_VAR("${CMAKE_CURRENT_LIST_FILE}" "${CMAKE_CURRENT_LIST_LINE}" BOOST_ROOT)
#
function(_Boost_DEBUG_PRINT_VAR file line name)
if(Boost_DEBUG)
cmake_parse_arguments(_args "ENVIRONMENT" "SOURCE" "" ${ARGN})
unset(source)
if(_args_SOURCE)
set(source " (${_args_SOURCE})")
endif()
if(_args_ENVIRONMENT)
if(DEFINED ENV{${name}})
set(value "\"$ENV{${name}}\"")
else()
set(value "<unset>")
endif()
set(_name "ENV{${name}}")
else()
if(DEFINED "${name}")
set(value "\"${${name}}\"")
else()
set(value "<unset>")
endif()
set(_name "${name}")
endif()
_Boost_DEBUG_PRINT("${file}" "${line}" "${_name} = ${value}${source}")
endif()
endfunction()
############################################
#
# Check the existence of the libraries.
#
############################################
# This macro was taken directly from the FindQt4.cmake file that is included
# with the CMake distribution. This is NOT my work. All work was done by the
# original authors of the FindQt4.cmake file. Only minor modifications were
# made to remove references to Qt and make this file more generally applicable
# And ELSE/ENDIF pairs were removed for readability.
#########################################################################
macro(_Boost_ADJUST_LIB_VARS basename)
if(Boost_INCLUDE_DIR )
if(Boost_${basename}_LIBRARY_DEBUG AND Boost_${basename}_LIBRARY_RELEASE)
# if the generator is multi-config or if CMAKE_BUILD_TYPE is set for
# single-config generators, set optimized and debug libraries
get_property(_isMultiConfig GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG)
if(_isMultiConfig OR CMAKE_BUILD_TYPE)
set(Boost_${basename}_LIBRARY optimized ${Boost_${basename}_LIBRARY_RELEASE} debug ${Boost_${basename}_LIBRARY_DEBUG})
else()
# For single-config generators where CMAKE_BUILD_TYPE has no value,
# just use the release libraries
set(Boost_${basename}_LIBRARY ${Boost_${basename}_LIBRARY_RELEASE} )
endif()
# FIXME: This probably should be set for both cases
set(Boost_${basename}_LIBRARIES optimized ${Boost_${basename}_LIBRARY_RELEASE} debug ${Boost_${basename}_LIBRARY_DEBUG})
endif()
# if only the release version was found, set the debug variable also to the release version
if(Boost_${basename}_LIBRARY_RELEASE AND NOT Boost_${basename}_LIBRARY_DEBUG)
set(Boost_${basename}_LIBRARY_DEBUG ${Boost_${basename}_LIBRARY_RELEASE})
set(Boost_${basename}_LIBRARY ${Boost_${basename}_LIBRARY_RELEASE})
set(Boost_${basename}_LIBRARIES ${Boost_${basename}_LIBRARY_RELEASE})
endif()
# if only the debug version was found, set the release variable also to the debug version
if(Boost_${basename}_LIBRARY_DEBUG AND NOT Boost_${basename}_LIBRARY_RELEASE)
set(Boost_${basename}_LIBRARY_RELEASE ${Boost_${basename}_LIBRARY_DEBUG})
set(Boost_${basename}_LIBRARY ${Boost_${basename}_LIBRARY_DEBUG})
set(Boost_${basename}_LIBRARIES ${Boost_${basename}_LIBRARY_DEBUG})
endif()
# If the debug & release library ends up being the same, omit the keywords
if("${Boost_${basename}_LIBRARY_RELEASE}" STREQUAL "${Boost_${basename}_LIBRARY_DEBUG}")
set(Boost_${basename}_LIBRARY ${Boost_${basename}_LIBRARY_RELEASE} )
set(Boost_${basename}_LIBRARIES ${Boost_${basename}_LIBRARY_RELEASE} )
endif()
if(Boost_${basename}_LIBRARY AND Boost_${basename}_HEADER)
set(Boost_${basename}_FOUND ON)
if("x${basename}" STREQUAL "xTHREAD" AND NOT TARGET Threads::Threads)
string(APPEND Boost_ERROR_REASON_THREAD " (missing dependency: Threads)")
set(Boost_THREAD_FOUND OFF)
endif()
endif()
endif()
# Make variables changeable to the advanced user
mark_as_advanced(
Boost_${basename}_LIBRARY_RELEASE
Boost_${basename}_LIBRARY_DEBUG
)
endmacro()
# Detect changes in used variables.
# Compares the current variable value with the last one.
# In short form:
# v != v_LAST -> CHANGED = 1
# v is defined, v_LAST not -> CHANGED = 1
# v is not defined, but v_LAST is -> CHANGED = 1
# otherwise -> CHANGED = 0
# CHANGED is returned in variable named ${changed_var}
macro(_Boost_CHANGE_DETECT changed_var)
set(${changed_var} 0)
foreach(v ${ARGN})
if(DEFINED _Boost_COMPONENTS_SEARCHED)
if(${v})
if(_${v}_LAST)
string(COMPARE NOTEQUAL "${${v}}" "${_${v}_LAST}" _${v}_CHANGED)
else()
set(_${v}_CHANGED 1)
endif()
elseif(_${v}_LAST)
set(_${v}_CHANGED 1)
endif()
if(_${v}_CHANGED)
set(${changed_var} 1)
endif()
else()
set(_${v}_CHANGED 0)
endif()
endforeach()
endmacro()
#
# Find the given library (var).
# Use 'build_type' to support different lib paths for RELEASE or DEBUG builds
#
macro(_Boost_FIND_LIBRARY var build_type)
find_library(${var} ${ARGN})
if(${var})
# If this is the first library found then save Boost_LIBRARY_DIR_[RELEASE,DEBUG].
if(NOT Boost_LIBRARY_DIR_${build_type})
get_filename_component(_dir "${${var}}" PATH)
set(Boost_LIBRARY_DIR_${build_type} "${_dir}" CACHE PATH "Boost library directory ${build_type}" FORCE)
endif()
elseif(_Boost_FIND_LIBRARY_HINTS_FOR_COMPONENT)
# Try component-specific hints but do not save Boost_LIBRARY_DIR_[RELEASE,DEBUG].
find_library(${var} HINTS ${_Boost_FIND_LIBRARY_HINTS_FOR_COMPONENT} ${ARGN})
endif()
# If Boost_LIBRARY_DIR_[RELEASE,DEBUG] is known then search only there.
if(Boost_LIBRARY_DIR_${build_type})
set(_boost_LIBRARY_SEARCH_DIRS_${build_type} ${Boost_LIBRARY_DIR_${build_type}} NO_DEFAULT_PATH NO_CMAKE_FIND_ROOT_PATH)
_Boost_DEBUG_PRINT_VAR("${CMAKE_CURRENT_LIST_FILE}" "${CMAKE_CURRENT_LIST_LINE}"
"Boost_LIBRARY_DIR_${build_type}")
_Boost_DEBUG_PRINT_VAR("${CMAKE_CURRENT_LIST_FILE}" "${CMAKE_CURRENT_LIST_LINE}"
"_boost_LIBRARY_SEARCH_DIRS_${build_type}")
endif()
endmacro()
#-------------------------------------------------------------------------------
# Convert CMAKE_CXX_COMPILER_VERSION to boost compiler suffix version.
function(_Boost_COMPILER_DUMPVERSION _OUTPUT_VERSION _OUTPUT_VERSION_MAJOR _OUTPUT_VERSION_MINOR)
string(REGEX REPLACE "([0-9]+)\\.([0-9]+)(\\.[0-9]+)?" "\\1"
_boost_COMPILER_VERSION_MAJOR "${CMAKE_CXX_COMPILER_VERSION}")
string(REGEX REPLACE "([0-9]+)\\.([0-9]+)(\\.[0-9]+)?" "\\2"
_boost_COMPILER_VERSION_MINOR "${CMAKE_CXX_COMPILER_VERSION}")
set(_boost_COMPILER_VERSION "${_boost_COMPILER_VERSION_MAJOR}${_boost_COMPILER_VERSION_MINOR}")
set(${_OUTPUT_VERSION} ${_boost_COMPILER_VERSION} PARENT_SCOPE)
set(${_OUTPUT_VERSION_MAJOR} ${_boost_COMPILER_VERSION_MAJOR} PARENT_SCOPE)
set(${_OUTPUT_VERSION_MINOR} ${_boost_COMPILER_VERSION_MINOR} PARENT_SCOPE)
endfunction()
#
# Take a list of libraries with "thread" in it
# and prepend duplicates with "thread_${Boost_THREADAPI}"
# at the front of the list
#
function(_Boost_PREPEND_LIST_WITH_THREADAPI _output)
set(_orig_libnames ${ARGN})
string(REPLACE "thread" "thread_${Boost_THREADAPI}" _threadapi_libnames "${_orig_libnames}")
set(${_output} ${_threadapi_libnames} ${_orig_libnames} PARENT_SCOPE)
endfunction()
#
# If a library is found, replace its cache entry with its REALPATH
#
function(_Boost_SWAP_WITH_REALPATH _library _docstring)
if(${_library})
get_filename_component(_boost_filepathreal ${${_library}} REALPATH)
unset(${_library} CACHE)
set(${_library} ${_boost_filepathreal} CACHE FILEPATH "${_docstring}")
endif()
endfunction()
function(_Boost_CHECK_SPELLING _var)
if(${_var})
string(TOUPPER ${_var} _var_UC)
message(FATAL_ERROR "ERROR: ${_var} is not the correct spelling. The proper spelling is ${_var_UC}.")
endif()
endfunction()
# Guesses Boost's compiler prefix used in built library names
# Returns the guess by setting the variable pointed to by _ret
function(_Boost_GUESS_COMPILER_PREFIX _ret)
if("x${CMAKE_CXX_COMPILER_ID}" STREQUAL "xIntel")
if(WIN32)
set (_boost_COMPILER "-iw")
else()
set (_boost_COMPILER "-il")
endif()
elseif (GHSMULTI)
set(_boost_COMPILER "-ghs")
elseif("x${CMAKE_CXX_COMPILER_ID}" STREQUAL "xMSVC" OR "x${CMAKE_CXX_SIMULATE_ID}" STREQUAL "xMSVC")
if(MSVC_TOOLSET_VERSION GREATER_EQUAL 150)
# Not yet known.
set(_boost_COMPILER "")
elseif(MSVC_TOOLSET_VERSION GREATER_EQUAL 140)
# MSVC toolset 14.x versions are forward compatible.
set(_boost_COMPILER "")
foreach(v 9 8 7 6 5 4 3 2 1 0)
if(MSVC_TOOLSET_VERSION GREATER_EQUAL 14${v})
list(APPEND _boost_COMPILER "-vc14${v}")
endif()
endforeach()
elseif(MSVC_TOOLSET_VERSION GREATER_EQUAL 80)
set(_boost_COMPILER "-vc${MSVC_TOOLSET_VERSION}")
elseif(NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 13.10)
set(_boost_COMPILER "-vc71")
elseif(NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 13) # Good luck!
set(_boost_COMPILER "-vc7") # yes, this is correct
else() # VS 6.0 Good luck!
set(_boost_COMPILER "-vc6") # yes, this is correct
endif()
if("x${CMAKE_CXX_COMPILER_ID}" STREQUAL "xClang")
string(REPLACE "." ";" VERSION_LIST "${CMAKE_CXX_COMPILER_VERSION}")
list(GET VERSION_LIST 0 CLANG_VERSION_MAJOR)
set(_boost_COMPILER "-clangw${CLANG_VERSION_MAJOR};${_boost_COMPILER}")
endif()
elseif (BORLAND)
set(_boost_COMPILER "-bcb")
elseif(CMAKE_CXX_COMPILER_ID STREQUAL "SunPro")
set(_boost_COMPILER "-sw")
elseif(CMAKE_CXX_COMPILER_ID STREQUAL "XL")
set(_boost_COMPILER "-xlc")
elseif (MINGW)
if(Boost_VERSION_STRING VERSION_LESS 1.34)
set(_boost_COMPILER "-mgw") # no GCC version encoding prior to 1.34
else()
_Boost_COMPILER_DUMPVERSION(_boost_COMPILER_VERSION _boost_COMPILER_VERSION_MAJOR _boost_COMPILER_VERSION_MINOR)
set(_boost_COMPILER "-mgw${_boost_COMPILER_VERSION}")
endif()
elseif (UNIX)
_Boost_COMPILER_DUMPVERSION(_boost_COMPILER_VERSION _boost_COMPILER_VERSION_MAJOR _boost_COMPILER_VERSION_MINOR)
if(NOT Boost_VERSION_STRING VERSION_LESS 1.69.0)
# From GCC 5 and clang 4, versioning changes and minor becomes patch.
# For those compilers, patch is exclude from compiler tag in Boost 1.69+ library naming.
if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU" AND _boost_COMPILER_VERSION_MAJOR VERSION_GREATER 4)
set(_boost_COMPILER_VERSION "${_boost_COMPILER_VERSION_MAJOR}")
elseif(CMAKE_CXX_COMPILER_ID STREQUAL "Clang" AND _boost_COMPILER_VERSION_MAJOR VERSION_GREATER 3)
set(_boost_COMPILER_VERSION "${_boost_COMPILER_VERSION_MAJOR}")
endif()
endif()
if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
if(Boost_VERSION_STRING VERSION_LESS 1.34)
set(_boost_COMPILER "-gcc") # no GCC version encoding prior to 1.34
else()
# Determine which version of GCC we have.
if(APPLE)
if(Boost_VERSION_STRING VERSION_LESS 1.36.0)
# In Boost <= 1.35.0, there is no mangled compiler name for
# the macOS/Darwin version of GCC.
set(_boost_COMPILER "")
else()
# In Boost 1.36.0 and newer, the mangled compiler name used
# on macOS/Darwin is "xgcc".
set(_boost_COMPILER "-xgcc${_boost_COMPILER_VERSION}")
endif()
else()
set(_boost_COMPILER "-gcc${_boost_COMPILER_VERSION}")
endif()
endif()
elseif(CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
# TODO: Find out any Boost version constraints vs clang support.
set(_boost_COMPILER "-clang${_boost_COMPILER_VERSION}")
endif()
else()
set(_boost_COMPILER "")
endif()
_Boost_DEBUG_PRINT_VAR("${CMAKE_CURRENT_LIST_FILE}" "${CMAKE_CURRENT_LIST_LINE}"
"_boost_COMPILER" SOURCE "guessed")
set(${_ret} ${_boost_COMPILER} PARENT_SCOPE)
endfunction()
#
# Get component dependencies. Requires the dependencies to have been
# defined for the Boost release version.
#
# component - the component to check
# _ret - list of library dependencies
#
function(_Boost_COMPONENT_DEPENDENCIES component _ret)
# Note: to add a new Boost release, run
#
# % cmake -DBOOST_DIR=/path/to/boost/source -P Utilities/Scripts/BoostScanDeps.cmake
#
# The output may be added in a new block below. If it's the same as
# the previous release, simply update the version range of the block
# for the previous release. Also check if any new components have
# been added, and add any new components to
# _Boost_COMPONENT_HEADERS.
#
# This information was originally generated by running
# BoostScanDeps.cmake against every boost release to date supported
# by FindBoost:
#
# % for version in /path/to/boost/sources/*
# do
# cmake -DBOOST_DIR=$version -P Utilities/Scripts/BoostScanDeps.cmake
# done
#
# The output was then updated by search and replace with these regexes:
#
# - Strip message(STATUS) prefix dashes
# s;^-- ;;
# - Indent
# s;^set(; set(;;
# - Add conditionals
# s;Scanning /path/to/boost/sources/boost_\(.*\)_\(.*\)_\(.*); elseif(NOT Boost_VERSION_STRING VERSION_LESS \1\.\2\.\3 AND Boost_VERSION_STRING VERSION_LESS xxxx);
#
# This results in the logic seen below, but will require the xxxx
# replacing with the following Boost release version (or the next
# minor version to be released, e.g. 1.59 was the latest at the time
# of writing, making 1.60 the next. Identical consecutive releases
# were then merged together by updating the end range of the first
# block and removing the following redundant blocks.
#
# Running the script against all historical releases should be
# required only if the BoostScanDeps.cmake script logic is changed.
# The addition of a new release should only require it to be run
# against the new release.
# Handle Python version suffixes
if(component MATCHES "^(python|mpi_python|numpy)([0-9][0-9]?|[0-9]\\.[0-9])\$")
set(component "${CMAKE_MATCH_1}")
set(component_python_version "${CMAKE_MATCH_2}")
endif()
set(_Boost_IMPORTED_TARGETS TRUE)
if(Boost_VERSION_STRING AND Boost_VERSION_STRING VERSION_LESS 1.33.0)
message(WARNING "Imported targets and dependency information not available for Boost version ${Boost_VERSION_STRING} (all versions older than 1.33)")
set(_Boost_IMPORTED_TARGETS FALSE)
elseif(NOT Boost_VERSION_STRING VERSION_LESS 1.33.0 AND Boost_VERSION_STRING VERSION_LESS 1.35.0)
set(_Boost_IOSTREAMS_DEPENDENCIES regex thread)
set(_Boost_REGEX_DEPENDENCIES thread)
set(_Boost_WAVE_DEPENDENCIES filesystem thread)
set(_Boost_WSERIALIZATION_DEPENDENCIES serialization)
elseif(NOT Boost_VERSION_STRING VERSION_LESS 1.35.0 AND Boost_VERSION_STRING VERSION_LESS 1.36.0)
set(_Boost_FILESYSTEM_DEPENDENCIES system)
set(_Boost_IOSTREAMS_DEPENDENCIES regex)
set(_Boost_MPI_DEPENDENCIES serialization)
set(_Boost_MPI_PYTHON_DEPENDENCIES python${component_python_version} mpi serialization)
set(_Boost_WAVE_DEPENDENCIES filesystem system thread)
set(_Boost_WSERIALIZATION_DEPENDENCIES serialization)
elseif(NOT Boost_VERSION_STRING VERSION_LESS 1.36.0 AND Boost_VERSION_STRING VERSION_LESS 1.38.0)
set(_Boost_FILESYSTEM_DEPENDENCIES system)
set(_Boost_IOSTREAMS_DEPENDENCIES regex)
set(_Boost_MATH_DEPENDENCIES math_c99 math_c99f math_c99l math_tr1 math_tr1f math_tr1l)
set(_Boost_MPI_DEPENDENCIES serialization)
set(_Boost_MPI_PYTHON_DEPENDENCIES python${component_python_version} mpi serialization)
set(_Boost_WAVE_DEPENDENCIES filesystem system thread)
set(_Boost_WSERIALIZATION_DEPENDENCIES serialization)
elseif(NOT Boost_VERSION_STRING VERSION_LESS 1.38.0 AND Boost_VERSION_STRING VERSION_LESS 1.43.0)
set(_Boost_FILESYSTEM_DEPENDENCIES system)
set(_Boost_IOSTREAMS_DEPENDENCIES regex)
set(_Boost_MATH_DEPENDENCIES math_c99 math_c99f math_c99l math_tr1 math_tr1f math_tr1l)
set(_Boost_MPI_DEPENDENCIES serialization)
set(_Boost_MPI_PYTHON_DEPENDENCIES python${component_python_version} mpi serialization)
set(_Boost_THREAD_DEPENDENCIES date_time)
set(_Boost_WAVE_DEPENDENCIES filesystem system thread date_time)
set(_Boost_WSERIALIZATION_DEPENDENCIES serialization)
elseif(NOT Boost_VERSION_STRING VERSION_LESS 1.43.0 AND Boost_VERSION_STRING VERSION_LESS 1.44.0)
set(_Boost_FILESYSTEM_DEPENDENCIES system)
set(_Boost_IOSTREAMS_DEPENDENCIES regex)
set(_Boost_MATH_DEPENDENCIES math_c99 math_c99f math_c99l math_tr1 math_tr1f math_tr1l random)
set(_Boost_MPI_DEPENDENCIES serialization)
set(_Boost_MPI_PYTHON_DEPENDENCIES python${component_python_version} mpi serialization)
set(_Boost_THREAD_DEPENDENCIES date_time)
set(_Boost_WAVE_DEPENDENCIES filesystem system thread date_time)
set(_Boost_WSERIALIZATION_DEPENDENCIES serialization)
elseif(NOT Boost_VERSION_STRING VERSION_LESS 1.44.0 AND Boost_VERSION_STRING VERSION_LESS 1.45.0)
set(_Boost_FILESYSTEM_DEPENDENCIES system)
set(_Boost_IOSTREAMS_DEPENDENCIES regex)
set(_Boost_MATH_DEPENDENCIES math_c99 math_c99f math_c99l math_tr1 math_tr1f math_tr1l random serialization)
set(_Boost_MPI_DEPENDENCIES serialization)
set(_Boost_MPI_PYTHON_DEPENDENCIES python${component_python_version} mpi serialization)
set(_Boost_THREAD_DEPENDENCIES date_time)
set(_Boost_WAVE_DEPENDENCIES serialization filesystem system thread date_time)
set(_Boost_WSERIALIZATION_DEPENDENCIES serialization)
elseif(NOT Boost_VERSION_STRING VERSION_LESS 1.45.0 AND Boost_VERSION_STRING VERSION_LESS 1.47.0)
set(_Boost_FILESYSTEM_DEPENDENCIES system)
set(_Boost_IOSTREAMS_DEPENDENCIES regex)
set(_Boost_MATH_DEPENDENCIES math_c99 math_c99f math_c99l math_tr1 math_tr1f math_tr1l random)
set(_Boost_MPI_DEPENDENCIES serialization)
set(_Boost_MPI_PYTHON_DEPENDENCIES python${component_python_version} mpi serialization)
set(_Boost_THREAD_DEPENDENCIES date_time)
set(_Boost_WAVE_DEPENDENCIES filesystem system serialization thread date_time)
set(_Boost_WSERIALIZATION_DEPENDENCIES serialization)
elseif(NOT Boost_VERSION_STRING VERSION_LESS 1.47.0 AND Boost_VERSION_STRING VERSION_LESS 1.48.0)
set(_Boost_CHRONO_DEPENDENCIES system)
set(_Boost_FILESYSTEM_DEPENDENCIES system)
set(_Boost_IOSTREAMS_DEPENDENCIES regex)
set(_Boost_MATH_DEPENDENCIES math_c99 math_c99f math_c99l math_tr1 math_tr1f math_tr1l random)
set(_Boost_MPI_DEPENDENCIES serialization)
set(_Boost_MPI_PYTHON_DEPENDENCIES python${component_python_version} mpi serialization)
set(_Boost_THREAD_DEPENDENCIES date_time)
set(_Boost_WAVE_DEPENDENCIES filesystem system serialization thread date_time)
set(_Boost_WSERIALIZATION_DEPENDENCIES serialization)
elseif(NOT Boost_VERSION_STRING VERSION_LESS 1.48.0 AND Boost_VERSION_STRING VERSION_LESS 1.50.0)
set(_Boost_CHRONO_DEPENDENCIES system)
set(_Boost_FILESYSTEM_DEPENDENCIES system)
set(_Boost_IOSTREAMS_DEPENDENCIES regex)
set(_Boost_MATH_DEPENDENCIES math_c99 math_c99f math_c99l math_tr1 math_tr1f math_tr1l random)
set(_Boost_MPI_DEPENDENCIES serialization)
set(_Boost_MPI_PYTHON_DEPENDENCIES python${component_python_version} mpi serialization)
set(_Boost_THREAD_DEPENDENCIES date_time)
set(_Boost_TIMER_DEPENDENCIES chrono system)
set(_Boost_WAVE_DEPENDENCIES filesystem system serialization thread date_time)
set(_Boost_WSERIALIZATION_DEPENDENCIES serialization)
elseif(NOT Boost_VERSION_STRING VERSION_LESS 1.50.0 AND Boost_VERSION_STRING VERSION_LESS 1.53.0)
set(_Boost_CHRONO_DEPENDENCIES system)
set(_Boost_FILESYSTEM_DEPENDENCIES system)
set(_Boost_IOSTREAMS_DEPENDENCIES regex)
set(_Boost_MATH_DEPENDENCIES math_c99 math_c99f math_c99l math_tr1 math_tr1f math_tr1l regex random)
set(_Boost_MPI_DEPENDENCIES serialization)
set(_Boost_MPI_PYTHON_DEPENDENCIES python${component_python_version} mpi serialization)
set(_Boost_THREAD_DEPENDENCIES chrono system date_time)
set(_Boost_TIMER_DEPENDENCIES chrono system)
set(_Boost_WAVE_DEPENDENCIES filesystem system serialization thread chrono date_time)
set(_Boost_WSERIALIZATION_DEPENDENCIES serialization)
elseif(NOT Boost_VERSION_STRING VERSION_LESS 1.53.0 AND Boost_VERSION_STRING VERSION_LESS 1.54.0)
set(_Boost_ATOMIC_DEPENDENCIES thread chrono system date_time)
set(_Boost_CHRONO_DEPENDENCIES system)
set(_Boost_FILESYSTEM_DEPENDENCIES system)
set(_Boost_IOSTREAMS_DEPENDENCIES regex)
set(_Boost_MATH_DEPENDENCIES math_c99 math_c99f math_c99l math_tr1 math_tr1f math_tr1l regex random)
set(_Boost_MPI_DEPENDENCIES serialization)
set(_Boost_MPI_PYTHON_DEPENDENCIES python${component_python_version} mpi serialization)
set(_Boost_THREAD_DEPENDENCIES chrono system date_time atomic)
set(_Boost_TIMER_DEPENDENCIES chrono system)
set(_Boost_WAVE_DEPENDENCIES filesystem system serialization thread chrono date_time)
set(_Boost_WSERIALIZATION_DEPENDENCIES serialization)
elseif(NOT Boost_VERSION_STRING VERSION_LESS 1.54.0 AND Boost_VERSION_STRING VERSION_LESS 1.55.0)
set(_Boost_ATOMIC_DEPENDENCIES thread chrono system date_time)
set(_Boost_CHRONO_DEPENDENCIES system)
set(_Boost_FILESYSTEM_DEPENDENCIES system)
set(_Boost_IOSTREAMS_DEPENDENCIES regex)
set(_Boost_LOG_DEPENDENCIES log_setup date_time system filesystem thread regex chrono)
set(_Boost_MATH_DEPENDENCIES math_c99 math_c99f math_c99l math_tr1 math_tr1f math_tr1l regex random)
set(_Boost_MPI_DEPENDENCIES serialization)
set(_Boost_MPI_PYTHON_DEPENDENCIES python${component_python_version} mpi serialization)
set(_Boost_THREAD_DEPENDENCIES chrono system date_time atomic)
set(_Boost_TIMER_DEPENDENCIES chrono system)
set(_Boost_WAVE_DEPENDENCIES filesystem system serialization thread chrono date_time atomic)
set(_Boost_WSERIALIZATION_DEPENDENCIES serialization)
elseif(NOT Boost_VERSION_STRING VERSION_LESS 1.55.0 AND Boost_VERSION_STRING VERSION_LESS 1.56.0)
set(_Boost_CHRONO_DEPENDENCIES system)
set(_Boost_COROUTINE_DEPENDENCIES context system)
set(_Boost_FILESYSTEM_DEPENDENCIES system)
set(_Boost_IOSTREAMS_DEPENDENCIES regex)
set(_Boost_LOG_DEPENDENCIES log_setup date_time system filesystem thread regex chrono)
set(_Boost_MATH_DEPENDENCIES math_c99 math_c99f math_c99l math_tr1 math_tr1f math_tr1l regex random)
set(_Boost_MPI_DEPENDENCIES serialization)
set(_Boost_MPI_PYTHON_DEPENDENCIES python${component_python_version} mpi serialization)
set(_Boost_THREAD_DEPENDENCIES chrono system date_time atomic)
set(_Boost_TIMER_DEPENDENCIES chrono system)
set(_Boost_WAVE_DEPENDENCIES filesystem system serialization thread chrono date_time atomic)
set(_Boost_WSERIALIZATION_DEPENDENCIES serialization)
elseif(NOT Boost_VERSION_STRING VERSION_LESS 1.56.0 AND Boost_VERSION_STRING VERSION_LESS 1.59.0)
set(_Boost_CHRONO_DEPENDENCIES system)
set(_Boost_COROUTINE_DEPENDENCIES context system)
set(_Boost_FILESYSTEM_DEPENDENCIES system)
set(_Boost_IOSTREAMS_DEPENDENCIES regex)
set(_Boost_LOG_DEPENDENCIES log_setup date_time system filesystem thread regex chrono)
set(_Boost_MATH_DEPENDENCIES math_c99 math_c99f math_c99l math_tr1 math_tr1f math_tr1l atomic)
set(_Boost_MPI_DEPENDENCIES serialization)
set(_Boost_MPI_PYTHON_DEPENDENCIES python${component_python_version} mpi serialization)
set(_Boost_RANDOM_DEPENDENCIES system)
set(_Boost_THREAD_DEPENDENCIES chrono system date_time atomic)
set(_Boost_TIMER_DEPENDENCIES chrono system)
set(_Boost_WAVE_DEPENDENCIES filesystem system serialization thread chrono date_time atomic)
set(_Boost_WSERIALIZATION_DEPENDENCIES serialization)
elseif(NOT Boost_VERSION_STRING VERSION_LESS 1.59.0 AND Boost_VERSION_STRING VERSION_LESS 1.60.0)
set(_Boost_CHRONO_DEPENDENCIES system)
set(_Boost_COROUTINE_DEPENDENCIES context system)
set(_Boost_FILESYSTEM_DEPENDENCIES system)
set(_Boost_IOSTREAMS_DEPENDENCIES regex)
set(_Boost_LOG_DEPENDENCIES log_setup date_time system filesystem thread regex chrono atomic)
set(_Boost_MATH_DEPENDENCIES math_c99 math_c99f math_c99l math_tr1 math_tr1f math_tr1l atomic)
set(_Boost_MPI_DEPENDENCIES serialization)
set(_Boost_MPI_PYTHON_DEPENDENCIES python${component_python_version} mpi serialization)
set(_Boost_RANDOM_DEPENDENCIES system)
set(_Boost_THREAD_DEPENDENCIES chrono system date_time atomic)
set(_Boost_TIMER_DEPENDENCIES chrono system)
set(_Boost_WAVE_DEPENDENCIES filesystem system serialization thread chrono date_time atomic)
set(_Boost_WSERIALIZATION_DEPENDENCIES serialization)
elseif(NOT Boost_VERSION_STRING VERSION_LESS 1.60.0 AND Boost_VERSION_STRING VERSION_LESS 1.61.0)
set(_Boost_CHRONO_DEPENDENCIES system)
set(_Boost_COROUTINE_DEPENDENCIES context system)
set(_Boost_FILESYSTEM_DEPENDENCIES system)
set(_Boost_IOSTREAMS_DEPENDENCIES regex)
set(_Boost_LOG_DEPENDENCIES date_time log_setup system filesystem thread regex chrono atomic)
set(_Boost_MATH_DEPENDENCIES math_c99 math_c99f math_c99l math_tr1 math_tr1f math_tr1l atomic)
set(_Boost_MPI_DEPENDENCIES serialization)
set(_Boost_MPI_PYTHON_DEPENDENCIES python${component_python_version} mpi serialization)
set(_Boost_RANDOM_DEPENDENCIES system)
set(_Boost_THREAD_DEPENDENCIES chrono system date_time atomic)
set(_Boost_TIMER_DEPENDENCIES chrono system)
set(_Boost_WAVE_DEPENDENCIES filesystem system serialization thread chrono date_time atomic)
set(_Boost_WSERIALIZATION_DEPENDENCIES serialization)
elseif(NOT Boost_VERSION_STRING VERSION_LESS 1.61.0 AND Boost_VERSION_STRING VERSION_LESS 1.62.0)
set(_Boost_CHRONO_DEPENDENCIES system)
set(_Boost_CONTEXT_DEPENDENCIES thread chrono system date_time)
set(_Boost_COROUTINE_DEPENDENCIES context system)
set(_Boost_FILESYSTEM_DEPENDENCIES system)
set(_Boost_IOSTREAMS_DEPENDENCIES regex)
set(_Boost_LOG_DEPENDENCIES date_time log_setup system filesystem thread regex chrono atomic)
set(_Boost_MATH_DEPENDENCIES math_c99 math_c99f math_c99l math_tr1 math_tr1f math_tr1l atomic)
set(_Boost_MPI_DEPENDENCIES serialization)
set(_Boost_MPI_PYTHON_DEPENDENCIES python${component_python_version} mpi serialization)
set(_Boost_RANDOM_DEPENDENCIES system)
set(_Boost_THREAD_DEPENDENCIES chrono system date_time atomic)
set(_Boost_WAVE_DEPENDENCIES filesystem system serialization thread chrono date_time atomic)
set(_Boost_WSERIALIZATION_DEPENDENCIES serialization)
elseif(NOT Boost_VERSION_STRING VERSION_LESS 1.62.0 AND Boost_VERSION_STRING VERSION_LESS 1.63.0)
set(_Boost_CHRONO_DEPENDENCIES system)
set(_Boost_CONTEXT_DEPENDENCIES thread chrono system date_time)
set(_Boost_COROUTINE_DEPENDENCIES context system)
set(_Boost_FIBER_DEPENDENCIES context thread chrono system date_time)
set(_Boost_FILESYSTEM_DEPENDENCIES system)
set(_Boost_IOSTREAMS_DEPENDENCIES regex)
set(_Boost_LOG_DEPENDENCIES date_time log_setup system filesystem thread regex chrono atomic)
set(_Boost_MATH_DEPENDENCIES math_c99 math_c99f math_c99l math_tr1 math_tr1f math_tr1l atomic)
set(_Boost_MPI_DEPENDENCIES serialization)
set(_Boost_MPI_PYTHON_DEPENDENCIES python${component_python_version} mpi serialization)
set(_Boost_RANDOM_DEPENDENCIES system)
set(_Boost_THREAD_DEPENDENCIES chrono system date_time atomic)
set(_Boost_WAVE_DEPENDENCIES filesystem system serialization thread chrono date_time atomic)
set(_Boost_WSERIALIZATION_DEPENDENCIES serialization)
elseif(NOT Boost_VERSION_STRING VERSION_LESS 1.63.0 AND Boost_VERSION_STRING VERSION_LESS 1.65.0)
set(_Boost_CHRONO_DEPENDENCIES system)
set(_Boost_CONTEXT_DEPENDENCIES thread chrono system date_time)
set(_Boost_COROUTINE_DEPENDENCIES context system)
set(_Boost_COROUTINE2_DEPENDENCIES context fiber thread chrono system date_time)
set(_Boost_FIBER_DEPENDENCIES context thread chrono system date_time)
set(_Boost_FILESYSTEM_DEPENDENCIES system)
set(_Boost_IOSTREAMS_DEPENDENCIES regex)
set(_Boost_LOG_DEPENDENCIES date_time log_setup system filesystem thread regex chrono atomic)
set(_Boost_MATH_DEPENDENCIES math_c99 math_c99f math_c99l math_tr1 math_tr1f math_tr1l atomic)
set(_Boost_MPI_DEPENDENCIES serialization)
set(_Boost_MPI_PYTHON_DEPENDENCIES python${component_python_version} mpi serialization)
set(_Boost_RANDOM_DEPENDENCIES system)
set(_Boost_THREAD_DEPENDENCIES chrono system date_time atomic)
set(_Boost_WAVE_DEPENDENCIES filesystem system serialization thread chrono date_time atomic)
set(_Boost_WSERIALIZATION_DEPENDENCIES serialization)
elseif(NOT Boost_VERSION_STRING VERSION_LESS 1.65.0 AND Boost_VERSION_STRING VERSION_LESS 1.67.0)
set(_Boost_CHRONO_DEPENDENCIES system)
set(_Boost_CONTEXT_DEPENDENCIES thread chrono system date_time)
set(_Boost_COROUTINE_DEPENDENCIES context system)
set(_Boost_FIBER_DEPENDENCIES context thread chrono system date_time)
set(_Boost_FILESYSTEM_DEPENDENCIES system)
set(_Boost_IOSTREAMS_DEPENDENCIES regex)
set(_Boost_LOG_DEPENDENCIES date_time log_setup system filesystem thread regex chrono atomic)
set(_Boost_MATH_DEPENDENCIES math_c99 math_c99f math_c99l math_tr1 math_tr1f math_tr1l atomic)
set(_Boost_MPI_DEPENDENCIES serialization)
set(_Boost_MPI_PYTHON_DEPENDENCIES python${component_python_version} mpi serialization)
set(_Boost_NUMPY_DEPENDENCIES python${component_python_version})
set(_Boost_RANDOM_DEPENDENCIES system)
set(_Boost_THREAD_DEPENDENCIES chrono system date_time atomic)
set(_Boost_TIMER_DEPENDENCIES chrono system)
set(_Boost_WAVE_DEPENDENCIES filesystem system serialization thread chrono date_time atomic)
set(_Boost_WSERIALIZATION_DEPENDENCIES serialization)
elseif(NOT Boost_VERSION_STRING VERSION_LESS 1.67.0 AND Boost_VERSION_STRING VERSION_LESS 1.68.0)
set(_Boost_CHRONO_DEPENDENCIES system)
set(_Boost_CONTEXT_DEPENDENCIES thread chrono system date_time)
set(_Boost_COROUTINE_DEPENDENCIES context system)
set(_Boost_FIBER_DEPENDENCIES context thread chrono system date_time)
set(_Boost_FILESYSTEM_DEPENDENCIES system)
set(_Boost_IOSTREAMS_DEPENDENCIES regex)
set(_Boost_LOG_DEPENDENCIES date_time log_setup system filesystem thread regex chrono atomic)
set(_Boost_MATH_DEPENDENCIES math_c99 math_c99f math_c99l math_tr1 math_tr1f math_tr1l atomic)
set(_Boost_MPI_DEPENDENCIES serialization)
set(_Boost_MPI_PYTHON_DEPENDENCIES python${component_python_version} mpi serialization)
set(_Boost_NUMPY_DEPENDENCIES python${component_python_version})
set(_Boost_RANDOM_DEPENDENCIES system)
set(_Boost_THREAD_DEPENDENCIES chrono system date_time atomic)
set(_Boost_TIMER_DEPENDENCIES chrono system)
set(_Boost_WAVE_DEPENDENCIES filesystem system serialization thread chrono date_time atomic)
set(_Boost_WSERIALIZATION_DEPENDENCIES serialization)
elseif(NOT Boost_VERSION_STRING VERSION_LESS 1.68.0 AND Boost_VERSION_STRING VERSION_LESS 1.69.0)
set(_Boost_CHRONO_DEPENDENCIES system)
set(_Boost_CONTEXT_DEPENDENCIES thread chrono system date_time)
set(_Boost_CONTRACT_DEPENDENCIES thread chrono system date_time)
set(_Boost_COROUTINE_DEPENDENCIES context system)
set(_Boost_FIBER_DEPENDENCIES context thread chrono system date_time)
set(_Boost_FILESYSTEM_DEPENDENCIES system)
set(_Boost_IOSTREAMS_DEPENDENCIES regex)
set(_Boost_LOG_DEPENDENCIES date_time log_setup system filesystem thread regex chrono atomic)
set(_Boost_MATH_DEPENDENCIES math_c99 math_c99f math_c99l math_tr1 math_tr1f math_tr1l atomic)
set(_Boost_MPI_DEPENDENCIES serialization)
set(_Boost_MPI_PYTHON_DEPENDENCIES python${component_python_version} mpi serialization)
set(_Boost_NUMPY_DEPENDENCIES python${component_python_version})
set(_Boost_RANDOM_DEPENDENCIES system)
set(_Boost_THREAD_DEPENDENCIES chrono system date_time atomic)
set(_Boost_TIMER_DEPENDENCIES chrono system)
set(_Boost_WAVE_DEPENDENCIES filesystem system serialization thread chrono date_time atomic)
set(_Boost_WSERIALIZATION_DEPENDENCIES serialization)
elseif(NOT Boost_VERSION_STRING VERSION_LESS 1.69.0 AND Boost_VERSION_STRING VERSION_LESS 1.70.0)
set(_Boost_CONTRACT_DEPENDENCIES thread chrono date_time)
set(_Boost_COROUTINE_DEPENDENCIES context)
set(_Boost_FIBER_DEPENDENCIES context)
set(_Boost_IOSTREAMS_DEPENDENCIES regex)
set(_Boost_LOG_DEPENDENCIES date_time log_setup filesystem thread regex chrono atomic)
set(_Boost_MATH_DEPENDENCIES math_c99 math_c99f math_c99l math_tr1 math_tr1f math_tr1l atomic)
set(_Boost_MPI_DEPENDENCIES serialization)
set(_Boost_MPI_PYTHON_DEPENDENCIES python${component_python_version} mpi serialization)
set(_Boost_NUMPY_DEPENDENCIES python${component_python_version})
set(_Boost_THREAD_DEPENDENCIES chrono date_time atomic)
set(_Boost_TIMER_DEPENDENCIES chrono system)
set(_Boost_WAVE_DEPENDENCIES filesystem serialization thread chrono date_time atomic)
set(_Boost_WSERIALIZATION_DEPENDENCIES serialization)
elseif(NOT Boost_VERSION_STRING VERSION_LESS 1.70.0)
set(_Boost_CONTRACT_DEPENDENCIES thread chrono date_time)
set(_Boost_COROUTINE_DEPENDENCIES context)
set(_Boost_FIBER_DEPENDENCIES context)
set(_Boost_IOSTREAMS_DEPENDENCIES regex)
set(_Boost_LOG_DEPENDENCIES date_time log_setup filesystem thread regex chrono atomic)
set(_Boost_MATH_DEPENDENCIES math_c99 math_c99f math_c99l math_tr1 math_tr1f math_tr1l atomic)
set(_Boost_MPI_DEPENDENCIES serialization)
set(_Boost_MPI_PYTHON_DEPENDENCIES python${component_python_version} mpi serialization)
set(_Boost_NUMPY_DEPENDENCIES python${component_python_version})
set(_Boost_THREAD_DEPENDENCIES chrono date_time atomic)
set(_Boost_TIMER_DEPENDENCIES chrono)
set(_Boost_WAVE_DEPENDENCIES filesystem serialization thread chrono date_time atomic)
set(_Boost_WSERIALIZATION_DEPENDENCIES serialization)
if(NOT Boost_VERSION_STRING VERSION_LESS 1.72.0)
message(WARNING "New Boost version may have incorrect or missing dependencies and imported targets")
endif()
endif()
string(TOUPPER ${component} uppercomponent)
set(${_ret} ${_Boost_${uppercomponent}_DEPENDENCIES} PARENT_SCOPE)
set(_Boost_IMPORTED_TARGETS ${_Boost_IMPORTED_TARGETS} PARENT_SCOPE)
string(REGEX REPLACE ";" " " _boost_DEPS_STRING "${_Boost_${uppercomponent}_DEPENDENCIES}")
if (NOT _boost_DEPS_STRING)
set(_boost_DEPS_STRING "(none)")
endif()
# message(STATUS "Dependencies for Boost::${component}: ${_boost_DEPS_STRING}")
endfunction()
#
# Get component headers. This is the primary header (or headers) for
# a given component, and is used to check that the headers are present
# as well as the library itself as an extra sanity check of the build
# environment.
#
# component - the component to check
# _hdrs
#
function(_Boost_COMPONENT_HEADERS component _hdrs)
# Handle Python version suffixes
if(component MATCHES "^(python|mpi_python|numpy)([0-9][0-9]?|[0-9]\\.[0-9])\$")
set(component "${CMAKE_MATCH_1}")
set(component_python_version "${CMAKE_MATCH_2}")
endif()
# Note: new boost components will require adding here. The header
# must be present in all versions of Boost providing a library.
set(_Boost_ATOMIC_HEADERS "boost/atomic.hpp")
set(_Boost_CHRONO_HEADERS "boost/chrono.hpp")
set(_Boost_CONTAINER_HEADERS "boost/container/container_fwd.hpp")
set(_Boost_CONTRACT_HEADERS "boost/contract.hpp")
if(Boost_VERSION_STRING VERSION_LESS 1.61.0)
set(_Boost_CONTEXT_HEADERS "boost/context/all.hpp")
else()
set(_Boost_CONTEXT_HEADERS "boost/context/detail/fcontext.hpp")
endif()
set(_Boost_COROUTINE_HEADERS "boost/coroutine/all.hpp")
set(_Boost_DATE_TIME_HEADERS "boost/date_time/date.hpp")
set(_Boost_EXCEPTION_HEADERS "boost/exception/exception.hpp")
set(_Boost_FIBER_HEADERS "boost/fiber/all.hpp")
set(_Boost_FILESYSTEM_HEADERS "boost/filesystem/path.hpp")
set(_Boost_GRAPH_HEADERS "boost/graph/adjacency_list.hpp")
set(_Boost_GRAPH_PARALLEL_HEADERS "boost/graph/adjacency_list.hpp")
set(_Boost_IOSTREAMS_HEADERS "boost/iostreams/stream.hpp")
set(_Boost_LOCALE_HEADERS "boost/locale.hpp")
set(_Boost_LOG_HEADERS "boost/log/core.hpp")
set(_Boost_LOG_SETUP_HEADERS "boost/log/detail/setup_config.hpp")
set(_Boost_MATH_HEADERS "boost/math_fwd.hpp")
set(_Boost_MATH_C99_HEADERS "boost/math/tr1.hpp")
set(_Boost_MATH_C99F_HEADERS "boost/math/tr1.hpp")
set(_Boost_MATH_C99L_HEADERS "boost/math/tr1.hpp")
set(_Boost_MATH_TR1_HEADERS "boost/math/tr1.hpp")
set(_Boost_MATH_TR1F_HEADERS "boost/math/tr1.hpp")
set(_Boost_MATH_TR1L_HEADERS "boost/math/tr1.hpp")
set(_Boost_MPI_HEADERS "boost/mpi.hpp")
set(_Boost_MPI_PYTHON_HEADERS "boost/mpi/python/config.hpp")
set(_Boost_NUMPY_HEADERS "boost/python/numpy.hpp")
set(_Boost_PRG_EXEC_MONITOR_HEADERS "boost/test/prg_exec_monitor.hpp")
set(_Boost_PROGRAM_OPTIONS_HEADERS "boost/program_options.hpp")
set(_Boost_PYTHON_HEADERS "boost/python.hpp")
set(_Boost_RANDOM_HEADERS "boost/random.hpp")
set(_Boost_REGEX_HEADERS "boost/regex.hpp")
set(_Boost_SERIALIZATION_HEADERS "boost/serialization/serialization.hpp")
set(_Boost_SIGNALS_HEADERS "boost/signals.hpp")
set(_Boost_STACKTRACE_ADDR2LINE_HEADERS "boost/stacktrace.hpp")
set(_Boost_STACKTRACE_BACKTRACE_HEADERS "boost/stacktrace.hpp")
set(_Boost_STACKTRACE_BASIC_HEADERS "boost/stacktrace.hpp")
set(_Boost_STACKTRACE_NOOP_HEADERS "boost/stacktrace.hpp")
set(_Boost_STACKTRACE_WINDBG_CACHED_HEADERS "boost/stacktrace.hpp")
set(_Boost_STACKTRACE_WINDBG_HEADERS "boost/stacktrace.hpp")
set(_Boost_SYSTEM_HEADERS "boost/system/config.hpp")
set(_Boost_TEST_EXEC_MONITOR_HEADERS "boost/test/test_exec_monitor.hpp")
set(_Boost_THREAD_HEADERS "boost/thread.hpp")
set(_Boost_TIMER_HEADERS "boost/timer.hpp")
set(_Boost_TYPE_ERASURE_HEADERS "boost/type_erasure/config.hpp")
set(_Boost_UNIT_TEST_FRAMEWORK_HEADERS "boost/test/framework.hpp")
set(_Boost_WAVE_HEADERS "boost/wave.hpp")
set(_Boost_WSERIALIZATION_HEADERS "boost/archive/text_wiarchive.hpp")
if(WIN32)
set(_Boost_BZIP2_HEADERS "boost/iostreams/filter/bzip2.hpp")
set(_Boost_ZLIB_HEADERS "boost/iostreams/filter/zlib.hpp")
endif()
string(TOUPPER ${component} uppercomponent)
set(${_hdrs} ${_Boost_${uppercomponent}_HEADERS} PARENT_SCOPE)
string(REGEX REPLACE ";" " " _boost_HDRS_STRING "${_Boost_${uppercomponent}_HEADERS}")
if (NOT _boost_HDRS_STRING)
set(_boost_HDRS_STRING "(none)")
endif()
# message(STATUS "Headers for Boost::${component}: ${_boost_HDRS_STRING}")
endfunction()
#
# Determine if any missing dependencies require adding to the component list.
#
# Sets _Boost_${COMPONENT}_DEPENDENCIES for each required component,
# plus _Boost_IMPORTED_TARGETS (TRUE if imported targets should be
# defined; FALSE if dependency information is unavailable).
#
# componentvar - the component list variable name
# extravar - the indirect dependency list variable name
#
#
function(_Boost_MISSING_DEPENDENCIES componentvar extravar)
# _boost_unprocessed_components - list of components requiring processing
# _boost_processed_components - components already processed (or currently being processed)
# _boost_new_components - new components discovered for future processing
#
list(APPEND _boost_unprocessed_components ${${componentvar}})
while(_boost_unprocessed_components)
list(APPEND _boost_processed_components ${_boost_unprocessed_components})
foreach(component ${_boost_unprocessed_components})
string(TOUPPER ${component} uppercomponent)
set(${_ret} ${_Boost_${uppercomponent}_DEPENDENCIES} PARENT_SCOPE)
_Boost_COMPONENT_DEPENDENCIES("${component}" _Boost_${uppercomponent}_DEPENDENCIES)
set(_Boost_${uppercomponent}_DEPENDENCIES ${_Boost_${uppercomponent}_DEPENDENCIES} PARENT_SCOPE)
set(_Boost_IMPORTED_TARGETS ${_Boost_IMPORTED_TARGETS} PARENT_SCOPE)
foreach(componentdep ${_Boost_${uppercomponent}_DEPENDENCIES})
if (NOT ("${componentdep}" IN_LIST _boost_processed_components OR "${componentdep}" IN_LIST _boost_new_components))
list(APPEND _boost_new_components ${componentdep})
endif()
endforeach()
endforeach()
set(_boost_unprocessed_components ${_boost_new_components})
unset(_boost_new_components)
endwhile()
set(_boost_extra_components ${_boost_processed_components})
if(_boost_extra_components AND ${componentvar})
list(REMOVE_ITEM _boost_extra_components ${${componentvar}})
endif()
set(${componentvar} ${_boost_processed_components} PARENT_SCOPE)
set(${extravar} ${_boost_extra_components} PARENT_SCOPE)
endfunction()
#
# Some boost libraries may require particular set of compler features.
# The very first one was `boost::fiber` introduced in Boost 1.62.
# One can check required compiler features of it in
# - `${Boost_ROOT}/libs/fiber/build/Jamfile.v2`;
# - `${Boost_ROOT}/libs/context/build/Jamfile.v2`.
#
# TODO (Re)Check compiler features on (every?) release ???
# One may use the following command to get the files to check:
#
# $ find . -name Jamfile.v2 | grep build | xargs grep -l cxx1
#
function(_Boost_COMPILER_FEATURES component _ret)
# Boost >= 1.62
if(NOT Boost_VERSION_STRING VERSION_LESS 1.62.0)
set(_Boost_FIBER_COMPILER_FEATURES
cxx_alias_templates
cxx_auto_type
cxx_constexpr
cxx_defaulted_functions
cxx_final
cxx_lambdas
cxx_noexcept
cxx_nullptr
cxx_rvalue_references
cxx_thread_local
cxx_variadic_templates
)
# Compiler feature for `context` same as for `fiber`.
set(_Boost_CONTEXT_COMPILER_FEATURES ${_Boost_FIBER_COMPILER_FEATURES})
endif()
# Boost Contract library available in >= 1.67
if(NOT Boost_VERSION_STRING VERSION_LESS 1.67.0)
# From `libs/contract/build/boost_contract_build.jam`
set(_Boost_CONTRACT_COMPILER_FEATURES
cxx_lambdas
cxx_variadic_templates
)
endif()
string(TOUPPER ${component} uppercomponent)
set(${_ret} ${_Boost_${uppercomponent}_COMPILER_FEATURES} PARENT_SCOPE)
endfunction()
#
# Update library search directory hint variable with paths used by prebuilt boost binaries.
#
# Prebuilt windows binaries (https://sourceforge.net/projects/boost/files/boost-binaries/)
# have library directories named using MSVC compiler version and architecture.
# This function would append corresponding directories if MSVC is a current compiler,
# so having `BOOST_ROOT` would be enough to specify to find everything.
#
function(_Boost_UPDATE_WINDOWS_LIBRARY_SEARCH_DIRS_WITH_PREBUILT_PATHS componentlibvar basedir)
if("x${CMAKE_CXX_COMPILER_ID}" STREQUAL "xMSVC")
if(CMAKE_SIZEOF_VOID_P EQUAL 8)
set(_arch_suffix 64)
else()
set(_arch_suffix 32)
endif()
if(MSVC_TOOLSET_VERSION GREATER_EQUAL 150)
# Not yet known.
elseif(MSVC_TOOLSET_VERSION GREATER_EQUAL 140)
# MSVC toolset 14.x versions are forward compatible.
foreach(v 9 8 7 6 5 4 3 2 1 0)
if(MSVC_TOOLSET_VERSION GREATER_EQUAL 14${v})
list(APPEND ${componentlibvar} ${basedir}/lib${_arch_suffix}-msvc-14.${v})
endif()
endforeach()
elseif(MSVC_TOOLSET_VERSION GREATER_EQUAL 80)
math(EXPR _toolset_major_version "${MSVC_TOOLSET_VERSION} / 10")
list(APPEND ${componentlibvar} ${basedir}/lib${_arch_suffix}-msvc-${_toolset_major_version}.0)
endif()
set(${componentlibvar} ${${componentlibvar}} PARENT_SCOPE)
endif()
endfunction()
#
# End functions/macros
#
#-------------------------------------------------------------------------------
#-------------------------------------------------------------------------------
# main.
#-------------------------------------------------------------------------------
# If the user sets Boost_LIBRARY_DIR, use it as the default for both
# configurations.
if(NOT Boost_LIBRARY_DIR_RELEASE AND Boost_LIBRARY_DIR)
set(Boost_LIBRARY_DIR_RELEASE "${Boost_LIBRARY_DIR}")
endif()
if(NOT Boost_LIBRARY_DIR_DEBUG AND Boost_LIBRARY_DIR)
set(Boost_LIBRARY_DIR_DEBUG "${Boost_LIBRARY_DIR}")
endif()
if(NOT DEFINED Boost_USE_DEBUG_LIBS)
set(Boost_USE_DEBUG_LIBS TRUE)
endif()
if(NOT DEFINED Boost_USE_RELEASE_LIBS)
set(Boost_USE_RELEASE_LIBS TRUE)
endif()
if(NOT DEFINED Boost_USE_MULTITHREADED)
set(Boost_USE_MULTITHREADED TRUE)
endif()
if(NOT DEFINED Boost_USE_DEBUG_RUNTIME)
set(Boost_USE_DEBUG_RUNTIME TRUE)
endif()
# Check the version of Boost against the requested version.
if(Boost_FIND_VERSION AND NOT Boost_FIND_VERSION_MINOR)
message(SEND_ERROR "When requesting a specific version of Boost, you must provide at least the major and minor version numbers, e.g., 1.34")
endif()
if(Boost_FIND_VERSION_EXACT)
# The version may appear in a directory with or without the patch
# level, even when the patch level is non-zero.
set(_boost_TEST_VERSIONS
"${Boost_FIND_VERSION_MAJOR}.${Boost_FIND_VERSION_MINOR}.${Boost_FIND_VERSION_PATCH}"
"${Boost_FIND_VERSION_MAJOR}.${Boost_FIND_VERSION_MINOR}")
else()
# The user has not requested an exact version. Among known
# versions, find those that are acceptable to the user request.
#
# Note: When adding a new Boost release, also update the dependency
# information in _Boost_COMPONENT_DEPENDENCIES and
# _Boost_COMPONENT_HEADERS. See the instructions at the top of
# _Boost_COMPONENT_DEPENDENCIES.
set(_Boost_KNOWN_VERSIONS ${Boost_ADDITIONAL_VERSIONS}
"1.71.0" "1.71" "1.70.0" "1.70" "1.69.0" "1.69"
"1.68.0" "1.68" "1.67.0" "1.67" "1.66.0" "1.66" "1.65.1" "1.65.0" "1.65"
"1.64.0" "1.64" "1.63.0" "1.63" "1.62.0" "1.62" "1.61.0" "1.61" "1.60.0" "1.60"
"1.59.0" "1.59" "1.58.0" "1.58" "1.57.0" "1.57" "1.56.0" "1.56" "1.55.0" "1.55"
"1.54.0" "1.54" "1.53.0" "1.53" "1.52.0" "1.52" "1.51.0" "1.51"
"1.50.0" "1.50" "1.49.0" "1.49" "1.48.0" "1.48" "1.47.0" "1.47" "1.46.1"
"1.46.0" "1.46" "1.45.0" "1.45" "1.44.0" "1.44" "1.43.0" "1.43" "1.42.0" "1.42"
"1.41.0" "1.41" "1.40.0" "1.40" "1.39.0" "1.39" "1.38.0" "1.38" "1.37.0" "1.37"
"1.36.1" "1.36.0" "1.36" "1.35.1" "1.35.0" "1.35" "1.34.1" "1.34.0"
"1.34" "1.33.1" "1.33.0" "1.33")
set(_boost_TEST_VERSIONS)
if(Boost_FIND_VERSION)
set(_Boost_FIND_VERSION_SHORT "${Boost_FIND_VERSION_MAJOR}.${Boost_FIND_VERSION_MINOR}")
# Select acceptable versions.
foreach(version ${_Boost_KNOWN_VERSIONS})
if(NOT "${version}" VERSION_LESS "${Boost_FIND_VERSION}")
# This version is high enough.
list(APPEND _boost_TEST_VERSIONS "${version}")
elseif("${version}.99" VERSION_EQUAL "${_Boost_FIND_VERSION_SHORT}.99")
# This version is a short-form for the requested version with
# the patch level dropped.
list(APPEND _boost_TEST_VERSIONS "${version}")
endif()
endforeach()
else()
# Any version is acceptable.
set(_boost_TEST_VERSIONS "${_Boost_KNOWN_VERSIONS}")
endif()
endif()
_Boost_DEBUG_PRINT_VAR("${CMAKE_CURRENT_LIST_FILE}" "${CMAKE_CURRENT_LIST_LINE}" "_boost_TEST_VERSIONS")
_Boost_DEBUG_PRINT_VAR("${CMAKE_CURRENT_LIST_FILE}" "${CMAKE_CURRENT_LIST_LINE}" "Boost_USE_MULTITHREADED")
_Boost_DEBUG_PRINT_VAR("${CMAKE_CURRENT_LIST_FILE}" "${CMAKE_CURRENT_LIST_LINE}" "Boost_USE_STATIC_LIBS")
_Boost_DEBUG_PRINT_VAR("${CMAKE_CURRENT_LIST_FILE}" "${CMAKE_CURRENT_LIST_LINE}" "Boost_USE_STATIC_RUNTIME")
_Boost_DEBUG_PRINT_VAR("${CMAKE_CURRENT_LIST_FILE}" "${CMAKE_CURRENT_LIST_LINE}" "Boost_ADDITIONAL_VERSIONS")
_Boost_DEBUG_PRINT_VAR("${CMAKE_CURRENT_LIST_FILE}" "${CMAKE_CURRENT_LIST_LINE}" "Boost_NO_SYSTEM_PATHS")
# Supply Boost_LIB_DIAGNOSTIC_DEFINITIONS as a convenience target. It
# will only contain any interface definitions on WIN32, but is created
# on all platforms to keep end user code free from platform dependent
# code. Also provide convenience targets to disable autolinking and
# enable dynamic linking.
if(NOT TARGET Boost::diagnostic_definitions)
add_library(Boost::diagnostic_definitions INTERFACE IMPORTED)
add_library(Boost::disable_autolinking INTERFACE IMPORTED)
add_library(Boost::dynamic_linking INTERFACE IMPORTED)
set_target_properties(Boost::dynamic_linking PROPERTIES
INTERFACE_COMPILE_DEFINITIONS "BOOST_ALL_DYN_LINK")
endif()
if(WIN32)
# In windows, automatic linking is performed, so you do not have
# to specify the libraries. If you are linking to a dynamic
# runtime, then you can choose to link to either a static or a
# dynamic Boost library, the default is to do a static link. You
# can alter this for a specific library "whatever" by defining
# BOOST_WHATEVER_DYN_LINK to force Boost library "whatever" to be
# linked dynamically. Alternatively you can force all Boost
# libraries to dynamic link by defining BOOST_ALL_DYN_LINK.
# This feature can be disabled for Boost library "whatever" by
# defining BOOST_WHATEVER_NO_LIB, or for all of Boost by defining
# BOOST_ALL_NO_LIB.
# If you want to observe which libraries are being linked against
# then defining BOOST_LIB_DIAGNOSTIC will cause the auto-linking
# code to emit a #pragma message each time a library is selected
# for linking.
set(Boost_LIB_DIAGNOSTIC_DEFINITIONS "-DBOOST_LIB_DIAGNOSTIC")
set_target_properties(Boost::diagnostic_definitions PROPERTIES
INTERFACE_COMPILE_DEFINITIONS "BOOST_LIB_DIAGNOSTIC")
set_target_properties(Boost::disable_autolinking PROPERTIES
INTERFACE_COMPILE_DEFINITIONS "BOOST_ALL_NO_LIB")
endif()
# Patch for GTSAM:
if (POLICY CMP0074)
cmake_policy(GET CMP0074 _Boost_CMP0074)
endif()
if(NOT "x${_Boost_CMP0074}x" STREQUAL "xNEWx")
_Boost_CHECK_SPELLING(Boost_ROOT)
endif()
unset(_Boost_CMP0074)
_Boost_CHECK_SPELLING(Boost_LIBRARYDIR)
_Boost_CHECK_SPELLING(Boost_INCLUDEDIR)
# Collect environment variable inputs as hints. Do not consider changes.
foreach(v BOOSTROOT BOOST_ROOT BOOST_INCLUDEDIR BOOST_LIBRARYDIR)
set(_env $ENV{${v}})
if(_env)
file(TO_CMAKE_PATH "${_env}" _ENV_${v})
else()
set(_ENV_${v} "")
endif()
endforeach()
if(NOT _ENV_BOOST_ROOT AND _ENV_BOOSTROOT)
set(_ENV_BOOST_ROOT "${_ENV_BOOSTROOT}")
endif()
# Collect inputs and cached results. Detect changes since the last run.
if(NOT BOOST_ROOT AND BOOSTROOT)
set(BOOST_ROOT "${BOOSTROOT}")
endif()
set(_Boost_VARS
Showing preview only (374K chars total). Download the full file or copy to clipboard to get everything.
gitextract_x6z1z4d3/ ├── .gitignore ├── LICENSE ├── NOTICE ├── README.md ├── planner/ │ ├── build.sh │ ├── build_thirdparty.sh │ ├── config/ │ │ ├── __init__.py │ │ └── param.py │ ├── lib/ │ │ ├── 3rdparty/ │ │ │ ├── gtsam-4.1.1/ │ │ │ │ ├── .github/ │ │ │ │ │ ├── ISSUE_TEMPLATE/ │ │ │ │ │ │ ├── bug-report.md │ │ │ │ │ │ ├── feature-request.md │ │ │ │ │ │ └── questions-help-support.md │ │ │ │ │ ├── scripts/ │ │ │ │ │ │ ├── boost.sh │ │ │ │ │ │ ├── python.sh │ │ │ │ │ │ └── unix.sh │ │ │ │ │ └── workflows/ │ │ │ │ │ ├── build-linux.yml │ │ │ │ │ ├── build-macos.yml │ │ │ │ │ ├── build-python.yml │ │ │ │ │ ├── build-special.yml │ │ │ │ │ ├── build-windows.yml │ │ │ │ │ └── trigger-python.yml │ │ │ │ ├── .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 │ │ │ │ │ ├── FindEigen3.cmake │ │ │ │ │ ├── FindGooglePerfTools.cmake │ │ │ │ │ ├── FindMKL.cmake │ │ │ │ │ ├── FindNumPy.cmake │ │ │ │ │ ├── FindTBB.cmake │ │ │ │ │ ├── GTSAMCMakeToolsConfig.cmake │ │ │ │ │ ├── GtsamAddPch.cmake │ │ │ │ │ ├── GtsamBuildTypes.cmake │ │ │ │ │ ├── GtsamMakeConfigFile.cmake │ │ │ │ │ ├── GtsamPrinting.cmake │ │ │ │ │ ├── GtsamTesting.cmake │ │ │ │ │ ├── HandleAllocators.cmake │ │ │ │ │ ├── HandleBoost.cmake │ │ │ │ │ ├── HandleCCache.cmake │ │ │ │ │ ├── HandleCPack.cmake │ │ │ │ │ ├── HandleEigen.cmake │ │ │ │ │ ├── HandleFinalChecks.cmake │ │ │ │ │ ├── HandleGeneralOptions.cmake │ │ │ │ │ ├── HandleGlobalBuildFlags.cmake │ │ │ │ │ ├── HandleMKL.cmake │ │ │ │ │ ├── HandleMetis.cmake │ │ │ │ │ ├── HandleOpenMP.cmake │ │ │ │ │ ├── HandlePerfTools.cmake │ │ │ │ │ ├── HandlePrintConfiguration.cmake │ │ │ │ │ ├── HandlePython.cmake │ │ │ │ │ ├── HandleTBB.cmake │ │ │ │ │ ├── HandleUninstall.cmake │ │ │ │ │ ├── README.html │ │ │ │ │ ├── README.md │ │ │ │ │ ├── cmake_uninstall.cmake.in │ │ │ │ │ ├── dllexport.h.in │ │ │ │ │ ├── example_cmake_find_gtsam/ │ │ │ │ │ │ ├── CMakeLists.txt │ │ │ │ │ │ └── main.cpp │ │ │ │ │ └── obsolete/ │ │ │ │ │ ├── FindCppUnitLite.cmake │ │ │ │ │ ├── FindWrap.cmake │ │ │ │ │ └── GtsamTestingObsolete.cmake │ │ │ │ ├── doc/ │ │ │ │ │ ├── .gitignore │ │ │ │ │ ├── CMakeLists.txt │ │ │ │ │ ├── Code/ │ │ │ │ │ │ ├── LocalizationExample2.cpp │ │ │ │ │ │ ├── LocalizationFactor.cpp │ │ │ │ │ │ ├── LocalizationOutput5.txt │ │ │ │ │ │ ├── OdometryExample.cpp │ │ │ │ │ │ ├── OdometryMarginals.cpp │ │ │ │ │ │ ├── OdometryOptimize.cpp │ │ │ │ │ │ ├── OdometryOutput1.txt │ │ │ │ │ │ ├── OdometryOutput2.txt │ │ │ │ │ │ ├── OdometryOutput3.txt │ │ │ │ │ │ ├── PlanarSLAMExample.m │ │ │ │ │ │ ├── PlanarSLAMExample.txt │ │ │ │ │ │ ├── Pose2SLAMExample-graph.m │ │ │ │ │ │ ├── Pose2SLAMExample.cpp │ │ │ │ │ │ ├── Pose2SLAMExample.m │ │ │ │ │ │ ├── Pose3SLAMExample-graph.m │ │ │ │ │ │ ├── SFMExample.m │ │ │ │ │ │ ├── VisualISAMExample.cpp │ │ │ │ │ │ ├── calls.txt │ │ │ │ │ │ ├── print.txt │ │ │ │ │ │ └── whos.txt │ │ │ │ │ ├── CodingGuidelines.docx │ │ │ │ │ ├── CodingGuidelines.lyx │ │ │ │ │ ├── Doxyfile.in │ │ │ │ │ ├── DoxygenLayout.xml │ │ │ │ │ ├── ImuFactor.lyx │ │ │ │ │ ├── LieGroups.lyx │ │ │ │ │ ├── Mathematica/ │ │ │ │ │ │ ├── CalibratedCamera.nb │ │ │ │ │ │ ├── CalibratedStereoCamera.nb │ │ │ │ │ │ ├── Quaternion-Logmap.nb │ │ │ │ │ │ ├── Rot3.nb │ │ │ │ │ │ ├── StereoCamera.nb │ │ │ │ │ │ └── dexpInvL_SE2.nb │ │ │ │ │ ├── cholesky.lyx │ │ │ │ │ ├── common_macros.tex │ │ │ │ │ ├── gtsam-coordinate-frames.lyx │ │ │ │ │ ├── gtsam.bib │ │ │ │ │ ├── gtsam.lyx │ │ │ │ │ ├── images/ │ │ │ │ │ │ └── gtsam-structure.graffle │ │ │ │ │ ├── macros.lyx │ │ │ │ │ ├── math.lyx │ │ │ │ │ ├── refs.bib │ │ │ │ │ ├── stats.html │ │ │ │ │ ├── trustregion.bib │ │ │ │ │ └── trustregion.lyx │ │ │ │ ├── docker/ │ │ │ │ │ ├── README.md │ │ │ │ │ ├── ubuntu-boost-tbb/ │ │ │ │ │ │ ├── Dockerfile │ │ │ │ │ │ └── build.sh │ │ │ │ │ ├── ubuntu-gtsam/ │ │ │ │ │ │ ├── Dockerfile │ │ │ │ │ │ └── build.sh │ │ │ │ │ ├── ubuntu-gtsam-python/ │ │ │ │ │ │ ├── Dockerfile │ │ │ │ │ │ └── build.sh │ │ │ │ │ └── ubuntu-gtsam-python-vnc/ │ │ │ │ │ ├── Dockerfile │ │ │ │ │ ├── bootstrap.sh │ │ │ │ │ ├── build.sh │ │ │ │ │ └── vnc.sh │ │ │ │ ├── examples/ │ │ │ │ │ ├── CMakeLists.txt │ │ │ │ │ ├── CameraResectioning.cpp │ │ │ │ │ ├── CombinedImuFactorsExample.cpp │ │ │ │ │ ├── CreateSFMExampleData.cpp │ │ │ │ │ ├── Data/ │ │ │ │ │ │ ├── .gitignore │ │ │ │ │ │ ├── Balbianello.out │ │ │ │ │ │ ├── HS21.QPS │ │ │ │ │ │ ├── HS268.QPS │ │ │ │ │ │ ├── HS35.QPS │ │ │ │ │ │ ├── HS35MOD.QPS │ │ │ │ │ │ ├── HS51.QPS │ │ │ │ │ │ ├── HS52.QPS │ │ │ │ │ │ ├── Klaus3.g2o │ │ │ │ │ │ ├── Plaza1_.mat │ │ │ │ │ │ ├── Plaza2_.mat │ │ │ │ │ │ ├── QPExample.QPS │ │ │ │ │ │ ├── QPTEST.QPS │ │ │ │ │ │ ├── example.graph │ │ │ │ │ │ ├── example_with_vertices.g2o │ │ │ │ │ │ ├── imuAndGPSdata.csv │ │ │ │ │ │ ├── quadraped_imu_data.csv │ │ │ │ │ │ ├── randomGrid3D.xml │ │ │ │ │ │ ├── sphere_smallnoise.graph │ │ │ │ │ │ ├── toy3D.xml │ │ │ │ │ │ ├── toyExample.g2o │ │ │ │ │ │ ├── w100.graph │ │ │ │ │ │ └── w10000.graph │ │ │ │ │ ├── DiscreteBayesNetExample.cpp │ │ │ │ │ ├── DiscreteBayesNet_FG.cpp │ │ │ │ │ ├── FisheyeExample.cpp │ │ │ │ │ ├── HMMExample.cpp │ │ │ │ │ ├── IMUKittiExampleGPS.cpp │ │ │ │ │ ├── ISAM2Example_SmartFactor.cpp │ │ │ │ │ ├── ImuFactorsExample.cpp │ │ │ │ │ ├── ImuFactorsExample2.cpp │ │ │ │ │ ├── InverseKinematicsExampleExpressions.cpp │ │ │ │ │ ├── LocalizationExample.cpp │ │ │ │ │ ├── METISOrderingExample.cpp │ │ │ │ │ ├── OdometryExample.cpp │ │ │ │ │ ├── PlanarSLAMExample.cpp │ │ │ │ │ ├── Pose2SLAMExample.cpp │ │ │ │ │ ├── Pose2SLAMExampleExpressions.cpp │ │ │ │ │ ├── Pose2SLAMExample_g2o.cpp │ │ │ │ │ ├── Pose2SLAMExample_graph.cpp │ │ │ │ │ ├── Pose2SLAMExample_graphviz.cpp │ │ │ │ │ ├── Pose2SLAMExample_lago.cpp │ │ │ │ │ ├── Pose2SLAMStressTest.cpp │ │ │ │ │ ├── Pose2SLAMwSPCG.cpp │ │ │ │ │ ├── Pose3Localization.cpp │ │ │ │ │ ├── Pose3SLAMExampleExpressions_BearingRangeWithTransform.cpp │ │ │ │ │ ├── Pose3SLAMExample_changeKeys.cpp │ │ │ │ │ ├── Pose3SLAMExample_g2o.cpp │ │ │ │ │ ├── Pose3SLAMExample_initializePose3Chordal.cpp │ │ │ │ │ ├── Pose3SLAMExample_initializePose3Gradient.cpp │ │ │ │ │ ├── README.md │ │ │ │ │ ├── RangeISAMExample_plaza2.cpp │ │ │ │ │ ├── SFMExample.cpp │ │ │ │ │ ├── SFMExampleExpressions.cpp │ │ │ │ │ ├── SFMExampleExpressions_bal.cpp │ │ │ │ │ ├── SFMExample_SmartFactor.cpp │ │ │ │ │ ├── SFMExample_SmartFactorPCG.cpp │ │ │ │ │ ├── SFMExample_bal.cpp │ │ │ │ │ ├── SFMExample_bal_COLAMD_METIS.cpp │ │ │ │ │ ├── SFMdata.h │ │ │ │ │ ├── SelfCalibrationExample.cpp │ │ │ │ │ ├── ShonanAveragingCLI.cpp │ │ │ │ │ ├── SimpleRotation.cpp │ │ │ │ │ ├── SolverComparer.cpp │ │ │ │ │ ├── StereoVOExample.cpp │ │ │ │ │ ├── StereoVOExample_large.cpp │ │ │ │ │ ├── TimeTBB.cpp │ │ │ │ │ ├── UGM_chain.cpp │ │ │ │ │ ├── UGM_small.cpp │ │ │ │ │ ├── VisualISAM2Example.cpp │ │ │ │ │ ├── VisualISAMExample.cpp │ │ │ │ │ ├── easyPoint2KalmanFilter.cpp │ │ │ │ │ └── elaboratePoint2KalmanFilter.cpp │ │ │ │ ├── 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 │ │ │ │ │ │ │ │ │ ├── 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 │ │ │ │ │ │ │ │ │ └── obj/ │ │ │ │ │ │ │ │ │ └── x86/ │ │ │ │ │ │ │ │ │ └── Debug/ │ │ │ │ │ │ │ │ │ ├── .NETFramework,Version=v4.0,Profile=Client.AssemblyAttributes.cs │ │ │ │ │ │ │ │ │ └── Projections.csproj.AssemblyReference.cache │ │ │ │ │ │ │ │ └── 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 │ │ │ │ │ │ ├── base.i │ │ │ │ │ │ ├── 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 │ │ │ │ │ │ └── utilities.h │ │ │ │ │ ├── basis/ │ │ │ │ │ │ ├── Basis.h │ │ │ │ │ │ ├── BasisFactors.h │ │ │ │ │ │ ├── CMakeLists.txt │ │ │ │ │ │ ├── Chebyshev.cpp │ │ │ │ │ │ ├── Chebyshev.h │ │ │ │ │ │ ├── Chebyshev2.cpp │ │ │ │ │ │ ├── Chebyshev2.h │ │ │ │ │ │ ├── FitBasis.h │ │ │ │ │ │ ├── Fourier.h │ │ │ │ │ │ ├── ParameterMatrix.h │ │ │ │ │ │ ├── basis.i │ │ │ │ │ │ └── tests/ │ │ │ │ │ │ ├── CMakeLists.txt │ │ │ │ │ │ ├── testChebyshev.cpp │ │ │ │ │ │ ├── testChebyshev2.cpp │ │ │ │ │ │ ├── testFourier.cpp │ │ │ │ │ │ └── testParameterMatrix.cpp │ │ │ │ │ ├── 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 │ │ │ │ │ │ ├── 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 │ │ │ │ │ │ ├── Cal3.cpp │ │ │ │ │ │ ├── Cal3.h │ │ │ │ │ │ ├── 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 │ │ │ │ │ │ ├── Similarity3.cpp │ │ │ │ │ │ ├── Similarity3.h │ │ │ │ │ │ ├── SimpleCamera.cpp │ │ │ │ │ │ ├── SimpleCamera.h │ │ │ │ │ │ ├── StereoCamera.cpp │ │ │ │ │ │ ├── StereoCamera.h │ │ │ │ │ │ ├── StereoPoint2.cpp │ │ │ │ │ │ ├── StereoPoint2.h │ │ │ │ │ │ ├── Unit3.cpp │ │ │ │ │ │ ├── Unit3.h │ │ │ │ │ │ ├── concepts.h │ │ │ │ │ │ ├── geometry.i │ │ │ │ │ │ ├── tests/ │ │ │ │ │ │ │ ├── CMakeLists.txt │ │ │ │ │ │ │ ├── testBearingRange.cpp │ │ │ │ │ │ │ ├── testCal3Bundler.cpp │ │ │ │ │ │ │ ├── testCal3DFisheye.cpp │ │ │ │ │ │ │ ├── testCal3DS2.cpp │ │ │ │ │ │ │ ├── testCal3Unified.cpp │ │ │ │ │ │ │ ├── testCal3_S2.cpp │ │ │ │ │ │ │ ├── testCal3_S2Stereo.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 │ │ │ │ │ │ │ ├── testSimilarity3.cpp │ │ │ │ │ │ │ ├── testSimpleCamera.cpp │ │ │ │ │ │ │ ├── testStereoCamera.cpp │ │ │ │ │ │ │ ├── testStereoPoint2.cpp │ │ │ │ │ │ │ ├── testTriangulation.cpp │ │ │ │ │ │ │ ├── testUnit3.cpp │ │ │ │ │ │ │ └── testUtilities.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/ │ │ │ │ │ │ ├── AcceleratedPowerMethod.h │ │ │ │ │ │ ├── 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 │ │ │ │ │ │ ├── PowerMethod.h │ │ │ │ │ │ ├── Preconditioner.cpp │ │ │ │ │ │ ├── Preconditioner.h │ │ │ │ │ │ ├── RegularHessianFactor.h │ │ │ │ │ │ ├── RegularJacobianFactor.h │ │ │ │ │ │ ├── Sampler.cpp │ │ │ │ │ │ ├── Sampler.h │ │ │ │ │ │ ├── Scatter.cpp │ │ │ │ │ │ ├── Scatter.h │ │ │ │ │ │ ├── SparseEigen.h │ │ │ │ │ │ ├── SubgraphBuilder.cpp │ │ │ │ │ │ ├── SubgraphBuilder.h │ │ │ │ │ │ ├── SubgraphPreconditioner.cpp │ │ │ │ │ │ ├── SubgraphPreconditioner.h │ │ │ │ │ │ ├── SubgraphSolver.cpp │ │ │ │ │ │ ├── SubgraphSolver.h │ │ │ │ │ │ ├── VectorValues.cpp │ │ │ │ │ │ ├── VectorValues.h │ │ │ │ │ │ ├── iterative-inl.h │ │ │ │ │ │ ├── iterative.cpp │ │ │ │ │ │ ├── iterative.h │ │ │ │ │ │ ├── linear.i │ │ │ │ │ │ ├── linearAlgorithms-inst.h │ │ │ │ │ │ ├── linearExceptions.cpp │ │ │ │ │ │ ├── linearExceptions.h │ │ │ │ │ │ └── tests/ │ │ │ │ │ │ ├── CMakeLists.txt │ │ │ │ │ │ ├── powerMethodExample.h │ │ │ │ │ │ ├── testAcceleratedPowerMethod.cpp │ │ │ │ │ │ ├── testErrors.cpp │ │ │ │ │ │ ├── testGaussianBayesNet.cpp │ │ │ │ │ │ ├── testGaussianBayesTree.cpp │ │ │ │ │ │ ├── testGaussianConditional.cpp │ │ │ │ │ │ ├── testGaussianDensity.cpp │ │ │ │ │ │ ├── testGaussianFactorGraph.cpp │ │ │ │ │ │ ├── testHessianFactor.cpp │ │ │ │ │ │ ├── testJacobianFactor.cpp │ │ │ │ │ │ ├── testKalmanFilter.cpp │ │ │ │ │ │ ├── testNoiseModel.cpp │ │ │ │ │ │ ├── testPowerMethod.cpp │ │ │ │ │ │ ├── testRegularHessianFactor.cpp │ │ │ │ │ │ ├── testRegularJacobianFactor.cpp │ │ │ │ │ │ ├── testSampler.cpp │ │ │ │ │ │ ├── testScatter.cpp │ │ │ │ │ │ ├── testSerializationLinear.cpp │ │ │ │ │ │ ├── testSparseEigen.cpp │ │ │ │ │ │ └── testVectorValues.cpp │ │ │ │ │ ├── mainpage.dox │ │ │ │ │ ├── navigation/ │ │ │ │ │ │ ├── .gitignore │ │ │ │ │ │ ├── AHRSFactor.cpp │ │ │ │ │ │ ├── AHRSFactor.h │ │ │ │ │ │ ├── AttitudeFactor.cpp │ │ │ │ │ │ ├── AttitudeFactor.h │ │ │ │ │ │ ├── CMakeLists.txt │ │ │ │ │ │ ├── CombinedImuFactor.cpp │ │ │ │ │ │ ├── CombinedImuFactor.h │ │ │ │ │ │ ├── ConstantVelocityFactor.h │ │ │ │ │ │ ├── GPSFactor.cpp │ │ │ │ │ │ ├── GPSFactor.h │ │ │ │ │ │ ├── ImuBias.cpp │ │ │ │ │ │ ├── ImuBias.h │ │ │ │ │ │ ├── ImuFactor.cpp │ │ │ │ │ │ ├── ImuFactor.h │ │ │ │ │ │ ├── MagFactor.h │ │ │ │ │ │ ├── MagPoseFactor.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 │ │ │ │ │ │ ├── navigation.i │ │ │ │ │ │ └── tests/ │ │ │ │ │ │ ├── CMakeLists.txt │ │ │ │ │ │ ├── imuFactorTesting.h │ │ │ │ │ │ ├── testAHRSFactor.cpp │ │ │ │ │ │ ├── testAttitudeFactor.cpp │ │ │ │ │ │ ├── testCombinedImuFactor.cpp │ │ │ │ │ │ ├── testConstantVelocityFactor.cpp │ │ │ │ │ │ ├── testGPSFactor.cpp │ │ │ │ │ │ ├── testGeographicLib.cpp │ │ │ │ │ │ ├── testImuBias.cpp │ │ │ │ │ │ ├── testImuFactor.cpp │ │ │ │ │ │ ├── testImuFactorSerialization.cpp │ │ │ │ │ │ ├── testMagFactor.cpp │ │ │ │ │ │ ├── testMagPoseFactor.cpp │ │ │ │ │ │ ├── testManifoldPreintegration.cpp │ │ │ │ │ │ ├── testNavExpressions.cpp │ │ │ │ │ │ ├── testNavState.cpp │ │ │ │ │ │ ├── testPoseVelocityBias.cpp │ │ │ │ │ │ ├── testScenario.cpp │ │ │ │ │ │ ├── testScenarioRunner.cpp │ │ │ │ │ │ └── testTangentPreintegration.cpp │ │ │ │ │ ├── nonlinear/ │ │ │ │ │ │ ├── AdaptAutoDiff.h │ │ │ │ │ │ ├── CMakeLists.txt │ │ │ │ │ │ ├── CustomFactor.cpp │ │ │ │ │ │ ├── CustomFactor.h │ │ │ │ │ │ ├── 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 │ │ │ │ │ │ ├── GncOptimizer.h │ │ │ │ │ │ ├── GncParams.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 │ │ │ │ │ │ ├── nonlinear.i │ │ │ │ │ │ ├── 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 │ │ │ │ │ │ ├── sam.i │ │ │ │ │ │ └── tests/ │ │ │ │ │ │ ├── CMakeLists.txt │ │ │ │ │ │ ├── testBearingFactor.cpp │ │ │ │ │ │ ├── testBearingRangeFactor.cpp │ │ │ │ │ │ └── testRangeFactor.cpp │ │ │ │ │ ├── sfm/ │ │ │ │ │ │ ├── BinaryMeasurement.h │ │ │ │ │ │ ├── CMakeLists.txt │ │ │ │ │ │ ├── MFAS.cpp │ │ │ │ │ │ ├── MFAS.h │ │ │ │ │ │ ├── ShonanAveraging.cpp │ │ │ │ │ │ ├── ShonanAveraging.h │ │ │ │ │ │ ├── ShonanFactor.cpp │ │ │ │ │ │ ├── ShonanFactor.h │ │ │ │ │ │ ├── ShonanGaugeFactor.h │ │ │ │ │ │ ├── TranslationFactor.h │ │ │ │ │ │ ├── TranslationRecovery.cpp │ │ │ │ │ │ ├── TranslationRecovery.h │ │ │ │ │ │ ├── sfm.i │ │ │ │ │ │ └── tests/ │ │ │ │ │ │ ├── CMakeLists.txt │ │ │ │ │ │ ├── testBinaryMeasurement.cpp │ │ │ │ │ │ ├── testMFAS.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 │
Showing preview only (1,791K chars total). Download the full file or copy to clipboard to get everything.
SYMBOL INDEX (19545 symbols across 2835 files)
FILE: planner/config/param.py
class ConfigPlanner (line 1) | class ConfigPlanner():
class ConfigWrapper (line 6) | class ConfigWrapper():
class Config (line 10) | class Config():
FILE: planner/lib/3rdparty/gtsam-4.1.1/CppUnitLite/Failure.h
function class (line 28) | class Failure
FILE: planner/lib/3rdparty/gtsam-4.1.1/CppUnitLite/Test.cpp
function Test (line 33) | Test *Test::getNext() const
FILE: planner/lib/3rdparty/gtsam-4.1.1/CppUnitLite/Test.h
function class (line 30) | class Test
FILE: planner/lib/3rdparty/gtsam-4.1.1/CppUnitLite/TestRegistry.cpp
function TestRegistry (line 33) | TestRegistry& TestRegistry::instance ()
FILE: planner/lib/3rdparty/gtsam-4.1.1/CppUnitLite/TestRegistry.h
function class (line 29) | class TestRegistry
FILE: planner/lib/3rdparty/gtsam-4.1.1/CppUnitLite/TestResult.h
function class (line 26) | class TestResult
FILE: planner/lib/3rdparty/gtsam-4.1.1/cmake/example_cmake_find_gtsam/main.cpp
function main (line 63) | int main(int argc, char** argv) {
FILE: planner/lib/3rdparty/gtsam-4.1.1/doc/Code/LocalizationFactor.cpp
class UnaryFactor (line 1) | class UnaryFactor: public NoiseModelFactor1<Pose2> {
method UnaryFactor (line 5) | UnaryFactor(Key j, double x, double y, const SharedNoiseModel& model):
method Vector (line 8) | Vector evaluateError(const Pose2& q,
FILE: planner/lib/3rdparty/gtsam-4.1.1/examples/CameraResectioning.cpp
class ResectioningFactor (line 33) | class ResectioningFactor: public NoiseModelFactor1<Pose3> {
method ResectioningFactor (line 43) | ResectioningFactor(const SharedNoiseModel& model, const Key& key,
method Vector (line 49) | Vector evaluateError(const Pose3& pose, boost::optional<Matrix&> H =
function main (line 64) | int main(int argc, char* argv[]) {
FILE: planner/lib/3rdparty/gtsam-4.1.1/examples/CombinedImuFactorsExample.cpp
function parseOptions (line 61) | po::variables_map parseOptions(int argc, char* argv[]) {
function Vector10 (line 82) | Vector10 readInitialState(ifstream& file) {
function imuParams (line 97) | boost::shared_ptr<PreintegratedCombinedMeasurements::Params> imuParams() {
function main (line 130) | int main(int argc, char* argv[]) {
FILE: planner/lib/3rdparty/gtsam-4.1.1/examples/CreateSFMExampleData.cpp
function createExampleBALFile (line 29) | void createExampleBALFile(const string& filename, const vector<Point3>& ...
function create5PointExample1 (line 59) | void create5PointExample1() {
function create5PointExample2 (line 76) | void create5PointExample2() {
function create18PointExample1 (line 95) | void create18PointExample1() {
function main (line 115) | int main(int argc, char* argv[]) {
FILE: planner/lib/3rdparty/gtsam-4.1.1/examples/DiscreteBayesNetExample.cpp
function main (line 28) | int main(int argc, char **argv) {
FILE: planner/lib/3rdparty/gtsam-4.1.1/examples/DiscreteBayesNet_FG.cpp
function main (line 33) | int main(int argc, char **argv) {
FILE: planner/lib/3rdparty/gtsam-4.1.1/examples/FisheyeExample.cpp
function main (line 62) | int main(int argc, char *argv[]) {
FILE: planner/lib/3rdparty/gtsam-4.1.1/examples/HMMExample.cpp
function main (line 29) | int main(int argc, char **argv) {
FILE: planner/lib/3rdparty/gtsam-4.1.1/examples/IMUKittiExampleGPS.cpp
type KittiCalibration (line 43) | struct KittiCalibration {
type ImuMeasurement (line 58) | struct ImuMeasurement {
type GpsMeasurement (line 65) | struct GpsMeasurement {
function loadKittiData (line 72) | void loadKittiData(KittiCalibration& kitti_calibration,
function main (line 156) | int main(int argc, char* argv[]) {
FILE: planner/lib/3rdparty/gtsam-4.1.1/examples/ISAM2Example_SmartFactor.cpp
function main (line 24) | int main(int argc, char* argv[]) {
FILE: planner/lib/3rdparty/gtsam-4.1.1/examples/ImuFactorsExample.cpp
function parseOptions (line 64) | po::variables_map parseOptions(int argc, char* argv[]) {
function imuParams (line 85) | boost::shared_ptr<PreintegratedCombinedMeasurements::Params> imuParams() {
function main (line 118) | int main(int argc, char* argv[]) {
FILE: planner/lib/3rdparty/gtsam-4.1.1/examples/ImuFactorsExample2.cpp
function main (line 39) | int main(int argc, char* argv[]) {
FILE: planner/lib/3rdparty/gtsam-4.1.1/examples/InverseKinematicsExampleExpressions.cpp
function Vector3 (line 33) | inline Vector3 scalarMultiply(const double& s, const Vector3& v,
function Vector3_ (line 42) | inline Vector3_ operator*(const Double_& s, const Vector3_& v) {
function Pose2_ (line 47) | inline Pose2_ Expmap(const Vector3_& xi) { return Pose2_(&Pose2::Expmap,...
function main (line 50) | int main(int argc, char** argv) {
FILE: planner/lib/3rdparty/gtsam-4.1.1/examples/LocalizationExample.cpp
class UnaryFactor (line 68) | class UnaryFactor: public NoiseModelFactor1<Pose2> {
method UnaryFactor (line 78) | UnaryFactor(Key j, double x, double y, const SharedNoiseModel& model):
method Vector (line 87) | Vector evaluateError(const Pose2& q, boost::optional<Matrix&> H = boos...
method clone (line 103) | gtsam::NonlinearFactor::shared_ptr clone() const override {
function main (line 113) | int main(int argc, char** argv) {
FILE: planner/lib/3rdparty/gtsam-4.1.1/examples/METISOrderingExample.cpp
function main (line 35) | int main(int argc, char** argv) {
FILE: planner/lib/3rdparty/gtsam-4.1.1/examples/OdometryExample.cpp
function main (line 58) | int main(int argc, char** argv) {
FILE: planner/lib/3rdparty/gtsam-4.1.1/examples/PlanarSLAMExample.cpp
function main (line 71) | int main(int argc, char** argv) {
FILE: planner/lib/3rdparty/gtsam-4.1.1/examples/Pose2SLAMExample.cpp
function main (line 66) | int main(int argc, char** argv) {
FILE: planner/lib/3rdparty/gtsam-4.1.1/examples/Pose2SLAMExampleExpressions.cpp
function main (line 32) | int main(int argc, char** argv) {
FILE: planner/lib/3rdparty/gtsam-4.1.1/examples/Pose2SLAMExample_g2o.cpp
function main (line 30) | int main(const int argc, const char *argv[]) {
FILE: planner/lib/3rdparty/gtsam-4.1.1/examples/Pose2SLAMExample_graph.cpp
function main (line 31) | int main (int argc, char** argv) {
FILE: planner/lib/3rdparty/gtsam-4.1.1/examples/Pose2SLAMExample_graphviz.cpp
function main (line 28) | int main(int argc, char** argv) {
FILE: planner/lib/3rdparty/gtsam-4.1.1/examples/Pose2SLAMExample_lago.cpp
function main (line 30) | int main(const int argc, const char *argv[]) {
FILE: planner/lib/3rdparty/gtsam-4.1.1/examples/Pose2SLAMStressTest.cpp
function testGtsam (line 29) | void testGtsam(int numberNodes) {
function main (line 78) | int main(int args, char* argv[]) {
FILE: planner/lib/3rdparty/gtsam-4.1.1/examples/Pose2SLAMwSPCG.cpp
function main (line 30) | int main(int argc, char** argv) {
FILE: planner/lib/3rdparty/gtsam-4.1.1/examples/Pose3Localization.cpp
function main (line 29) | int main(const int argc, const char* argv[]) {
FILE: planner/lib/3rdparty/gtsam-4.1.1/examples/Pose3SLAMExampleExpressions_BearingRangeWithTransform.cpp
function main (line 21) | int main(int argc, char* argv[]) {
FILE: planner/lib/3rdparty/gtsam-4.1.1/examples/Pose3SLAMExample_changeKeys.cpp
function main (line 27) | int main(const int argc, const char *argv[]) {
FILE: planner/lib/3rdparty/gtsam-4.1.1/examples/Pose3SLAMExample_g2o.cpp
function main (line 28) | int main(const int argc, const char* argv[]) {
FILE: planner/lib/3rdparty/gtsam-4.1.1/examples/Pose3SLAMExample_initializePose3Chordal.cpp
function main (line 28) | int main(const int argc, const char* argv[]) {
FILE: planner/lib/3rdparty/gtsam-4.1.1/examples/Pose3SLAMExample_initializePose3Gradient.cpp
function main (line 28) | int main(const int argc, const char* argv[]) {
FILE: planner/lib/3rdparty/gtsam-4.1.1/examples/RangeISAMExample_plaza2.cpp
function readOdometry (line 59) | list<TimedOdometry> readOdometry() {
function readTriples (line 77) | vector<RangeTriple> readTriples() {
function main (line 93) | int main (int argc, char** argv) {
FILE: planner/lib/3rdparty/gtsam-4.1.1/examples/SFMExample.cpp
function main (line 58) | int main(int argc, char* argv[]) {
FILE: planner/lib/3rdparty/gtsam-4.1.1/examples/SFMExampleExpressions.cpp
function main (line 43) | int main(int argc, char* argv[]) {
FILE: planner/lib/3rdparty/gtsam-4.1.1/examples/SFMExampleExpressions_bal.cpp
function main (line 43) | int main(int argc, char* argv[]) {
FILE: planner/lib/3rdparty/gtsam-4.1.1/examples/SFMExample_SmartFactor.cpp
function main (line 41) | int main(int argc, char* argv[]) {
FILE: planner/lib/3rdparty/gtsam-4.1.1/examples/SFMExample_SmartFactorPCG.cpp
function main (line 37) | int main(int argc, char* argv[]) {
FILE: planner/lib/3rdparty/gtsam-4.1.1/examples/SFMExample_bal.cpp
function main (line 37) | int main (int argc, char* argv[]) {
FILE: planner/lib/3rdparty/gtsam-4.1.1/examples/SFMExample_bal_COLAMD_METIS.cpp
function main (line 42) | int main(int argc, char* argv[]) {
FILE: planner/lib/3rdparty/gtsam-4.1.1/examples/SelfCalibrationExample.cpp
function main (line 44) | int main(int argc, char* argv[]) {
FILE: planner/lib/3rdparty/gtsam-4.1.1/examples/ShonanAveragingCLI.cpp
function main (line 45) | int main(int argc, char* argv[]) {
FILE: planner/lib/3rdparty/gtsam-4.1.1/examples/SimpleRotation.cpp
function main (line 61) | int main() {
FILE: planner/lib/3rdparty/gtsam-4.1.1/examples/SolverComparer.cpp
function chi2_red (line 76) | double chi2_red(const gtsam::NonlinearFactorGraph& graph, const gtsam::V...
function main (line 117) | int main(int argc, char *argv[]) {
function runIncremental (line 245) | void runIncremental()
function runBatch (line 469) | void runBatch()
function runCompare (line 514) | void runCompare()
function runPerturb (line 554) | void runPerturb()
function runStats (line 585) | void runStats()
FILE: planner/lib/3rdparty/gtsam-4.1.1/examples/StereoVOExample.cpp
function main (line 37) | int main(int argc, char** argv) {
FILE: planner/lib/3rdparty/gtsam-4.1.1/examples/StereoVOExample_large.cpp
function main (line 44) | int main(int argc, char** argv) {
FILE: planner/lib/3rdparty/gtsam-4.1.1/examples/TimeTBB.cpp
type ResultWithThreads (line 44) | struct ResultWithThreads
type WorkerWithoutAllocation (line 54) | struct WorkerWithoutAllocation
method WorkerWithoutAllocation (line 58) | WorkerWithoutAllocation(vector<double>& results) : results(results) {}
function testWithoutMemoryAllocation (line 73) | map<int, double> testWithoutMemoryAllocation(int num_threads)
type WorkerWithAllocation (line 106) | struct WorkerWithAllocation
method WorkerWithAllocation (line 110) | WorkerWithAllocation(vector<double>& results) : results(results) {}
function testWithMemoryAllocation (line 137) | map<int, double> testWithMemoryAllocation(int num_threads)
function main (line 170) | int main(int argc, char* argv[])
function main (line 214) | int main(int argc, char* argv [])
FILE: planner/lib/3rdparty/gtsam-4.1.1/examples/UGM_chain.cpp
function main (line 31) | int main(int argc, char** argv) {
FILE: planner/lib/3rdparty/gtsam-4.1.1/examples/UGM_small.cpp
function main (line 27) | int main(int argc, char** argv) {
FILE: planner/lib/3rdparty/gtsam-4.1.1/examples/VisualISAM2Example.cpp
function main (line 58) | int main(int argc, char* argv[]) {
FILE: planner/lib/3rdparty/gtsam-4.1.1/examples/VisualISAMExample.cpp
function main (line 58) | int main(int argc, char* argv[]) {
FILE: planner/lib/3rdparty/gtsam-4.1.1/examples/easyPoint2KalmanFilter.cpp
function main (line 36) | int main() {
FILE: planner/lib/3rdparty/gtsam-4.1.1/examples/elaboratePoint2KalmanFilter.cpp
function main (line 35) | int main() {
FILE: planner/lib/3rdparty/gtsam-4.1.1/gtsam/3rdparty/CCOLAMD/Demo/ccolamd_example.c
function main (line 47) | int main (void)
FILE: planner/lib/3rdparty/gtsam-4.1.1/gtsam/3rdparty/CCOLAMD/Demo/ccolamd_l_example.c
function main (line 47) | int main (void)
FILE: planner/lib/3rdparty/gtsam-4.1.1/gtsam/3rdparty/CCOLAMD/MATLAB/ccolamdmex.c
function mexFunction (line 33) | void mexFunction
FILE: planner/lib/3rdparty/gtsam-4.1.1/gtsam/3rdparty/CCOLAMD/MATLAB/ccolamdtestmex.c
function dump_matrix (line 60) | static void dump_matrix
function mexFunction (line 91) | void mexFunction
FILE: planner/lib/3rdparty/gtsam-4.1.1/gtsam/3rdparty/CCOLAMD/MATLAB/csymamdmex.c
function mexFunction (line 32) | void mexFunction
FILE: planner/lib/3rdparty/gtsam-4.1.1/gtsam/3rdparty/CCOLAMD/MATLAB/csymamdtestmex.c
function dump_matrix (line 46) | static void dump_matrix
function mexFunction (line 89) | void mexFunction
FILE: planner/lib/3rdparty/gtsam-4.1.1/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: planner/lib/3rdparty/gtsam-4.1.1/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: planner/lib/3rdparty/gtsam-4.1.1/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: planner/lib/3rdparty/gtsam-4.1.1/gtsam/3rdparty/Eigen/Eigen/src/Cholesky/LLT_LAPACKE.h
function namespace (line 36) | namespace Eigen {
FILE: planner/lib/3rdparty/gtsam-4.1.1/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: planner/lib/3rdparty/gtsam-4.1.1/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: planner/lib/3rdparty/gtsam-4.1.1/gtsam/3rdparty/Eigen/Eigen/src/Core/ArrayBase.h
function namespace (line 13) | namespace Eigen {
FILE: planner/lib/3rdparty/gtsam-4.1.1/gtsam/3rdparty/Eigen/Eigen/src/Core/ArrayWrapper.h
function namespace (line 13) | namespace Eigen {
FILE: planner/lib/3rdparty/gtsam-4.1.1/gtsam/3rdparty/Eigen/Eigen/src/Core/Assign.h
function namespace (line 15) | namespace Eigen {
FILE: planner/lib/3rdparty/gtsam-4.1.1/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: planner/lib/3rdparty/gtsam-4.1.1/gtsam/3rdparty/Eigen/Eigen/src/Core/Assign_MKL.h
function namespace (line 37) | namespace Eigen {
FILE: planner/lib/3rdparty/gtsam-4.1.1/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: planner/lib/3rdparty/gtsam-4.1.1/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: planner/lib/3rdparty/gtsam-4.1.1/gtsam/3rdparty/Eigen/Eigen/src/Core/BooleanRedux.h
function namespace (line 13) | namespace Eigen {
FILE: planner/lib/3rdparty/gtsam-4.1.1/gtsam/3rdparty/Eigen/Eigen/src/Core/CommaInitializer.h
function namespace (line 14) | namespace Eigen {
function EIGEN_DEVICE_FUNC (line 116) | EIGEN_DEVICE_FUNC
FILE: planner/lib/3rdparty/gtsam-4.1.1/gtsam/3rdparty/Eigen/Eigen/src/Core/ConditionEstimator.h
function namespace (line 13) | namespace Eigen {
FILE: planner/lib/3rdparty/gtsam-4.1.1/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: planner/lib/3rdparty/gtsam-4.1.1/gtsam/3rdparty/Eigen/Eigen/src/Core/CoreIterators.h
function namespace (line 13) | namespace Eigen {
FILE: planner/lib/3rdparty/gtsam-4.1.1/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: planner/lib/3rdparty/gtsam-4.1.1/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: planner/lib/3rdparty/gtsam-4.1.1/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: planner/lib/3rdparty/gtsam-4.1.1/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: planner/lib/3rdparty/gtsam-4.1.1/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: planner/lib/3rdparty/gtsam-4.1.1/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: planner/lib/3rdparty/gtsam-4.1.1/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: planner/lib/3rdparty/gtsam-4.1.1/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: planner/lib/3rdparty/gtsam-4.1.1/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: planner/lib/3rdparty/gtsam-4.1.1/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: planner/lib/3rdparty/gtsam-4.1.1/gtsam/3rdparty/Eigen/Eigen/src/Core/DiagonalProduct.h
function namespace (line 14) | namespace Eigen {
FILE: planner/lib/3rdparty/gtsam-4.1.1/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: planner/lib/3rdparty/gtsam-4.1.1/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: planner/lib/3rdparty/gtsam-4.1.1/gtsam/3rdparty/Eigen/Eigen/src/Core/ForceAlignedAccess.h
function namespace (line 13) | namespace Eigen {
FILE: planner/lib/3rdparty/gtsam-4.1.1/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: planner/lib/3rdparty/gtsam-4.1.1/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: planner/lib/3rdparty/gtsam-4.1.1/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: planner/lib/3rdparty/gtsam-4.1.1/gtsam/3rdparty/Eigen/Eigen/src/Core/GlobalFunctions.h
function namespace (line 54) | namespace Eigen
FILE: planner/lib/3rdparty/gtsam-4.1.1/gtsam/3rdparty/Eigen/Eigen/src/Core/IO.h
function namespace (line 14) | namespace Eigen {
function namespace (line 112) | namespace internal {
FILE: planner/lib/3rdparty/gtsam-4.1.1/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: planner/lib/3rdparty/gtsam-4.1.1/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: planner/lib/3rdparty/gtsam-4.1.1/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: planner/lib/3rdparty/gtsam-4.1.1/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: planner/lib/3rdparty/gtsam-4.1.1/gtsam/3rdparty/Eigen/Eigen/src/Core/MathFunctionsImpl.h
function namespace (line 14) | namespace Eigen {
FILE: planner/lib/3rdparty/gtsam-4.1.1/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: planner/lib/3rdparty/gtsam-4.1.1/gtsam/3rdparty/Eigen/Eigen/src/Core/MatrixBase.h
function namespace (line 14) | namespace Eigen {
FILE: planner/lib/3rdparty/gtsam-4.1.1/gtsam/3rdparty/Eigen/Eigen/src/Core/NestByValue.h
function namespace (line 14) | namespace Eigen {
FILE: planner/lib/3rdparty/gtsam-4.1.1/gtsam/3rdparty/Eigen/Eigen/src/Core/NoAlias.h
function namespace (line 13) | namespace Eigen {
FILE: planner/lib/3rdparty/gtsam-4.1.1/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: planner/lib/3rdparty/gtsam-4.1.1/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: planner/lib/3rdparty/gtsam-4.1.1/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: planner/lib/3rdparty/gtsam-4.1.1/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: planner/lib/3rdparty/gtsam-4.1.1/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: planner/lib/3rdparty/gtsam-4.1.1/gtsam/3rdparty/Eigen/Eigen/src/Core/Random.h
function namespace (line 15) | namespace internal {
FILE: planner/lib/3rdparty/gtsam-4.1.1/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: planner/lib/3rdparty/gtsam-4.1.1/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: planner/lib/3rdparty/gtsam-4.1.1/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: planner/lib/3rdparty/gtsam-4.1.1/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: planner/lib/3rdparty/gtsam-4.1.1/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: planner/lib/3rdparty/gtsam-4.1.1/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: planner/lib/3rdparty/gtsam-4.1.1/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: planner/lib/3rdparty/gtsam-4.1.1/gtsam/3rdparty/Eigen/Eigen/src/Core/SelfCwiseBinaryOp.h
function namespace (line 13) | namespace Eigen {
FILE: planner/lib/3rdparty/gtsam-4.1.1/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: planner/lib/3rdparty/gtsam-4.1.1/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: planner/lib/3rdparty/gtsam-4.1.1/gtsam/3rdparty/Eigen/Eigen/src/Core/SolverBase.h
function namespace (line 13) | namespace Eigen {
FILE: planner/lib/3rdparty/gtsam-4.1.1/gtsam/3rdparty/Eigen/Eigen/src/Core/StableNorm.h
function namespace (line 13) | namespace Eigen {
FILE: planner/lib/3rdparty/gtsam-4.1.1/gtsam/3rdparty/Eigen/Eigen/src/Core/Stride.h
function namespace (line 13) | namespace Eigen {
FILE: planner/lib/3rdparty/gtsam-4.1.1/gtsam/3rdparty/Eigen/Eigen/src/Core/Swap.h
function namespace (line 13) | namespace Eigen {
FILE: planner/lib/3rdparty/gtsam-4.1.1/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: planner/lib/3rdparty/gtsam-4.1.1/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: planner/lib/3rdparty/gtsam-4.1.1/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: planner/lib/3rdparty/gtsam-4.1.1/gtsam/3rdparty/Eigen/Eigen/src/Core/VectorBlock.h
function namespace (line 14) | namespace Eigen {
FILE: planner/lib/3rdparty/gtsam-4.1.1/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: planner/lib/3rdparty/gtsam-4.1.1/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: planner/lib/3rdparty/gtsam-4.1.1/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: planner/lib/3rdparty/gtsam-4.1.1/gtsam/3rdparty/Eigen/Eigen/src/Core/arch/AVX/MathFunctions.h
function namespace (line 17) | namespace Eigen {
FILE: planner/lib/3rdparty/gtsam-4.1.1/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: planner/lib/3rdparty/gtsam-4.1.1/gtsam/3rdparty/Eigen/Eigen/src/Core/arch/AVX/TypeCasting.h
function namespace (line 13) | namespace Eigen {
FILE: planner/lib/3rdparty/gtsam-4.1.1/gtsam/3rdparty/Eigen/Eigen/src/Core/arch/AVX512/MathFunctions.h
function namespace (line 13) | namespace Eigen {
FILE: planner/lib/3rdparty/gtsam-4.1.1/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: planner/lib/3rdparty/gtsam-4.1.1/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: planner/lib/3rdparty/gtsam-4.1.1/gtsam/3rdparty/Eigen/Eigen/src/Core/arch/AltiVec/MathFunctions.h
function namespace (line 19) | namespace Eigen {
FILE: planner/lib/3rdparty/gtsam-4.1.1/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: planner/lib/3rdparty/gtsam-4.1.1/gtsam/3rdparty/Eigen/Eigen/src/Core/arch/CUDA/Complex.h
function namespace (line 15) | namespace Eigen {
FILE: planner/lib/3rdparty/gtsam-4.1.1/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: planner/lib/3rdparty/gtsam-4.1.1/gtsam/3rdparty/Eigen/Eigen/src/Core/arch/CUDA/MathFunctions.h
function namespace (line 13) | namespace Eigen {
FILE: planner/lib/3rdparty/gtsam-4.1.1/gtsam/3rdparty/Eigen/Eigen/src/Core/arch/CUDA/PacketMath.h
function namespace (line 13) | namespace Eigen {
FILE: planner/lib/3rdparty/gtsam-4.1.1/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: planner/lib/3rdparty/gtsam-4.1.1/gtsam/3rdparty/Eigen/Eigen/src/Core/arch/CUDA/TypeCasting.h
function namespace (line 13) | namespace Eigen {
FILE: planner/lib/3rdparty/gtsam-4.1.1/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: planner/lib/3rdparty/gtsam-4.1.1/gtsam/3rdparty/Eigen/Eigen/src/Core/arch/NEON/MathFunctions.h
function namespace (line 15) | namespace Eigen {
FILE: planner/lib/3rdparty/gtsam-4.1.1/gtsam/3rdparty/Eigen/Eigen/src/Core/arch/NEON/PacketMath.h
function namespace (line 15) | namespace Eigen {
FILE: planner/lib/3rdparty/gtsam-4.1.1/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: planner/lib/3rdparty/gtsam-4.1.1/gtsam/3rdparty/Eigen/Eigen/src/Core/arch/SSE/MathFunctions.h
function namespace (line 18) | namespace Eigen {
FILE: planner/lib/3rdparty/gtsam-4.1.1/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: planner/lib/3rdparty/gtsam-4.1.1/gtsam/3rdparty/Eigen/Eigen/src/Core/arch/SSE/TypeCasting.h
function namespace (line 13) | namespace Eigen {
FILE: planner/lib/3rdparty/gtsam-4.1.1/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: planner/lib/3rdparty/gtsam-4.1.1/gtsam/3rdparty/Eigen/Eigen/src/Core/arch/ZVector/MathFunctions.h
function namespace (line 19) | namespace Eigen {
FILE: planner/lib/3rdparty/gtsam-4.1.1/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: planner/lib/3rdparty/gtsam-4.1.1/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: planner/lib/3rdparty/gtsam-4.1.1/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: planner/lib/3rdparty/gtsam-4.1.1/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: planner/lib/3rdparty/gtsam-4.1.1/gtsam/3rdparty/Eigen/Eigen/src/Core/functors/StlFunctors.h
function namespace (line 13) | namespace Eigen {
FILE: planner/lib/3rdparty/gtsam-4.1.1/gtsam/3rdparty/Eigen/Eigen/src/Core/functors/TernaryFunctors.h
function namespace (line 13) | namespace Eigen {
FILE: planner/lib/3rdparty/gtsam-4.1.1/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: planner/lib/3rdparty/gtsam-4.1.1/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: planner/lib/3rdparty/gtsam-4.1.1/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: planner/lib/3rdparty/gtsam-4.1.1/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: planner/lib/3rdparty/gtsam-4.1.1/gtsam/3rdparty/Eigen/Eigen/src/Core/products/GeneralMatrixMatrixTriangular_BLAS.h
function namespace (line 36) | namespace Eigen {
FILE: planner/lib/3rdparty/gtsam-4.1.1/gtsam/3rdparty/Eigen/Eigen/src/Core/products/GeneralMatrixMatrix_BLAS.h
function namespace (line 38) | namespace internal {
FILE: planner/lib/3rdparty/gtsam-4.1.1/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: planner/lib/3rdparty/gtsam-4.1.1/gtsam/3rdparty/Eigen/Eigen/src/Core/products/GeneralMatrixVector_BLAS.h
function namespace (line 36) | namespace Eigen {
FILE: planner/lib/3rdparty/gtsam-4.1.1/gtsam/3rdparty/Eigen/Eigen/src/Core/products/Parallelizer.h
function namespace (line 13) | namespace Eigen {
FILE: planner/lib/3rdparty/gtsam-4.1.1/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: planner/lib/3rdparty/gtsam-4.1.1/gtsam/3rdparty/Eigen/Eigen/src/Core/products/SelfadjointMatrixVector.h
function namespace (line 13) | namespace Eigen {
function namespace (line 160) | namespace internal {
FILE: planner/lib/3rdparty/gtsam-4.1.1/gtsam/3rdparty/Eigen/Eigen/src/Core/products/SelfadjointMatrixVector_BLAS.h
function namespace (line 36) | namespace Eigen {
FILE: planner/lib/3rdparty/gtsam-4.1.1/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: planner/lib/3rdparty/gtsam-4.1.1/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: planner/lib/3rdparty/gtsam-4.1.1/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: planner/lib/3rdparty/gtsam-4.1.1/gtsam/3rdparty/Eigen/Eigen/src/Core/products/TriangularMatrixMatrix_BLAS.h
function namespace (line 36) | namespace Eigen {
FILE: planner/lib/3rdparty/gtsam-4.1.1/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: planner/lib/3rdparty/gtsam-4.1.1/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: planner/lib/3rdparty/gtsam-4.1.1/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: planner/lib/3rdparty/gtsam-4.1.1/gtsam/3rdparty/Eigen/Eigen/src/Core/products/TriangularSolverMatrix_BLAS.h
function namespace (line 36) | namespace Eigen {
FILE: planner/lib/3rdparty/gtsam-4.1.1/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: planner/lib/3rdparty/gtsam-4.1.1/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: planner/lib/3rdparty/gtsam-4.1.1/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: planner/lib/3rdparty/gtsam-4.1.1/gtsam/3rdparty/Eigen/Eigen/src/Core/util/ForwardDeclarations.h
function namespace (line 14) | namespace Eigen {
FILE: planner/lib/3rdparty/gtsam-4.1.1/gtsam/3rdparty/Eigen/Eigen/src/Core/util/MKL_support.h
function namespace (line 116) | namespace Eigen {
FILE: planner/lib/3rdparty/gtsam-4.1.1/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: planner/lib/3rdparty/gtsam-4.1.1/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: planner/lib/3rdparty/gtsam-4.1.1/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: planner/lib/3rdparty/gtsam-4.1.1/gtsam/3rdparty/Eigen/Eigen/src/Core/util/StaticAssert.h
function namespace (line 37) | namespace Eigen {
FILE: planner/lib/3rdparty/gtsam-4.1.1/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<
type Matrix (line 614) | typedef Matrix<Scalar, diag_size, 1, ExpressionType::PlainObject::Options
type Array (line 615) | typedef Array<Scalar, diag_size, 1, ExpressionType::PlainObject::Options
type typename (line 617) | typedef typename conditional<
type Array (line 629) | typedef Array<Scalar, traits<Expr>::RowsAtCompileTime, traits<Expr>::...
type Matrix (line 632) | typedef Matrix<Scalar, traits<Expr>::RowsAtCompileTime, traits<Expr>:...
type CwiseNullaryOp (line 635) | typedef CwiseNullaryOp<scalar_constant_op<Scalar>, const
type glue_shapes (line 658) | struct glue_shapes
type TriangularShape (line 658) | typedef TriangularShape type;
type ScalarBinaryOpTraits (line 766) | struct ScalarBinaryOpTraits
type T (line 776) | typedef T ReturnType;
type T (line 782) | typedef T ReturnType;
type T (line 787) | typedef T ReturnType;
type T (line 794) | typedef T ReturnType;
type T (line 801) | typedef T ReturnType;
type ReturnType (line 808) | typedef void ReturnType;
FILE: planner/lib/3rdparty/gtsam-4.1.1/gtsam/3rdparty/Eigen/Eigen/src/Eigenvalues/ComplexEigenSolver.h
function namespace (line 17) | namespace Eigen {
function EigenvalueType (line 182) | const EigenvalueType& eigenvalues() const
function Index (line 233) | Index getMaxIterations()
FILE: planner/lib/3rdparty/gtsam-4.1.1/gtsam/3rdparty/Eigen/Eigen/src/Eigenvalues/ComplexSchur.h
function namespace (line 17) | namespace Eigen {
function ComplexMatrixType (line 162) | const ComplexMatrixType& matrixT() const
function Index (line 235) | Index getMaxIterations()
function namespace (line 349) | namespace internal {
FILE: planner/lib/3rdparty/gtsam-4.1.1/gtsam/3rdparty/Eigen/Eigen/src/Eigenvalues/ComplexSchur_LAPACKE.h
function namespace (line 36) | namespace Eigen {
FILE: planner/lib/3rdparty/gtsam-4.1.1/gtsam/3rdparty/Eigen/Eigen/src/Eigenvalues/EigenSolver.h
function namespace (line 16) | namespace Eigen {
function EigenvalueType (line 244) | const EigenvalueType& eigenvalues() const
function Index (line 295) | Index getMaxIterations()
type Matrix (line 319) | typedef Matrix<Scalar, ColsAtCompileTime, 1, Options
FILE: planner/lib/3rdparty/gtsam-4.1.1/gtsam/3rdparty/Eigen/Eigen/src/Eigenvalues/GeneralizedEigenSolver.h
function namespace (line 17) | namespace Eigen {
FILE: planner/lib/3rdparty/gtsam-4.1.1/gtsam/3rdparty/Eigen/Eigen/src/Eigenvalues/GeneralizedSelfAdjointEigenSolver.h
function namespace (line 16) | namespace Eigen {
FILE: planner/lib/3rdparty/gtsam-4.1.1/gtsam/3rdparty/Eigen/Eigen/src/Eigenvalues/HessenbergDecomposition.h
function namespace (line 14) | namespace Eigen {
function CoeffVectorType (line 179) | const CoeffVectorType& householderCoefficients() const
type typename (line 271) | typedef typename NumTraits<Scalar>::Real RealScalar;
function namespace (line 322) | namespace internal {
FILE: planner/lib/3rdparty/gtsam-4.1.1/gtsam/3rdparty/Eigen/Eigen/src/Eigenvalues/MatrixBaseEigenvalues.h
function namespace (line 14) | namespace Eigen {
FILE: planner/lib/3rdparty/gtsam-4.1.1/gtsam/3rdparty/Eigen/Eigen/src/Eigenvalues/RealQZ.h
function namespace (line 13) | namespace Eigen {
function MatrixType (line 139) | const MatrixType& matrixS() const {
type Matrix (line 200) | typedef Matrix<Scalar,3,1> Vector3s;
type Matrix (line 201) | typedef Matrix<Scalar,2,1> Vector2s;
type Matrix (line 202) | typedef Matrix<Scalar,2,2> Matrix2s;
type JacobiRotation (line 203) | typedef JacobiRotation<Scalar> JRs;
FILE: planner/lib/3rdparty/gtsam-4.1.1/gtsam/3rdparty/Eigen/Eigen/src/Eigenvalues/RealSchur.h
function namespace (line 16) | namespace Eigen {
function MatrixType (line 144) | const MatrixType& matrixT() const
function Index (line 213) | Index getMaxIterations()
type Matrix (line 236) | typedef Matrix<Scalar,3,1> Vector3s;
function typename (line 353) | typename MatrixType::Scalar RealSchur<MatrixType>::computeNormOfT()
FILE: planner/lib/3rdparty/gtsam-4.1.1/gtsam/3rdparty/Eigen/Eigen/src/Eigenvalues/RealSchur_LAPACKE.h
function namespace (line 36) | namespace Eigen {
FILE: planner/lib/3rdparty/gtsam-4.1.1/gtsam/3rdparty/Eigen/Eigen/src/Eigenvalues/SelfAdjointEigenSolver.h
function namespace (line 16) | namespace Eigen {
function namespace (line 370) | namespace internal {
function namespace (line 469) | namespace internal {
type typename (line 715) | typedef typename SolverType::RealVectorType VectorType;
type typename (line 716) | typedef typename SolverType::Scalar Scalar;
type typename (line 717) | typedef typename SolverType::EigenvectorsType EigenvectorsType;
function EIGEN_DEVICE_FUNC (line 719) | EIGEN_DEVICE_FUNC
function namespace (line 805) | namespace internal {
FILE: planner/lib/3rdparty/gtsam-4.1.1/gtsam/3rdparty/Eigen/Eigen/src/Eigenvalues/SelfAdjointEigenSolver_LAPACKE.h
function namespace (line 36) | namespace Eigen {
FILE: planner/lib/3rdparty/gtsam-4.1.1/gtsam/3rdparty/Eigen/Eigen/src/Eigenvalues/Tridiagonalization.h
function namespace (line 14) | namespace Eigen {
function namespace (line 321) | namespace internal {
type typename (line 439) | typedef typename Tridiagonalization<MatrixType>::CoeffVectorType CoeffVe...
type typename (line 440) | typedef typename Tridiagonalization<MatrixType>::HouseholderSequenceType...
type typename (line 463) | typedef typename MatrixType::RealScalar RealScalar;
FILE: planner/lib/3rdparty/gtsam-4.1.1/gtsam/3rdparty/Eigen/Eigen/src/Geometry/AlignedBox.h
function namespace (line 13) | namespace Eigen {
function EIGEN_DEVICE_FUNC (line 146) | EIGEN_DEVICE_FUNC inline VectorType corner(CornerType corner) const
function EIGEN_DEVICE_FUNC (line 164) | EIGEN_DEVICE_FUNC inline VectorType sample() const
function contains (line 182) | inline bool contains(const MatrixBase<Derived>& p) const
function EIGEN_DEVICE_FUNC (line 189) | EIGEN_DEVICE_FUNC inline bool contains(const AlignedBox& b) const
function EIGEN_DEVICE_FUNC (line 194) | EIGEN_DEVICE_FUNC inline bool intersects(const AlignedBox& b) const
function EIGEN_DEVICE_FUNC (line 210) | EIGEN_DEVICE_FUNC inline AlignedBox& extend(const AlignedBox& b)
function EIGEN_DEVICE_FUNC (line 220) | EIGEN_DEVICE_FUNC inline AlignedBox& clamp(const AlignedBox& b)
function EIGEN_DEVICE_FUNC (line 230) | EIGEN_DEVICE_FUNC inline AlignedBox intersection(const AlignedBox& b) const
function EIGEN_DEVICE_FUNC (line 236) | EIGEN_DEVICE_FUNC inline AlignedBox merged(const AlignedBox& b) const
function NonInteger (line 267) | inline NonInteger exteriorDistance(const MatrixBase<Derived>& p) const
function EIGEN_DEVICE_FUNC (line 274) | EIGEN_DEVICE_FUNC inline NonInteger exteriorDistance(const AlignedBox& b...
function explicit (line 292) | inline explicit AlignedBox(const AlignedBox<OtherScalarType,AmbientDimAt...
FILE: planner/lib/3rdparty/gtsam-4.1.1/gtsam/3rdparty/Eigen/Eigen/src/Geometry/AngleAxis.h
function namespace (line 13) | namespace Eigen {
function explicit (line 139) | inline explicit AngleAxis(const AngleAxis<OtherScalarType>& other)
function EIGEN_DEVICE_FUNC (line 145) | EIGEN_DEVICE_FUNC static inline const AngleAxis Identity() { return Angl...
function EIGEN_DEVICE_FUNC (line 151) | EIGEN_DEVICE_FUNC bool isApprox(const AngleAxis& other, const typename N...
type AngleAxis (line 157) | typedef AngleAxis<float> AngleAxisf;
type AngleAxis (line 160) | typedef AngleAxis<double> AngleAxisd;
FILE: planner/lib/3rdparty/gtsam-4.1.1/gtsam/3rdparty/Eigen/Eigen/src/Geometry/EulerAngles.h
function namespace (line 13) | namespace Eigen {
FILE: planner/lib/3rdparty/gtsam-4.1.1/gtsam/3rdparty/Eigen/Eigen/src/Geometry/Homogeneous.h
function namespace (line 13) | namespace Eigen {
type MatrixBase (line 68) | typedef MatrixBase<Homogeneous> Base;
function explicit (line 71) | explicit inline Homogeneous(const MatrixType& matrix)
function EIGEN_DEVICE_FUNC (line 299) | EIGEN_DEVICE_FUNC homogeneous_right_product_impl(const MatrixType& lhs, ...
type HomogeneousShape (line 325) | typedef HomogeneousShape Shape;
type AssignmentKind (line 328) | struct AssignmentKind
type Dense2Dense (line 328) | typedef Dense2Dense Kind;
type typename (line 336) | typedef typename XprType::PlainObject PlainObject;
type evaluator (line 337) | typedef evaluator<PlainObject> Base;
function EIGEN_DEVICE_FUNC (line 339) | EIGEN_DEVICE_FUNC explicit unary_evaluator(const XprType& op)
type Homogeneous (line 370) | typedef Homogeneous<ArgType,Horizontal> SrcXprType;
type typename (line 400) | typedef typename Rhs::template
type typename (line 401) | typedef typename remove_const<LinearBlockConst>::type Li...
type typename (line 402) | typedef typename Rhs::ConstRowXpr Co...
type Replicate (line 403) | typedef Replicate<const ConstantColumn,Rows,1> Co...
type Product (line 404) | typedef Product<Lhs,LinearBlock,LazyProduct> Li...
type CwiseBinaryOp (line 405) | typedef CwiseBinaryOp<internal::scalar_sum_op<typename
type homogeneous_right_product_refactoring_helper (line 413) | typedef homogeneous_right_product_refactoring_helper<typename
type typename (line 414) | typedef typename helper::ConstantBlock ConstantBlock;
type typename (line 415) | typedef typename helper::Xpr RefactoredXpr;
type evaluator (line 416) | typedef evaluator<RefactoredXpr> Base;
function EIGEN_DEVICE_FUNC (line 418) | EIGEN_DEVICE_FUNC explicit product_evaluator(const XprType& xpr)
type typename (line 453) | typedef typename Lhs::template
type typename (line 454) | typedef typename remove_const<LinearBlockConst>::type Li...
type typename (line 455) | typedef typename Lhs::ConstColXpr Co...
type Replicate (line 456) | typedef Replicate<const ConstantColumn,1,Cols> Co...
type Product (line 457) | typedef Product<LinearBlock,Rhs,LazyProduct> Li...
type CwiseBinaryOp (line 458) | typedef CwiseBinaryOp<internal::scalar_sum_op<typename
type homogeneous_left_product_refactoring_helper (line 466) | typedef homogeneous_left_product_refactoring_helper<Lhs,typename
type typename (line 467) | typedef typename helper::ConstantBlock ConstantBlock;
type typename (line 468) | typedef typename helper::Xpr RefactoredXpr;
type evaluator (line 469) | typedef evaluator<RefactoredXpr> Base;
function EIGEN_DEVICE_FUNC (line 471) | EIGEN_DEVICE_FUNC explicit product_evaluator(const XprType& xpr)
function evalTo (line 482) | static void evalTo(Dest& dst, const TransformType& lhs, const Homogeneou...
FILE: planner/lib/3rdparty/gtsam-4.1.1/gtsam/3rdparty/Eigen/Eigen/src/Geometry/Hyperplane.h
function namespace (line 14) | namespace Eigen {
FILE: planner/lib/3rdparty/gtsam-4.1.1/gtsam/3rdparty/Eigen/Eigen/src/Geometry/OrthoMethods.h
function namespace (line 14) | namespace Eigen {
function namespace (line 50) | namespace internal {
type typename (line 87) | typedef typename internal::nested_eval<Derived,2>::type DerivedNested;
type typename (line 88) | typedef typename internal::nested_eval<OtherDerived,2>::type OtherDerive...
function namespace (line 137) | namespace internal {
FILE: planner/lib/3rdparty/gtsam-4.1.1/gtsam/3rdparty/Eigen/Eigen/src/Geometry/ParametrizedLine.h
function namespace (line 14) | namespace Eigen {
FILE: planner/lib/3rdparty/gtsam-4.1.1/gtsam/3rdparty/Eigen/Eigen/src/Geometry/Quaternion.h
function namespace (line 13) | namespace Eigen {
type Quaternion (line 307) | typedef Quaternion<float> Quaternionf;
type Quaternion (line 310) | typedef Quaternion<double> Quaterniond;
function namespace (line 316) | namespace internal {
function namespace (line 324) | namespace internal {
type _Scalar (line 354) | typedef _Scalar Scalar;
type typename (line 355) | typedef typename internal::traits<Map>::Coefficients Coefficients;
function EIGEN_STRONG_INLINE (line 365) | EIGEN_STRONG_INLINE Map(const Scalar* coeffs) : m_coeffs(coeffs) {}
type _Scalar (line 391) | typedef _Scalar Scalar;
type typename (line 392) | typedef typename internal::traits<Map>::Coefficients Coefficients;
function EIGEN_STRONG_INLINE (line 402) | EIGEN_STRONG_INLINE Map(Scalar* coeffs) : m_coeffs(coeffs) {}
function EIGEN_DEVICE_FUNC (line 404) | EIGEN_DEVICE_FUNC inline Coefficients& coeffs() { return m_coeffs; }
type Map (line 413) | typedef Map<Quaternion<float>, 0> QuaternionMapf;
type Map (line 416) | typedef Map<Quaternion<double>, 0> QuaternionMapd;
type Map (line 419) | typedef Map<Quaternion<float>, Aligned> QuaternionMapAlignedf;
type Map (line 422) | typedef Map<Quaternion<double>, Aligned> QuaternionMapAlignedd;
function namespace (line 430) | namespace internal {
function typename (line 535) | inline typename QuaternionBase<Derived>::Matrix3
function namespace (line 678) | namespace internal {
function typename (line 707) | inline typename internal::traits<Derived>::Scalar
function namespace (line 756) | namespace internal {
function run (line 804) | static inline void run(QuaternionBase<Derived>& q, const Other& vec)
FILE: planner/lib/3rdparty/gtsam-4.1.1/gtsam/3rdparty/Eigen/Eigen/src/Geometry/Rotation2D.h
function namespace (line 13) | namespace Eigen {
function explicit (line 147) | inline explicit Rotation2D(const Rotation2D<OtherScalarType>& other)
function EIGEN_DEVICE_FUNC (line 152) | EIGEN_DEVICE_FUNC static inline Rotation2D Identity() { return Rotation2...
function EIGEN_DEVICE_FUNC (line 158) | EIGEN_DEVICE_FUNC bool isApprox(const Rotation2D& other, const typename ...
type Rotation2D (line 165) | typedef Rotation2D<float> Rotation2Df;
type Rotation2D (line 168) | typedef Rotation2D<double> Rotation2Dd;
FILE: planner/lib/3rdparty/gtsam-4.1.1/gtsam/3rdparty/Eigen/Eigen/src/Geometry/RotationBase.h
function namespace (line 13) | namespace Eigen {
function VectorType (line 93) | inline VectorType _transformVector(const OtherVectorType& v) const
function namespace (line 97) | namespace internal {
function EIGEN_DEVICE_FUNC (line 113) | EIGEN_DEVICE_FUNC static inline ReturnType run(const RotationDerived& r,...
type Matrix (line 125) | typedef Matrix<typename
function ReturnType (line 126) | ReturnType run(const RotationDerived& r, const OtherVectorType& v)
function namespace (line 161) | namespace internal {
FILE: planner/lib/3rdparty/gtsam-4.1.1/gtsam/3rdparty/Eigen/Eigen/src/Geometry/Scaling.h
function explicit (line 48) | explicit inline UniformScaling(const Scalar& s) : m_factor(s) {}
function Scalar (line 51) | inline Scalar& factor() { return m_factor; }
function UniformScaling (line 54) | inline UniformScaling operator* (const UniformScaling& other) const
function typename (line 73) | typename internal::plain_matrix_type<Derived>::type operator* (const Mat...
function UniformScaling (line 81) | inline UniformScaling inverse() const
type DiagonalMatrix (line 146) | typedef DiagonalMatrix<float, 2> AlignedScaling2f;
type DiagonalMatrix (line 148) | typedef DiagonalMatrix<double,2> AlignedScaling2d;
type DiagonalMatrix (line 150) | typedef DiagonalMatrix<float, 3> AlignedScaling3f;
type DiagonalMatrix (line 152) | typedef DiagonalMatrix<double,3> AlignedScaling3d;
FILE: planner/lib/3rdparty/gtsam-4.1.1/gtsam/3rdparty/Eigen/Eigen/src/Geometry/Transform.h
function namespace (line 15) | namespace Eigen {
type _Scalar (line 213) | typedef _Scalar Scalar;
type Eigen (line 214) | typedef Eigen::Index StorageIndex;
type Eigen (line 215) | typedef Eigen::Index Index;
type typename (line 217) | typedef typename internal::make_proper_matrix_type<Scalar,Rows,HDim,Opti...
type MatrixType (line 219) | typedef const MatrixType ConstMatrixType;
type Matrix (line 221) | typedef Matrix<Scalar,Dim,Dim,Options> LinearMatrixType;
type Block (line 223) | typedef Block<MatrixType,Dim,Dim,int(Mode)==(AffineCompact) && (Options&...
type Block (line 225) | typedef const Block<ConstMatrixType,Dim,Dim,int(Mode)==(AffineCompact) &...
type typename (line 227) | typedef typename internal::conditional<int(Mode)==int(AffineCompact),
type typename (line 231) | typedef typename internal::conditional<int(Mode)==int(AffineCompact),
type Matrix (line 235) | typedef Matrix<Scalar,Dim,1> VectorType;
type Block (line 237) | typedef Block<MatrixType,Dim,1,!(internal::traits<MatrixType>::Flags & R...
type Block (line 239) | typedef const Block<ConstMatrixType,Dim,1,!(internal::traits<MatrixType>...
type Translation (line 241) | typedef Translation<Scalar,Dim> TranslationType;
type Transform (line 246) | typedef Transform<Scalar,Dim,TransformTimeDiagonalMode> TransformTimeDia...
function EIGEN_DEVICE_FUNC (line 262) | EIGEN_DEVICE_FUNC inline Transform(const Transform& other)
function EIGEN_DEVICE_FUNC (line 268) | EIGEN_DEVICE_FUNC inline explicit Transform(const TranslationType& t)
function EIGEN_DEVICE_FUNC (line 273) | EIGEN_DEVICE_FUNC inline explicit Transform(const UniformScaling<Scalar>...
function explicit (line 279) | inline explicit Transform(const RotationBase<Derived, Dim>& r)
type internal (line 288) | typedef internal::transform_take_affine_part<Transform> take_affine_part;
function explicit (line 292) | inline explicit Transform(const EigenBase<OtherDerived>& other)
type typename (line 348) | typedef typename Transform<Scalar,Dim,OtherMode,OtherOptions>::MatrixTyp...
function EIGEN_DEVICE_FUNC (line 389) | EIGEN_DEVICE_FUNC inline Scalar operator() (Index row, Index col) const ...
function EIGEN_DEVICE_FUNC (line 392) | EIGEN_DEVICE_FUNC inline Scalar& operator() (Index row, Index col) { ret...
function EIGEN_DEVICE_FUNC (line 397) | EIGEN_DEVICE_FUNC inline MatrixType& matrix() { return m_matrix; }
function EIGEN_DEVICE_FUNC (line 402) | EIGEN_DEVICE_FUNC inline LinearPart linear() { return LinearPart(m_matri...
function EIGEN_DEVICE_FUNC (line 405) | EIGEN_DEVICE_FUNC inline ConstAffinePart affine() const { return take_af...
type internal (line 509) | typedef internal::transform_transform_product_impl<Transform,Transform<S...
type typename (line 510) | typedef typename ProductType::ResultType ResultType;
type typename (line 519) | typedef typename icc_11_workaround<OtherMode,OtherOptions>::ProductType ...
function EIGEN_DEVICE_FUNC (line 533) | EIGEN_DEVICE_FUNC void setIdentity() { m_matrix.setIdentity(); }
function EIGEN_DEVICE_FUNC (line 539) | EIGEN_DEVICE_FUNC static const Transform Identity()
function Scalar (line 622) | const Scalar* data() const { return m_matrix.data(); }
function EIGEN_DEVICE_FUNC (line 624) | EIGEN_DEVICE_FUNC Scalar* data() { return m_matrix.data(); }
function explicit (line 637) | inline explicit Transform(const Transform<OtherScalarType,Dim,Mode,Optio...
function EIGEN_DEVICE_FUNC (line 647) | EIGEN_DEVICE_FUNC bool isApprox(const Transform& other, const typename N...
function EIGEN_DEVICE_FUNC (line 652) | EIGEN_DEVICE_FUNC void makeAffine()
function check_template_params (line 690) | void check_template_params()
function else (line 917) | else
function namespace (line 1140) | namespace internal {
function namespace (line 1231) | namespace internal {
function MatrixType (line 1251) | static inline const MatrixType& run(const MatrixType& m) { return m; }
function EIGEN_STRONG_INLINE (line 1315) | static EIGEN_STRONG_INLINE ResultType run(const TransformType& T, const ...
type typename (line 1331) | typedef typename MatrixType::PlainObject ResultType;
function EIGEN_STRONG_INLINE (line 1333) | static EIGEN_STRONG_INLINE ResultType run(const TransformType& T, const ...
type typename (line 1357) | typedef typename MatrixType::PlainObject ResultType;
function EIGEN_STRONG_INLINE (line 1359) | static EIGEN_STRONG_INLINE ResultType run(const TransformType& T, const ...
type typename (line 1382) | typedef typename MatrixType::PlainObject ResultType;
function EIGEN_STRONG_INLINE (line 1384) | static EIGEN_STRONG_INLINE ResultType run(const TransformType& T, const ...
type typename (line 1404) | typedef typename TransformType::MatrixType MatrixType;
type Transform (line 1405) | typedef Transform<typename
function ResultType (line 1406) | static ResultType run(const Other& other,const TransformType& tr)
type typename (line 1415) | typedef typename TransformType::MatrixType MatrixType;
type Transform (line 1416) | typedef Transform<typename
function ResultType (line 1417) | static ResultType run(const Other& other,const TransformType& tr)
type typename (line 1431) | typedef typename TransformType::MatrixType MatrixType;
type TransformType (line 1432) | typedef TransformType ResultType;
function ResultType (line 1433) | static ResultType run(const Other& other,const TransformType& tr)
type typename (line 1447) | typedef typename TransformType::MatrixType MatrixType;
type TransformType (line 1448) | typedef TransformType ResultType;
function ResultType (line 1449) | static ResultType run(const Other& other,const TransformType& tr)
type typename (line 1463) | typedef typename TransformType::MatrixType MatrixType;
type TransformType (line 1464) | typedef TransformType ResultType;
function ResultType (line 1465) | static ResultType run(const Other& other, const TransformType& tr)
type Transform (line 1484) | typedef Transform<Scalar,Dim,LhsMode,LhsOptions> Lhs;
type Transform (line 1485) | typedef Transform<Scalar,Dim,RhsMode,RhsOptions> Rhs;
type Transform (line 1486) | typedef Transform<Scalar,Dim,ResultMode,LhsOptions> ResultType;
function ResultType (line 1487) | static ResultType run(const Lhs& lhs, const Rhs& rhs)
type Transform (line 1501) | typedef Transform<Scalar,Dim,RhsMode,RhsOptions> Rhs;
type Transform (line 1502) | typedef Transform<Scalar,Dim,Projective> ResultType;
function ResultType (line 1503) | static ResultType run(const Lhs& lhs, const Rhs& rhs)
type Transform (line 1513) | typedef Transform<Scalar,Dim,Projective,RhsOptions> Rhs;
type Transform (line 1514) | typedef Transform<Scalar,Dim,Projective> ResultType;
function ResultType (line 1515) | static ResultType run(const Lhs& lhs, const Rhs& rhs)
type Transform (line 1528) | typedef Transform<Scalar,Dim,AffineCompact,RhsOptions> Rhs;
type Transform (line 1529) | typedef Transform<Scalar,Dim,Projective> ResultType;
function ResultType (line 1530) | static ResultType run(const Lhs& lhs, const Rhs& rhs)
FILE: planner/lib/3rdparty/gtsam-4.1.1/gtsam/3rdparty/Eigen/Eigen/src/Geometry/Translation.h
function namespace (line 13) | namespace Eigen {
function explicit (line 160) | inline explicit Translation(const Translation<OtherScalarType,Dim>& other)
function EIGEN_DEVICE_FUNC (line 167) | EIGEN_DEVICE_FUNC bool isApprox(const Translation& other, const typename...
type Translation (line 174) | typedef Translation<float, 2> Translation2f;
type Translation (line 175) | typedef Translation<double,2> Translation2d;
type Translation (line 176) | typedef Translation<float, 3> Translation3f;
type Translation (line 177) | typedef Translation<double,3> Translation3d;
FILE: planner/lib/3rdparty/gtsam-4.1.1/gtsam/3rdparty/Eigen/Eigen/src/Geometry/Umeyama.h
function namespace (line 26) | namespace internal {
type typename (line 97) | typedef typename internal::umeyama_transform_matrix_type<Derived, OtherD...
type typename (line 98) | typedef typename internal::traits<TransformationMatrixType>::Scalar Scalar;
type typename (line 99) | typedef typename NumTraits<Scalar>::Real RealScalar;
function EIGEN_STATIC_ASSERT (line 102) | EIGEN_STATIC_ASSERT((internal::is_same<Scalar, typename internal::traits...
FILE: planner/lib/3rdparty/gtsam-4.1.1/gtsam/3rdparty/Eigen/Eigen/src/Geometry/arch/Geometry_SSE.h
function namespace (line 14) | namespace Eigen {
function Quaternion (line 91) | static inline Quaternion<double> run(const QuaternionBase<Derived>& _a, ...
function Quaternion (line 146) | static inline Quaternion<double> run(const QuaternionBase<Derived>& q)
FILE: planner/lib/3rdparty/gtsam-4.1.1/gtsam/3rdparty/Eigen/Eigen/src/Householder/BlockHouseholder.h
function namespace (line 16) | namespace Eigen {
FILE: planner/lib/3rdparty/gtsam-4.1.1/gtsam/3rdparty/Eigen/Eigen/src/Householder/Householder.h
function namespace (line 14) | namespace Eigen {
FILE: planner/lib/3rdparty/gtsam-4.1.1/gtsam/3rdparty/Eigen/Eigen/src/Householder/HouseholderSequence.h
function namespace (line 14) | namespace Eigen {
type Block (line 88) | typedef Block<const VectorsType, Dynamic, 1> EssentialVectorType;
type HouseholderSequence (line 89) | typedef HouseholderSequence<VectorsType, CoeffsType, OnTheLeft> Househol...
function EssentialVectorType (line 90) | static inline const EssentialVectorType essentialVector(const Householde...
type HouseholderSequence (line 101) | typedef HouseholderSequence<VectorsType, CoeffsType, OnTheRight> Househo...
function EssentialVectorType (line 102) | static inline const EssentialVectorType essentialVector(const Householde...
type typename (line 111) | typedef typename ScalarBinaryOpTraits<OtherScalarType, typename
type Matrix (line 113) | typedef Matrix<ResultScalar, MatrixType::RowsAtCompileTime, MatrixType::...
type typename (line 131) | typedef typename internal::traits<HouseholderSequence>::Scalar Scalar;
type HouseholderSequence (line 133) | typedef HouseholderSequence<
function EssentialVectorType (line 202) | const EssentialVectorType essentialVector(Index k) const
type Block (line 326) | typedef Block<typename
type internal (line 364) | struct internal
FILE: planner/lib/3rdparty/gtsam-4.1.1/gtsam/3rdparty/Eigen/Eigen/src/IterativeLinearSolvers/BasicPreconditioners.h
function namespace (line 13) | namespace Eigen {
type _Scalar (line 130) | typedef _Scalar Scalar;
type typename (line 131) | typedef typename NumTraits<Scalar>::Real RealScalar;
type DiagonalPreconditioner (line 132) | typedef DiagonalPreconditioner<_Scalar> Base;
function Base (line 139) | LeastSquareDiagonalPreconditioner(const MatType& mat) : Base()
function ComputationInfo (line 188) | ComputationInfo info() { return Success; }
FILE: planner/lib/3rdparty/gtsam-4.1.1/gtsam/3rdparty/Eigen/Eigen/src/IterativeLinearSolvers/BiCGSTAB.h
function namespace (line 14) | namespace Eigen {
type typename (line 168) | typedef typena
Copy disabled (too large)
Download .json
Condensed preview — 4732 files, each showing path, character count, and a content snippet. Download the .json file for the full structured content (58,686K chars).
[
{
"path": ".gitignore",
"chars": 79,
"preview": "*.stl\n*.obj\n*.ply\n*.pcd\n*.npy\n*.pyc\n*.pickle\n*.so\n\n__pycache__/\nbuild/\ninstall/"
},
{
"path": "LICENSE",
"chars": 18092,
"preview": " GNU GENERAL PUBLIC LICENSE\n Version 2, June 1991\n\n Copyright (C) 1989, 1991 Fr"
},
{
"path": "NOTICE",
"chars": 1439,
"preview": "Copyright (c) 2024 Bowen Yang <byangar@connect.ust.hk>, Jie Cheng <jchengai@connect.ust.hk>\n\nPCT_planner contains severa"
},
{
"path": "README.md",
"chars": 3427,
"preview": "# PCT Planner\n\n## Overview\n\nThis is an implementation of paper **Efficient Global Navigational Planning in 3-D Structure"
},
{
"path": "planner/build.sh",
"chars": 986,
"preview": "#!/bin/bash\n\nROOT_DIR=$(cd $(dirname \"$0\"); pwd)\n# echo \"ROOT_DIR: ${ROOT_DIR}\"\n\ncd lib\n\n# rm -rf build\nmkdir build\n\ncd "
},
{
"path": "planner/build_thirdparty.sh",
"chars": 455,
"preview": "ROOT_DIR=$(cd $(dirname \"$0\"); pwd)\n\n# build gtsam\ncd ${ROOT_DIR}/lib/3rdparty/gtsam-4.1.1\nrm -rf build install\nmkdir bu"
},
{
"path": "planner/config/__init__.py",
"chars": 25,
"preview": "from .param import Config"
},
{
"path": "planner/config/param.py",
"chars": 206,
"preview": "class ConfigPlanner():\n use_quintic = True\n max_heading_rate = 10\n\n\nclass ConfigWrapper():\n tomo_dir = '/rsc/to"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/.github/ISSUE_TEMPLATE/bug-report.md",
"chars": 1340,
"preview": "---\nname: \"Bug Report\"\nabout: Submit a bug report to help us improve GTSAM\n---\n\n<!--Please only submit issues/bug report"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/.github/ISSUE_TEMPLATE/feature-request.md",
"chars": 700,
"preview": "---\nname: \"Feature Request\"\nabout: Submit a proposal/request for a new GTSAM feature\n---\n\n## Feature\n\n<!-- A clear and c"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/.github/ISSUE_TEMPLATE/questions-help-support.md",
"chars": 183,
"preview": "---\nname: \"Questions/Help/Support\"\n---\n\nPlease post questions and support requests in the [GTSAM Google group](https://g"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/.github/scripts/boost.sh",
"chars": 471,
"preview": "### Script to install Boost\nBOOST_FOLDER=boost_${BOOST_VERSION//./_}\n\n# Download Boost\nwget https://boostorg.jfrog.io/ar"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/.github/scripts/python.sh",
"chars": 2519,
"preview": "#!/bin/bash\n\n##########################################################\n# Build and test the GTSAM Python wrapper.\n#####"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/.github/scripts/unix.sh",
"chars": 3288,
"preview": "#!/bin/bash\n\n##########################################################\n# Build and test GTSAM for *nix based systems.\n#"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/.github/workflows/build-linux.yml",
"chars": 2938,
"preview": "name: Linux CI\n\non: [push, pull_request]\n\njobs:\n build:\n name: ${{ matrix.name }} ${{ matrix.build_type }}\n runs-"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/.github/workflows/build-macos.yml",
"chars": 1501,
"preview": "name: macOS CI\n\non: [pull_request]\n\njobs:\n build:\n name: ${{ matrix.name }} ${{ matrix.build_type }}\n runs-on: ${"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/.github/workflows/build-python.yml",
"chars": 4339,
"preview": "name: Python CI\n\non: [pull_request]\n\njobs:\n build:\n name: ${{ matrix.name }} ${{ matrix.build_type }} Python ${{ mat"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/.github/workflows/build-special.yml",
"chars": 4625,
"preview": "name: Special Cases CI\n\non: [pull_request]\n\njobs:\n build:\n name: ${{ matrix.name }} ${{ matrix.build_type }}\n run"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/.github/workflows/build-windows.yml",
"chars": 4009,
"preview": "name: Windows CI\n\non: [pull_request]\n\njobs:\n build:\n name: ${{ matrix.name }} ${{ matrix.build_type }}\n runs-on: "
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/.github/workflows/trigger-python.yml",
"chars": 519,
"preview": "# This triggers Python builds on `gtsam-manylinux-build`\nname: Trigger Python Builds\non:\n push:\n branches:\n - d"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/.gitignore",
"chars": 305,
"preview": "/build*\n/debug*\n.idea\n*.pyc\n*.DS_Store\n*.swp\n/examples/Data/dubrovnik-3-7-pre-rewritten.txt\n/examples/Data/pose2example-"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/.project",
"chars": 2425,
"preview": "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<projectDescription>\n\t<name>gtsam</name>\n\t<comment></comment>\n\t<projects>\n\t</proj"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/.settings/.gitignore",
"chars": 34,
"preview": "/org.eclipse.cdt.codan.core.prefs\n"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/.settings/org.eclipse.cdt.core.prefs",
"chars": 508,
"preview": "eclipse.preferences.version=1\nenvironment/project/cdt.managedbuild.toolchain.gnu.macosx.base.1359703544/PATH/delimiter=\\"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/CMakeLists.txt",
"chars": 4192,
"preview": "project(GTSAM CXX C)\ncmake_minimum_required(VERSION 3.0)\n\n# new feature to Cmake Version > 2.8.12\n# Mac ONLY. Define Rel"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/CppUnitLite/CMakeLists.txt",
"chars": 817,
"preview": "# Build/install CppUnitLite\n\nfile(GLOB cppunitlite_headers \"*.h\")\nfile(GLOB cppunitlite_src \"*.cpp\")\n\nadd_library(CppUni"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/CppUnitLite/Failure.h",
"chars": 1838,
"preview": "/* ----------------------------------------------------------------------------\n\n * GTSAM Copyright 2010, Georgia Tech R"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/CppUnitLite/Test.cpp",
"chars": 1755,
"preview": "/* ----------------------------------------------------------------------------\n\n * GTSAM Copyright 2010, Georgia Tech R"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/CppUnitLite/Test.h",
"chars": 6708,
"preview": "/* ----------------------------------------------------------------------------\n\n * GTSAM Copyright 2010, Georgia Tech R"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/CppUnitLite/TestHarness.h",
"chars": 772,
"preview": "/* ----------------------------------------------------------------------------\n\n * GTSAM Copyright 2010, Georgia Tech R"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/CppUnitLite/TestRegistry.cpp",
"chars": 1776,
"preview": "/* ----------------------------------------------------------------------------\n\n * GTSAM Copyright 2010, Georgia Tech R"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/CppUnitLite/TestRegistry.h",
"chars": 1047,
"preview": "/* ----------------------------------------------------------------------------\n\n * GTSAM Copyright 2010, Georgia Tech R"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/CppUnitLite/TestResult.cpp",
"chars": 1260,
"preview": "/* ----------------------------------------------------------------------------\n\n * GTSAM Copyright 2010, Georgia Tech R"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/CppUnitLite/TestResult.h",
"chars": 1040,
"preview": "/* ----------------------------------------------------------------------------\n\n * GTSAM Copyright 2010, Georgia Tech R"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/DEVELOP.md",
"chars": 607,
"preview": "# Information for Developers\n\n### Coding Conventions\n\n* Classes are Uppercase, methods and functions lowerMixedCase.\n* W"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/GTSAM-Concepts.md",
"chars": 11654,
"preview": "GTSAM Concepts\n==============\n\nAs discussed in [Generic Programming Techniques](http://www.boost.org/community/generic_p"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/INSTALL.md",
"chars": 10686,
"preview": "# Quickstart\n\nIn the root library folder execute:\n\n```sh\n$ mkdir build\n$ cd build\n$ cmake ..\n$ make check # (optional, r"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/LICENSE",
"chars": 1507,
"preview": "GTSAM is released under the simplified BSD license, reproduced in the file \nLICENSE.BSD in this directory.\n\nGTSAM contai"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/LICENSE.BSD",
"chars": 1530,
"preview": "Copyright (c) 2010, Georgia Tech Research Corporation\nAtlanta, Georgia 30332-0415\nAll Rights Reserved\n\nRedistribution an"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/README.md",
"chars": 5676,
"preview": "# README - Georgia Tech Smoothing and Mapping Library\n\n**Important Note**\n\nAs of August 1 2020, the `develop` branch is "
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/THANKS.md",
"chars": 963,
"preview": "GTSAM was made possible by the efforts of many collaborators at Georgia Tech, listed below with their current afffiliati"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/USAGE.md",
"chars": 2309,
"preview": "# GTSAM USAGE\n\nThis file explains how to make use of the library for common SLAM tasks, using a visual SLAM implementati"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/Using-GTSAM-EXPORT.md",
"chars": 5883,
"preview": "# Using GTSAM_EXPORT\n\nTo create a DLL in windows, the `GTSAM_EXPORT` keyword has been created and needs to be applied to"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/cmake/CMakeLists.txt",
"chars": 693,
"preview": "# This file installs the scripts from this directory that may be used in other \n# projects. See README.txt in this dire"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/cmake/Config.cmake.in",
"chars": 1235,
"preview": "# - Config file for @CMAKE_PROJECT_NAME@\n# It defines the following variables\n# @PACKAGE_NAME@_INCLUDE_DIR - include di"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/cmake/FindBoost.cmake",
"chars": 111063,
"preview": "# Distributed under the OSI-approved BSD 3-Clause License. See accompanying\n# file Copyright.txt or https://cmake.org/l"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/cmake/FindEigen3.cmake",
"chars": 2995,
"preview": "# - Try to find Eigen3 lib\n#\n# This module supports requiring a minimum version, e.g. you can do\n# find_package(Eigen3"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/cmake/FindGooglePerfTools.cmake",
"chars": 1357,
"preview": "# -*- cmake -*-\n\n# - Find Google perftools\n# Find the Google perftools includes and libraries\n# This module defines\n# G"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/cmake/FindMKL.cmake",
"chars": 9148,
"preview": "# This file is adapted from the one in OpenMEEG: http://www-sop.inria.fr/athena/software/OpenMEEG/\n# - Try to find the I"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/cmake/FindNumPy.cmake",
"chars": 4306,
"preview": "# - Find the NumPy libraries\r\n# This module finds if NumPy is installed, and sets the following variables\r\n# indicating "
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/cmake/FindTBB.cmake",
"chars": 12849,
"preview": "# The MIT License (MIT)\n#\n# Copyright (c) 2015 Justus Calvin\n#\n# Permission is hereby granted, free of charge, to any pe"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/cmake/GTSAMCMakeToolsConfig.cmake",
"chars": 212,
"preview": "# This config file modifies CMAKE_MODULE_PATH so that the GTSAM-CMakeTools files may be included\n\nset(GTSAM_CMAKE_TOOLS_"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/cmake/GtsamAddPch.cmake",
"chars": 1245,
"preview": "###############################################################################\n# Macro:\n#\n# gtsamAddPch(precompiledHead"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/cmake/GtsamBuildTypes.cmake",
"chars": 15511,
"preview": "include(CheckCXXCompilerFlag) # for check_cxx_compiler_flag()\n\n# Set cmake policy to recognize the AppleClang compiler\n#"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/cmake/GtsamMakeConfigFile.cmake",
"chars": 2240,
"preview": "# Writes a config file\n\nset(GTSAM_CONFIG_TEMPLATE_PATH ${CMAKE_CURRENT_LIST_DIR})\n\nfunction(GtsamMakeConfigFile PACKAGE_"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/cmake/GtsamPrinting.cmake",
"chars": 2452,
"preview": "# Based on https://github.com/jimbraun/XCDF/blob/master/cmake/CMakePadString.cmake\nfunction(string_pad RESULT_NAME DESIR"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/cmake/GtsamTesting.cmake",
"chars": 12246,
"preview": "# This file defines the two macros below for easily adding groups of unit tests and scripts,\n# as well as sets up unit t"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/cmake/HandleAllocators.cmake",
"chars": 1354,
"preview": "# Build list of possible allocators\nset(possible_allocators \"\")\nif(GTSAM_USE_TBB)\n list(APPEND possible_allocators TB"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/cmake/HandleBoost.cmake",
"chars": 2507,
"preview": "###############################################################################\n# Find boost\n\n# To change the path for b"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/cmake/HandleCCache.cmake",
"chars": 566,
"preview": "###############################################################################\n# Support ccache, if installed\nif(NOT MS"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/cmake/HandleCPack.cmake",
"chars": 1728,
"preview": "#JLBC: is all this actually used by someone? could it be removed?\n\n# Flags for choosing default packaging tools\nset(CPAC"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/cmake/HandleEigen.cmake",
"chars": 3844,
"preview": "###############################################################################\n# Option for using system Eigen or GTSAM"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/cmake/HandleFinalChecks.cmake",
"chars": 734,
"preview": "# Print warnings at the end\nif(GTSAM_WITH_TBB AND NOT TBB_FOUND)\n message(WARNING \"TBB 4.4 or newer was not found - t"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/cmake/HandleGeneralOptions.cmake",
"chars": 3239,
"preview": "###############################################################################\n# Set up options\n\n# See whether gtsam_un"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/cmake/HandleGlobalBuildFlags.cmake",
"chars": 2267,
"preview": "# JLBC: These should ideally be ported to \"modern cmake\" via target properties.\n#\n\nif (CMAKE_GENERATOR STREQUAL \"Ninja\" "
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/cmake/HandleMKL.cmake",
"chars": 645,
"preview": "###############################################################################\n# Find MKL\nfind_package(MKL)\n\nif(MKL_FOU"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/cmake/HandleMetis.cmake",
"chars": 1687,
"preview": "###############################################################################\n# Metis library\n\n# For both system or bu"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/cmake/HandleOpenMP.cmake",
"chars": 524,
"preview": "\n###############################################################################\n# Find OpenMP (if we're also using MKL)"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/cmake/HandlePerfTools.cmake",
"chars": 135,
"preview": "\n###############################################################################\n# Find Google perftools\nfind_package(Go"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/cmake/HandlePrintConfiguration.cmake",
"chars": 5303,
"preview": "###############################################################################\n# Print configuration variables\nmessage("
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/cmake/HandlePython.cmake",
"chars": 1784,
"preview": "# Set Python version if either Python or MATLAB wrapper is requested.\nif(GTSAM_BUILD_PYTHON OR GTSAM_INSTALL_MATLAB_TOOL"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/cmake/HandleTBB.cmake",
"chars": 1372,
"preview": "###############################################################################\nif (GTSAM_WITH_TBB)\n # Find TBB\n f"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/cmake/HandleUninstall.cmake",
"chars": 703,
"preview": "# ----------------------------------------------------------------------------\n# Uninstall target, for \"make uninstall"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/cmake/README.html",
"chars": 5704,
"preview": "<h1>GTSAMCMakeTools</h1>\n<p>This is the collection of GTSAM CMake tools that may be useful in external projects. The wa"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/cmake/README.md",
"chars": 4090,
"preview": "# GTSAMCMakeTools\n\nThis is the collection of GTSAM CMake tools that may be useful in external projects. The way to use "
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/cmake/cmake_uninstall.cmake.in",
"chars": 1129,
"preview": "# -----------------------------------------------\n# File that provides \"make uninstall\" target\n# We use the file 'insta"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/cmake/dllexport.h.in",
"chars": 1856,
"preview": "/* ----------------------------------------------------------------------------\n\n * @library_name@ Copyright 2010, Georg"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/cmake/example_cmake_find_gtsam/CMakeLists.txt",
"chars": 686,
"preview": "# This file shows how to build and link a user project against GTSAM using CMake\n#######################################"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/cmake/example_cmake_find_gtsam/main.cpp",
"chars": 6076,
"preview": "/* ----------------------------------------------------------------------------\n * GTSAM Copyright 2010, Georgia Tech Re"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/cmake/obsolete/FindCppUnitLite.cmake",
"chars": 2103,
"preview": "# This is FindCppUnitLite.cmake\n# DEPRECIATED: Use config file approach to pull in targets from gtsam\n# CMake module to "
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/cmake/obsolete/FindWrap.cmake",
"chars": 1813,
"preview": "# This is FindWrap.cmake\n# DEPRECIATED: Use config file approach to pull in targets from gtsam\n# CMake module to locate "
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/cmake/obsolete/GtsamTestingObsolete.cmake",
"chars": 8307,
"preview": "\n# Macro for adding categorized tests in a \"tests\" folder, with\n# optional exclusion of tests and convenience library li"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/doc/.gitignore",
"chars": 21,
"preview": "/html/\n*.lyx~\n*.bib~\n"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/doc/CMakeLists.txt",
"chars": 2663,
"preview": "# Doxygen documentation configuration\noption(GTSAM_BUILD_DOCS \"Enable/Disable building of doxygen docs\""
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/doc/Code/LocalizationExample2.cpp",
"chars": 386,
"preview": "// add unary measurement factors, like GPS, on all three poses\nnoiseModel::Diagonal::shared_ptr unaryNoise =\n noiseModel"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/doc/Code/LocalizationFactor.cpp",
"chars": 574,
"preview": "class UnaryFactor: public NoiseModelFactor1<Pose2> {\n double mx_, my_; ///< X and Y measurements\n\npublic:\n UnaryFactor"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/doc/Code/LocalizationOutput5.txt",
"chars": 526,
"preview": "Final Result:\nValues with 3 values:\nValue 1: (-1.5e-14, 1.3e-15, -1.4e-16)\nValue 2: (2, 3.1e-16, -8.5e-17)\nValue 3: (4, "
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/doc/Code/OdometryExample.cpp",
"chars": 576,
"preview": "// Create an empty nonlinear factor graph\nNonlinearFactorGraph graph;\n\n// Add a Gaussian prior on pose x_1\nPose2 priorMe"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/doc/Code/OdometryMarginals.cpp",
"chars": 291,
"preview": "// Query the marginals\ncout.precision(2);\nMarginals marginals(graph, result);\ncout << \"x1 covariance:\\n\" << marginals.ma"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/doc/Code/OdometryOptimize.cpp",
"chars": 317,
"preview": "// create (deliberatly inaccurate) initial estimate\nValues initial;\ninitial.insert(1, Pose2(0.5, 0.0, 0.2));\ninitial.ins"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/doc/Code/OdometryOutput1.txt",
"chars": 319,
"preview": "Factor Graph:\nsize: 3\nfactor 0: PriorFactor on 1\n prior mean: (0, 0, 0)\n noise model: diagonal sigmas [0.3; 0.3; 0.1];"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/doc/Code/OdometryOutput2.txt",
"chars": 255,
"preview": "Initial Estimate:\nValues with 3 values:\nValue 1: (0.5, 0, 0.2)\nValue 2: (2.3, 0.1, -0.2)\nValue 3: (4.1, 0.1, 0.1)\n\nFinal"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/doc/Code/OdometryOutput3.txt",
"chars": 369,
"preview": "x1 covariance:\n 0.09 1.1e-47 5.7e-33\n 1.1e-47 0.09 1.9e-17\n 5.7e-33 1.9e-17 0."
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/doc/Code/PlanarSLAMExample.m",
"chars": 975,
"preview": "% Create graph container and add factors to it\ngraph = NonlinearFactorGraph;\n\n% Create keys for variables\ni1 = symbol('x"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/doc/Code/PlanarSLAMExample.txt",
"chars": 154,
"preview": ">> result\nValues with 5 values:\n l1: (2, 2)\n l2: (4, 2)\n x1: (-1.8e-16, 5.1e-17, -1.5e-17)\n x2: (2, -5.8e-16, -4.6e-"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/doc/Code/Pose2SLAMExample-graph.m",
"chars": 589,
"preview": "%% Initialize graph, initial estimate, and odometry noise\ndatafile = findExampleDataFile('w100.graph');\nmodel = noiseMod"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/doc/Code/Pose2SLAMExample.cpp",
"chars": 671,
"preview": "NonlinearFactorGraph graph;\nnoiseModel::Diagonal::shared_ptr priorNoise =\n noiseModel::Diagonal::Sigmas(Vector3(0.3, 0."
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/doc/Code/Pose2SLAMExample.m",
"chars": 566,
"preview": "graph = NonlinearFactorGraph;\npriorNoise = noiseModel.Diagonal.Sigmas([0.3; 0.3; 0.1]);\ngraph.add(PriorFactorPose2(1, Po"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/doc/Code/Pose3SLAMExample-graph.m",
"chars": 617,
"preview": "%% Initialize graph, initial estimate, and odometry noise\ndatafile = findExampleDataFile('sphere2500.txt');\nmodel = nois"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/doc/Code/SFMExample.m",
"chars": 293,
"preview": "%% Add factors for all measurements\nnoise = noiseModel.Isotropic.Sigma(2, measurementNoiseSigma);\nfor i = 1:length(Z), \n"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/doc/Code/VisualISAMExample.cpp",
"chars": 703,
"preview": "int relinearizeInterval = 3;\nNonlinearISAM isam(relinearizeInterval);\n\n// ... first frame initialization omitted ...\n\n//"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/doc/Code/calls.txt",
"chars": 93,
"preview": ">> graph.error(initialEstimate)\nans =\n 20.1086\n\n>> graph.error(result)\nans =\n 8.2631e-18\n"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/doc/Code/print.txt",
"chars": 667,
"preview": ">> priorNoise\ndiagonal sigmas [0.3; 0.3; 0.1];\n\n>> graph\nsize: 6\nfactor 0: PriorFactor on 1\n prior mean: (0, 0, 0)\n no"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/doc/Code/whos.txt",
"chars": 465,
"preview": ">> whos\n Name Size Bytes Class\n graph 1x1 112 gtsam.Nonlinea"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/doc/CodingGuidelines.lyx",
"chars": 10079,
"preview": "#LyX 2.0 created this file. For more info see http://www.lyx.org/\n\\lyxformat 413\n\\begin_document\n\\begin_header\n\\textclas"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/doc/Doxyfile.in",
"chars": 76616,
"preview": "# Doxyfile 1.7.5.1\n\n# This file describes the settings to be used by the documentation system\n# doxygen (www.doxygen.org"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/doc/DoxygenLayout.xml",
"chars": 5774,
"preview": "<doxygenlayout version=\"1.0\">\n <!-- Navigation index tabs for HTML output -->\n <navindex>\n <tab type=\"mainpage\" vis"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/doc/ImuFactor.lyx",
"chars": 26649,
"preview": "#LyX 2.0 created this file. For more info see http://www.lyx.org/\n\\lyxformat 413\n\\begin_document\n\\begin_header\n\\textclas"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/doc/LieGroups.lyx",
"chars": 65886,
"preview": "#LyX 2.1 created this file. For more info see http://www.lyx.org/\n\\lyxformat 474\n\\begin_document\n\\begin_header\n\\textclas"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/doc/Mathematica/CalibratedCamera.nb",
"chars": 11606,
"preview": "(* Content-type: application/vnd.wolfram.mathematica *)\n\n(*** Wolfram Notebook File ***)\n(* http://www.wolfram.com/nb *)"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/doc/Mathematica/CalibratedStereoCamera.nb",
"chars": 16581,
"preview": "(* Content-type: application/vnd.wolfram.mathematica *)\n\n(*** Wolfram Notebook File ***)\n(* http://www.wolfram.com/nb *)"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/doc/Mathematica/Quaternion-Logmap.nb",
"chars": 6203,
"preview": "(* Content-type: application/vnd.wolfram.mathematica *)\n\n(*** Wolfram Notebook File ***)\n(* http://www.wolfram.com/nb *)"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/doc/Mathematica/Rot3.nb",
"chars": 55163,
"preview": "(* Content-type: application/vnd.wolfram.mathematica *)\n\n(*** Wolfram Notebook File ***)\n(* http://www.wolfram.com/nb *)"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/doc/Mathematica/StereoCamera.nb",
"chars": 27434,
"preview": "(* Content-type: application/vnd.wolfram.mathematica *)\n\n(*** Wolfram Notebook File ***)\n(* http://www.wolfram.com/nb *)"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/doc/Mathematica/dexpInvL_SE2.nb",
"chars": 19131,
"preview": "(* Content-type: application/vnd.wolfram.mathematica *)\n\n(*** Wolfram Notebook File ***)\n(* http://www.wolfram.com/nb *)"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/doc/cholesky.lyx",
"chars": 2957,
"preview": "#LyX 1.6.7 created this file. For more info see http://www.lyx.org/\n\\lyxformat 345\n\\begin_document\n\\begin_header\n\\textcl"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/doc/common_macros.tex",
"chars": 2559,
"preview": "\\global\\long\\def\\Vector#1{{\\bf #1}}\n \\global\\long\\def\\Matrix#1{{\\bf #1}}\n \n\n\\global\\long\\def\\eq#1{equation (\\ref{eq:=000"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/doc/gtsam-coordinate-frames.lyx",
"chars": 41664,
"preview": "#LyX 2.0 created this file. For more info see http://www.lyx.org/\n\\lyxformat 413\n\\begin_document\n\\begin_header\n\\textclas"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/doc/gtsam.bib",
"chars": 4486,
"preview": "@String { ICCV = {Intl. Conf. on Computer Vision (ICCV)} }\n@String { IROS = {IEEE/RSJ Intl. Conf. on Intellige"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/doc/gtsam.lyx",
"chars": 72802,
"preview": "#LyX 2.2 created this file. For more info see http://www.lyx.org/\n\\lyxformat 508\n\\begin_document\n\\begin_header\n\\save_tra"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/doc/images/gtsam-structure.graffle",
"chars": 62068,
"preview": "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<!DOCTYPE plist PUBLIC \"-//Apple//DTD PLIST 1.0//EN\" \"http://www.apple.com/DTDs/P"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/doc/macros.lyx",
"chars": 5927,
"preview": "#LyX 2.0 created this file. For more info see http://www.lyx.org/\n\\lyxformat 413\n\\begin_document\n\\begin_header\n\\textclas"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/doc/math.lyx",
"chars": 125831,
"preview": "#LyX 2.3 created this file. For more info see http://www.lyx.org/\n\\lyxformat 544\n\\begin_document\n\\begin_header\n\\save_tra"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/doc/refs.bib",
"chars": 713,
"preview": "@article{Iserles00an,\n title =\t {Lie-group methods},\n author =\t {Iserles, Arieh and Munthe-Kaas, Hans Z and\n "
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/doc/stats.html",
"chars": 636852,
"preview": "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n<html xmlns=\"http://www.w3.org/1999/xhtml\">\n\t<head>\n\t\t<meta http-equiv=\"content-t"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/doc/trustregion.bib",
"chars": 590,
"preview": "%% This BibTeX bibliography file was created using BibDesk.\n%% http://bibdesk.sourceforge.net/\n\n\n%% Created for Richard "
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/doc/trustregion.lyx",
"chars": 16684,
"preview": "#LyX 2.1 created this file. For more info see http://www.lyx.org/\n\\lyxformat 474\n\\begin_document\n\\begin_header\n\\textclas"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/docker/README.md",
"chars": 1888,
"preview": "# Instructions\n\n# Images on Docker Hub\n\nThere are 4 images available on https://hub.docker.com/orgs/borglab/repositories"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/docker/ubuntu-boost-tbb/Dockerfile",
"chars": 496,
"preview": "# Basic Ubuntu 18.04 image with Boost and TBB installed. To be used for building further downstream packages.\n\n# Get the"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/docker/ubuntu-boost-tbb/build.sh",
"chars": 144,
"preview": "# Build command for Docker image\n# TODO(dellaert): use docker compose and/or cmake\ndocker build --no-cache -t borglab/ub"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/docker/ubuntu-gtsam/Dockerfile",
"chars": 893,
"preview": "# Ubuntu image with GTSAM installed. Configured with Boost and TBB support.\n\n# Get the base Ubuntu image from Docker Hu"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/docker/ubuntu-gtsam/build.sh",
"chars": 140,
"preview": "# Build command for Docker image\n# TODO(dellaert): use docker compose and/or cmake\ndocker build --no-cache -t borglab/ub"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/docker/ubuntu-gtsam-python/Dockerfile",
"chars": 878,
"preview": "# GTSAM Ubuntu image with Python wrapper support.\n\n# Get the base Ubuntu/GTSAM image from Docker Hub\nFROM borglab/ubunt"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/docker/ubuntu-gtsam-python/build.sh",
"chars": 147,
"preview": "# Build command for Docker image\n# TODO(dellaert): use docker compose and/or cmake\ndocker build --no-cache -t borglab/ub"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/docker/ubuntu-gtsam-python-vnc/Dockerfile",
"chars": 611,
"preview": "# This GTSAM image connects to the host X-server via VNC to provide a Graphical User Interface for interaction.\n\n# Get t"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/docker/ubuntu-gtsam-python-vnc/bootstrap.sh",
"chars": 2505,
"preview": "#!/bin/bash\n\n# Based on: http://www.richud.com/wiki/Ubuntu_Fluxbox_GUI_with_x11vnc_and_Xvfb\n\nmain() {\n log_i \"Startin"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/docker/ubuntu-gtsam-python-vnc/build.sh",
"chars": 202,
"preview": "# Build command for Docker image\n# TODO(dellaert): use docker compose and/or cmake\n# Needs to be run in docker/ubuntu-gt"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/docker/ubuntu-gtsam-python-vnc/vnc.sh",
"chars": 175,
"preview": "# After running this script, connect VNC client to 0.0.0.0:5900\ndocker run -it \\\n --workdir=\"/usr/src/gtsam\" \\\n -p"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/examples/CMakeLists.txt",
"chars": 156,
"preview": "set (excluded_examples\n elaboratePoint2KalmanFilter.cpp\n)\n\ngtsamAddExamplesGlob(\"*.cpp\" \"${excluded_examples}\" \"gtsam"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/examples/CameraResectioning.cpp",
"chars": 3425,
"preview": "/* ----------------------------------------------------------------------------\n\n * GTSAM Copyright 2010, Georgia Tech R"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/examples/CombinedImuFactorsExample.cpp",
"chars": 11355,
"preview": "/* ----------------------------------------------------------------------------\n\n * GTSAM Copyright 2010, Georgia Tech R"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/examples/CreateSFMExampleData.cpp",
"chars": 3967,
"preview": "/* ----------------------------------------------------------------------------\n\n * GTSAM Copyright 2010, Georgia Tech R"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/examples/Data/.gitignore",
"chars": 6,
"preview": "*.txt\n"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/examples/Data/Balbianello.out",
"chars": 70747,
"preview": "# Bundle file v0.3\n5 544\n5.1869203975e+02 -1.1457014134e-01 -3.4479818947e-02\n9.9972739831e-01 5.9754666132e-03 2.257039"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/examples/Data/HS21.QPS",
"chars": 461,
"preview": "NAME HS21\nROWS\n N OBJ.FUNC\n G R------1\nCOLUMNS\n C------1 R------1 0.100000e+02\n C------2 R------1 -"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/examples/Data/HS268.QPS",
"chars": 1966,
"preview": "NAME HS268\nROWS\n N OBJ.FUNC\n G R------1\n G R------2\n G R------3\n G R------4\n G R------5\nCOLUMNS\n C----"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/examples/Data/HS35.QPS",
"chars": 536,
"preview": "NAME HS35\nROWS\n N OBJ.FUNC\n G R------1\nCOLUMNS\n C------1 OBJ.FUNC -.800000e+01 R------1 -.100000e+01\n"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/examples/Data/HS35MOD.QPS",
"chars": 576,
"preview": "NAME HS35MOD\nROWS\n N OBJ.FUNC\n G R------1\nCOLUMNS\n C------1 OBJ.FUNC -.800000e+01 R------1 -.100000e+"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/examples/Data/HS51.QPS",
"chars": 924,
"preview": "NAME HS51\nROWS\n N OBJ.FUNC\n E R------1\n E R------2\n E R------3\nCOLUMNS\n C------1 R------1 0.100000e+01"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/examples/Data/HS52.QPS",
"chars": 887,
"preview": "NAME HS52\nROWS\n N OBJ.FUNC\n E R------1\n E R------2\n E R------3\nCOLUMNS\n C------1 R------1 0.100000e+01"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/examples/Data/Klaus3.g2o",
"chars": 1235,
"preview": "VERTEX_SE3:QUAT 0 -1.6618596980158338 -0.5736497760548741 -3.3319774096611026 -0.02676080288219576 -0.024497002638379624"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/examples/Data/QPExample.QPS",
"chars": 551,
"preview": "NAME QP example\nROWS\n N obj\n G r1\n L r2\nCOLUMNS\n c1 r1 2.0 r2 "
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/examples/Data/QPTEST.QPS",
"chars": 494,
"preview": "NAME QP example\nROWS\n N obj\n G r1\n L r2\nCOLUMNS\n c1 r1 2.0 r2 -1."
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/examples/Data/example.graph",
"chars": 33069,
"preview": "VERTEX2 0 -0.13824042322 0.342115061624 -0.21557075232\nVERTEX2 1 0.612650361503 0.369015313751 -0.0563461272597\nVERTEX2 "
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/examples/Data/example_with_vertices.g2o",
"chars": 847,
"preview": "VERTEX_SE3:QUAT 0 40 -1.15443e-13 10 0.557345 0.557345 -0.435162 -0.435162\nVERTEX_SE3:QUAT 1 28.2843 28.2843 10 0.301633"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/examples/Data/imuAndGPSdata.csv",
"chars": 623728,
"preview": "i,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0\n0,0.000100,0.0,0.0,0.0,0.0,0.0\n1,0.000000,0.0,0.0,0.0,0.0,0.0,1.0\n0,0.000200,0"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/examples/Data/quadraped_imu_data.csv",
"chars": 848654,
"preview": "%time,field.header.seq,field.header.stamp,field.header.frame_id,field.orientation.x,field.orientation.y,field.orientatio"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/examples/Data/randomGrid3D.xml",
"chars": 126070,
"preview": "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\" ?>\n<!DOCTYPE boost_serialization>\n<boost_serialization signature=\""
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/examples/Data/sphere_smallnoise.graph",
"chars": 793977,
"preview": "VERTEX3 0 18.7381 0 98.2287 0 -0 0\nVERTEX3 1 19.0431 1.63954 98.2211 -0.00241135 0.00245691 0.0227253\nVERTEX3 2 19.3024 "
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/examples/Data/toy3D.xml",
"chars": 6066,
"preview": "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\" ?>\n<!DOCTYPE boost_serialization>\n<boost_serialization signature=\""
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/examples/Data/toyExample.g2o",
"chars": 869,
"preview": "VERTEX_SE3:QUAT 0 0 0 0 0 0 0 1\nVERTEX_SE3:QUAT 1 0 0 0 0 0 0 1\nVERTEX_SE3:QUAT 2 0 0 0 0.00499994 0.00499994 0.00499994"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/examples/Data/w100.graph",
"chars": 20262,
"preview": "VERTEX2 0 0 0 0\nVERTEX2 1 0.995595 0.0837204 0.0146728\nVERTEX2 2 2.0463 0.0352563 -0.0332615\nVERTEX2 3 3.01173 0.0011769"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/examples/Data/w10000.graph",
"chars": 4203673,
"preview": "VERTEX2 0 0 0 0\nVERTEX2 1 0.995595 0.0837204 0.0146728\nVERTEX2 2 2.0463 0.0352563 -0.0332615\nVERTEX2 3 3.01173 0.0011769"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/examples/DiscreteBayesNetExample.cpp",
"chars": 2681,
"preview": "/* ----------------------------------------------------------------------------\n\n * GTSAM Copyright 2010, Georgia Tech R"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/examples/DiscreteBayesNet_FG.cpp",
"chars": 4490,
"preview": "/* ----------------------------------------------------------------------------\n\n * GTSAM Copyright 2010, Georgia Tech R"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/examples/FisheyeExample.cpp",
"chars": 4972,
"preview": "/* ----------------------------------------------------------------------------\n\n * GTSAM Copyright 2010, Georgia Tech R"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/examples/HMMExample.cpp",
"chars": 2637,
"preview": "/* ----------------------------------------------------------------------------\n\n * GTSAM Copyright 2010-2020, Georgia T"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/examples/IMUKittiExampleGPS.cpp",
"chars": 14528,
"preview": "/* ----------------------------------------------------------------------------\n\n * GTSAM Copyright 2010, Georgia Tech R"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/examples/ISAM2Example_SmartFactor.cpp",
"chars": 3964,
"preview": "/**\n * @file ISAM2Example_SmartFactor.cpp\n * @brief test of iSAM with smart factors, led to bitbucket issue #367\n * @aut"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/examples/ImuFactorsExample.cpp",
"chars": 12252,
"preview": "/* ----------------------------------------------------------------------------\n\n * GTSAM Copyright 2010, Georgia Tech R"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/examples/ImuFactorsExample2.cpp",
"chars": 5337,
"preview": "/* ----------------------------------------------------------------------------\n\n * GTSAM Copyright 2010, Georgia Tech R"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/examples/InverseKinematicsExampleExpressions.cpp",
"chars": 3100,
"preview": "/* ----------------------------------------------------------------------------\n\n * GTSAM Copyright 2010, Georgia Tech R"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/examples/LocalizationExample.cpp",
"chars": 7515,
"preview": "/* ----------------------------------------------------------------------------\n\n * GTSAM Copyright 2010, Georgia Tech R"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/examples/METISOrderingExample.cpp",
"chars": 2232,
"preview": "/* ----------------------------------------------------------------------------\n\n * GTSAM Copyright 2010, Georgia Tech R"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/examples/OdometryExample.cpp",
"chars": 4273,
"preview": "/* ----------------------------------------------------------------------------\n\n * GTSAM Copyright 2010, Georgia Tech R"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/examples/PlanarSLAMExample.cpp",
"chars": 6473,
"preview": "/* ----------------------------------------------------------------------------\n\n * GTSAM Copyright 2010, Georgia Tech R"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/examples/Pose2SLAMExample.cpp",
"chars": 6008,
"preview": "/* ----------------------------------------------------------------------------\n\n * GTSAM Copyright 2010, Georgia Tech R"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/examples/Pose2SLAMExampleExpressions.cpp",
"chars": 3410,
"preview": "/* ----------------------------------------------------------------------------\n\n * GTSAM Copyright 2010, Georgia Tech R"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/examples/Pose2SLAMExample_g2o.cpp",
"chars": 3401,
"preview": "/* ----------------------------------------------------------------------------\n\n * GTSAM Copyright 2010, Georgia Tech R"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/examples/Pose2SLAMExample_graph.cpp",
"chars": 1996,
"preview": "/* ----------------------------------------------------------------------------\n\n * GTSAM Copyright 2010, Georgia Tech R"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/examples/Pose2SLAMExample_graphviz.cpp",
"chars": 2557,
"preview": "/* ----------------------------------------------------------------------------\n\n * GTSAM Copyright 2010, Georgia Tech R"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/examples/Pose2SLAMExample_lago.cpp",
"chars": 2022,
"preview": "/* ----------------------------------------------------------------------------\n\n * GTSAM Copyright 2010, Georgia Tech R"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/examples/Pose2SLAMStressTest.cpp",
"chars": 2480,
"preview": "/**\n * @file Pose2SLAMStressTest.cpp\n * @brief Test GTSAM on large open-loop chains\n * @date May 23, 2018\n * @author Wen"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/examples/Pose2SLAMwSPCG.cpp",
"chars": 3349,
"preview": "/* ----------------------------------------------------------------------------\n\n * GTSAM Copyright 2010, Georgia Tech R"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/examples/Pose3Localization.cpp",
"chars": 2803,
"preview": "/* ----------------------------------------------------------------------------\n\n * GTSAM Copyright 2010, Georgia Tech R"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/examples/Pose3SLAMExampleExpressions_BearingRangeWithTransform.cpp",
"chars": 4464,
"preview": "/**\n * @file Pose3SLAMExampleExpressions_BearingRangeWithTransform.cpp\n * @brief A simultaneous optimization of tra"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/examples/Pose3SLAMExample_changeKeys.cpp",
"chars": 2769,
"preview": "/* ----------------------------------------------------------------------------\n\n * GTSAM Copyright 2010, Georgia Tech R"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/examples/Pose3SLAMExample_g2o.cpp",
"chars": 2446,
"preview": "/* ----------------------------------------------------------------------------\n\n * GTSAM Copyright 2010, Georgia Tech R"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/examples/Pose3SLAMExample_initializePose3Chordal.cpp",
"chars": 2209,
"preview": "/* ----------------------------------------------------------------------------\n\n * GTSAM Copyright 2010, Georgia Tech R"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/examples/Pose3SLAMExample_initializePose3Gradient.cpp",
"chars": 2438,
"preview": "/* ----------------------------------------------------------------------------\n\n * GTSAM Copyright 2010, Georgia Tech R"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/examples/README.md",
"chars": 4076,
"preview": "# GTSAM Examples\n\nThis directory contains all GTSAM C++ examples GTSAM pertaining to SFM\n\n\n## Basic Examples:\n\n* **Simpl"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/examples/RangeISAMExample_plaza2.cpp",
"chars": 7098,
"preview": "/* ----------------------------------------------------------------------------\n\n * GTSAM Copyright 2010, Georgia Tech R"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/examples/SFMExample.cpp",
"chars": 5438,
"preview": "/* ----------------------------------------------------------------------------\n\n * GTSAM Copyright 2010, Georgia Tech R"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/examples/SFMExampleExpressions.cpp",
"chars": 3648,
"preview": "/* ----------------------------------------------------------------------------\n\n * GTSAM Copyright 2010, Georgia Tech R"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/examples/SFMExampleExpressions_bal.cpp",
"chars": 3877,
"preview": "/* ----------------------------------------------------------------------------\n\n * GTSAM Copyright 2010, Georgia Tech R"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/examples/SFMExample_SmartFactor.cpp",
"chars": 5188,
"preview": "/* ----------------------------------------------------------------------------\n\n * GTSAM Copyright 2010, Georgia Tech R"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/examples/SFMExample_SmartFactorPCG.cpp",
"chars": 4690,
"preview": "/* ----------------------------------------------------------------------------\n\n * GTSAM Copyright 2010, Georgia Tech R"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/examples/SFMExample_bal.cpp",
"chars": 3239,
"preview": "/* ----------------------------------------------------------------------------\n\n * GTSAM Copyright 2010, Georgia Tech R"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/examples/SFMExample_bal_COLAMD_METIS.cpp",
"chars": 4823,
"preview": "/* ----------------------------------------------------------------------------\n\n * GTSAM Copyright 2010, Georgia Tech R"
},
{
"path": "planner/lib/3rdparty/gtsam-4.1.1/examples/SFMdata.h",
"chars": 2801,
"preview": "/* ----------------------------------------------------------------------------\n\n * GTSAM Copyright 2010, Georgia Tech R"
}
]
// ... and 4532 more files (download for full content)
About this extraction
This page contains the full source code of the byangw/PCT_planner GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 4732 files (53.7 MB), approximately 14.4M tokens, and a symbol index with 19545 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.