Copy disabled (too large)
Download .txt
Showing preview only (29,979K chars total). Download the full file to get everything.
Repository: zju3dv/PVO
Branch: main
Commit: c67a15f4e095
Files: 3988
Total size: 27.7 MB
Directory structure:
gitextract_fb98d_ml/
├── .gitignore
├── README.md
├── VO_Module/
│ ├── README.md
│ ├── calib/
│ │ ├── barn.txt
│ │ ├── eth.txt
│ │ ├── euroc.txt
│ │ ├── kitti.txt
│ │ ├── replica.txt
│ │ ├── tartan.txt
│ │ └── tum3.txt
│ ├── demo.py
│ ├── droid_slam/
│ │ ├── data_readers/
│ │ │ ├── __init__.py
│ │ │ ├── augmentation.py
│ │ │ ├── base.py
│ │ │ ├── factory.py
│ │ │ ├── replica.py
│ │ │ ├── replica_test.txt
│ │ │ ├── replica_utils.py
│ │ │ ├── rgbd_utils.py
│ │ │ ├── stream.py
│ │ │ ├── tartan.py
│ │ │ ├── tartan_test.txt
│ │ │ └── vkitti2.py
│ │ ├── depth_video.py
│ │ ├── droid.py
│ │ ├── droid_backend.py
│ │ ├── droid_frontend.py
│ │ ├── droid_net.py
│ │ ├── factor_graph.py
│ │ ├── geom/
│ │ │ ├── __init__.py
│ │ │ ├── ba.py
│ │ │ ├── chol.py
│ │ │ ├── graph_utils.py
│ │ │ ├── losses.py
│ │ │ └── projective_ops.py
│ │ ├── logger.py
│ │ ├── modules/
│ │ │ ├── __init__.py
│ │ │ ├── clipping.py
│ │ │ ├── corr.py
│ │ │ ├── extractor.py
│ │ │ └── gru.py
│ │ ├── motion_filter.py
│ │ ├── trajectory_filler.py
│ │ └── visualization.py
│ ├── environment.yaml
│ ├── environment_novis.yaml
│ ├── evaluation_scripts/
│ │ ├── flow_vis_utils.py
│ │ ├── test_vo.py
│ │ └── test_vo2.py
│ ├── setup.py
│ ├── src/
│ │ ├── altcorr_kernel.cu
│ │ ├── correlation_kernels.cu
│ │ ├── droid.cpp
│ │ └── droid_kernels.cu
│ ├── thirdparty/
│ │ ├── eigen/
│ │ │ ├── .gitignore
│ │ │ ├── .gitlab/
│ │ │ │ ├── issue_templates/
│ │ │ │ │ ├── Bug Report.md
│ │ │ │ │ └── Feature Request.md
│ │ │ │ └── merge_request_templates/
│ │ │ │ └── Merge Request Template.md
│ │ │ ├── .gitlab-ci.yml
│ │ │ ├── .hgeol
│ │ │ ├── CMakeLists.txt
│ │ │ ├── COPYING.APACHE
│ │ │ ├── COPYING.BSD
│ │ │ ├── COPYING.GPL
│ │ │ ├── COPYING.LGPL
│ │ │ ├── COPYING.MINPACK
│ │ │ ├── COPYING.MPL2
│ │ │ ├── COPYING.README
│ │ │ ├── CTestConfig.cmake
│ │ │ ├── CTestCustom.cmake.in
│ │ │ ├── Eigen/
│ │ │ │ ├── Cholesky
│ │ │ │ ├── CholmodSupport
│ │ │ │ ├── Dense
│ │ │ │ ├── Eigen
│ │ │ │ ├── Eigenvalues
│ │ │ │ ├── Geometry
│ │ │ │ ├── Householder
│ │ │ │ ├── IterativeLinearSolvers
│ │ │ │ ├── Jacobi
│ │ │ │ ├── KLUSupport
│ │ │ │ ├── LU
│ │ │ │ ├── MetisSupport
│ │ │ │ ├── OrderingMethods
│ │ │ │ ├── PaStiXSupport
│ │ │ │ ├── PardisoSupport
│ │ │ │ ├── QR
│ │ │ │ ├── QtAlignedMalloc
│ │ │ │ ├── SPQRSupport
│ │ │ │ ├── SVD
│ │ │ │ ├── Sparse
│ │ │ │ ├── SparseCholesky
│ │ │ │ ├── SparseCore
│ │ │ │ ├── SparseLU
│ │ │ │ ├── SparseQR
│ │ │ │ ├── StdDeque
│ │ │ │ ├── StdList
│ │ │ │ ├── StdVector
│ │ │ │ ├── SuperLUSupport
│ │ │ │ ├── UmfPackSupport
│ │ │ │ └── src/
│ │ │ │ ├── Cholesky/
│ │ │ │ │ ├── LDLT.h
│ │ │ │ │ ├── LLT.h
│ │ │ │ │ └── LLT_LAPACKE.h
│ │ │ │ ├── CholmodSupport/
│ │ │ │ │ └── CholmodSupport.h
│ │ │ │ ├── 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_SIMD.h
│ │ │ │ ├── Householder/
│ │ │ │ │ ├── BlockHouseholder.h
│ │ │ │ │ ├── Householder.h
│ │ │ │ │ └── HouseholderSequence.h
│ │ │ │ ├── IterativeLinearSolvers/
│ │ │ │ │ ├── BasicPreconditioners.h
│ │ │ │ │ ├── BiCGSTAB.h
│ │ │ │ │ ├── ConjugateGradient.h
│ │ │ │ │ ├── IncompleteCholesky.h
│ │ │ │ │ ├── IncompleteLUT.h
│ │ │ │ │ ├── IterativeSolverBase.h
│ │ │ │ │ ├── LeastSquareConjugateGradient.h
│ │ │ │ │ └── SolveWithGuess.h
│ │ │ │ ├── Jacobi/
│ │ │ │ │ └── Jacobi.h
│ │ │ │ ├── KLUSupport/
│ │ │ │ │ └── KLUSupport.h
│ │ │ │ ├── LU/
│ │ │ │ │ ├── Determinant.h
│ │ │ │ │ ├── FullPivLU.h
│ │ │ │ │ ├── InverseImpl.h
│ │ │ │ │ ├── PartialPivLU.h
│ │ │ │ │ ├── PartialPivLU_LAPACKE.h
│ │ │ │ │ └── arch/
│ │ │ │ │ └── InverseSize4.h
│ │ │ │ ├── MetisSupport/
│ │ │ │ │ └── MetisSupport.h
│ │ │ │ ├── OrderingMethods/
│ │ │ │ │ ├── Amd.h
│ │ │ │ │ ├── Eigen_Colamd.h
│ │ │ │ │ └── Ordering.h
│ │ │ │ ├── PaStiXSupport/
│ │ │ │ │ └── PaStiXSupport.h
│ │ │ │ ├── PardisoSupport/
│ │ │ │ │ └── PardisoSupport.h
│ │ │ │ ├── QR/
│ │ │ │ │ ├── ColPivHouseholderQR.h
│ │ │ │ │ ├── ColPivHouseholderQR_LAPACKE.h
│ │ │ │ │ ├── CompleteOrthogonalDecomposition.h
│ │ │ │ │ ├── FullPivHouseholderQR.h
│ │ │ │ │ ├── HouseholderQR.h
│ │ │ │ │ └── HouseholderQR_LAPACKE.h
│ │ │ │ ├── SPQRSupport/
│ │ │ │ │ └── SuiteSparseQRSupport.h
│ │ │ │ ├── SVD/
│ │ │ │ │ ├── BDCSVD.h
│ │ │ │ │ ├── JacobiSVD.h
│ │ │ │ │ ├── JacobiSVD_LAPACKE.h
│ │ │ │ │ ├── SVDBase.h
│ │ │ │ │ └── UpperBidiagonalization.h
│ │ │ │ ├── SparseCholesky/
│ │ │ │ │ ├── SimplicialCholesky.h
│ │ │ │ │ └── SimplicialCholesky_impl.h
│ │ │ │ ├── SparseCore/
│ │ │ │ │ ├── AmbiVector.h
│ │ │ │ │ ├── CompressedStorage.h
│ │ │ │ │ ├── ConservativeSparseSparseProduct.h
│ │ │ │ │ ├── MappedSparseMatrix.h
│ │ │ │ │ ├── SparseAssign.h
│ │ │ │ │ ├── SparseBlock.h
│ │ │ │ │ ├── SparseColEtree.h
│ │ │ │ │ ├── SparseCompressedBase.h
│ │ │ │ │ ├── SparseCwiseBinaryOp.h
│ │ │ │ │ ├── SparseCwiseUnaryOp.h
│ │ │ │ │ ├── SparseDenseProduct.h
│ │ │ │ │ ├── SparseDiagonalProduct.h
│ │ │ │ │ ├── SparseDot.h
│ │ │ │ │ ├── SparseFuzzy.h
│ │ │ │ │ ├── SparseMap.h
│ │ │ │ │ ├── SparseMatrix.h
│ │ │ │ │ ├── SparseMatrixBase.h
│ │ │ │ │ ├── SparsePermutation.h
│ │ │ │ │ ├── SparseProduct.h
│ │ │ │ │ ├── SparseRedux.h
│ │ │ │ │ ├── SparseRef.h
│ │ │ │ │ ├── SparseSelfAdjointView.h
│ │ │ │ │ ├── SparseSolverBase.h
│ │ │ │ │ ├── SparseSparseProductWithPruning.h
│ │ │ │ │ ├── SparseTranspose.h
│ │ │ │ │ ├── SparseTriangularView.h
│ │ │ │ │ ├── SparseUtil.h
│ │ │ │ │ ├── SparseVector.h
│ │ │ │ │ ├── SparseView.h
│ │ │ │ │ └── TriangularSolver.h
│ │ │ │ ├── SparseLU/
│ │ │ │ │ ├── SparseLU.h
│ │ │ │ │ ├── SparseLUImpl.h
│ │ │ │ │ ├── SparseLU_Memory.h
│ │ │ │ │ ├── SparseLU_Structs.h
│ │ │ │ │ ├── SparseLU_SupernodalMatrix.h
│ │ │ │ │ ├── SparseLU_Utils.h
│ │ │ │ │ ├── SparseLU_column_bmod.h
│ │ │ │ │ ├── SparseLU_column_dfs.h
│ │ │ │ │ ├── SparseLU_copy_to_ucol.h
│ │ │ │ │ ├── SparseLU_gemm_kernel.h
│ │ │ │ │ ├── SparseLU_heap_relax_snode.h
│ │ │ │ │ ├── SparseLU_kernel_bmod.h
│ │ │ │ │ ├── SparseLU_panel_bmod.h
│ │ │ │ │ ├── SparseLU_panel_dfs.h
│ │ │ │ │ ├── SparseLU_pivotL.h
│ │ │ │ │ ├── SparseLU_pruneL.h
│ │ │ │ │ └── SparseLU_relax_snode.h
│ │ │ │ ├── SparseQR/
│ │ │ │ │ └── SparseQR.h
│ │ │ │ ├── StlSupport/
│ │ │ │ │ ├── StdDeque.h
│ │ │ │ │ ├── StdList.h
│ │ │ │ │ ├── StdVector.h
│ │ │ │ │ └── details.h
│ │ │ │ ├── SuperLUSupport/
│ │ │ │ │ └── SuperLUSupport.h
│ │ │ │ ├── UmfPackSupport/
│ │ │ │ │ └── UmfPackSupport.h
│ │ │ │ ├── misc/
│ │ │ │ │ ├── Image.h
│ │ │ │ │ ├── Kernel.h
│ │ │ │ │ ├── RealSvd2x2.h
│ │ │ │ │ ├── blas.h
│ │ │ │ │ ├── lapack.h
│ │ │ │ │ ├── lapacke.h
│ │ │ │ │ └── lapacke_mangling.h
│ │ │ │ └── plugins/
│ │ │ │ ├── ArrayCwiseBinaryOps.h
│ │ │ │ ├── ArrayCwiseUnaryOps.h
│ │ │ │ ├── BlockMethods.h
│ │ │ │ ├── CommonCwiseBinaryOps.h
│ │ │ │ ├── CommonCwiseUnaryOps.h
│ │ │ │ ├── IndexedViewMethods.h
│ │ │ │ ├── MatrixCwiseBinaryOps.h
│ │ │ │ ├── MatrixCwiseUnaryOps.h
│ │ │ │ └── ReshapedMethods.h
│ │ │ ├── INSTALL
│ │ │ ├── README.md
│ │ │ ├── bench/
│ │ │ │ ├── BenchSparseUtil.h
│ │ │ │ ├── BenchTimer.h
│ │ │ │ ├── BenchUtil.h
│ │ │ │ ├── README.txt
│ │ │ │ ├── analyze-blocking-sizes.cpp
│ │ │ │ ├── basicbench.cxxlist
│ │ │ │ ├── basicbenchmark.cpp
│ │ │ │ ├── basicbenchmark.h
│ │ │ │ ├── benchBlasGemm.cpp
│ │ │ │ ├── benchCholesky.cpp
│ │ │ │ ├── benchEigenSolver.cpp
│ │ │ │ ├── benchFFT.cpp
│ │ │ │ ├── benchGeometry.cpp
│ │ │ │ ├── benchVecAdd.cpp
│ │ │ │ ├── bench_gemm.cpp
│ │ │ │ ├── bench_move_semantics.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/
│ │ │ │ │ ├── changesets.txt
│ │ │ │ │ ├── gemm.cpp
│ │ │ │ │ ├── gemm_common.h
│ │ │ │ │ ├── gemm_settings.txt
│ │ │ │ │ ├── gemm_square_settings.txt
│ │ │ │ │ ├── gemv.cpp
│ │ │ │ │ ├── gemv_common.h
│ │ │ │ │ ├── gemv_settings.txt
│ │ │ │ │ ├── gemv_square_settings.txt
│ │ │ │ │ ├── gemvt.cpp
│ │ │ │ │ ├── lazy_gemm.cpp
│ │ │ │ │ ├── lazy_gemm_settings.txt
│ │ │ │ │ ├── llt.cpp
│ │ │ │ │ ├── make_plot.sh
│ │ │ │ │ ├── resources/
│ │ │ │ │ │ ├── chart_footer.html
│ │ │ │ │ │ ├── chart_header.html
│ │ │ │ │ │ ├── footer.html
│ │ │ │ │ │ ├── header.html
│ │ │ │ │ │ ├── s1.js
│ │ │ │ │ │ └── s2.js
│ │ │ │ │ ├── run.sh
│ │ │ │ │ ├── runall.sh
│ │ │ │ │ ├── trmv_lo.cpp
│ │ │ │ │ ├── trmv_lot.cpp
│ │ │ │ │ ├── trmv_up.cpp
│ │ │ │ │ └── trmv_upt.cpp
│ │ │ │ ├── product_threshold.cpp
│ │ │ │ ├── quat_slerp.cpp
│ │ │ │ ├── quatmul.cpp
│ │ │ │ ├── sparse_cholesky.cpp
│ │ │ │ ├── sparse_dense_product.cpp
│ │ │ │ ├── sparse_lu.cpp
│ │ │ │ ├── sparse_product.cpp
│ │ │ │ ├── sparse_randomsetter.cpp
│ │ │ │ ├── sparse_setter.cpp
│ │ │ │ ├── sparse_transpose.cpp
│ │ │ │ ├── sparse_trisolver.cpp
│ │ │ │ ├── spbench/
│ │ │ │ │ ├── CMakeLists.txt
│ │ │ │ │ ├── sp_solver.cpp
│ │ │ │ │ ├── spbench.dtd
│ │ │ │ │ ├── spbenchsolver.cpp
│ │ │ │ │ ├── spbenchsolver.h
│ │ │ │ │ ├── spbenchstyle.h
│ │ │ │ │ └── test_sparseLU.cpp
│ │ │ │ ├── spmv.cpp
│ │ │ │ ├── tensors/
│ │ │ │ │ ├── README
│ │ │ │ │ ├── benchmark.h
│ │ │ │ │ ├── benchmark_main.cc
│ │ │ │ │ ├── contraction_benchmarks_cpu.cc
│ │ │ │ │ ├── eigen_sycl_bench.sh
│ │ │ │ │ ├── eigen_sycl_bench_contract.sh
│ │ │ │ │ ├── tensor_benchmarks.h
│ │ │ │ │ ├── tensor_benchmarks_cpu.cc
│ │ │ │ │ ├── tensor_benchmarks_fp16_gpu.cu
│ │ │ │ │ ├── tensor_benchmarks_gpu.cu
│ │ │ │ │ ├── tensor_benchmarks_sycl.cc
│ │ │ │ │ └── tensor_contract_sycl_bench.cc
│ │ │ │ └── vdw_new.cpp
│ │ │ ├── blas/
│ │ │ │ ├── BandTriangularSolver.h
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── GeneralRank1Update.h
│ │ │ │ ├── PackedSelfadjointProduct.h
│ │ │ │ ├── PackedTriangularMatrixVector.h
│ │ │ │ ├── PackedTriangularSolverVector.h
│ │ │ │ ├── README.txt
│ │ │ │ ├── Rank2Update.h
│ │ │ │ ├── common.h
│ │ │ │ ├── complex_double.cpp
│ │ │ │ ├── complex_single.cpp
│ │ │ │ ├── double.cpp
│ │ │ │ ├── f2c/
│ │ │ │ │ ├── chbmv.c
│ │ │ │ │ ├── chpmv.c
│ │ │ │ │ ├── complexdots.c
│ │ │ │ │ ├── ctbmv.c
│ │ │ │ │ ├── d_cnjg.c
│ │ │ │ │ ├── datatypes.h
│ │ │ │ │ ├── drotm.c
│ │ │ │ │ ├── drotmg.c
│ │ │ │ │ ├── dsbmv.c
│ │ │ │ │ ├── dspmv.c
│ │ │ │ │ ├── dtbmv.c
│ │ │ │ │ ├── lsame.c
│ │ │ │ │ ├── r_cnjg.c
│ │ │ │ │ ├── srotm.c
│ │ │ │ │ ├── srotmg.c
│ │ │ │ │ ├── ssbmv.c
│ │ │ │ │ ├── sspmv.c
│ │ │ │ │ ├── stbmv.c
│ │ │ │ │ ├── zhbmv.c
│ │ │ │ │ ├── zhpmv.c
│ │ │ │ │ └── ztbmv.c
│ │ │ │ ├── fortran/
│ │ │ │ │ └── complexdots.f
│ │ │ │ ├── level1_cplx_impl.h
│ │ │ │ ├── level1_impl.h
│ │ │ │ ├── level1_real_impl.h
│ │ │ │ ├── level2_cplx_impl.h
│ │ │ │ ├── level2_impl.h
│ │ │ │ ├── level2_real_impl.h
│ │ │ │ ├── level3_impl.h
│ │ │ │ ├── single.cpp
│ │ │ │ ├── testing/
│ │ │ │ │ ├── CMakeLists.txt
│ │ │ │ │ ├── cblat1.f
│ │ │ │ │ ├── cblat2.f
│ │ │ │ │ ├── cblat3.f
│ │ │ │ │ ├── dblat1.f
│ │ │ │ │ ├── dblat2.f
│ │ │ │ │ ├── dblat3.f
│ │ │ │ │ ├── runblastest.sh
│ │ │ │ │ ├── sblat1.f
│ │ │ │ │ ├── sblat2.f
│ │ │ │ │ ├── sblat3.f
│ │ │ │ │ ├── zblat1.f
│ │ │ │ │ ├── zblat2.f
│ │ │ │ │ └── zblat3.f
│ │ │ │ └── xerbla.cpp
│ │ │ ├── ci/
│ │ │ │ ├── CTest2JUnit.xsl
│ │ │ │ ├── README.md
│ │ │ │ ├── smoketests.gitlab-ci.yml
│ │ │ │ └── test.gitlab-ci.yml
│ │ │ ├── cmake/
│ │ │ │ ├── ComputeCppCompilerChecks.cmake
│ │ │ │ ├── ComputeCppIRMap.cmake
│ │ │ │ ├── Eigen3Config.cmake.in
│ │ │ │ ├── EigenConfigureTesting.cmake
│ │ │ │ ├── EigenDetermineOSVersion.cmake
│ │ │ │ ├── EigenDetermineVSServicePack.cmake
│ │ │ │ ├── EigenSmokeTestList.cmake
│ │ │ │ ├── EigenTesting.cmake
│ │ │ │ ├── EigenUninstall.cmake
│ │ │ │ ├── FindAdolc.cmake
│ │ │ │ ├── FindBLAS.cmake
│ │ │ │ ├── FindBLASEXT.cmake
│ │ │ │ ├── FindCHOLMOD.cmake
│ │ │ │ ├── FindComputeCpp.cmake
│ │ │ │ ├── FindFFTW.cmake
│ │ │ │ ├── FindGLEW.cmake
│ │ │ │ ├── FindGMP.cmake
│ │ │ │ ├── FindGSL.cmake
│ │ │ │ ├── FindGoogleHash.cmake
│ │ │ │ ├── FindHWLOC.cmake
│ │ │ │ ├── FindKLU.cmake
│ │ │ │ ├── FindLAPACK.cmake
│ │ │ │ ├── FindMPFR.cmake
│ │ │ │ ├── FindMPREAL.cmake
│ │ │ │ ├── FindMetis.cmake
│ │ │ │ ├── FindPASTIX.cmake
│ │ │ │ ├── FindPTSCOTCH.cmake
│ │ │ │ ├── FindSCOTCH.cmake
│ │ │ │ ├── FindSPQR.cmake
│ │ │ │ ├── FindStandardMathLibrary.cmake
│ │ │ │ ├── FindSuperLU.cmake
│ │ │ │ ├── FindTriSYCL.cmake
│ │ │ │ ├── FindUMFPACK.cmake
│ │ │ │ └── RegexUtils.cmake
│ │ │ ├── debug/
│ │ │ │ ├── gdb/
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ └── printers.py
│ │ │ │ └── msvc/
│ │ │ │ └── eigen.natvis
│ │ │ ├── demos/
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── mandelbrot/
│ │ │ │ │ ├── CMakeLists.txt
│ │ │ │ │ ├── README
│ │ │ │ │ ├── mandelbrot.cpp
│ │ │ │ │ └── mandelbrot.h
│ │ │ │ ├── mix_eigen_and_c/
│ │ │ │ │ ├── README
│ │ │ │ │ ├── binary_library.cpp
│ │ │ │ │ ├── binary_library.h
│ │ │ │ │ └── example.c
│ │ │ │ └── opengl/
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── README
│ │ │ │ ├── camera.cpp
│ │ │ │ ├── camera.h
│ │ │ │ ├── gpuhelper.cpp
│ │ │ │ ├── gpuhelper.h
│ │ │ │ ├── icosphere.cpp
│ │ │ │ ├── icosphere.h
│ │ │ │ ├── quaternion_demo.cpp
│ │ │ │ ├── quaternion_demo.h
│ │ │ │ ├── trackball.cpp
│ │ │ │ └── trackball.h
│ │ │ ├── doc/
│ │ │ │ ├── AsciiQuickReference.txt
│ │ │ │ ├── B01_Experimental.dox
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── ClassHierarchy.dox
│ │ │ │ ├── CoeffwiseMathFunctionsTable.dox
│ │ │ │ ├── CustomizingEigen_CustomScalar.dox
│ │ │ │ ├── CustomizingEigen_InheritingMatrix.dox
│ │ │ │ ├── CustomizingEigen_NullaryExpr.dox
│ │ │ │ ├── CustomizingEigen_Plugins.dox
│ │ │ │ ├── DenseDecompositionBenchmark.dox
│ │ │ │ ├── Doxyfile.in
│ │ │ │ ├── FixedSizeVectorizable.dox
│ │ │ │ ├── FunctionsTakingEigenTypes.dox
│ │ │ │ ├── HiPerformance.dox
│ │ │ │ ├── InplaceDecomposition.dox
│ │ │ │ ├── InsideEigenExample.dox
│ │ │ │ ├── LeastSquares.dox
│ │ │ │ ├── Manual.dox
│ │ │ │ ├── MatrixfreeSolverExample.dox
│ │ │ │ ├── NewExpressionType.dox
│ │ │ │ ├── Overview.dox
│ │ │ │ ├── PassingByValue.dox
│ │ │ │ ├── Pitfalls.dox
│ │ │ │ ├── PreprocessorDirectives.dox
│ │ │ │ ├── QuickReference.dox
│ │ │ │ ├── QuickStartGuide.dox
│ │ │ │ ├── SparseLinearSystems.dox
│ │ │ │ ├── SparseQuickReference.dox
│ │ │ │ ├── StlContainers.dox
│ │ │ │ ├── StorageOrders.dox
│ │ │ │ ├── StructHavingEigenMembers.dox
│ │ │ │ ├── TemplateKeyword.dox
│ │ │ │ ├── TopicAliasing.dox
│ │ │ │ ├── TopicAssertions.dox
│ │ │ │ ├── TopicCMakeGuide.dox
│ │ │ │ ├── TopicEigenExpressionTemplates.dox
│ │ │ │ ├── TopicLazyEvaluation.dox
│ │ │ │ ├── TopicLinearAlgebraDecompositions.dox
│ │ │ │ ├── TopicMultithreading.dox
│ │ │ │ ├── TopicResizing.dox
│ │ │ │ ├── TopicScalarTypes.dox
│ │ │ │ ├── TopicVectorization.dox
│ │ │ │ ├── TutorialAdvancedInitialization.dox
│ │ │ │ ├── TutorialArrayClass.dox
│ │ │ │ ├── TutorialBlockOperations.dox
│ │ │ │ ├── TutorialGeometry.dox
│ │ │ │ ├── TutorialLinearAlgebra.dox
│ │ │ │ ├── TutorialMapClass.dox
│ │ │ │ ├── TutorialMatrixArithmetic.dox
│ │ │ │ ├── TutorialMatrixClass.dox
│ │ │ │ ├── TutorialReductionsVisitorsBroadcasting.dox
│ │ │ │ ├── TutorialReshape.dox
│ │ │ │ ├── TutorialSTL.dox
│ │ │ │ ├── TutorialSlicingIndexing.dox
│ │ │ │ ├── TutorialSparse.dox
│ │ │ │ ├── TutorialSparse_example_details.dox
│ │ │ │ ├── UnalignedArrayAssert.dox
│ │ │ │ ├── UsingBlasLapackBackends.dox
│ │ │ │ ├── UsingIntelMKL.dox
│ │ │ │ ├── UsingNVCC.dox
│ │ │ │ ├── WrongStackAlignment.dox
│ │ │ │ ├── eigen_navtree_hacks.js
│ │ │ │ ├── eigendoxy.css
│ │ │ │ ├── eigendoxy_footer.html.in
│ │ │ │ ├── eigendoxy_header.html.in
│ │ │ │ ├── eigendoxy_layout.xml.in
│ │ │ │ ├── eigendoxy_tabs.css
│ │ │ │ ├── examples/
│ │ │ │ │ ├── .krazy
│ │ │ │ │ ├── CMakeLists.txt
│ │ │ │ │ ├── CustomizingEigen_Inheritance.cpp
│ │ │ │ │ ├── Cwise_erf.cpp
│ │ │ │ │ ├── Cwise_erfc.cpp
│ │ │ │ │ ├── Cwise_lgamma.cpp
│ │ │ │ │ ├── DenseBase_middleCols_int.cpp
│ │ │ │ │ ├── DenseBase_middleRows_int.cpp
│ │ │ │ │ ├── DenseBase_template_int_middleCols.cpp
│ │ │ │ │ ├── DenseBase_template_int_middleRows.cpp
│ │ │ │ │ ├── QuickStart_example.cpp
│ │ │ │ │ ├── QuickStart_example2_dynamic.cpp
│ │ │ │ │ ├── QuickStart_example2_fixed.cpp
│ │ │ │ │ ├── TemplateKeyword_flexible.cpp
│ │ │ │ │ ├── TemplateKeyword_simple.cpp
│ │ │ │ │ ├── TutorialInplaceLU.cpp
│ │ │ │ │ ├── TutorialLinAlgComputeTwice.cpp
│ │ │ │ │ ├── TutorialLinAlgExComputeSolveError.cpp
│ │ │ │ │ ├── TutorialLinAlgExSolveColPivHouseholderQR.cpp
│ │ │ │ │ ├── TutorialLinAlgExSolveLDLT.cpp
│ │ │ │ │ ├── TutorialLinAlgInverseDeterminant.cpp
│ │ │ │ │ ├── TutorialLinAlgRankRevealing.cpp
│ │ │ │ │ ├── TutorialLinAlgSVDSolve.cpp
│ │ │ │ │ ├── TutorialLinAlgSelfAdjointEigenSolver.cpp
│ │ │ │ │ ├── TutorialLinAlgSetThreshold.cpp
│ │ │ │ │ ├── Tutorial_ArrayClass_accessors.cpp
│ │ │ │ │ ├── Tutorial_ArrayClass_addition.cpp
│ │ │ │ │ ├── Tutorial_ArrayClass_cwise_other.cpp
│ │ │ │ │ ├── Tutorial_ArrayClass_interop.cpp
│ │ │ │ │ ├── Tutorial_ArrayClass_interop_matrix.cpp
│ │ │ │ │ ├── Tutorial_ArrayClass_mult.cpp
│ │ │ │ │ ├── Tutorial_BlockOperations_block_assignment.cpp
│ │ │ │ │ ├── Tutorial_BlockOperations_colrow.cpp
│ │ │ │ │ ├── Tutorial_BlockOperations_corner.cpp
│ │ │ │ │ ├── Tutorial_BlockOperations_print_block.cpp
│ │ │ │ │ ├── Tutorial_BlockOperations_vector.cpp
│ │ │ │ │ ├── Tutorial_PartialLU_solve.cpp
│ │ │ │ │ ├── Tutorial_ReductionsVisitorsBroadcasting_broadcast_1nn.cpp
│ │ │ │ │ ├── Tutorial_ReductionsVisitorsBroadcasting_broadcast_simple.cpp
│ │ │ │ │ ├── Tutorial_ReductionsVisitorsBroadcasting_broadcast_simple_rowwise.cpp
│ │ │ │ │ ├── Tutorial_ReductionsVisitorsBroadcasting_colwise.cpp
│ │ │ │ │ ├── Tutorial_ReductionsVisitorsBroadcasting_maxnorm.cpp
│ │ │ │ │ ├── Tutorial_ReductionsVisitorsBroadcasting_reductions_bool.cpp
│ │ │ │ │ ├── Tutorial_ReductionsVisitorsBroadcasting_reductions_norm.cpp
│ │ │ │ │ ├── Tutorial_ReductionsVisitorsBroadcasting_reductions_operatornorm.cpp
│ │ │ │ │ ├── Tutorial_ReductionsVisitorsBroadcasting_rowwise.cpp
│ │ │ │ │ ├── Tutorial_ReductionsVisitorsBroadcasting_visitors.cpp
│ │ │ │ │ ├── Tutorial_simple_example_dynamic_size.cpp
│ │ │ │ │ ├── Tutorial_simple_example_fixed_size.cpp
│ │ │ │ │ ├── class_Block.cpp
│ │ │ │ │ ├── class_CwiseBinaryOp.cpp
│ │ │ │ │ ├── class_CwiseUnaryOp.cpp
│ │ │ │ │ ├── class_CwiseUnaryOp_ptrfun.cpp
│ │ │ │ │ ├── class_FixedBlock.cpp
│ │ │ │ │ ├── class_FixedReshaped.cpp
│ │ │ │ │ ├── class_FixedVectorBlock.cpp
│ │ │ │ │ ├── class_Reshaped.cpp
│ │ │ │ │ ├── class_VectorBlock.cpp
│ │ │ │ │ ├── function_taking_eigenbase.cpp
│ │ │ │ │ ├── function_taking_ref.cpp
│ │ │ │ │ ├── make_circulant.cpp
│ │ │ │ │ ├── make_circulant.cpp.entry
│ │ │ │ │ ├── make_circulant.cpp.evaluator
│ │ │ │ │ ├── make_circulant.cpp.expression
│ │ │ │ │ ├── make_circulant.cpp.main
│ │ │ │ │ ├── make_circulant.cpp.preamble
│ │ │ │ │ ├── make_circulant.cpp.traits
│ │ │ │ │ ├── make_circulant2.cpp
│ │ │ │ │ ├── matrixfree_cg.cpp
│ │ │ │ │ ├── nullary_indexing.cpp
│ │ │ │ │ ├── tut_arithmetic_add_sub.cpp
│ │ │ │ │ ├── tut_arithmetic_dot_cross.cpp
│ │ │ │ │ ├── tut_arithmetic_matrix_mul.cpp
│ │ │ │ │ ├── tut_arithmetic_redux_basic.cpp
│ │ │ │ │ ├── tut_arithmetic_scalar_mul_div.cpp
│ │ │ │ │ ├── tut_matrix_coefficient_accessors.cpp
│ │ │ │ │ ├── tut_matrix_resize.cpp
│ │ │ │ │ └── tut_matrix_resize_fixed_size.cpp
│ │ │ │ ├── snippets/
│ │ │ │ │ ├── .krazy
│ │ │ │ │ ├── AngleAxis_mimic_euler.cpp
│ │ │ │ │ ├── Array_initializer_list_23_cxx11.cpp
│ │ │ │ │ ├── Array_initializer_list_vector_cxx11.cpp
│ │ │ │ │ ├── Array_variadic_ctor_cxx11.cpp
│ │ │ │ │ ├── BiCGSTAB_simple.cpp
│ │ │ │ │ ├── BiCGSTAB_step_by_step.cpp
│ │ │ │ │ ├── CMakeLists.txt
│ │ │ │ │ ├── ColPivHouseholderQR_solve.cpp
│ │ │ │ │ ├── ComplexEigenSolver_compute.cpp
│ │ │ │ │ ├── ComplexEigenSolver_eigenvalues.cpp
│ │ │ │ │ ├── ComplexEigenSolver_eigenvectors.cpp
│ │ │ │ │ ├── ComplexSchur_compute.cpp
│ │ │ │ │ ├── ComplexSchur_matrixT.cpp
│ │ │ │ │ ├── ComplexSchur_matrixU.cpp
│ │ │ │ │ ├── Cwise_abs.cpp
│ │ │ │ │ ├── Cwise_abs2.cpp
│ │ │ │ │ ├── Cwise_acos.cpp
│ │ │ │ │ ├── Cwise_arg.cpp
│ │ │ │ │ ├── Cwise_array_power_array.cpp
│ │ │ │ │ ├── Cwise_asin.cpp
│ │ │ │ │ ├── Cwise_atan.cpp
│ │ │ │ │ ├── Cwise_boolean_and.cpp
│ │ │ │ │ ├── Cwise_boolean_not.cpp
│ │ │ │ │ ├── Cwise_boolean_or.cpp
│ │ │ │ │ ├── Cwise_boolean_xor.cpp
│ │ │ │ │ ├── Cwise_ceil.cpp
│ │ │ │ │ ├── Cwise_cos.cpp
│ │ │ │ │ ├── Cwise_cosh.cpp
│ │ │ │ │ ├── Cwise_cube.cpp
│ │ │ │ │ ├── Cwise_equal_equal.cpp
│ │ │ │ │ ├── Cwise_exp.cpp
│ │ │ │ │ ├── Cwise_floor.cpp
│ │ │ │ │ ├── Cwise_greater.cpp
│ │ │ │ │ ├── Cwise_greater_equal.cpp
│ │ │ │ │ ├── Cwise_inverse.cpp
│ │ │ │ │ ├── Cwise_isFinite.cpp
│ │ │ │ │ ├── Cwise_isInf.cpp
│ │ │ │ │ ├── Cwise_isNaN.cpp
│ │ │ │ │ ├── Cwise_less.cpp
│ │ │ │ │ ├── Cwise_less_equal.cpp
│ │ │ │ │ ├── Cwise_log.cpp
│ │ │ │ │ ├── Cwise_log10.cpp
│ │ │ │ │ ├── Cwise_max.cpp
│ │ │ │ │ ├── Cwise_min.cpp
│ │ │ │ │ ├── Cwise_minus.cpp
│ │ │ │ │ ├── Cwise_minus_equal.cpp
│ │ │ │ │ ├── Cwise_not_equal.cpp
│ │ │ │ │ ├── Cwise_plus.cpp
│ │ │ │ │ ├── Cwise_plus_equal.cpp
│ │ │ │ │ ├── Cwise_pow.cpp
│ │ │ │ │ ├── Cwise_product.cpp
│ │ │ │ │ ├── Cwise_quotient.cpp
│ │ │ │ │ ├── Cwise_rint.cpp
│ │ │ │ │ ├── Cwise_round.cpp
│ │ │ │ │ ├── Cwise_scalar_power_array.cpp
│ │ │ │ │ ├── Cwise_sign.cpp
│ │ │ │ │ ├── Cwise_sin.cpp
│ │ │ │ │ ├── Cwise_sinh.cpp
│ │ │ │ │ ├── Cwise_slash_equal.cpp
│ │ │ │ │ ├── Cwise_sqrt.cpp
│ │ │ │ │ ├── Cwise_square.cpp
│ │ │ │ │ ├── Cwise_tan.cpp
│ │ │ │ │ ├── Cwise_tanh.cpp
│ │ │ │ │ ├── Cwise_times_equal.cpp
│ │ │ │ │ ├── DenseBase_LinSpaced.cpp
│ │ │ │ │ ├── DenseBase_LinSpacedInt.cpp
│ │ │ │ │ ├── DenseBase_LinSpaced_seq_deprecated.cpp
│ │ │ │ │ ├── DenseBase_setLinSpaced.cpp
│ │ │ │ │ ├── DirectionWise_hnormalized.cpp
│ │ │ │ │ ├── DirectionWise_replicate.cpp
│ │ │ │ │ ├── DirectionWise_replicate_int.cpp
│ │ │ │ │ ├── EigenSolver_EigenSolver_MatrixType.cpp
│ │ │ │ │ ├── EigenSolver_compute.cpp
│ │ │ │ │ ├── EigenSolver_eigenvalues.cpp
│ │ │ │ │ ├── EigenSolver_eigenvectors.cpp
│ │ │ │ │ ├── EigenSolver_pseudoEigenvectors.cpp
│ │ │ │ │ ├── FullPivHouseholderQR_solve.cpp
│ │ │ │ │ ├── FullPivLU_image.cpp
│ │ │ │ │ ├── FullPivLU_kernel.cpp
│ │ │ │ │ ├── FullPivLU_solve.cpp
│ │ │ │ │ ├── GeneralizedEigenSolver.cpp
│ │ │ │ │ ├── HessenbergDecomposition_compute.cpp
│ │ │ │ │ ├── HessenbergDecomposition_matrixH.cpp
│ │ │ │ │ ├── HessenbergDecomposition_packedMatrix.cpp
│ │ │ │ │ ├── HouseholderQR_householderQ.cpp
│ │ │ │ │ ├── HouseholderQR_solve.cpp
│ │ │ │ │ ├── HouseholderSequence_HouseholderSequence.cpp
│ │ │ │ │ ├── IOFormat.cpp
│ │ │ │ │ ├── JacobiSVD_basic.cpp
│ │ │ │ │ ├── Jacobi_makeGivens.cpp
│ │ │ │ │ ├── Jacobi_makeJacobi.cpp
│ │ │ │ │ ├── LLT_example.cpp
│ │ │ │ │ ├── LLT_solve.cpp
│ │ │ │ │ ├── LeastSquaresNormalEquations.cpp
│ │ │ │ │ ├── LeastSquaresQR.cpp
│ │ │ │ │ ├── Map_general_stride.cpp
│ │ │ │ │ ├── Map_inner_stride.cpp
│ │ │ │ │ ├── Map_outer_stride.cpp
│ │ │ │ │ ├── Map_placement_new.cpp
│ │ │ │ │ ├── Map_simple.cpp
│ │ │ │ │ ├── MatrixBase_adjoint.cpp
│ │ │ │ │ ├── MatrixBase_all.cpp
│ │ │ │ │ ├── MatrixBase_applyOnTheLeft.cpp
│ │ │ │ │ ├── MatrixBase_applyOnTheRight.cpp
│ │ │ │ │ ├── MatrixBase_array.cpp
│ │ │ │ │ ├── MatrixBase_array_const.cpp
│ │ │ │ │ ├── MatrixBase_asDiagonal.cpp
│ │ │ │ │ ├── MatrixBase_block_int_int.cpp
│ │ │ │ │ ├── MatrixBase_block_int_int_int_int.cpp
│ │ │ │ │ ├── MatrixBase_bottomLeftCorner_int_int.cpp
│ │ │ │ │ ├── MatrixBase_bottomRightCorner_int_int.cpp
│ │ │ │ │ ├── MatrixBase_bottomRows_int.cpp
│ │ │ │ │ ├── MatrixBase_cast.cpp
│ │ │ │ │ ├── MatrixBase_col.cpp
│ │ │ │ │ ├── MatrixBase_colwise.cpp
│ │ │ │ │ ├── MatrixBase_colwise_iterator_cxx11.cpp
│ │ │ │ │ ├── MatrixBase_computeInverseAndDetWithCheck.cpp
│ │ │ │ │ ├── MatrixBase_computeInverseWithCheck.cpp
│ │ │ │ │ ├── MatrixBase_cwiseAbs.cpp
│ │ │ │ │ ├── MatrixBase_cwiseAbs2.cpp
│ │ │ │ │ ├── MatrixBase_cwiseArg.cpp
│ │ │ │ │ ├── MatrixBase_cwiseEqual.cpp
│ │ │ │ │ ├── MatrixBase_cwiseInverse.cpp
│ │ │ │ │ ├── MatrixBase_cwiseMax.cpp
│ │ │ │ │ ├── MatrixBase_cwiseMin.cpp
│ │ │ │ │ ├── MatrixBase_cwiseNotEqual.cpp
│ │ │ │ │ ├── MatrixBase_cwiseProduct.cpp
│ │ │ │ │ ├── MatrixBase_cwiseQuotient.cpp
│ │ │ │ │ ├── MatrixBase_cwiseSign.cpp
│ │ │ │ │ ├── MatrixBase_cwiseSqrt.cpp
│ │ │ │ │ ├── MatrixBase_diagonal.cpp
│ │ │ │ │ ├── MatrixBase_diagonal_int.cpp
│ │ │ │ │ ├── MatrixBase_diagonal_template_int.cpp
│ │ │ │ │ ├── MatrixBase_eigenvalues.cpp
│ │ │ │ │ ├── MatrixBase_end_int.cpp
│ │ │ │ │ ├── MatrixBase_eval.cpp
│ │ │ │ │ ├── MatrixBase_fixedBlock_int_int.cpp
│ │ │ │ │ ├── MatrixBase_hnormalized.cpp
│ │ │ │ │ ├── MatrixBase_homogeneous.cpp
│ │ │ │ │ ├── MatrixBase_identity.cpp
│ │ │ │ │ ├── MatrixBase_identity_int_int.cpp
│ │ │ │ │ ├── MatrixBase_inverse.cpp
│ │ │ │ │ ├── MatrixBase_isDiagonal.cpp
│ │ │ │ │ ├── MatrixBase_isIdentity.cpp
│ │ │ │ │ ├── MatrixBase_isOnes.cpp
│ │ │ │ │ ├── MatrixBase_isOrthogonal.cpp
│ │ │ │ │ ├── MatrixBase_isUnitary.cpp
│ │ │ │ │ ├── MatrixBase_isZero.cpp
│ │ │ │ │ ├── MatrixBase_leftCols_int.cpp
│ │ │ │ │ ├── MatrixBase_noalias.cpp
│ │ │ │ │ ├── MatrixBase_ones.cpp
│ │ │ │ │ ├── MatrixBase_ones_int.cpp
│ │ │ │ │ ├── MatrixBase_ones_int_int.cpp
│ │ │ │ │ ├── MatrixBase_operatorNorm.cpp
│ │ │ │ │ ├── MatrixBase_prod.cpp
│ │ │ │ │ ├── MatrixBase_random.cpp
│ │ │ │ │ ├── MatrixBase_random_int.cpp
│ │ │ │ │ ├── MatrixBase_random_int_int.cpp
│ │ │ │ │ ├── MatrixBase_replicate.cpp
│ │ │ │ │ ├── MatrixBase_replicate_int_int.cpp
│ │ │ │ │ ├── MatrixBase_reshaped_auto.cpp
│ │ │ │ │ ├── MatrixBase_reshaped_fixed.cpp
│ │ │ │ │ ├── MatrixBase_reshaped_int_int.cpp
│ │ │ │ │ ├── MatrixBase_reshaped_to_vector.cpp
│ │ │ │ │ ├── MatrixBase_reverse.cpp
│ │ │ │ │ ├── MatrixBase_rightCols_int.cpp
│ │ │ │ │ ├── MatrixBase_row.cpp
│ │ │ │ │ ├── MatrixBase_rowwise.cpp
│ │ │ │ │ ├── MatrixBase_segment_int_int.cpp
│ │ │ │ │ ├── MatrixBase_select.cpp
│ │ │ │ │ ├── MatrixBase_selfadjointView.cpp
│ │ │ │ │ ├── MatrixBase_set.cpp
│ │ │ │ │ ├── MatrixBase_setIdentity.cpp
│ │ │ │ │ ├── MatrixBase_setOnes.cpp
│ │ │ │ │ ├── MatrixBase_setRandom.cpp
│ │ │ │ │ ├── MatrixBase_setZero.cpp
│ │ │ │ │ ├── MatrixBase_start_int.cpp
│ │ │ │ │ ├── MatrixBase_template_int_bottomRows.cpp
│ │ │ │ │ ├── MatrixBase_template_int_end.cpp
│ │ │ │ │ ├── MatrixBase_template_int_int_block_int_int_int_int.cpp
│ │ │ │ │ ├── MatrixBase_template_int_int_bottomLeftCorner.cpp
│ │ │ │ │ ├── MatrixBase_template_int_int_bottomLeftCorner_int_int.cpp
│ │ │ │ │ ├── MatrixBase_template_int_int_bottomRightCorner.cpp
│ │ │ │ │ ├── MatrixBase_template_int_int_bottomRightCorner_int_int.cpp
│ │ │ │ │ ├── MatrixBase_template_int_int_topLeftCorner.cpp
│ │ │ │ │ ├── MatrixBase_template_int_int_topLeftCorner_int_int.cpp
│ │ │ │ │ ├── MatrixBase_template_int_int_topRightCorner.cpp
│ │ │ │ │ ├── MatrixBase_template_int_int_topRightCorner_int_int.cpp
│ │ │ │ │ ├── MatrixBase_template_int_leftCols.cpp
│ │ │ │ │ ├── MatrixBase_template_int_rightCols.cpp
│ │ │ │ │ ├── MatrixBase_template_int_segment.cpp
│ │ │ │ │ ├── MatrixBase_template_int_start.cpp
│ │ │ │ │ ├── MatrixBase_template_int_topRows.cpp
│ │ │ │ │ ├── MatrixBase_topLeftCorner_int_int.cpp
│ │ │ │ │ ├── MatrixBase_topRightCorner_int_int.cpp
│ │ │ │ │ ├── MatrixBase_topRows_int.cpp
│ │ │ │ │ ├── MatrixBase_transpose.cpp
│ │ │ │ │ ├── MatrixBase_triangularView.cpp
│ │ │ │ │ ├── MatrixBase_zero.cpp
│ │ │ │ │ ├── MatrixBase_zero_int.cpp
│ │ │ │ │ ├── MatrixBase_zero_int_int.cpp
│ │ │ │ │ ├── Matrix_Map_stride.cpp
│ │ │ │ │ ├── Matrix_initializer_list_23_cxx11.cpp
│ │ │ │ │ ├── Matrix_initializer_list_vector_cxx11.cpp
│ │ │ │ │ ├── Matrix_resize_NoChange_int.cpp
│ │ │ │ │ ├── Matrix_resize_int.cpp
│ │ │ │ │ ├── Matrix_resize_int_NoChange.cpp
│ │ │ │ │ ├── Matrix_resize_int_int.cpp
│ │ │ │ │ ├── Matrix_setConstant_int.cpp
│ │ │ │ │ ├── Matrix_setConstant_int_int.cpp
│ │ │ │ │ ├── Matrix_setIdentity_int_int.cpp
│ │ │ │ │ ├── Matrix_setOnes_int.cpp
│ │ │ │ │ ├── Matrix_setOnes_int_int.cpp
│ │ │ │ │ ├── Matrix_setRandom_int.cpp
│ │ │ │ │ ├── Matrix_setRandom_int_int.cpp
│ │ │ │ │ ├── Matrix_setZero_int.cpp
│ │ │ │ │ ├── Matrix_setZero_int_int.cpp
│ │ │ │ │ ├── Matrix_variadic_ctor_cxx11.cpp
│ │ │ │ │ ├── PartialPivLU_solve.cpp
│ │ │ │ │ ├── PartialRedux_count.cpp
│ │ │ │ │ ├── PartialRedux_maxCoeff.cpp
│ │ │ │ │ ├── PartialRedux_minCoeff.cpp
│ │ │ │ │ ├── PartialRedux_norm.cpp
│ │ │ │ │ ├── PartialRedux_prod.cpp
│ │ │ │ │ ├── PartialRedux_squaredNorm.cpp
│ │ │ │ │ ├── PartialRedux_sum.cpp
│ │ │ │ │ ├── RealQZ_compute.cpp
│ │ │ │ │ ├── RealSchur_RealSchur_MatrixType.cpp
│ │ │ │ │ ├── RealSchur_compute.cpp
│ │ │ │ │ ├── SelfAdjointEigenSolver_SelfAdjointEigenSolver.cpp
│ │ │ │ │ ├── SelfAdjointEigenSolver_SelfAdjointEigenSolver_MatrixType.cpp
│ │ │ │ │ ├── SelfAdjointEigenSolver_SelfAdjointEigenSolver_MatrixType2.cpp
│ │ │ │ │ ├── SelfAdjointEigenSolver_compute_MatrixType.cpp
│ │ │ │ │ ├── SelfAdjointEigenSolver_compute_MatrixType2.cpp
│ │ │ │ │ ├── SelfAdjointEigenSolver_eigenvalues.cpp
│ │ │ │ │ ├── SelfAdjointEigenSolver_eigenvectors.cpp
│ │ │ │ │ ├── SelfAdjointEigenSolver_operatorInverseSqrt.cpp
│ │ │ │ │ ├── SelfAdjointEigenSolver_operatorSqrt.cpp
│ │ │ │ │ ├── SelfAdjointView_eigenvalues.cpp
│ │ │ │ │ ├── SelfAdjointView_operatorNorm.cpp
│ │ │ │ │ ├── Slicing_arrayexpr.cpp
│ │ │ │ │ ├── Slicing_custom_padding_cxx11.cpp
│ │ │ │ │ ├── Slicing_rawarray_cxx11.cpp
│ │ │ │ │ ├── Slicing_stdvector_cxx11.cpp
│ │ │ │ │ ├── SparseMatrix_coeffs.cpp
│ │ │ │ │ ├── TopicAliasing_block.cpp
│ │ │ │ │ ├── TopicAliasing_block_correct.cpp
│ │ │ │ │ ├── TopicAliasing_cwise.cpp
│ │ │ │ │ ├── TopicAliasing_mult1.cpp
│ │ │ │ │ ├── TopicAliasing_mult2.cpp
│ │ │ │ │ ├── TopicAliasing_mult3.cpp
│ │ │ │ │ ├── TopicAliasing_mult4.cpp
│ │ │ │ │ ├── TopicAliasing_mult5.cpp
│ │ │ │ │ ├── TopicStorageOrders_example.cpp
│ │ │ │ │ ├── Triangular_solve.cpp
│ │ │ │ │ ├── Tridiagonalization_Tridiagonalization_MatrixType.cpp
│ │ │ │ │ ├── Tridiagonalization_compute.cpp
│ │ │ │ │ ├── Tridiagonalization_decomposeInPlace.cpp
│ │ │ │ │ ├── Tridiagonalization_diagonal.cpp
│ │ │ │ │ ├── Tridiagonalization_householderCoefficients.cpp
│ │ │ │ │ ├── Tridiagonalization_packedMatrix.cpp
│ │ │ │ │ ├── Tutorial_AdvancedInitialization_Block.cpp
│ │ │ │ │ ├── Tutorial_AdvancedInitialization_CommaTemporary.cpp
│ │ │ │ │ ├── Tutorial_AdvancedInitialization_Join.cpp
│ │ │ │ │ ├── Tutorial_AdvancedInitialization_LinSpaced.cpp
│ │ │ │ │ ├── Tutorial_AdvancedInitialization_ThreeWays.cpp
│ │ │ │ │ ├── Tutorial_AdvancedInitialization_Zero.cpp
│ │ │ │ │ ├── Tutorial_Map_rowmajor.cpp
│ │ │ │ │ ├── Tutorial_Map_using.cpp
│ │ │ │ │ ├── Tutorial_ReshapeMat2Mat.cpp
│ │ │ │ │ ├── Tutorial_ReshapeMat2Vec.cpp
│ │ │ │ │ ├── Tutorial_SlicingCol.cpp
│ │ │ │ │ ├── Tutorial_SlicingVec.cpp
│ │ │ │ │ ├── Tutorial_commainit_01.cpp
│ │ │ │ │ ├── Tutorial_commainit_01b.cpp
│ │ │ │ │ ├── Tutorial_commainit_02.cpp
│ │ │ │ │ ├── Tutorial_range_for_loop_1d_cxx11.cpp
│ │ │ │ │ ├── Tutorial_range_for_loop_2d_cxx11.cpp
│ │ │ │ │ ├── Tutorial_reshaped_vs_resize_1.cpp
│ │ │ │ │ ├── Tutorial_reshaped_vs_resize_2.cpp
│ │ │ │ │ ├── Tutorial_solve_matrix_inverse.cpp
│ │ │ │ │ ├── Tutorial_solve_multiple_rhs.cpp
│ │ │ │ │ ├── Tutorial_solve_reuse_decomposition.cpp
│ │ │ │ │ ├── Tutorial_solve_singular.cpp
│ │ │ │ │ ├── Tutorial_solve_triangular.cpp
│ │ │ │ │ ├── Tutorial_solve_triangular_inplace.cpp
│ │ │ │ │ ├── Tutorial_std_sort.cpp
│ │ │ │ │ ├── Tutorial_std_sort_rows_cxx11.cpp
│ │ │ │ │ ├── VectorwiseOp_homogeneous.cpp
│ │ │ │ │ ├── Vectorwise_reverse.cpp
│ │ │ │ │ ├── class_FullPivLU.cpp
│ │ │ │ │ ├── compile_snippet.cpp.in
│ │ │ │ │ ├── tut_arithmetic_redux_minmax.cpp
│ │ │ │ │ ├── tut_arithmetic_transpose_aliasing.cpp
│ │ │ │ │ ├── tut_arithmetic_transpose_conjugate.cpp
│ │ │ │ │ ├── tut_arithmetic_transpose_inplace.cpp
│ │ │ │ │ └── tut_matrix_assignment_resizing.cpp
│ │ │ │ ├── special_examples/
│ │ │ │ │ ├── CMakeLists.txt
│ │ │ │ │ ├── Tutorial_sparse_example.cpp
│ │ │ │ │ ├── Tutorial_sparse_example_details.cpp
│ │ │ │ │ └── random_cpp11.cpp
│ │ │ │ └── tutorial.cpp
│ │ │ ├── eigen3.pc.in
│ │ │ ├── failtest/
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── bdcsvd_int.cpp
│ │ │ │ ├── block_nonconst_ctor_on_const_xpr_0.cpp
│ │ │ │ ├── block_nonconst_ctor_on_const_xpr_1.cpp
│ │ │ │ ├── block_nonconst_ctor_on_const_xpr_2.cpp
│ │ │ │ ├── block_on_const_type_actually_const_0.cpp
│ │ │ │ ├── block_on_const_type_actually_const_1.cpp
│ │ │ │ ├── colpivqr_int.cpp
│ │ │ │ ├── const_qualified_block_method_retval_0.cpp
│ │ │ │ ├── const_qualified_block_method_retval_1.cpp
│ │ │ │ ├── const_qualified_diagonal_method_retval.cpp
│ │ │ │ ├── const_qualified_transpose_method_retval.cpp
│ │ │ │ ├── cwiseunaryview_nonconst_ctor_on_const_xpr.cpp
│ │ │ │ ├── cwiseunaryview_on_const_type_actually_const.cpp
│ │ │ │ ├── diagonal_nonconst_ctor_on_const_xpr.cpp
│ │ │ │ ├── diagonal_on_const_type_actually_const.cpp
│ │ │ │ ├── eigensolver_cplx.cpp
│ │ │ │ ├── eigensolver_int.cpp
│ │ │ │ ├── failtest_sanity_check.cpp
│ │ │ │ ├── fullpivlu_int.cpp
│ │ │ │ ├── fullpivqr_int.cpp
│ │ │ │ ├── initializer_list_1.cpp
│ │ │ │ ├── initializer_list_2.cpp
│ │ │ │ ├── jacobisvd_int.cpp
│ │ │ │ ├── ldlt_int.cpp
│ │ │ │ ├── llt_int.cpp
│ │ │ │ ├── map_nonconst_ctor_on_const_ptr_0.cpp
│ │ │ │ ├── map_nonconst_ctor_on_const_ptr_1.cpp
│ │ │ │ ├── map_nonconst_ctor_on_const_ptr_2.cpp
│ │ │ │ ├── map_nonconst_ctor_on_const_ptr_3.cpp
│ │ │ │ ├── map_nonconst_ctor_on_const_ptr_4.cpp
│ │ │ │ ├── map_on_const_type_actually_const_0.cpp
│ │ │ │ ├── map_on_const_type_actually_const_1.cpp
│ │ │ │ ├── partialpivlu_int.cpp
│ │ │ │ ├── qr_int.cpp
│ │ │ │ ├── ref_1.cpp
│ │ │ │ ├── ref_2.cpp
│ │ │ │ ├── ref_3.cpp
│ │ │ │ ├── ref_4.cpp
│ │ │ │ ├── ref_5.cpp
│ │ │ │ ├── selfadjointview_nonconst_ctor_on_const_xpr.cpp
│ │ │ │ ├── selfadjointview_on_const_type_actually_const.cpp
│ │ │ │ ├── sparse_ref_1.cpp
│ │ │ │ ├── sparse_ref_2.cpp
│ │ │ │ ├── sparse_ref_3.cpp
│ │ │ │ ├── sparse_ref_4.cpp
│ │ │ │ ├── sparse_ref_5.cpp
│ │ │ │ ├── sparse_storage_mismatch.cpp
│ │ │ │ ├── swap_1.cpp
│ │ │ │ ├── swap_2.cpp
│ │ │ │ ├── ternary_1.cpp
│ │ │ │ ├── ternary_2.cpp
│ │ │ │ ├── transpose_nonconst_ctor_on_const_xpr.cpp
│ │ │ │ ├── transpose_on_const_type_actually_const.cpp
│ │ │ │ ├── triangularview_nonconst_ctor_on_const_xpr.cpp
│ │ │ │ └── triangularview_on_const_type_actually_const.cpp
│ │ │ ├── lapack/
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── cholesky.cpp
│ │ │ │ ├── clacgv.f
│ │ │ │ ├── cladiv.f
│ │ │ │ ├── clarf.f
│ │ │ │ ├── clarfb.f
│ │ │ │ ├── clarfg.f
│ │ │ │ ├── clarft.f
│ │ │ │ ├── complex_double.cpp
│ │ │ │ ├── complex_single.cpp
│ │ │ │ ├── dladiv.f
│ │ │ │ ├── dlamch.f
│ │ │ │ ├── dlapy2.f
│ │ │ │ ├── dlapy3.f
│ │ │ │ ├── dlarf.f
│ │ │ │ ├── dlarfb.f
│ │ │ │ ├── dlarfg.f
│ │ │ │ ├── dlarft.f
│ │ │ │ ├── double.cpp
│ │ │ │ ├── dsecnd_NONE.f
│ │ │ │ ├── eigenvalues.cpp
│ │ │ │ ├── ilaclc.f
│ │ │ │ ├── ilaclr.f
│ │ │ │ ├── iladlc.f
│ │ │ │ ├── iladlr.f
│ │ │ │ ├── ilaslc.f
│ │ │ │ ├── ilaslr.f
│ │ │ │ ├── ilazlc.f
│ │ │ │ ├── ilazlr.f
│ │ │ │ ├── lapack_common.h
│ │ │ │ ├── lu.cpp
│ │ │ │ ├── second_NONE.f
│ │ │ │ ├── single.cpp
│ │ │ │ ├── sladiv.f
│ │ │ │ ├── slamch.f
│ │ │ │ ├── slapy2.f
│ │ │ │ ├── slapy3.f
│ │ │ │ ├── slarf.f
│ │ │ │ ├── slarfb.f
│ │ │ │ ├── slarfg.f
│ │ │ │ ├── slarft.f
│ │ │ │ ├── svd.cpp
│ │ │ │ ├── zlacgv.f
│ │ │ │ ├── zladiv.f
│ │ │ │ ├── zlarf.f
│ │ │ │ ├── zlarfb.f
│ │ │ │ ├── zlarfg.f
│ │ │ │ └── zlarft.f
│ │ │ ├── scripts/
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── cdashtesting.cmake.in
│ │ │ │ ├── check.in
│ │ │ │ ├── debug.in
│ │ │ │ ├── eigen_gen_credits.cpp
│ │ │ │ ├── eigen_gen_docs
│ │ │ │ ├── eigen_gen_split_test_help.cmake
│ │ │ │ ├── eigen_monitor_perf.sh
│ │ │ │ ├── release.in
│ │ │ │ └── relicense.py
│ │ │ ├── signature_of_eigen3_matrix_library
│ │ │ ├── test/
│ │ │ │ ├── AnnoyingScalar.h
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── MovableScalar.h
│ │ │ │ ├── OffByOneScalar.h
│ │ │ │ ├── SafeScalar.h
│ │ │ │ ├── adjoint.cpp
│ │ │ │ ├── array_cwise.cpp
│ │ │ │ ├── array_for_matrix.cpp
│ │ │ │ ├── array_of_string.cpp
│ │ │ │ ├── array_replicate.cpp
│ │ │ │ ├── array_reverse.cpp
│ │ │ │ ├── bandmatrix.cpp
│ │ │ │ ├── basicstuff.cpp
│ │ │ │ ├── bdcsvd.cpp
│ │ │ │ ├── bfloat16_float.cpp
│ │ │ │ ├── bicgstab.cpp
│ │ │ │ ├── blasutil.cpp
│ │ │ │ ├── block.cpp
│ │ │ │ ├── boostmultiprec.cpp
│ │ │ │ ├── bug1213.cpp
│ │ │ │ ├── bug1213.h
│ │ │ │ ├── bug1213_main.cpp
│ │ │ │ ├── cholesky.cpp
│ │ │ │ ├── cholmod_support.cpp
│ │ │ │ ├── commainitializer.cpp
│ │ │ │ ├── conjugate_gradient.cpp
│ │ │ │ ├── conservative_resize.cpp
│ │ │ │ ├── constructor.cpp
│ │ │ │ ├── corners.cpp
│ │ │ │ ├── ctorleak.cpp
│ │ │ │ ├── denseLM.cpp
│ │ │ │ ├── dense_storage.cpp
│ │ │ │ ├── determinant.cpp
│ │ │ │ ├── diagonal.cpp
│ │ │ │ ├── diagonal_matrix_variadic_ctor.cpp
│ │ │ │ ├── diagonalmatrices.cpp
│ │ │ │ ├── dontalign.cpp
│ │ │ │ ├── dynalloc.cpp
│ │ │ │ ├── eigen2support.cpp
│ │ │ │ ├── eigensolver_complex.cpp
│ │ │ │ ├── eigensolver_generalized_real.cpp
│ │ │ │ ├── eigensolver_generic.cpp
│ │ │ │ ├── eigensolver_selfadjoint.cpp
│ │ │ │ ├── evaluator_common.h
│ │ │ │ ├── evaluators.cpp
│ │ │ │ ├── exceptions.cpp
│ │ │ │ ├── fastmath.cpp
│ │ │ │ ├── first_aligned.cpp
│ │ │ │ ├── geo_alignedbox.cpp
│ │ │ │ ├── geo_eulerangles.cpp
│ │ │ │ ├── geo_homogeneous.cpp
│ │ │ │ ├── geo_hyperplane.cpp
│ │ │ │ ├── geo_orthomethods.cpp
│ │ │ │ ├── geo_parametrizedline.cpp
│ │ │ │ ├── geo_quaternion.cpp
│ │ │ │ ├── geo_transformations.cpp
│ │ │ │ ├── gpu_basic.cu
│ │ │ │ ├── gpu_common.h
│ │ │ │ ├── half_float.cpp
│ │ │ │ ├── hessenberg.cpp
│ │ │ │ ├── householder.cpp
│ │ │ │ ├── incomplete_cholesky.cpp
│ │ │ │ ├── indexed_view.cpp
│ │ │ │ ├── initializer_list_construction.cpp
│ │ │ │ ├── inplace_decomposition.cpp
│ │ │ │ ├── integer_types.cpp
│ │ │ │ ├── inverse.cpp
│ │ │ │ ├── io.cpp
│ │ │ │ ├── is_same_dense.cpp
│ │ │ │ ├── jacobi.cpp
│ │ │ │ ├── jacobisvd.cpp
│ │ │ │ ├── klu_support.cpp
│ │ │ │ ├── linearstructure.cpp
│ │ │ │ ├── lscg.cpp
│ │ │ │ ├── lu.cpp
│ │ │ │ ├── main.h
│ │ │ │ ├── mapped_matrix.cpp
│ │ │ │ ├── mapstaticmethods.cpp
│ │ │ │ ├── mapstride.cpp
│ │ │ │ ├── meta.cpp
│ │ │ │ ├── metis_support.cpp
│ │ │ │ ├── miscmatrices.cpp
│ │ │ │ ├── mixingtypes.cpp
│ │ │ │ ├── mpl2only.cpp
│ │ │ │ ├── nestbyvalue.cpp
│ │ │ │ ├── nesting_ops.cpp
│ │ │ │ ├── nomalloc.cpp
│ │ │ │ ├── nullary.cpp
│ │ │ │ ├── num_dimensions.cpp
│ │ │ │ ├── numext.cpp
│ │ │ │ ├── packetmath.cpp
│ │ │ │ ├── packetmath_test_shared.h
│ │ │ │ ├── pardiso_support.cpp
│ │ │ │ ├── pastix_support.cpp
│ │ │ │ ├── permutationmatrices.cpp
│ │ │ │ ├── prec_inverse_4x4.cpp
│ │ │ │ ├── product.h
│ │ │ │ ├── product_extra.cpp
│ │ │ │ ├── product_large.cpp
│ │ │ │ ├── product_mmtr.cpp
│ │ │ │ ├── product_notemporary.cpp
│ │ │ │ ├── product_selfadjoint.cpp
│ │ │ │ ├── product_small.cpp
│ │ │ │ ├── product_symm.cpp
│ │ │ │ ├── product_syrk.cpp
│ │ │ │ ├── product_trmm.cpp
│ │ │ │ ├── product_trmv.cpp
│ │ │ │ ├── product_trsolve.cpp
│ │ │ │ ├── qr.cpp
│ │ │ │ ├── qr_colpivoting.cpp
│ │ │ │ ├── qr_fullpivoting.cpp
│ │ │ │ ├── qtvector.cpp
│ │ │ │ ├── rand.cpp
│ │ │ │ ├── random_matrix.cpp
│ │ │ │ ├── random_without_cast_overflow.h
│ │ │ │ ├── real_qz.cpp
│ │ │ │ ├── redux.cpp
│ │ │ │ ├── ref.cpp
│ │ │ │ ├── reshape.cpp
│ │ │ │ ├── resize.cpp
│ │ │ │ ├── rvalue_types.cpp
│ │ │ │ ├── schur_complex.cpp
│ │ │ │ ├── schur_real.cpp
│ │ │ │ ├── selfadjoint.cpp
│ │ │ │ ├── simplicial_cholesky.cpp
│ │ │ │ ├── sizeof.cpp
│ │ │ │ ├── sizeoverflow.cpp
│ │ │ │ ├── smallvectors.cpp
│ │ │ │ ├── solverbase.h
│ │ │ │ ├── sparse.h
│ │ │ │ ├── sparseLM.cpp
│ │ │ │ ├── sparse_basic.cpp
│ │ │ │ ├── sparse_block.cpp
│ │ │ │ ├── sparse_permutations.cpp
│ │ │ │ ├── sparse_product.cpp
│ │ │ │ ├── sparse_ref.cpp
│ │ │ │ ├── sparse_solver.h
│ │ │ │ ├── sparse_solvers.cpp
│ │ │ │ ├── sparse_vector.cpp
│ │ │ │ ├── sparselu.cpp
│ │ │ │ ├── sparseqr.cpp
│ │ │ │ ├── special_numbers.cpp
│ │ │ │ ├── split_test_helper.h
│ │ │ │ ├── spqr_support.cpp
│ │ │ │ ├── stable_norm.cpp
│ │ │ │ ├── stddeque.cpp
│ │ │ │ ├── stddeque_overload.cpp
│ │ │ │ ├── stdlist.cpp
│ │ │ │ ├── stdlist_overload.cpp
│ │ │ │ ├── stdvector.cpp
│ │ │ │ ├── stdvector_overload.cpp
│ │ │ │ ├── stl_iterators.cpp
│ │ │ │ ├── superlu_support.cpp
│ │ │ │ ├── svd_common.h
│ │ │ │ ├── svd_fill.h
│ │ │ │ ├── swap.cpp
│ │ │ │ ├── symbolic_index.cpp
│ │ │ │ ├── triangular.cpp
│ │ │ │ ├── type_alias.cpp
│ │ │ │ ├── umeyama.cpp
│ │ │ │ ├── umfpack_support.cpp
│ │ │ │ ├── unalignedcount.cpp
│ │ │ │ ├── upperbidiagonalization.cpp
│ │ │ │ ├── vectorization_logic.cpp
│ │ │ │ ├── vectorwiseop.cpp
│ │ │ │ ├── visitor.cpp
│ │ │ │ └── zerosized.cpp
│ │ │ └── unsupported/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── Eigen/
│ │ │ │ ├── AdolcForward
│ │ │ │ ├── AlignedVector3
│ │ │ │ ├── ArpackSupport
│ │ │ │ ├── AutoDiff
│ │ │ │ ├── BVH
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── CXX11/
│ │ │ │ │ ├── CMakeLists.txt
│ │ │ │ │ ├── Tensor
│ │ │ │ │ ├── TensorSymmetry
│ │ │ │ │ ├── ThreadPool
│ │ │ │ │ └── src/
│ │ │ │ │ ├── Tensor/
│ │ │ │ │ │ ├── README.md
│ │ │ │ │ │ ├── Tensor.h
│ │ │ │ │ │ ├── TensorArgMax.h
│ │ │ │ │ │ ├── TensorAssign.h
│ │ │ │ │ │ ├── TensorBase.h
│ │ │ │ │ │ ├── TensorBlock.h
│ │ │ │ │ │ ├── TensorBroadcasting.h
│ │ │ │ │ │ ├── TensorChipping.h
│ │ │ │ │ │ ├── TensorConcatenation.h
│ │ │ │ │ │ ├── TensorContraction.h
│ │ │ │ │ │ ├── TensorContractionBlocking.h
│ │ │ │ │ │ ├── TensorContractionCuda.h
│ │ │ │ │ │ ├── TensorContractionGpu.h
│ │ │ │ │ │ ├── TensorContractionMapper.h
│ │ │ │ │ │ ├── TensorContractionSycl.h
│ │ │ │ │ │ ├── TensorContractionThreadPool.h
│ │ │ │ │ │ ├── TensorConversion.h
│ │ │ │ │ │ ├── TensorConvolution.h
│ │ │ │ │ │ ├── TensorConvolutionSycl.h
│ │ │ │ │ │ ├── TensorCostModel.h
│ │ │ │ │ │ ├── TensorCustomOp.h
│ │ │ │ │ │ ├── TensorDevice.h
│ │ │ │ │ │ ├── TensorDeviceCuda.h
│ │ │ │ │ │ ├── TensorDeviceDefault.h
│ │ │ │ │ │ ├── TensorDeviceGpu.h
│ │ │ │ │ │ ├── TensorDeviceSycl.h
│ │ │ │ │ │ ├── TensorDeviceThreadPool.h
│ │ │ │ │ │ ├── TensorDimensionList.h
│ │ │ │ │ │ ├── TensorDimensions.h
│ │ │ │ │ │ ├── TensorEvalTo.h
│ │ │ │ │ │ ├── TensorEvaluator.h
│ │ │ │ │ │ ├── TensorExecutor.h
│ │ │ │ │ │ ├── TensorExpr.h
│ │ │ │ │ │ ├── TensorFFT.h
│ │ │ │ │ │ ├── TensorFixedSize.h
│ │ │ │ │ │ ├── TensorForcedEval.h
│ │ │ │ │ │ ├── TensorForwardDeclarations.h
│ │ │ │ │ │ ├── TensorFunctors.h
│ │ │ │ │ │ ├── TensorGenerator.h
│ │ │ │ │ │ ├── TensorGlobalFunctions.h
│ │ │ │ │ │ ├── TensorGpuHipCudaDefines.h
│ │ │ │ │ │ ├── TensorGpuHipCudaUndefines.h
│ │ │ │ │ │ ├── TensorIO.h
│ │ │ │ │ │ ├── TensorImagePatch.h
│ │ │ │ │ │ ├── TensorIndexList.h
│ │ │ │ │ │ ├── TensorInflation.h
│ │ │ │ │ │ ├── TensorInitializer.h
│ │ │ │ │ │ ├── TensorIntDiv.h
│ │ │ │ │ │ ├── TensorLayoutSwap.h
│ │ │ │ │ │ ├── TensorMacros.h
│ │ │ │ │ │ ├── TensorMap.h
│ │ │ │ │ │ ├── TensorMeta.h
│ │ │ │ │ │ ├── TensorMorphing.h
│ │ │ │ │ │ ├── TensorPadding.h
│ │ │ │ │ │ ├── TensorPatch.h
│ │ │ │ │ │ ├── TensorRandom.h
│ │ │ │ │ │ ├── TensorReduction.h
│ │ │ │ │ │ ├── TensorReductionCuda.h
│ │ │ │ │ │ ├── TensorReductionGpu.h
│ │ │ │ │ │ ├── TensorReductionSycl.h
│ │ │ │ │ │ ├── TensorRef.h
│ │ │ │ │ │ ├── TensorReverse.h
│ │ │ │ │ │ ├── TensorScan.h
│ │ │ │ │ │ ├── TensorScanSycl.h
│ │ │ │ │ │ ├── TensorShuffling.h
│ │ │ │ │ │ ├── TensorStorage.h
│ │ │ │ │ │ ├── TensorStriding.h
│ │ │ │ │ │ ├── TensorTrace.h
│ │ │ │ │ │ ├── TensorTraits.h
│ │ │ │ │ │ ├── TensorUInt128.h
│ │ │ │ │ │ └── TensorVolumePatch.h
│ │ │ │ │ ├── TensorSymmetry/
│ │ │ │ │ │ ├── DynamicSymmetry.h
│ │ │ │ │ │ ├── StaticSymmetry.h
│ │ │ │ │ │ ├── Symmetry.h
│ │ │ │ │ │ └── util/
│ │ │ │ │ │ └── TemplateGroupTheory.h
│ │ │ │ │ ├── ThreadPool/
│ │ │ │ │ │ ├── Barrier.h
│ │ │ │ │ │ ├── EventCount.h
│ │ │ │ │ │ ├── NonBlockingThreadPool.h
│ │ │ │ │ │ ├── RunQueue.h
│ │ │ │ │ │ ├── ThreadCancel.h
│ │ │ │ │ │ ├── ThreadEnvironment.h
│ │ │ │ │ │ ├── ThreadLocal.h
│ │ │ │ │ │ ├── ThreadPoolInterface.h
│ │ │ │ │ │ └── ThreadYield.h
│ │ │ │ │ └── util/
│ │ │ │ │ ├── CXX11Meta.h
│ │ │ │ │ ├── CXX11Workarounds.h
│ │ │ │ │ ├── EmulateArray.h
│ │ │ │ │ └── MaxSizeVector.h
│ │ │ │ ├── EulerAngles
│ │ │ │ ├── FFT
│ │ │ │ ├── IterativeSolvers
│ │ │ │ ├── KroneckerProduct
│ │ │ │ ├── LevenbergMarquardt
│ │ │ │ ├── MPRealSupport
│ │ │ │ ├── MatrixFunctions
│ │ │ │ ├── MoreVectorization
│ │ │ │ ├── NonLinearOptimization
│ │ │ │ ├── NumericalDiff
│ │ │ │ ├── OpenGLSupport
│ │ │ │ ├── Polynomials
│ │ │ │ ├── Skyline
│ │ │ │ ├── SparseExtra
│ │ │ │ ├── SpecialFunctions
│ │ │ │ ├── Splines
│ │ │ │ └── src/
│ │ │ │ ├── AutoDiff/
│ │ │ │ │ ├── AutoDiffJacobian.h
│ │ │ │ │ ├── AutoDiffScalar.h
│ │ │ │ │ └── AutoDiffVector.h
│ │ │ │ ├── BVH/
│ │ │ │ │ ├── BVAlgorithms.h
│ │ │ │ │ └── KdBVH.h
│ │ │ │ ├── Eigenvalues/
│ │ │ │ │ └── ArpackSelfAdjointEigenSolver.h
│ │ │ │ ├── EulerAngles/
│ │ │ │ │ ├── CMakeLists.txt
│ │ │ │ │ ├── EulerAngles.h
│ │ │ │ │ └── EulerSystem.h
│ │ │ │ ├── FFT/
│ │ │ │ │ ├── ei_fftw_impl.h
│ │ │ │ │ └── ei_kissfft_impl.h
│ │ │ │ ├── IterativeSolvers/
│ │ │ │ │ ├── ConstrainedConjGrad.h
│ │ │ │ │ ├── DGMRES.h
│ │ │ │ │ ├── GMRES.h
│ │ │ │ │ ├── IDRS.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/
│ │ │ │ │ ├── BlockSparseMatrix.h
│ │ │ │ │ ├── MarketIO.h
│ │ │ │ │ ├── MatrixMarketIterator.h
│ │ │ │ │ └── RandomSetter.h
│ │ │ │ ├── SpecialFunctions/
│ │ │ │ │ ├── BesselFunctionsArrayAPI.h
│ │ │ │ │ ├── BesselFunctionsBFloat16.h
│ │ │ │ │ ├── BesselFunctionsFunctors.h
│ │ │ │ │ ├── BesselFunctionsHalf.h
│ │ │ │ │ ├── BesselFunctionsImpl.h
│ │ │ │ │ ├── BesselFunctionsPacketMath.h
│ │ │ │ │ ├── HipVectorCompatibility.h
│ │ │ │ │ ├── SpecialFunctionsArrayAPI.h
│ │ │ │ │ ├── SpecialFunctionsBFloat16.h
│ │ │ │ │ ├── SpecialFunctionsFunctors.h
│ │ │ │ │ ├── SpecialFunctionsHalf.h
│ │ │ │ │ ├── SpecialFunctionsImpl.h
│ │ │ │ │ ├── SpecialFunctionsPacketMath.h
│ │ │ │ │ └── arch/
│ │ │ │ │ ├── AVX/
│ │ │ │ │ │ ├── BesselFunctions.h
│ │ │ │ │ │ └── SpecialFunctions.h
│ │ │ │ │ ├── AVX512/
│ │ │ │ │ │ ├── BesselFunctions.h
│ │ │ │ │ │ └── SpecialFunctions.h
│ │ │ │ │ ├── GPU/
│ │ │ │ │ │ └── SpecialFunctions.h
│ │ │ │ │ └── NEON/
│ │ │ │ │ ├── BesselFunctions.h
│ │ │ │ │ └── SpecialFunctions.h
│ │ │ │ └── Splines/
│ │ │ │ ├── Spline.h
│ │ │ │ ├── SplineFitting.h
│ │ │ │ └── SplineFwd.h
│ │ │ ├── README.txt
│ │ │ ├── bench/
│ │ │ │ └── bench_svd.cpp
│ │ │ ├── doc/
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── Overview.dox
│ │ │ │ ├── SYCL.dox
│ │ │ │ ├── eigendoxy_layout.xml.in
│ │ │ │ ├── examples/
│ │ │ │ │ ├── BVH_Example.cpp
│ │ │ │ │ ├── CMakeLists.txt
│ │ │ │ │ ├── EulerAngles.cpp
│ │ │ │ │ ├── FFT.cpp
│ │ │ │ │ ├── MatrixExponential.cpp
│ │ │ │ │ ├── MatrixFunction.cpp
│ │ │ │ │ ├── MatrixLogarithm.cpp
│ │ │ │ │ ├── MatrixPower.cpp
│ │ │ │ │ ├── MatrixPower_optimal.cpp
│ │ │ │ │ ├── MatrixSine.cpp
│ │ │ │ │ ├── MatrixSinh.cpp
│ │ │ │ │ ├── MatrixSquareRoot.cpp
│ │ │ │ │ ├── PolynomialSolver1.cpp
│ │ │ │ │ ├── PolynomialUtils1.cpp
│ │ │ │ │ └── SYCL/
│ │ │ │ │ ├── CMakeLists.txt
│ │ │ │ │ └── CwiseMul.cpp
│ │ │ │ └── snippets/
│ │ │ │ └── CMakeLists.txt
│ │ │ └── test/
│ │ │ ├── BVH.cpp
│ │ │ ├── CMakeLists.txt
│ │ │ ├── EulerAngles.cpp
│ │ │ ├── FFT.cpp
│ │ │ ├── FFTW.cpp
│ │ │ ├── NonLinearOptimization.cpp
│ │ │ ├── NumericalDiff.cpp
│ │ │ ├── alignedvector3.cpp
│ │ │ ├── autodiff.cpp
│ │ │ ├── autodiff_scalar.cpp
│ │ │ ├── bessel_functions.cpp
│ │ │ ├── cxx11_eventcount.cpp
│ │ │ ├── cxx11_maxsizevector.cpp
│ │ │ ├── cxx11_meta.cpp
│ │ │ ├── cxx11_non_blocking_thread_pool.cpp
│ │ │ ├── cxx11_runqueue.cpp
│ │ │ ├── cxx11_tensor_argmax.cpp
│ │ │ ├── cxx11_tensor_argmax_gpu.cu
│ │ │ ├── cxx11_tensor_argmax_sycl.cpp
│ │ │ ├── cxx11_tensor_assign.cpp
│ │ │ ├── cxx11_tensor_block_access.cpp
│ │ │ ├── cxx11_tensor_block_eval.cpp
│ │ │ ├── cxx11_tensor_block_io.cpp
│ │ │ ├── cxx11_tensor_broadcast_sycl.cpp
│ │ │ ├── cxx11_tensor_broadcasting.cpp
│ │ │ ├── cxx11_tensor_builtins_sycl.cpp
│ │ │ ├── cxx11_tensor_cast_float16_gpu.cu
│ │ │ ├── cxx11_tensor_casts.cpp
│ │ │ ├── cxx11_tensor_chipping.cpp
│ │ │ ├── cxx11_tensor_chipping_sycl.cpp
│ │ │ ├── cxx11_tensor_comparisons.cpp
│ │ │ ├── cxx11_tensor_complex_cwise_ops_gpu.cu
│ │ │ ├── cxx11_tensor_complex_gpu.cu
│ │ │ ├── cxx11_tensor_concatenation.cpp
│ │ │ ├── cxx11_tensor_concatenation_sycl.cpp
│ │ │ ├── cxx11_tensor_const.cpp
│ │ │ ├── cxx11_tensor_contract_gpu.cu
│ │ │ ├── cxx11_tensor_contract_sycl.cpp
│ │ │ ├── cxx11_tensor_contraction.cpp
│ │ │ ├── cxx11_tensor_convolution.cpp
│ │ │ ├── cxx11_tensor_convolution_sycl.cpp
│ │ │ ├── cxx11_tensor_custom_index.cpp
│ │ │ ├── cxx11_tensor_custom_op.cpp
│ │ │ ├── cxx11_tensor_custom_op_sycl.cpp
│ │ │ ├── cxx11_tensor_device.cu
│ │ │ ├── cxx11_tensor_device_sycl.cpp
│ │ │ ├── cxx11_tensor_dimension.cpp
│ │ │ ├── cxx11_tensor_empty.cpp
│ │ │ ├── cxx11_tensor_executor.cpp
│ │ │ ├── cxx11_tensor_expr.cpp
│ │ │ ├── cxx11_tensor_fft.cpp
│ │ │ ├── cxx11_tensor_fixed_size.cpp
│ │ │ ├── cxx11_tensor_forced_eval.cpp
│ │ │ ├── cxx11_tensor_forced_eval_sycl.cpp
│ │ │ ├── cxx11_tensor_generator.cpp
│ │ │ ├── cxx11_tensor_generator_sycl.cpp
│ │ │ ├── cxx11_tensor_gpu.cu
│ │ │ ├── cxx11_tensor_ifft.cpp
│ │ │ ├── cxx11_tensor_image_op_sycl.cpp
│ │ │ ├── cxx11_tensor_image_patch.cpp
│ │ │ ├── cxx11_tensor_image_patch_sycl.cpp
│ │ │ ├── cxx11_tensor_index_list.cpp
│ │ │ ├── cxx11_tensor_inflation.cpp
│ │ │ ├── cxx11_tensor_inflation_sycl.cpp
│ │ │ ├── cxx11_tensor_intdiv.cpp
│ │ │ ├── cxx11_tensor_io.cpp
│ │ │ ├── cxx11_tensor_layout_swap.cpp
│ │ │ ├── cxx11_tensor_layout_swap_sycl.cpp
│ │ │ ├── cxx11_tensor_lvalue.cpp
│ │ │ ├── cxx11_tensor_map.cpp
│ │ │ ├── cxx11_tensor_math.cpp
│ │ │ ├── cxx11_tensor_math_sycl.cpp
│ │ │ ├── cxx11_tensor_mixed_indices.cpp
│ │ │ ├── cxx11_tensor_morphing.cpp
│ │ │ ├── cxx11_tensor_morphing_sycl.cpp
│ │ │ ├── cxx11_tensor_move.cpp
│ │ │ ├── cxx11_tensor_notification.cpp
│ │ │ ├── cxx11_tensor_of_complex.cpp
│ │ │ ├── cxx11_tensor_of_const_values.cpp
│ │ │ ├── cxx11_tensor_of_float16_gpu.cu
│ │ │ ├── cxx11_tensor_of_strings.cpp
│ │ │ ├── cxx11_tensor_padding.cpp
│ │ │ ├── cxx11_tensor_padding_sycl.cpp
│ │ │ ├── cxx11_tensor_patch.cpp
│ │ │ ├── cxx11_tensor_patch_sycl.cpp
│ │ │ ├── cxx11_tensor_random.cpp
│ │ │ ├── cxx11_tensor_random_gpu.cu
│ │ │ ├── cxx11_tensor_random_sycl.cpp
│ │ │ ├── cxx11_tensor_reduction.cpp
│ │ │ ├── cxx11_tensor_reduction_gpu.cu
│ │ │ ├── cxx11_tensor_reduction_sycl.cpp
│ │ │ ├── cxx11_tensor_ref.cpp
│ │ │ ├── cxx11_tensor_reverse.cpp
│ │ │ ├── cxx11_tensor_reverse_sycl.cpp
│ │ │ ├── cxx11_tensor_roundings.cpp
│ │ │ ├── cxx11_tensor_scan.cpp
│ │ │ ├── cxx11_tensor_scan_gpu.cu
│ │ │ ├── cxx11_tensor_scan_sycl.cpp
│ │ │ ├── cxx11_tensor_shuffling.cpp
│ │ │ ├── cxx11_tensor_shuffling_sycl.cpp
│ │ │ ├── cxx11_tensor_simple.cpp
│ │ │ ├── cxx11_tensor_striding.cpp
│ │ │ ├── cxx11_tensor_striding_sycl.cpp
│ │ │ ├── cxx11_tensor_sugar.cpp
│ │ │ ├── cxx11_tensor_sycl.cpp
│ │ │ ├── cxx11_tensor_symmetry.cpp
│ │ │ ├── cxx11_tensor_thread_local.cpp
│ │ │ ├── cxx11_tensor_thread_pool.cpp
│ │ │ ├── cxx11_tensor_trace.cpp
│ │ │ ├── cxx11_tensor_uint128.cpp
│ │ │ ├── cxx11_tensor_volume_patch.cpp
│ │ │ ├── cxx11_tensor_volume_patch_sycl.cpp
│ │ │ ├── dgmres.cpp
│ │ │ ├── forward_adolc.cpp
│ │ │ ├── gmres.cpp
│ │ │ ├── idrs.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_support.cpp
│ │ │ ├── openglsupport.cpp
│ │ │ ├── polynomialsolver.cpp
│ │ │ ├── polynomialutils.cpp
│ │ │ ├── sparse_extra.cpp
│ │ │ ├── special_functions.cpp
│ │ │ ├── special_packetmath.cpp
│ │ │ └── splines.cpp
│ │ ├── lietorch/
│ │ │ ├── .gitignore
│ │ │ ├── .gitmodules
│ │ │ ├── LICENSE
│ │ │ ├── README.md
│ │ │ ├── eigen/
│ │ │ │ ├── .gitignore
│ │ │ │ ├── .gitlab-ci.yml
│ │ │ │ ├── .hgeol
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── COPYING.APACHE
│ │ │ │ ├── COPYING.BSD
│ │ │ │ ├── COPYING.GPL
│ │ │ │ ├── COPYING.LGPL
│ │ │ │ ├── COPYING.MINPACK
│ │ │ │ ├── COPYING.MPL2
│ │ │ │ ├── COPYING.README
│ │ │ │ ├── CTestConfig.cmake
│ │ │ │ ├── CTestCustom.cmake.in
│ │ │ │ ├── Eigen/
│ │ │ │ │ ├── Cholesky
│ │ │ │ │ ├── CholmodSupport
│ │ │ │ │ ├── Dense
│ │ │ │ │ ├── Eigen
│ │ │ │ │ ├── Eigenvalues
│ │ │ │ │ ├── Geometry
│ │ │ │ │ ├── Householder
│ │ │ │ │ ├── IterativeLinearSolvers
│ │ │ │ │ ├── Jacobi
│ │ │ │ │ ├── KLUSupport
│ │ │ │ │ ├── LU
│ │ │ │ │ ├── MetisSupport
│ │ │ │ │ ├── OrderingMethods
│ │ │ │ │ ├── PaStiXSupport
│ │ │ │ │ ├── PardisoSupport
│ │ │ │ │ ├── QR
│ │ │ │ │ ├── QtAlignedMalloc
│ │ │ │ │ ├── SPQRSupport
│ │ │ │ │ ├── SVD
│ │ │ │ │ ├── Sparse
│ │ │ │ │ ├── SparseCholesky
│ │ │ │ │ ├── SparseCore
│ │ │ │ │ ├── SparseLU
│ │ │ │ │ ├── SparseQR
│ │ │ │ │ ├── StdDeque
│ │ │ │ │ ├── StdList
│ │ │ │ │ ├── StdVector
│ │ │ │ │ ├── SuperLUSupport
│ │ │ │ │ ├── UmfPackSupport
│ │ │ │ │ └── src/
│ │ │ │ │ ├── Cholesky/
│ │ │ │ │ │ ├── LDLT.h
│ │ │ │ │ │ ├── LLT.h
│ │ │ │ │ │ └── LLT_LAPACKE.h
│ │ │ │ │ ├── CholmodSupport/
│ │ │ │ │ │ └── CholmodSupport.h
│ │ │ │ │ ├── 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_SIMD.h
│ │ │ │ │ ├── Householder/
│ │ │ │ │ │ ├── BlockHouseholder.h
│ │ │ │ │ │ ├── Householder.h
│ │ │ │ │ │ └── HouseholderSequence.h
│ │ │ │ │ ├── IterativeLinearSolvers/
│ │ │ │ │ │ ├── BasicPreconditioners.h
│ │ │ │ │ │ ├── BiCGSTAB.h
│ │ │ │ │ │ ├── ConjugateGradient.h
│ │ │ │ │ │ ├── IncompleteCholesky.h
│ │ │ │ │ │ ├── IncompleteLUT.h
│ │ │ │ │ │ ├── IterativeSolverBase.h
│ │ │ │ │ │ ├── LeastSquareConjugateGradient.h
│ │ │ │ │ │ └── SolveWithGuess.h
│ │ │ │ │ ├── Jacobi/
│ │ │ │ │ │ └── Jacobi.h
│ │ │ │ │ ├── KLUSupport/
│ │ │ │ │ │ └── KLUSupport.h
│ │ │ │ │ ├── LU/
│ │ │ │ │ │ ├── Determinant.h
│ │ │ │ │ │ ├── FullPivLU.h
│ │ │ │ │ │ ├── InverseImpl.h
│ │ │ │ │ │ ├── PartialPivLU.h
│ │ │ │ │ │ ├── PartialPivLU_LAPACKE.h
│ │ │ │ │ │ └── arch/
│ │ │ │ │ │ └── InverseSize4.h
│ │ │ │ │ ├── MetisSupport/
│ │ │ │ │ │ └── MetisSupport.h
│ │ │ │ │ ├── OrderingMethods/
│ │ │ │ │ │ ├── Amd.h
│ │ │ │ │ │ ├── Eigen_Colamd.h
│ │ │ │ │ │ └── Ordering.h
│ │ │ │ │ ├── PaStiXSupport/
│ │ │ │ │ │ └── PaStiXSupport.h
│ │ │ │ │ ├── PardisoSupport/
│ │ │ │ │ │ └── PardisoSupport.h
│ │ │ │ │ ├── QR/
│ │ │ │ │ │ ├── ColPivHouseholderQR.h
│ │ │ │ │ │ ├── ColPivHouseholderQR_LAPACKE.h
│ │ │ │ │ │ ├── CompleteOrthogonalDecomposition.h
│ │ │ │ │ │ ├── FullPivHouseholderQR.h
│ │ │ │ │ │ ├── HouseholderQR.h
│ │ │ │ │ │ └── HouseholderQR_LAPACKE.h
│ │ │ │ │ ├── SPQRSupport/
│ │ │ │ │ │ └── SuiteSparseQRSupport.h
│ │ │ │ │ ├── SVD/
│ │ │ │ │ │ ├── BDCSVD.h
│ │ │ │ │ │ ├── JacobiSVD.h
│ │ │ │ │ │ ├── JacobiSVD_LAPACKE.h
│ │ │ │ │ │ ├── SVDBase.h
│ │ │ │ │ │ └── UpperBidiagonalization.h
│ │ │ │ │ ├── SparseCholesky/
│ │ │ │ │ │ ├── SimplicialCholesky.h
│ │ │ │ │ │ └── SimplicialCholesky_impl.h
│ │ │ │ │ ├── SparseCore/
│ │ │ │ │ │ ├── AmbiVector.h
│ │ │ │ │ │ ├── CompressedStorage.h
│ │ │ │ │ │ ├── ConservativeSparseSparseProduct.h
│ │ │ │ │ │ ├── MappedSparseMatrix.h
│ │ │ │ │ │ ├── SparseAssign.h
│ │ │ │ │ │ ├── SparseBlock.h
│ │ │ │ │ │ ├── SparseColEtree.h
│ │ │ │ │ │ ├── SparseCompressedBase.h
│ │ │ │ │ │ ├── SparseCwiseBinaryOp.h
│ │ │ │ │ │ ├── SparseCwiseUnaryOp.h
│ │ │ │ │ │ ├── SparseDenseProduct.h
│ │ │ │ │ │ ├── SparseDiagonalProduct.h
│ │ │ │ │ │ ├── SparseDot.h
│ │ │ │ │ │ ├── SparseFuzzy.h
│ │ │ │ │ │ ├── SparseMap.h
│ │ │ │ │ │ ├── SparseMatrix.h
│ │ │ │ │ │ ├── SparseMatrixBase.h
│ │ │ │ │ │ ├── SparsePermutation.h
│ │ │ │ │ │ ├── SparseProduct.h
│ │ │ │ │ │ ├── SparseRedux.h
│ │ │ │ │ │ ├── SparseRef.h
│ │ │ │ │ │ ├── SparseSelfAdjointView.h
│ │ │ │ │ │ ├── SparseSolverBase.h
│ │ │ │ │ │ ├── SparseSparseProductWithPruning.h
│ │ │ │ │ │ ├── SparseTranspose.h
│ │ │ │ │ │ ├── SparseTriangularView.h
│ │ │ │ │ │ ├── SparseUtil.h
│ │ │ │ │ │ ├── SparseVector.h
│ │ │ │ │ │ ├── SparseView.h
│ │ │ │ │ │ └── TriangularSolver.h
│ │ │ │ │ ├── SparseLU/
│ │ │ │ │ │ ├── SparseLU.h
│ │ │ │ │ │ ├── SparseLUImpl.h
│ │ │ │ │ │ ├── SparseLU_Memory.h
│ │ │ │ │ │ ├── SparseLU_Structs.h
│ │ │ │ │ │ ├── SparseLU_SupernodalMatrix.h
│ │ │ │ │ │ ├── SparseLU_Utils.h
│ │ │ │ │ │ ├── SparseLU_column_bmod.h
│ │ │ │ │ │ ├── SparseLU_column_dfs.h
│ │ │ │ │ │ ├── SparseLU_copy_to_ucol.h
│ │ │ │ │ │ ├── SparseLU_gemm_kernel.h
│ │ │ │ │ │ ├── SparseLU_heap_relax_snode.h
│ │ │ │ │ │ ├── SparseLU_kernel_bmod.h
│ │ │ │ │ │ ├── SparseLU_panel_bmod.h
│ │ │ │ │ │ ├── SparseLU_panel_dfs.h
│ │ │ │ │ │ ├── SparseLU_pivotL.h
│ │ │ │ │ │ ├── SparseLU_pruneL.h
│ │ │ │ │ │ └── SparseLU_relax_snode.h
│ │ │ │ │ ├── SparseQR/
│ │ │ │ │ │ └── SparseQR.h
│ │ │ │ │ ├── StlSupport/
│ │ │ │ │ │ ├── StdDeque.h
│ │ │ │ │ │ ├── StdList.h
│ │ │ │ │ │ ├── StdVector.h
│ │ │ │ │ │ └── details.h
│ │ │ │ │ ├── SuperLUSupport/
│ │ │ │ │ │ └── SuperLUSupport.h
│ │ │ │ │ ├── UmfPackSupport/
│ │ │ │ │ │ └── UmfPackSupport.h
│ │ │ │ │ ├── misc/
│ │ │ │ │ │ ├── Image.h
│ │ │ │ │ │ ├── Kernel.h
│ │ │ │ │ │ ├── RealSvd2x2.h
│ │ │ │ │ │ ├── blas.h
│ │ │ │ │ │ ├── lapack.h
│ │ │ │ │ │ ├── lapacke.h
│ │ │ │ │ │ └── lapacke_mangling.h
│ │ │ │ │ └── plugins/
│ │ │ │ │ ├── ArrayCwiseBinaryOps.h
│ │ │ │ │ ├── ArrayCwiseUnaryOps.h
│ │ │ │ │ ├── BlockMethods.h
│ │ │ │ │ ├── CommonCwiseBinaryOps.h
│ │ │ │ │ ├── CommonCwiseUnaryOps.h
│ │ │ │ │ ├── IndexedViewMethods.h
│ │ │ │ │ ├── MatrixCwiseBinaryOps.h
│ │ │ │ │ ├── MatrixCwiseUnaryOps.h
│ │ │ │ │ └── ReshapedMethods.h
│ │ │ │ ├── INSTALL
│ │ │ │ ├── README.md
│ │ │ │ ├── bench/
│ │ │ │ │ ├── BenchSparseUtil.h
│ │ │ │ │ ├── BenchTimer.h
│ │ │ │ │ ├── BenchUtil.h
│ │ │ │ │ ├── README.txt
│ │ │ │ │ ├── analyze-blocking-sizes.cpp
│ │ │ │ │ ├── basicbench.cxxlist
│ │ │ │ │ ├── basicbenchmark.cpp
│ │ │ │ │ ├── basicbenchmark.h
│ │ │ │ │ ├── benchBlasGemm.cpp
│ │ │ │ │ ├── benchCholesky.cpp
│ │ │ │ │ ├── benchEigenSolver.cpp
│ │ │ │ │ ├── benchFFT.cpp
│ │ │ │ │ ├── benchGeometry.cpp
│ │ │ │ │ ├── benchVecAdd.cpp
│ │ │ │ │ ├── bench_gemm.cpp
│ │ │ │ │ ├── bench_move_semantics.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/
│ │ │ │ │ │ ├── changesets.txt
│ │ │ │ │ │ ├── gemm.cpp
│ │ │ │ │ │ ├── gemm_common.h
│ │ │ │ │ │ ├── gemm_settings.txt
│ │ │ │ │ │ ├── gemm_square_settings.txt
│ │ │ │ │ │ ├── gemv.cpp
│ │ │ │ │ │ ├── gemv_common.h
│ │ │ │ │ │ ├── gemv_settings.txt
│ │ │ │ │ │ ├── gemv_square_settings.txt
│ │ │ │ │ │ ├── gemvt.cpp
│ │ │ │ │ │ ├── lazy_gemm.cpp
│ │ │ │ │ │ ├── lazy_gemm_settings.txt
│ │ │ │ │ │ ├── llt.cpp
│ │ │ │ │ │ ├── make_plot.sh
│ │ │ │ │ │ ├── resources/
│ │ │ │ │ │ │ ├── chart_footer.html
│ │ │ │ │ │ │ ├── chart_header.html
│ │ │ │ │ │ │ ├── footer.html
│ │ │ │ │ │ │ ├── header.html
│ │ │ │ │ │ │ ├── s1.js
│ │ │ │ │ │ │ └── s2.js
│ │ │ │ │ │ ├── run.sh
│ │ │ │ │ │ ├── runall.sh
│ │ │ │ │ │ ├── trmv_lo.cpp
│ │ │ │ │ │ ├── trmv_lot.cpp
│ │ │ │ │ │ ├── trmv_up.cpp
│ │ │ │ │ │ └── trmv_upt.cpp
│ │ │ │ │ ├── product_threshold.cpp
│ │ │ │ │ ├── quat_slerp.cpp
│ │ │ │ │ ├── quatmul.cpp
│ │ │ │ │ ├── sparse_cholesky.cpp
│ │ │ │ │ ├── sparse_dense_product.cpp
│ │ │ │ │ ├── sparse_lu.cpp
│ │ │ │ │ ├── sparse_product.cpp
│ │ │ │ │ ├── sparse_randomsetter.cpp
│ │ │ │ │ ├── sparse_setter.cpp
│ │ │ │ │ ├── sparse_transpose.cpp
│ │ │ │ │ ├── sparse_trisolver.cpp
│ │ │ │ │ ├── spbench/
│ │ │ │ │ │ ├── CMakeLists.txt
│ │ │ │ │ │ ├── sp_solver.cpp
│ │ │ │ │ │ ├── spbench.dtd
│ │ │ │ │ │ ├── spbenchsolver.cpp
│ │ │ │ │ │ ├── spbenchsolver.h
│ │ │ │ │ │ ├── spbenchstyle.h
│ │ │ │ │ │ └── test_sparseLU.cpp
│ │ │ │ │ ├── spmv.cpp
│ │ │ │ │ ├── tensors/
│ │ │ │ │ │ ├── README
│ │ │ │ │ │ ├── benchmark.h
│ │ │ │ │ │ ├── benchmark_main.cc
│ │ │ │ │ │ ├── contraction_benchmarks_cpu.cc
│ │ │ │ │ │ ├── eigen_sycl_bench.sh
│ │ │ │ │ │ ├── eigen_sycl_bench_contract.sh
│ │ │ │ │ │ ├── tensor_benchmarks.h
│ │ │ │ │ │ ├── tensor_benchmarks_cpu.cc
│ │ │ │ │ │ ├── tensor_benchmarks_fp16_gpu.cu
│ │ │ │ │ │ ├── tensor_benchmarks_gpu.cu
│ │ │ │ │ │ ├── tensor_benchmarks_sycl.cc
│ │ │ │ │ │ └── tensor_contract_sycl_bench.cc
│ │ │ │ │ └── vdw_new.cpp
│ │ │ │ ├── blas/
│ │ │ │ │ ├── BandTriangularSolver.h
│ │ │ │ │ ├── CMakeLists.txt
│ │ │ │ │ ├── GeneralRank1Update.h
│ │ │ │ │ ├── PackedSelfadjointProduct.h
│ │ │ │ │ ├── PackedTriangularMatrixVector.h
│ │ │ │ │ ├── PackedTriangularSolverVector.h
│ │ │ │ │ ├── README.txt
│ │ │ │ │ ├── Rank2Update.h
│ │ │ │ │ ├── common.h
│ │ │ │ │ ├── complex_double.cpp
│ │ │ │ │ ├── complex_single.cpp
│ │ │ │ │ ├── double.cpp
│ │ │ │ │ ├── f2c/
│ │ │ │ │ │ ├── chbmv.c
│ │ │ │ │ │ ├── chpmv.c
│ │ │ │ │ │ ├── complexdots.c
│ │ │ │ │ │ ├── ctbmv.c
│ │ │ │ │ │ ├── d_cnjg.c
│ │ │ │ │ │ ├── datatypes.h
│ │ │ │ │ │ ├── drotm.c
│ │ │ │ │ │ ├── drotmg.c
│ │ │ │ │ │ ├── dsbmv.c
│ │ │ │ │ │ ├── dspmv.c
│ │ │ │ │ │ ├── dtbmv.c
│ │ │ │ │ │ ├── lsame.c
│ │ │ │ │ │ ├── r_cnjg.c
│ │ │ │ │ │ ├── srotm.c
│ │ │ │ │ │ ├── srotmg.c
│ │ │ │ │ │ ├── ssbmv.c
│ │ │ │ │ │ ├── sspmv.c
│ │ │ │ │ │ ├── stbmv.c
│ │ │ │ │ │ ├── zhbmv.c
│ │ │ │ │ │ ├── zhpmv.c
│ │ │ │ │ │ └── ztbmv.c
│ │ │ │ │ ├── fortran/
│ │ │ │ │ │ └── complexdots.f
│ │ │ │ │ ├── level1_cplx_impl.h
│ │ │ │ │ ├── level1_impl.h
│ │ │ │ │ ├── level1_real_impl.h
│ │ │ │ │ ├── level2_cplx_impl.h
│ │ │ │ │ ├── level2_impl.h
│ │ │ │ │ ├── level2_real_impl.h
│ │ │ │ │ ├── level3_impl.h
│ │ │ │ │ ├── single.cpp
│ │ │ │ │ ├── testing/
│ │ │ │ │ │ ├── CMakeLists.txt
│ │ │ │ │ │ ├── cblat1.f
│ │ │ │ │ │ ├── cblat2.f
│ │ │ │ │ │ ├── cblat3.f
│ │ │ │ │ │ ├── dblat1.f
│ │ │ │ │ │ ├── dblat2.f
│ │ │ │ │ │ ├── dblat3.f
│ │ │ │ │ │ ├── runblastest.sh
│ │ │ │ │ │ ├── sblat1.f
│ │ │ │ │ │ ├── sblat2.f
│ │ │ │ │ │ ├── sblat3.f
│ │ │ │ │ │ ├── zblat1.f
│ │ │ │ │ │ ├── zblat2.f
│ │ │ │ │ │ └── zblat3.f
│ │ │ │ │ └── xerbla.cpp
│ │ │ │ ├── ci/
│ │ │ │ │ ├── CTest2JUnit.xsl
│ │ │ │ │ ├── README.md
│ │ │ │ │ └── test.gitlab-ci.yml
│ │ │ │ ├── cmake/
│ │ │ │ │ ├── ComputeCppCompilerChecks.cmake
│ │ │ │ │ ├── ComputeCppIRMap.cmake
│ │ │ │ │ ├── Eigen3Config.cmake.in
│ │ │ │ │ ├── Eigen3ConfigLegacy.cmake.in
│ │ │ │ │ ├── EigenConfigureTesting.cmake
│ │ │ │ │ ├── EigenDetermineOSVersion.cmake
│ │ │ │ │ ├── EigenDetermineVSServicePack.cmake
│ │ │ │ │ ├── EigenTesting.cmake
│ │ │ │ │ ├── EigenUninstall.cmake
│ │ │ │ │ ├── FindAdolc.cmake
│ │ │ │ │ ├── FindBLAS.cmake
│ │ │ │ │ ├── FindBLASEXT.cmake
│ │ │ │ │ ├── FindCHOLMOD.cmake
│ │ │ │ │ ├── FindComputeCpp.cmake
│ │ │ │ │ ├── FindEigen2.cmake
│ │ │ │ │ ├── FindEigen3.cmake
│ │ │ │ │ ├── FindFFTW.cmake
│ │ │ │ │ ├── FindGLEW.cmake
│ │ │ │ │ ├── FindGMP.cmake
│ │ │ │ │ ├── FindGSL.cmake
│ │ │ │ │ ├── FindGoogleHash.cmake
│ │ │ │ │ ├── FindHWLOC.cmake
│ │ │ │ │ ├── FindKLU.cmake
│ │ │ │ │ ├── FindLAPACK.cmake
│ │ │ │ │ ├── FindMPFR.cmake
│ │ │ │ │ ├── FindMetis.cmake
│ │ │ │ │ ├── FindPTSCOTCH.cmake
│ │ │ │ │ ├── FindPastix.cmake
│ │ │ │ │ ├── FindSPQR.cmake
│ │ │ │ │ ├── FindScotch.cmake
│ │ │ │ │ ├── FindStandardMathLibrary.cmake
│ │ │ │ │ ├── FindSuperLU.cmake
│ │ │ │ │ ├── FindTriSYCL.cmake
│ │ │ │ │ ├── FindUMFPACK.cmake
│ │ │ │ │ ├── RegexUtils.cmake
│ │ │ │ │ └── UseEigen3.cmake
│ │ │ │ ├── debug/
│ │ │ │ │ ├── gdb/
│ │ │ │ │ │ ├── __init__.py
│ │ │ │ │ │ └── printers.py
│ │ │ │ │ └── msvc/
│ │ │ │ │ └── eigen.natvis
│ │ │ │ ├── demos/
│ │ │ │ │ ├── CMakeLists.txt
│ │ │ │ │ ├── mandelbrot/
│ │ │ │ │ │ ├── CMakeLists.txt
│ │ │ │ │ │ ├── README
│ │ │ │ │ │ ├── mandelbrot.cpp
│ │ │ │ │ │ └── mandelbrot.h
│ │ │ │ │ ├── mix_eigen_and_c/
│ │ │ │ │ │ ├── README
│ │ │ │ │ │ ├── binary_library.cpp
│ │ │ │ │ │ ├── binary_library.h
│ │ │ │ │ │ └── example.c
│ │ │ │ │ └── opengl/
│ │ │ │ │ ├── CMakeLists.txt
│ │ │ │ │ ├── README
│ │ │ │ │ ├── camera.cpp
│ │ │ │ │ ├── camera.h
│ │ │ │ │ ├── gpuhelper.cpp
│ │ │ │ │ ├── gpuhelper.h
│ │ │ │ │ ├── icosphere.cpp
│ │ │ │ │ ├── icosphere.h
│ │ │ │ │ ├── quaternion_demo.cpp
│ │ │ │ │ ├── quaternion_demo.h
│ │ │ │ │ ├── trackball.cpp
│ │ │ │ │ └── trackball.h
│ │ │ │ ├── doc/
│ │ │ │ │ ├── AsciiQuickReference.txt
│ │ │ │ │ ├── B01_Experimental.dox
│ │ │ │ │ ├── CMakeLists.txt
│ │ │ │ │ ├── ClassHierarchy.dox
│ │ │ │ │ ├── CoeffwiseMathFunctionsTable.dox
│ │ │ │ │ ├── CustomizingEigen_CustomScalar.dox
│ │ │ │ │ ├── CustomizingEigen_InheritingMatrix.dox
│ │ │ │ │ ├── CustomizingEigen_NullaryExpr.dox
│ │ │ │ │ ├── CustomizingEigen_Plugins.dox
│ │ │ │ │ ├── DenseDecompositionBenchmark.dox
│ │ │ │ │ ├── Doxyfile.in
│ │ │ │ │ ├── FixedSizeVectorizable.dox
│ │ │ │ │ ├── FunctionsTakingEigenTypes.dox
│ │ │ │ │ ├── HiPerformance.dox
│ │ │ │ │ ├── InplaceDecomposition.dox
│ │ │ │ │ ├── InsideEigenExample.dox
│ │ │ │ │ ├── LeastSquares.dox
│ │ │ │ │ ├── Manual.dox
│ │ │ │ │ ├── MatrixfreeSolverExample.dox
│ │ │ │ │ ├── NewExpressionType.dox
│ │ │ │ │ ├── Overview.dox
│ │ │ │ │ ├── PassingByValue.dox
│ │ │ │ │ ├── Pitfalls.dox
│ │ │ │ │ ├── PreprocessorDirectives.dox
│ │ │ │ │ ├── QuickReference.dox
│ │ │ │ │ ├── QuickStartGuide.dox
│ │ │ │ │ ├── SparseLinearSystems.dox
│ │ │ │ │ ├── SparseQuickReference.dox
│ │ │ │ │ ├── StlContainers.dox
│ │ │ │ │ ├── StorageOrders.dox
│ │ │ │ │ ├── StructHavingEigenMembers.dox
│ │ │ │ │ ├── TemplateKeyword.dox
│ │ │ │ │ ├── TopicAliasing.dox
│ │ │ │ │ ├── TopicAssertions.dox
│ │ │ │ │ ├── TopicCMakeGuide.dox
│ │ │ │ │ ├── TopicEigenExpressionTemplates.dox
│ │ │ │ │ ├── TopicLazyEvaluation.dox
│ │ │ │ │ ├── TopicLinearAlgebraDecompositions.dox
│ │ │ │ │ ├── TopicMultithreading.dox
│ │ │ │ │ ├── TopicResizing.dox
│ │ │ │ │ ├── TopicScalarTypes.dox
│ │ │ │ │ ├── TopicVectorization.dox
│ │ │ │ │ ├── TutorialAdvancedInitialization.dox
│ │ │ │ │ ├── TutorialArrayClass.dox
│ │ │ │ │ ├── TutorialBlockOperations.dox
│ │ │ │ │ ├── TutorialGeometry.dox
│ │ │ │ │ ├── TutorialLinearAlgebra.dox
│ │ │ │ │ ├── TutorialMapClass.dox
│ │ │ │ │ ├── TutorialMatrixArithmetic.dox
│ │ │ │ │ ├── TutorialMatrixClass.dox
│ │ │ │ │ ├── TutorialReductionsVisitorsBroadcasting.dox
│ │ │ │ │ ├── TutorialReshape.dox
│ │ │ │ │ ├── TutorialSTL.dox
│ │ │ │ │ ├── TutorialSlicingIndexing.dox
│ │ │ │ │ ├── TutorialSparse.dox
│ │ │ │ │ ├── TutorialSparse_example_details.dox
│ │ │ │ │ ├── UnalignedArrayAssert.dox
│ │ │ │ │ ├── UsingBlasLapackBackends.dox
│ │ │ │ │ ├── UsingIntelMKL.dox
│ │ │ │ │ ├── UsingNVCC.dox
│ │ │ │ │ ├── WrongStackAlignment.dox
│ │ │ │ │ ├── eigen_navtree_hacks.js
│ │ │ │ │ ├── eigendoxy.css
│ │ │ │ │ ├── eigendoxy_footer.html.in
│ │ │ │ │ ├── eigendoxy_header.html.in
│ │ │ │ │ ├── eigendoxy_layout.xml.in
│ │ │ │ │ ├── eigendoxy_tabs.css
│ │ │ │ │ ├── examples/
│ │ │ │ │ │ ├── .krazy
│ │ │ │ │ │ ├── CMakeLists.txt
│ │ │ │ │ │ ├── CustomizingEigen_Inheritance.cpp
│ │ │ │ │ │ ├── Cwise_erf.cpp
│ │ │ │ │ │ ├── Cwise_erfc.cpp
│ │ │ │ │ │ ├── Cwise_lgamma.cpp
│ │ │ │ │ │ ├── DenseBase_middleCols_int.cpp
│ │ │ │ │ │ ├── DenseBase_middleRows_int.cpp
│ │ │ │ │ │ ├── DenseBase_template_int_middleCols.cpp
│ │ │ │ │ │ ├── DenseBase_template_int_middleRows.cpp
│ │ │ │ │ │ ├── QuickStart_example.cpp
│ │ │ │ │ │ ├── QuickStart_example2_dynamic.cpp
│ │ │ │ │ │ ├── QuickStart_example2_fixed.cpp
│ │ │ │ │ │ ├── TemplateKeyword_flexible.cpp
│ │ │ │ │ │ ├── TemplateKeyword_simple.cpp
│ │ │ │ │ │ ├── TutorialInplaceLU.cpp
│ │ │ │ │ │ ├── TutorialLinAlgComputeTwice.cpp
│ │ │ │ │ │ ├── TutorialLinAlgExComputeSolveError.cpp
│ │ │ │ │ │ ├── TutorialLinAlgExSolveColPivHouseholderQR.cpp
│ │ │ │ │ │ ├── TutorialLinAlgExSolveLDLT.cpp
│ │ │ │ │ │ ├── TutorialLinAlgInverseDeterminant.cpp
│ │ │ │ │ │ ├── TutorialLinAlgRankRevealing.cpp
│ │ │ │ │ │ ├── TutorialLinAlgSVDSolve.cpp
│ │ │ │ │ │ ├── TutorialLinAlgSelfAdjointEigenSolver.cpp
│ │ │ │ │ │ ├── TutorialLinAlgSetThreshold.cpp
│ │ │ │ │ │ ├── Tutorial_ArrayClass_accessors.cpp
│ │ │ │ │ │ ├── Tutorial_ArrayClass_addition.cpp
│ │ │ │ │ │ ├── Tutorial_ArrayClass_cwise_other.cpp
│ │ │ │ │ │ ├── Tutorial_ArrayClass_interop.cpp
│ │ │ │ │ │ ├── Tutorial_ArrayClass_interop_matrix.cpp
│ │ │ │ │ │ ├── Tutorial_ArrayClass_mult.cpp
│ │ │ │ │ │ ├── Tutorial_BlockOperations_block_assignment.cpp
│ │ │ │ │ │ ├── Tutorial_BlockOperations_colrow.cpp
│ │ │ │ │ │ ├── Tutorial_BlockOperations_corner.cpp
│ │ │ │ │ │ ├── Tutorial_BlockOperations_print_block.cpp
│ │ │ │ │ │ ├── Tutorial_BlockOperations_vector.cpp
│ │ │ │ │ │ ├── Tutorial_PartialLU_solve.cpp
│ │ │ │ │ │ ├── Tutorial_ReductionsVisitorsBroadcasting_broadcast_1nn.cpp
│ │ │ │ │ │ ├── Tutorial_ReductionsVisitorsBroadcasting_broadcast_simple.cpp
│ │ │ │ │ │ ├── Tutorial_ReductionsVisitorsBroadcasting_broadcast_simple_rowwise.cpp
│ │ │ │ │ │ ├── Tutorial_ReductionsVisitorsBroadcasting_colwise.cpp
│ │ │ │ │ │ ├── Tutorial_ReductionsVisitorsBroadcasting_maxnorm.cpp
│ │ │ │ │ │ ├── Tutorial_ReductionsVisitorsBroadcasting_reductions_bool.cpp
│ │ │ │ │ │ ├── Tutorial_ReductionsVisitorsBroadcasting_reductions_norm.cpp
│ │ │ │ │ │ ├── Tutorial_ReductionsVisitorsBroadcasting_reductions_operatornorm.cpp
│ │ │ │ │ │ ├── Tutorial_ReductionsVisitorsBroadcasting_rowwise.cpp
│ │ │ │ │ │ ├── Tutorial_ReductionsVisitorsBroadcasting_visitors.cpp
│ │ │ │ │ │ ├── Tutorial_simple_example_dynamic_size.cpp
│ │ │ │ │ │ ├── Tutorial_simple_example_fixed_size.cpp
│ │ │ │ │ │ ├── class_Block.cpp
│ │ │ │ │ │ ├── class_CwiseBinaryOp.cpp
│ │ │ │ │ │ ├── class_CwiseUnaryOp.cpp
│ │ │ │ │ │ ├── class_CwiseUnaryOp_ptrfun.cpp
│ │ │ │ │ │ ├── class_FixedBlock.cpp
│ │ │ │ │ │ ├── class_FixedReshaped.cpp
│ │ │ │ │ │ ├── class_FixedVectorBlock.cpp
│ │ │ │ │ │ ├── class_Reshaped.cpp
│ │ │ │ │ │ ├── class_VectorBlock.cpp
│ │ │ │ │ │ ├── function_taking_eigenbase.cpp
│ │ │ │ │ │ ├── function_taking_ref.cpp
│ │ │ │ │ │ ├── make_circulant.cpp
│ │ │ │ │ │ ├── make_circulant.cpp.entry
│ │ │ │ │ │ ├── make_circulant.cpp.evaluator
│ │ │ │ │ │ ├── make_circulant.cpp.expression
│ │ │ │ │ │ ├── make_circulant.cpp.main
│ │ │ │ │ │ ├── make_circulant.cpp.preamble
│ │ │ │ │ │ ├── make_circulant.cpp.traits
│ │ │ │ │ │ ├── make_circulant2.cpp
│ │ │ │ │ │ ├── matrixfree_cg.cpp
│ │ │ │ │ │ ├── nullary_indexing.cpp
│ │ │ │ │ │ ├── tut_arithmetic_add_sub.cpp
│ │ │ │ │ │ ├── tut_arithmetic_dot_cross.cpp
│ │ │ │ │ │ ├── tut_arithmetic_matrix_mul.cpp
│ │ │ │ │ │ ├── tut_arithmetic_redux_basic.cpp
│ │ │ │ │ │ ├── tut_arithmetic_scalar_mul_div.cpp
│ │ │ │ │ │ ├── tut_matrix_coefficient_accessors.cpp
│ │ │ │ │ │ ├── tut_matrix_resize.cpp
│ │ │ │ │ │ └── tut_matrix_resize_fixed_size.cpp
│ │ │ │ │ ├── snippets/
│ │ │ │ │ │ ├── .krazy
│ │ │ │ │ │ ├── AngleAxis_mimic_euler.cpp
│ │ │ │ │ │ ├── Array_initializer_list_23_cxx11.cpp
│ │ │ │ │ │ ├── Array_initializer_list_vector_cxx11.cpp
│ │ │ │ │ │ ├── Array_variadic_ctor_cxx11.cpp
│ │ │ │ │ │ ├── BiCGSTAB_simple.cpp
│ │ │ │ │ │ ├── BiCGSTAB_step_by_step.cpp
│ │ │ │ │ │ ├── CMakeLists.txt
│ │ │ │ │ │ ├── ColPivHouseholderQR_solve.cpp
│ │ │ │ │ │ ├── ComplexEigenSolver_compute.cpp
│ │ │ │ │ │ ├── ComplexEigenSolver_eigenvalues.cpp
│ │ │ │ │ │ ├── ComplexEigenSolver_eigenvectors.cpp
│ │ │ │ │ │ ├── ComplexSchur_compute.cpp
│ │ │ │ │ │ ├── ComplexSchur_matrixT.cpp
│ │ │ │ │ │ ├── ComplexSchur_matrixU.cpp
│ │ │ │ │ │ ├── Cwise_abs.cpp
│ │ │ │ │ │ ├── Cwise_abs2.cpp
│ │ │ │ │ │ ├── Cwise_acos.cpp
│ │ │ │ │ │ ├── Cwise_arg.cpp
│ │ │ │ │ │ ├── Cwise_array_power_array.cpp
│ │ │ │ │ │ ├── Cwise_asin.cpp
│ │ │ │ │ │ ├── Cwise_atan.cpp
│ │ │ │ │ │ ├── Cwise_boolean_and.cpp
│ │ │ │ │ │ ├── Cwise_boolean_not.cpp
│ │ │ │ │ │ ├── Cwise_boolean_or.cpp
│ │ │ │ │ │ ├── Cwise_boolean_xor.cpp
│ │ │ │ │ │ ├── Cwise_ceil.cpp
│ │ │ │ │ │ ├── Cwise_cos.cpp
│ │ │ │ │ │ ├── Cwise_cosh.cpp
│ │ │ │ │ │ ├── Cwise_cube.cpp
│ │ │ │ │ │ ├── Cwise_equal_equal.cpp
│ │ │ │ │ │ ├── Cwise_exp.cpp
│ │ │ │ │ │ ├── Cwise_floor.cpp
│ │ │ │ │ │ ├── Cwise_greater.cpp
│ │ │ │ │ │ ├── Cwise_greater_equal.cpp
│ │ │ │ │ │ ├── Cwise_inverse.cpp
│ │ │ │ │ │ ├── Cwise_isFinite.cpp
│ │ │ │ │ │ ├── Cwise_isInf.cpp
│ │ │ │ │ │ ├── Cwise_isNaN.cpp
│ │ │ │ │ │ ├── Cwise_less.cpp
│ │ │ │ │ │ ├── Cwise_less_equal.cpp
│ │ │ │ │ │ ├── Cwise_log.cpp
│ │ │ │ │ │ ├── Cwise_log10.cpp
│ │ │ │ │ │ ├── Cwise_max.cpp
│ │ │ │ │ │ ├── Cwise_min.cpp
│ │ │ │ │ │ ├── Cwise_minus.cpp
│ │ │ │ │ │ ├── Cwise_minus_equal.cpp
│ │ │ │ │ │ ├── Cwise_not_equal.cpp
│ │ │ │ │ │ ├── Cwise_plus.cpp
│ │ │ │ │ │ ├── Cwise_plus_equal.cpp
│ │ │ │ │ │ ├── Cwise_pow.cpp
│ │ │ │ │ │ ├── Cwise_product.cpp
│ │ │ │ │ │ ├── Cwise_quotient.cpp
│ │ │ │ │ │ ├── Cwise_rint.cpp
│ │ │ │ │ │ ├── Cwise_round.cpp
│ │ │ │ │ │ ├── Cwise_scalar_power_array.cpp
│ │ │ │ │ │ ├── Cwise_sign.cpp
│ │ │ │ │ │ ├── Cwise_sin.cpp
│ │ │ │ │ │ ├── Cwise_sinh.cpp
│ │ │ │ │ │ ├── Cwise_slash_equal.cpp
│ │ │ │ │ │ ├── Cwise_sqrt.cpp
│ │ │ │ │ │ ├── Cwise_square.cpp
│ │ │ │ │ │ ├── Cwise_tan.cpp
│ │ │ │ │ │ ├── Cwise_tanh.cpp
│ │ │ │ │ │ ├── Cwise_times_equal.cpp
│ │ │ │ │ │ ├── DenseBase_LinSpaced.cpp
│ │ │ │ │ │ ├── DenseBase_LinSpacedInt.cpp
│ │ │ │ │ │ ├── DenseBase_LinSpaced_seq_deprecated.cpp
│ │ │ │ │ │ ├── DenseBase_setLinSpaced.cpp
│ │ │ │ │ │ ├── DirectionWise_hnormalized.cpp
│ │ │ │ │ │ ├── DirectionWise_replicate.cpp
│ │ │ │ │ │ ├── DirectionWise_replicate_int.cpp
│ │ │ │ │ │ ├── EigenSolver_EigenSolver_MatrixType.cpp
│ │ │ │ │ │ ├── EigenSolver_compute.cpp
│ │ │ │ │ │ ├── EigenSolver_eigenvalues.cpp
│ │ │ │ │ │ ├── EigenSolver_eigenvectors.cpp
│ │ │ │ │ │ ├── EigenSolver_pseudoEigenvectors.cpp
│ │ │ │ │ │ ├── FullPivHouseholderQR_solve.cpp
│ │ │ │ │ │ ├── FullPivLU_image.cpp
│ │ │ │ │ │ ├── FullPivLU_kernel.cpp
│ │ │ │ │ │ ├── FullPivLU_solve.cpp
│ │ │ │ │ │ ├── GeneralizedEigenSolver.cpp
│ │ │ │ │ │ ├── HessenbergDecomposition_compute.cpp
│ │ │ │ │ │ ├── HessenbergDecomposition_matrixH.cpp
│ │ │ │ │ │ ├── HessenbergDecomposition_packedMatrix.cpp
│ │ │ │ │ │ ├── HouseholderQR_householderQ.cpp
│ │ │ │ │ │ ├── HouseholderQR_solve.cpp
│ │ │ │ │ │ ├── HouseholderSequence_HouseholderSequence.cpp
│ │ │ │ │ │ ├── IOFormat.cpp
│ │ │ │ │ │ ├── JacobiSVD_basic.cpp
│ │ │ │ │ │ ├── Jacobi_makeGivens.cpp
│ │ │ │ │ │ ├── Jacobi_makeJacobi.cpp
│ │ │ │ │ │ ├── LLT_example.cpp
│ │ │ │ │ │ ├── LLT_solve.cpp
│ │ │ │ │ │ ├── LeastSquaresNormalEquations.cpp
│ │ │ │ │ │ ├── LeastSquaresQR.cpp
│ │ │ │ │ │ ├── Map_general_stride.cpp
│ │ │ │ │ │ ├── Map_inner_stride.cpp
│ │ │ │ │ │ ├── Map_outer_stride.cpp
│ │ │ │ │ │ ├── Map_placement_new.cpp
│ │ │ │ │ │ ├── Map_simple.cpp
│ │ │ │ │ │ ├── MatrixBase_adjoint.cpp
│ │ │ │ │ │ ├── MatrixBase_all.cpp
│ │ │ │ │ │ ├── MatrixBase_applyOnTheLeft.cpp
│ │ │ │ │ │ ├── MatrixBase_applyOnTheRight.cpp
│ │ │ │ │ │ ├── MatrixBase_array.cpp
│ │ │ │ │ │ ├── MatrixBase_array_const.cpp
│ │ │ │ │ │ ├── MatrixBase_asDiagonal.cpp
│ │ │ │ │ │ ├── MatrixBase_block_int_int.cpp
│ │ │ │ │ │ ├── MatrixBase_block_int_int_int_int.cpp
│ │ │ │ │ │ ├── MatrixBase_bottomLeftCorner_int_int.cpp
│ │ │ │ │ │ ├── MatrixBase_bottomRightCorner_int_int.cpp
│ │ │ │ │ │ ├── MatrixBase_bottomRows_int.cpp
│ │ │ │ │ │ ├── MatrixBase_cast.cpp
│ │ │ │ │ │ ├── MatrixBase_col.cpp
│ │ │ │ │ │ ├── MatrixBase_colwise.cpp
│ │ │ │ │ │ ├── MatrixBase_colwise_iterator_cxx11.cpp
│ │ │ │ │ │ ├── MatrixBase_computeInverseAndDetWithCheck.cpp
│ │ │ │ │ │ ├── MatrixBase_computeInverseWithCheck.cpp
│ │ │ │ │ │ ├── MatrixBase_cwiseAbs.cpp
│ │ │ │ │ │ ├── MatrixBase_cwiseAbs2.cpp
│ │ │ │ │ │ ├── MatrixBase_cwiseArg.cpp
│ │ │ │ │ │ ├── MatrixBase_cwiseEqual.cpp
│ │ │ │ │ │ ├── MatrixBase_cwiseInverse.cpp
│ │ │ │ │ │ ├── MatrixBase_cwiseMax.cpp
│ │ │ │ │ │ ├── MatrixBase_cwiseMin.cpp
│ │ │ │ │ │ ├── MatrixBase_cwiseNotEqual.cpp
│ │ │ │ │ │ ├── MatrixBase_cwiseProduct.cpp
│ │ │ │ │ │ ├── MatrixBase_cwiseQuotient.cpp
│ │ │ │ │ │ ├── MatrixBase_cwiseSign.cpp
│ │ │ │ │ │ ├── MatrixBase_cwiseSqrt.cpp
│ │ │ │ │ │ ├── MatrixBase_diagonal.cpp
│ │ │ │ │ │ ├── MatrixBase_diagonal_int.cpp
│ │ │ │ │ │ ├── MatrixBase_diagonal_template_int.cpp
│ │ │ │ │ │ ├── MatrixBase_eigenvalues.cpp
│ │ │ │ │ │ ├── MatrixBase_end_int.cpp
│ │ │ │ │ │ ├── MatrixBase_eval.cpp
│ │ │ │ │ │ ├── MatrixBase_fixedBlock_int_int.cpp
│ │ │ │ │ │ ├── MatrixBase_hnormalized.cpp
│ │ │ │ │ │ ├── MatrixBase_homogeneous.cpp
│ │ │ │ │ │ ├── MatrixBase_identity.cpp
│ │ │ │ │ │ ├── MatrixBase_identity_int_int.cpp
│ │ │ │ │ │ ├── MatrixBase_inverse.cpp
│ │ │ │ │ │ ├── MatrixBase_isDiagonal.cpp
│ │ │ │ │ │ ├── MatrixBase_isIdentity.cpp
│ │ │ │ │ │ ├── MatrixBase_isOnes.cpp
│ │ │ │ │ │ ├── MatrixBase_isOrthogonal.cpp
│ │ │ │ │ │ ├── MatrixBase_isUnitary.cpp
│ │ │ │ │ │ ├── MatrixBase_isZero.cpp
│ │ │ │ │ │ ├── MatrixBase_leftCols_int.cpp
│ │ │ │ │ │ ├── MatrixBase_noalias.cpp
│ │ │ │ │ │ ├── MatrixBase_ones.cpp
│ │ │ │ │ │ ├── MatrixBase_ones_int.cpp
│ │ │ │ │ │ ├── MatrixBase_ones_int_int.cpp
│ │ │ │ │ │ ├── MatrixBase_operatorNorm.cpp
│ │ │ │ │ │ ├── MatrixBase_prod.cpp
│ │ │ │ │ │ ├── MatrixBase_random.cpp
│ │ │ │ │ │ ├── MatrixBase_random_int.cpp
│ │ │ │ │ │ ├── MatrixBase_random_int_int.cpp
│ │ │ │ │ │ ├── MatrixBase_replicate.cpp
│ │ │ │ │ │ ├── MatrixBase_replicate_int_int.cpp
│ │ │ │ │ │ ├── MatrixBase_reshaped_auto.cpp
│ │ │ │ │ │ ├── MatrixBase_reshaped_fixed.cpp
│ │ │ │ │ │ ├── MatrixBase_reshaped_int_int.cpp
│ │ │ │ │ │ ├── MatrixBase_reshaped_to_vector.cpp
│ │ │ │ │ │ ├── MatrixBase_reverse.cpp
│ │ │ │ │ │ ├── MatrixBase_rightCols_int.cpp
│ │ │ │ │ │ ├── MatrixBase_row.cpp
│ │ │ │ │ │ ├── MatrixBase_rowwise.cpp
│ │ │ │ │ │ ├── MatrixBase_segment_int_int.cpp
│ │ │ │ │ │ ├── MatrixBase_select.cpp
│ │ │ │ │ │ ├── MatrixBase_selfadjointView.cpp
│ │ │ │ │ │ ├── MatrixBase_set.cpp
│ │ │ │ │ │ ├── MatrixBase_setIdentity.cpp
│ │ │ │ │ │ ├── MatrixBase_setOnes.cpp
│ │ │ │ │ │ ├── MatrixBase_setRandom.cpp
│ │ │ │ │ │ ├── MatrixBase_setZero.cpp
│ │ │ │ │ │ ├── MatrixBase_start_int.cpp
│ │ │ │ │ │ ├── MatrixBase_template_int_bottomRows.cpp
│ │ │ │ │ │ ├── MatrixBase_template_int_end.cpp
│ │ │ │ │ │ ├── MatrixBase_template_int_int_block_int_int_int_int.cpp
│ │ │ │ │ │ ├── MatrixBase_template_int_int_bottomLeftCorner.cpp
│ │ │ │ │ │ ├── MatrixBase_template_int_int_bottomLeftCorner_int_int.cpp
│ │ │ │ │ │ ├── MatrixBase_template_int_int_bottomRightCorner.cpp
│ │ │ │ │ │ ├── MatrixBase_template_int_int_bottomRightCorner_int_int.cpp
│ │ │ │ │ │ ├── MatrixBase_template_int_int_topLeftCorner.cpp
│ │ │ │ │ │ ├── MatrixBase_template_int_int_topLeftCorner_int_int.cpp
│ │ │ │ │ │ ├── MatrixBase_template_int_int_topRightCorner.cpp
│ │ │ │ │ │ ├── MatrixBase_template_int_int_topRightCorner_int_int.cpp
│ │ │ │ │ │ ├── MatrixBase_template_int_leftCols.cpp
│ │ │ │ │ │ ├── MatrixBase_template_int_rightCols.cpp
│ │ │ │ │ │ ├── MatrixBase_template_int_segment.cpp
│ │ │ │ │ │ ├── MatrixBase_template_int_start.cpp
│ │ │ │ │ │ ├── MatrixBase_template_int_topRows.cpp
│ │ │ │ │ │ ├── MatrixBase_topLeftCorner_int_int.cpp
│ │ │ │ │ │ ├── MatrixBase_topRightCorner_int_int.cpp
│ │ │ │ │ │ ├── MatrixBase_topRows_int.cpp
│ │ │ │ │ │ ├── MatrixBase_transpose.cpp
│ │ │ │ │ │ ├── MatrixBase_triangularView.cpp
│ │ │ │ │ │ ├── MatrixBase_zero.cpp
│ │ │ │ │ │ ├── MatrixBase_zero_int.cpp
│ │ │ │ │ │ ├── MatrixBase_zero_int_int.cpp
│ │ │ │ │ │ ├── Matrix_Map_stride.cpp
│ │ │ │ │ │ ├── Matrix_initializer_list_23_cxx11.cpp
│ │ │ │ │ │ ├── Matrix_initializer_list_vector_cxx11.cpp
│ │ │ │ │ │ ├── Matrix_resize_NoChange_int.cpp
│ │ │ │ │ │ ├── Matrix_resize_int.cpp
│ │ │ │ │ │ ├── Matrix_resize_int_NoChange.cpp
│ │ │ │ │ │ ├── Matrix_resize_int_int.cpp
│ │ │ │ │ │ ├── Matrix_setConstant_int.cpp
│ │ │ │ │ │ ├── Matrix_setConstant_int_int.cpp
│ │ │ │ │ │ ├── Matrix_setIdentity_int_int.cpp
│ │ │ │ │ │ ├── Matrix_setOnes_int.cpp
│ │ │ │ │ │ ├── Matrix_setOnes_int_int.cpp
│ │ │ │ │ │ ├── Matrix_setRandom_int.cpp
│ │ │ │ │ │ ├── Matrix_setRandom_int_int.cpp
│ │ │ │ │ │ ├── Matrix_setZero_int.cpp
│ │ │ │ │ │ ├── Matrix_setZero_int_int.cpp
│ │ │ │ │ │ ├── Matrix_variadic_ctor_cxx11.cpp
│ │ │ │ │ │ ├── PartialPivLU_solve.cpp
│ │ │ │ │ │ ├── PartialRedux_count.cpp
│ │ │ │ │ │ ├── PartialRedux_maxCoeff.cpp
│ │ │ │ │ │ ├── PartialRedux_minCoeff.cpp
│ │ │ │ │ │ ├── PartialRedux_norm.cpp
│ │ │ │ │ │ ├── PartialRedux_prod.cpp
│ │ │ │ │ │ ├── PartialRedux_squaredNorm.cpp
│ │ │ │ │ │ ├── PartialRedux_sum.cpp
│ │ │ │ │ │ ├── RealQZ_compute.cpp
│ │ │ │ │ │ ├── RealSchur_RealSchur_MatrixType.cpp
│ │ │ │ │ │ ├── RealSchur_compute.cpp
│ │ │ │ │ │ ├── SelfAdjointEigenSolver_SelfAdjointEigenSolver.cpp
│ │ │ │ │ │ ├── SelfAdjointEigenSolver_SelfAdjointEigenSolver_MatrixType.cpp
│ │ │ │ │ │ ├── SelfAdjointEigenSolver_SelfAdjointEigenSolver_MatrixType2.cpp
│ │ │ │ │ │ ├── SelfAdjointEigenSolver_compute_MatrixType.cpp
│ │ │ │ │ │ ├── SelfAdjointEigenSolver_compute_MatrixType2.cpp
│ │ │ │ │ │ ├── SelfAdjointEigenSolver_eigenvalues.cpp
│ │ │ │ │ │ ├── SelfAdjointEigenSolver_eigenvectors.cpp
│ │ │ │ │ │ ├── SelfAdjointEigenSolver_operatorInverseSqrt.cpp
│ │ │ │ │ │ ├── SelfAdjointEigenSolver_operatorSqrt.cpp
│ │ │ │ │ │ ├── SelfAdjointView_eigenvalues.cpp
│ │ │ │ │ │ ├── SelfAdjointView_operatorNorm.cpp
│ │ │ │ │ │ ├── Slicing_arrayexpr.cpp
│ │ │ │ │ │ ├── Slicing_custom_padding_cxx11.cpp
│ │ │ │ │ │ ├── Slicing_rawarray_cxx11.cpp
│ │ │ │ │ │ ├── Slicing_stdvector_cxx11.cpp
│ │ │ │ │ │ ├── SparseMatrix_coeffs.cpp
│ │ │ │ │ │ ├── TopicAliasing_block.cpp
│ │ │ │ │ │ ├── TopicAliasing_block_correct.cpp
│ │ │ │ │ │ ├── TopicAliasing_cwise.cpp
│ │ │ │ │ │ ├── TopicAliasing_mult1.cpp
│ │ │ │ │ │ ├── TopicAliasing_mult2.cpp
│ │ │ │ │ │ ├── TopicAliasing_mult3.cpp
│ │ │ │ │ │ ├── TopicAliasing_mult4.cpp
│ │ │ │ │ │ ├── TopicAliasing_mult5.cpp
│ │ │ │ │ │ ├── TopicStorageOrders_example.cpp
│ │ │ │ │ │ ├── Triangular_solve.cpp
│ │ │ │ │ │ ├── Tridiagonalization_Tridiagonalization_MatrixType.cpp
│ │ │ │ │ │ ├── Tridiagonalization_compute.cpp
│ │ │ │ │ │ ├── Tridiagonalization_decomposeInPlace.cpp
│ │ │ │ │ │ ├── Tridiagonalization_diagonal.cpp
│ │ │ │ │ │ ├── Tridiagonalization_householderCoefficients.cpp
│ │ │ │ │ │ ├── Tridiagonalization_packedMatrix.cpp
│ │ │ │ │ │ ├── Tutorial_AdvancedInitialization_Block.cpp
│ │ │ │ │ │ ├── Tutorial_AdvancedInitialization_CommaTemporary.cpp
│ │ │ │ │ │ ├── Tutorial_AdvancedInitialization_Join.cpp
│ │ │ │ │ │ ├── Tutorial_AdvancedInitialization_LinSpaced.cpp
│ │ │ │ │ │ ├── Tutorial_AdvancedInitialization_ThreeWays.cpp
│ │ │ │ │ │ ├── Tutorial_AdvancedInitialization_Zero.cpp
│ │ │ │ │ │ ├── Tutorial_Map_rowmajor.cpp
│ │ │ │ │ │ ├── Tutorial_Map_using.cpp
│ │ │ │ │ │ ├── Tutorial_ReshapeMat2Mat.cpp
│ │ │ │ │ │ ├── Tutorial_ReshapeMat2Vec.cpp
│ │ │ │ │ │ ├── Tutorial_SlicingCol.cpp
│ │ │ │ │ │ ├── Tutorial_SlicingVec.cpp
│ │ │ │ │ │ ├── Tutorial_commainit_01.cpp
│ │ │ │ │ │ ├── Tutorial_commainit_01b.cpp
│ │ │ │ │ │ ├── Tutorial_commainit_02.cpp
│ │ │ │ │ │ ├── Tutorial_range_for_loop_1d_cxx11.cpp
│ │ │ │ │ │ ├── Tutorial_range_for_loop_2d_cxx11.cpp
│ │ │ │ │ │ ├── Tutorial_reshaped_vs_resize_1.cpp
│ │ │ │ │ │ ├── Tutorial_reshaped_vs_resize_2.cpp
│ │ │ │ │ │ ├── Tutorial_solve_matrix_inverse.cpp
│ │ │ │ │ │ ├── Tutorial_solve_multiple_rhs.cpp
│ │ │ │ │ │ ├── Tutorial_solve_reuse_decomposition.cpp
│ │ │ │ │ │ ├── Tutorial_solve_singular.cpp
│ │ │ │ │ │ ├── Tutorial_solve_triangular.cpp
│ │ │ │ │ │ ├── Tutorial_solve_triangular_inplace.cpp
│ │ │ │ │ │ ├── Tutorial_std_sort.cpp
│ │ │ │ │ │ ├── Tutorial_std_sort_rows_cxx11.cpp
│ │ │ │ │ │ ├── VectorwiseOp_homogeneous.cpp
│ │ │ │ │ │ ├── Vectorwise_reverse.cpp
│ │ │ │ │ │ ├── class_FullPivLU.cpp
│ │ │ │ │ │ ├── compile_snippet.cpp.in
│ │ │ │ │ │ ├── tut_arithmetic_redux_minmax.cpp
│ │ │ │ │ │ ├── tut_arithmetic_transpose_aliasing.cpp
│ │ │ │ │ │ ├── tut_arithmetic_transpose_conjugate.cpp
│ │ │ │ │ │ ├── tut_arithmetic_transpose_inplace.cpp
│ │ │ │ │ │ └── tut_matrix_assignment_resizing.cpp
│ │ │ │ │ ├── special_examples/
│ │ │ │ │ │ ├── CMakeLists.txt
│ │ │ │ │ │ ├── Tutorial_sparse_example.cpp
│ │ │ │ │ │ ├── Tutorial_sparse_example_details.cpp
│ │ │ │ │ │ └── random_cpp11.cpp
│ │ │ │ │ └── tutorial.cpp
│ │ │ │ ├── eigen3.pc.in
│ │ │ │ ├── failtest/
│ │ │ │ │ ├── CMakeLists.txt
│ │ │ │ │ ├── bdcsvd_int.cpp
│ │ │ │ │ ├── block_nonconst_ctor_on_const_xpr_0.cpp
│ │ │ │ │ ├── block_nonconst_ctor_on_const_xpr_1.cpp
│ │ │ │ │ ├── block_nonconst_ctor_on_const_xpr_2.cpp
│ │ │ │ │ ├── block_on_const_type_actually_const_0.cpp
│ │ │ │ │ ├── block_on_const_type_actually_const_1.cpp
│ │ │ │ │ ├── colpivqr_int.cpp
│ │ │ │ │ ├── const_qualified_block_method_retval_0.cpp
│ │ │ │ │ ├── const_qualified_block_method_retval_1.cpp
│ │ │ │ │ ├── const_qualified_diagonal_method_retval.cpp
│ │ │ │ │ ├── const_qualified_transpose_method_retval.cpp
│ │ │ │ │ ├── cwiseunaryview_nonconst_ctor_on_const_xpr.cpp
│ │ │ │ │ ├── cwiseunaryview_on_const_type_actually_const.cpp
│ │ │ │ │ ├── diagonal_nonconst_ctor_on_const_xpr.cpp
│ │ │ │ │ ├── diagonal_on_const_type_actually_const.cpp
│ │ │ │ │ ├── eigensolver_cplx.cpp
│ │ │ │ │ ├── eigensolver_int.cpp
│ │ │ │ │ ├── failtest_sanity_check.cpp
│ │ │ │ │ ├── fullpivlu_int.cpp
│ │ │ │ │ ├── fullpivqr_int.cpp
│ │ │ │ │ ├── initializer_list_1.cpp
│ │ │ │ │ ├── initializer_list_2.cpp
│ │ │ │ │ ├── jacobisvd_int.cpp
│ │ │ │ │ ├── ldlt_int.cpp
│ │ │ │ │ ├── llt_int.cpp
│ │ │ │ │ ├── map_nonconst_ctor_on_const_ptr_0.cpp
│ │ │ │ │ ├── map_nonconst_ctor_on_const_ptr_1.cpp
│ │ │ │ │ ├── map_nonconst_ctor_on_const_ptr_2.cpp
│ │ │ │ │ ├── map_nonconst_ctor_on_const_ptr_3.cpp
│ │ │ │ │ ├── map_nonconst_ctor_on_const_ptr_4.cpp
│ │ │ │ │ ├── map_on_const_type_actually_const_0.cpp
│ │ │ │ │ ├── map_on_const_type_actually_const_1.cpp
│ │ │ │ │ ├── partialpivlu_int.cpp
│ │ │ │ │ ├── qr_int.cpp
│ │ │ │ │ ├── ref_1.cpp
│ │ │ │ │ ├── ref_2.cpp
│ │ │ │ │ ├── ref_3.cpp
│ │ │ │ │ ├── ref_4.cpp
│ │ │ │ │ ├── ref_5.cpp
│ │ │ │ │ ├── selfadjointview_nonconst_ctor_on_const_xpr.cpp
│ │ │ │ │ ├── selfadjointview_on_const_type_actually_const.cpp
│ │ │ │ │ ├── sparse_ref_1.cpp
│ │ │ │ │ ├── sparse_ref_2.cpp
│ │ │ │ │ ├── sparse_ref_3.cpp
│ │ │ │ │ ├── sparse_ref_4.cpp
│ │ │ │ │ ├── sparse_ref_5.cpp
│ │ │ │ │ ├── sparse_storage_mismatch.cpp
│ │ │ │ │ ├── swap_1.cpp
│ │ │ │ │ ├── swap_2.cpp
│ │ │ │ │ ├── ternary_1.cpp
│ │ │ │ │ ├── ternary_2.cpp
│ │ │ │ │ ├── transpose_nonconst_ctor_on_const_xpr.cpp
│ │ │ │ │ ├── transpose_on_const_type_actually_const.cpp
│ │ │ │ │ ├── triangularview_nonconst_ctor_on_const_xpr.cpp
│ │ │ │ │ └── triangularview_on_const_type_actually_const.cpp
│ │ │ │ ├── lapack/
│ │ │ │ │ ├── CMakeLists.txt
│ │ │ │ │ ├── cholesky.cpp
│ │ │ │ │ ├── clacgv.f
│ │ │ │ │ ├── cladiv.f
│ │ │ │ │ ├── clarf.f
│ │ │ │ │ ├── clarfb.f
│ │ │ │ │ ├── clarfg.f
│ │ │ │ │ ├── clarft.f
│ │ │ │ │ ├── complex_double.cpp
│ │ │ │ │ ├── complex_single.cpp
│ │ │ │ │ ├── dladiv.f
│ │ │ │ │ ├── dlamch.f
│ │ │ │ │ ├── dlapy2.f
│ │ │ │ │ ├── dlapy3.f
│ │ │ │ │ ├── dlarf.f
│ │ │ │ │ ├── dlarfb.f
│ │ │ │ │ ├── dlarfg.f
│ │ │ │ │ ├── dlarft.f
│ │ │ │ │ ├── double.cpp
│ │ │ │ │ ├── dsecnd_NONE.f
│ │ │ │ │ ├── eigenvalues.cpp
│ │ │ │ │ ├── ilaclc.f
│ │ │ │ │ ├── ilaclr.f
│ │ │ │ │ ├── iladlc.f
│ │ │ │ │ ├── iladlr.f
│ │ │ │ │ ├── ilaslc.f
│ │ │ │ │ ├── ilaslr.f
│ │ │ │ │ ├── ilazlc.f
│ │ │ │ │ ├── ilazlr.f
│ │ │ │ │ ├── lapack_common.h
│ │ │ │ │ ├── lu.cpp
│ │ │ │ │ ├── second_NONE.f
│ │ │ │ │ ├── single.cpp
│ │ │ │ │ ├── sladiv.f
│ │ │ │ │ ├── slamch.f
│ │ │ │ │ ├── slapy2.f
│ │ │ │ │ ├── slapy3.f
│ │ │ │ │ ├── slarf.f
│ │ │ │ │ ├── slarfb.f
│ │ │ │ │ ├── slarfg.f
│ │ │ │ │ ├── slarft.f
│ │ │ │ │ ├── svd.cpp
│ │ │ │ │ ├── zlacgv.f
│ │ │ │ │ ├── zladiv.f
│ │ │ │ │ ├── zlarf.f
│ │ │ │ │ ├── zlarfb.f
│ │ │ │ │ ├── zlarfg.f
│ │ │ │ │ └── zlarft.f
│ │ │ │ ├── scripts/
│ │ │ │ │ ├── CMakeLists.txt
│ │ │ │ │ ├── cdashtesting.cmake.in
│ │ │ │ │ ├── check.in
│ │ │ │ │ ├── debug.in
│ │ │ │ │ ├── eigen_gen_credits.cpp
│ │ │ │ │ ├── eigen_gen_docs
│ │ │ │ │ ├── eigen_gen_split_test_help.cmake
│ │ │ │ │ ├── eigen_monitor_perf.sh
│ │ │ │ │ ├── release.in
│ │ │ │ │ └── relicense.py
│ │ │ │ ├── signature_of_eigen3_matrix_library
│ │ │ │ ├── test/
│ │ │ │ │ ├── AnnoyingScalar.h
│ │ │ │ │ ├── CMakeLists.txt
│ │ │ │ │ ├── MovableScalar.h
│ │ │ │ │ ├── adjoint.cpp
│ │ │ │ │ ├── array_cwise.cpp
│ │ │ │ │ ├── array_for_matrix.cpp
│ │ │ │ │ ├── array_of_string.cpp
│ │ │ │ │ ├── array_replicate.cpp
│ │ │ │ │ ├── array_reverse.cpp
│ │ │ │ │ ├── bandmatrix.cpp
│ │ │ │ │ ├── basicstuff.cpp
│ │ │ │ │ ├── bdcsvd.cpp
│ │ │ │ │ ├── bfloat16_float.cpp
│ │ │ │ │ ├── bicgstab.cpp
│ │ │ │ │ ├── blasutil.cpp
│ │ │ │ │ ├── block.cpp
│ │ │ │ │ ├── boostmultiprec.cpp
│ │ │ │ │ ├── bug1213.cpp
│ │ │ │ │ ├── bug1213.h
│ │ │ │ │ ├── bug1213_main.cpp
│ │ │ │ │ ├── cholesky.cpp
│ │ │ │ │ ├── cholmod_support.cpp
│ │ │ │ │ ├── commainitializer.cpp
│ │ │ │ │ ├── conjugate_gradient.cpp
│ │ │ │ │ ├── conservative_resize.cpp
│ │ │ │ │ ├── constructor.cpp
│ │ │ │ │ ├── corners.cpp
│ │ │ │ │ ├── ctorleak.cpp
│ │ │ │ │ ├── denseLM.cpp
│ │ │ │ │ ├── dense_storage.cpp
│ │ │ │ │ ├── determinant.cpp
│ │ │ │ │ ├── diagonal.cpp
│ │ │ │ │ ├── diagonal_matrix_variadic_ctor.cpp
│ │ │ │ │ ├── diagonalmatrices.cpp
│ │ │ │ │ ├── dontalign.cpp
│ │ │ │ │ ├── dynalloc.cpp
│ │ │ │ │ ├── eigen2support.cpp
│ │ │ │ │ ├── eigensolver_complex.cpp
│ │ │ │ │ ├── eigensolver_generalized_real.cpp
│ │ │ │ │ ├── eigensolver_generic.cpp
│ │ │ │ │ ├── eigensolver_selfadjoint.cpp
│ │ │ │ │ ├── evaluator_common.h
│ │ │ │ │ ├── evaluators.cpp
│ │ │ │ │ ├── exceptions.cpp
│ │ │ │ │ ├── fastmath.cpp
│ │ │ │ │ ├── first_aligned.cpp
│ │ │ │ │ ├── geo_alignedbox.cpp
│ │ │ │ │ ├── geo_eulerangles.cpp
│ │ │ │ │ ├── geo_homogeneous.cpp
│ │ │ │ │ ├── geo_hyperplane.cpp
│ │ │ │ │ ├── geo_orthomethods.cpp
│ │ │ │ │ ├── geo_parametrizedline.cpp
│ │ │ │ │ ├── geo_quaternion.cpp
│ │ │ │ │ ├── geo_transformations.cpp
│ │ │ │ │ ├── gpu_basic.cu
│ │ │ │ │ ├── gpu_common.h
│ │ │ │ │ ├── half_float.cpp
│ │ │ │ │ ├── hessenberg.cpp
│ │ │ │ │ ├── householder.cpp
│ │ │ │ │ ├── incomplete_cholesky.cpp
│ │ │ │ │ ├── indexed_view.cpp
│ │ │ │ │ ├── initializer_list_construction.cpp
│ │ │ │ │ ├── inplace_decomposition.cpp
│ │ │ │ │ ├── integer_types.cpp
│ │ │ │ │ ├── inverse.cpp
│ │ │ │ │ ├── io.cpp
│ │ │ │ │ ├── is_same_dense.cpp
│ │ │ │ │ ├── jacobi.cpp
│ │ │ │ │ ├── jacobisvd.cpp
│ │ │ │ │ ├── klu_support.cpp
│ │ │ │ │ ├── linearstructure.cpp
│ │ │ │ │ ├── lscg.cpp
│ │ │ │ │ ├── lu.cpp
│ │ │ │ │ ├── main.h
│ │ │ │ │ ├── mapped_matrix.cpp
│ │ │ │ │ ├── mapstaticmethods.cpp
│ │ │ │ │ ├── mapstride.cpp
│ │ │ │ │ ├── meta.cpp
│ │ │ │ │ ├── metis_support.cpp
│ │ │ │ │ ├── miscmatrices.cpp
│ │ │ │ │ ├── mixingtypes.cpp
│ │ │ │ │ ├── mpl2only.cpp
│ │ │ │ │ ├── nestbyvalue.cpp
│ │ │ │ │ ├── nesting_ops.cpp
│ │ │ │ │ ├── nomalloc.cpp
│ │ │ │ │ ├── nullary.cpp
│ │ │ │ │ ├── num_dimensions.cpp
│ │ │ │ │ ├── numext.cpp
│ │ │ │ │ ├── packetmath.cpp
│ │ │ │ │ ├── packetmath_test_shared.h
│ │ │ │ │ ├── pardiso_support.cpp
│ │ │ │ │ ├── pastix_support.cpp
│ │ │ │ │ ├── permutationmatrices.cpp
│ │ │ │ │ ├── prec_inverse_4x4.cpp
│ │ │ │ │ ├── product.h
│ │ │ │ │ ├── product_extra.cpp
│ │ │ │ │ ├── product_large.cpp
│ │ │ │ │ ├── product_mmtr.cpp
│ │ │ │ │ ├── product_notemporary.cpp
│ │ │ │ │ ├── product_selfadjoint.cpp
│ │ │ │ │ ├── product_small.cpp
│ │ │ │ │ ├── product_symm.cpp
│ │ │ │ │ ├── product_syrk.cpp
│ │ │ │ │ ├── product_trmm.cpp
│ │ │ │ │ ├── product_trmv.cpp
│ │ │ │ │ ├── product_trsolve.cpp
│ │ │ │ │ ├── qr.cpp
│ │ │ │ │ ├── qr_colpivoting.cpp
│ │ │ │ │ ├── qr_fullpivoting.cpp
│ │ │ │ │ ├── qtvector.cpp
│ │ │ │ │ ├── rand.cpp
│ │ │ │ │ ├── random_without_cast_overflow.h
│ │ │ │ │ ├── real_qz.cpp
│ │ │ │ │ ├── redux.cpp
│ │ │ │ │ ├── ref.cpp
│ │ │ │ │ ├── reshape.cpp
│ │ │ │ │ ├── resize.cpp
│ │ │ │ │ ├── rvalue_types.cpp
│ │ │ │ │ ├── schur_complex.cpp
│ │ │ │ │ ├── schur_real.cpp
│ │ │ │ │ ├── selfadjoint.cpp
│ │ │ │ │ ├── simplicial_cholesky.cpp
│ │ │ │ │ ├── sizeof.cpp
│ │ │ │ │ ├── sizeoverflow.cpp
│ │ │ │ │ ├── smallvectors.cpp
│ │ │ │ │ ├── solverbase.h
│ │ │ │ │ ├── sparse.h
│ │ │ │ │ ├── sparseLM.cpp
│ │ │ │ │ ├── sparse_basic.cpp
│ │ │ │ │ ├── sparse_block.cpp
│ │ │ │ │ ├── sparse_permutations.cpp
│ │ │ │ │ ├── sparse_product.cpp
│ │ │ │ │ ├── sparse_ref.cpp
│ │ │ │ │ ├── sparse_solver.h
│ │ │ │ │ ├── sparse_solvers.cpp
│ │ │ │ │ ├── sparse_vector.cpp
│ │ │ │ │ ├── sparselu.cpp
│ │ │ │ │ ├── sparseqr.cpp
│ │ │ │ │ ├── special_numbers.cpp
│ │ │ │ │ ├── split_test_helper.h
│ │ │ │ │ ├── spqr_support.cpp
│ │ │ │ │ ├── stable_norm.cpp
│ │ │ │ │ ├── stddeque.cpp
│ │ │ │ │ ├── stddeque_overload.cpp
│ │ │ │ │ ├── stdlist.cpp
│ │ │ │ │ ├── stdlist_overload.cpp
│ │ │ │ │ ├── stdvector.cpp
│ │ │ │ │ ├── stdvector_overload.cpp
│ │ │ │ │ ├── stl_iterators.cpp
│ │ │ │ │ ├── superlu_support.cpp
│ │ │ │ │ ├── svd_common.h
│ │ │ │ │ ├── svd_fill.h
│ │ │ │ │ ├── swap.cpp
│ │ │ │ │ ├── symbolic_index.cpp
│ │ │ │ │ ├── triangular.cpp
│ │ │ │ │ ├── type_alias.cpp
│ │ │ │ │ ├── umeyama.cpp
│ │ │ │ │ ├── umfpack_support.cpp
│ │ │ │ │ ├── unalignedassert.cpp
│ │ │ │ │ ├── unalignedcount.cpp
│ │ │ │ │ ├── upperbidiagonalization.cpp
│ │ │ │ │ ├── vectorization_logic.cpp
│ │ │ │ │ ├── vectorwiseop.cpp
│ │ │ │ │ ├── visitor.cpp
│ │ │ │ │ └── zerosized.cpp
│ │ │ │ └── unsupported/
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── Eigen/
│ │ │ │ │ ├── AdolcForward
│ │ │ │ │ ├── AlignedVector3
│ │ │ │ │ ├── ArpackSupport
│ │ │ │ │ ├── AutoDiff
│ │ │ │ │ ├── BVH
│ │ │ │ │ ├── CMakeLists.txt
│ │ │ │ │ ├── CXX11/
│ │ │ │ │ │ ├── CMakeLists.txt
│ │ │ │ │ │ ├── Tensor
│ │ │ │ │ │ ├── TensorSymmetry
│ │ │ │ │ │ ├── ThreadPool
│ │ │ │ │ │ └── src/
│ │ │ │ │ │ ├── Tensor/
│ │ │ │ │ │ │ ├── README.md
│ │ │ │ │ │ │ ├── Tensor.h
│ │ │ │ │ │ │ ├── TensorArgMax.h
│ │ │ │ │ │ │ ├── TensorAssign.h
│ │ │ │ │ │ │ ├── TensorBase.h
│ │ │ │ │ │ │ ├── TensorBlock.h
│ │ │ │ │ │ │ ├── TensorBroadcasting.h
│ │ │ │ │ │ │ ├── TensorChipping.h
│ │ │ │ │ │ │ ├── TensorConcatenation.h
│ │ │ │ │ │ │ ├── TensorContraction.h
│ │ │ │ │ │ │ ├── TensorContractionBlocking.h
│ │ │ │ │ │ │ ├── TensorContractionCuda.h
│ │ │ │ │ │ │ ├── TensorContractionGpu.h
│ │ │ │ │ │ │ ├── TensorContractionMapper.h
│ │ │ │ │ │ │ ├── TensorContractionSycl.h
│ │ │ │ │ │ │ ├── TensorContractionThreadPool.h
│ │ │ │ │ │ │ ├── TensorConversion.h
│ │ │ │ │ │ │ ├── TensorConvolution.h
│ │ │ │ │ │ │ ├── TensorConvolutionSycl.h
│ │ │ │ │ │ │ ├── TensorCostModel.h
│ │ │ │ │ │ │ ├── TensorCustomOp.h
│ │ │ │ │ │ │ ├── TensorDevice.h
│ │ │ │ │ │ │ ├── TensorDeviceCuda.h
│ │ │ │ │ │ │ ├── TensorDeviceDefault.h
│ │ │ │ │ │ │ ├── TensorDeviceGpu.h
│ │ │ │ │ │ │ ├── TensorDeviceSycl.h
│ │ │ │ │ │ │ ├── TensorDeviceThreadPool.h
│ │ │ │ │ │ │ ├── TensorDimensionList.h
│ │ │ │ │ │ │ ├── TensorDimensions.h
│ │ │ │ │ │ │ ├── TensorEvalTo.h
│ │ │ │ │ │ │ ├── TensorEvaluator.h
│ │ │ │ │ │ │ ├── TensorExecutor.h
│ │ │ │ │ │ │ ├── TensorExpr.h
│ │ │ │ │ │ │ ├── TensorFFT.h
│ │ │ │ │ │ │ ├── TensorFixedSize.h
│ │ │ │ │ │ │ ├── TensorForcedEval.h
│ │ │ │ │ │ │ ├── TensorForwardDeclarations.h
│ │ │ │ │ │ │ ├── TensorFunctors.h
│ │ │ │ │ │ │ ├── TensorGenerator.h
│ │ │ │ │ │ │ ├── TensorGlobalFunctions.h
│ │ │ │ │ │ │ ├── TensorGpuHipCudaDefines.h
│ │ │ │ │ │ │ ├── TensorGpuHipCudaUndefines.h
│ │ │ │ │ │ │ ├── TensorIO.h
│ │ │ │ │ │ │ ├── TensorImagePatch.h
│ │ │ │ │ │ │ ├── TensorIndexList.h
│ │ │ │ │ │ │ ├── TensorInflation.h
│ │ │ │ │ │ │ ├── TensorInitializer.h
│ │ │ │ │ │ │ ├── TensorIntDiv.h
│ │ │ │ │ │ │ ├── TensorLayoutSwap.h
│ │ │ │ │ │ │ ├── TensorMacros.h
│ │ │ │ │ │ │ ├── TensorMap.h
│ │ │ │ │ │ │ ├── TensorMeta.h
│ │ │ │ │ │ │ ├── TensorMorphing.h
│ │ │ │ │ │ │ ├── TensorPadding.h
│ │ │ │ │ │ │ ├── TensorPatch.h
│ │ │ │ │ │ │ ├── TensorRandom.h
│ │ │ │ │ │ │ ├── TensorReduction.h
│ │ │ │ │ │ │ ├── TensorReductionCuda.h
│ │ │ │ │ │ │ ├── TensorReductionGpu.h
│ │ │ │ │ │ │ ├── TensorReductionSycl.h
│ │ │ │ │ │ │ ├── TensorRef.h
│ │ │ │ │ │ │ ├── TensorReverse.h
│ │ │ │ │ │ │ ├── TensorScan.h
│ │ │ │ │ │ │ ├── TensorScanSycl.h
│ │ │ │ │ │ │ ├── TensorShuffling.h
│ │ │ │ │ │ │ ├── TensorStorage.h
│ │ │ │ │ │ │ ├── TensorStriding.h
│ │ │ │ │ │ │ ├── TensorTrace.h
│ │ │ │ │ │ │ ├── TensorTraits.h
│ │ │ │ │ │ │ ├── TensorUInt128.h
│ │ │ │ │ │ │ └── TensorVolumePatch.h
│ │ │ │ │ │ ├── TensorSymmetry/
│ │ │ │ │ │ │ ├── DynamicSymmetry.h
│ │ │ │ │ │ │ ├── StaticSymmetry.h
│ │ │ │ │ │ │ ├── Symmetry.h
│ │ │ │ │ │ │ └── util/
│ │ │ │ │ │ │ └── TemplateGroupTheory.h
│ │ │ │ │ │ ├── ThreadPool/
│ │ │ │ │ │ │ ├── Barrier.h
│ │ │ │ │ │ │ ├── EventCount.h
│ │ │ │ │ │ │ ├── NonBlockingThreadPool.h
│ │ │ │ │ │ │ ├── RunQueue.h
│ │ │ │ │ │ │ ├── ThreadCancel.h
│ │ │ │ │ │ │ ├── ThreadEnvironment.h
│ │ │ │ │ │ │ ├── ThreadLocal.h
│ │ │ │ │ │ │ ├── ThreadPoolInterface.h
│ │ │ │ │ │ │ └── ThreadYield.h
│ │ │ │ │ │ └── util/
│ │ │ │ │ │ ├── CXX11Meta.h
│ │ │ │ │ │ ├── CXX11Workarounds.h
│ │ │ │ │ │ ├── EmulateArray.h
│ │ │ │ │ │ └── MaxSizeVector.h
│ │ │ │ │ ├── EulerAngles
│ │ │ │ │ ├── FFT
│ │ │ │ │ ├── IterativeSolvers
│ │ │ │ │ ├── KroneckerProduct
│ │ │ │ │ ├── LevenbergMarquardt
│ │ │ │ │ ├── MPRealSupport
│ │ │ │ │ ├── MatrixFunctions
│ │ │ │ │ ├── MoreVectorization
│ │ │ │ │ ├── NonLinearOptimization
│ │ │ │ │ ├── NumericalDiff
│ │ │ │ │ ├── OpenGLSupport
│ │ │ │ │ ├── Polynomials
│ │ │ │ │ ├── Skyline
│ │ │ │ │ ├── SparseExtra
│ │ │ │ │ ├── SpecialFunctions
│ │ │ │ │ ├── Splines
│ │ │ │ │ └── src/
│ │ │ │ │ ├── AutoDiff/
│ │ │ │ │ │ ├── AutoDiffJacobian.h
│ │ │ │ │ │ ├── AutoDiffScalar.h
│ │ │ │ │ │ └── AutoDiffVector.h
│ │ │ │ │ ├── BVH/
│ │ │ │ │ │ ├── BVAlgorithms.h
│ │ │ │ │ │ └── KdBVH.h
│ │ │ │ │ ├── Eigenvalues/
│ │ │ │ │ │ └── ArpackSelfAdjointEigenSolver.h
│ │ │ │ │ ├── EulerAngles/
│ │ │ │ │ │ ├── CMakeLists.txt
│ │ │ │ │ │ ├── EulerAngles.h
│ │ │ │ │ │ └── EulerSystem.h
│ │ │ │ │ ├── FFT/
│ │ │ │ │ │ ├── ei_fftw_impl.h
│ │ │ │ │ │ └── ei_kissfft_impl.h
│ │ │ │ │ ├── IterativeSolvers/
│ │ │ │ │ │ ├── ConstrainedConjGrad.h
│ │ │ │ │ │ ├── DGMRES.h
│ │ │ │ │ │ ├── GMRES.h
│ │ │ │ │ │ ├── IDRS.h
│ │ │ │ │ │ ├── IncompleteLU.h
│ │ │ │ │ │ ├── IterationController.h
│ │ │ │ │ │ ├── MINRES.h
│ │ │ │ │ │ └── Scaling.h
│ │ │ │ │ ├── KroneckerProduct/
│ │ │ │ │ │ └── KroneckerTensorProduct.h
│ │ │ │ │ ├── LevenbergMarquardt/
│ │ │ │ │ │ ├── CopyrightMINPACK.txt
│ │ │ │ │ │ ├── LMcovar.h
│ │ │ │ │ │ ├── LMonestep.h
│ │ │ │ │ │ ├── LMpar.h
│ │ │ │ │ │ ├── LMqrsolv.h
│ │ │ │ │ │ └── LevenbergMarquardt.h
│ │ │ │ │ ├── MatrixFunctions/
│ │ │ │ │ │ ├── MatrixExponential.h
│ │ │ │ │ │ ├── MatrixFunction.h
│ │ │ │ │ │ ├── MatrixLogarithm.h
│ │ │ │ │ │ ├── MatrixPower.h
│ │ │ │ │ │ ├── MatrixSquareRoot.h
│ │ │ │ │ │ └── StemFunction.h
│ │ │ │ │ ├── MoreVectorization/
│ │ │ │ │ │ └── MathFunctions.h
│ │ │ │ │ ├── NonLinearOptimization/
│ │ │ │ │ │ ├── HybridNonLinearSolver.h
│ │ │ │ │ │ ├── LevenbergMarquardt.h
│ │ │ │ │ │ ├── chkder.h
│ │ │ │ │ │ ├── covar.h
│ │ │ │ │ │ ├── dogleg.h
│ │ │ │ │ │ ├── fdjac1.h
│ │ │ │ │ │ ├── lmpar.h
│ │ │ │ │ │ ├── qrsolv.h
│ │ │ │ │ │ ├── r1mpyq.h
│ │ │ │ │ │ ├── r1updt.h
│ │ │ │ │ │ └── rwupdt.h
│ │ │ │ │ ├── NumericalDiff/
│ │ │ │ │ │ └── NumericalDiff.h
│ │ │ │ │ ├── Polynomials/
│ │ │ │ │ │ ├── Companion.h
│ │ │ │ │ │ ├── PolynomialSolver.h
│ │ │ │ │ │ └── PolynomialUtils.h
│ │ │ │ │ ├── Skyline/
│ │ │ │ │ │ ├── SkylineInplaceLU.h
│ │ │ │ │ │ ├── SkylineMatrix.h
│ │ │ │ │ │ ├── SkylineMatrixBase.h
│ │ │ │ │ │ ├── SkylineProduct.h
│ │ │ │ │ │ ├── SkylineStorage.h
│ │ │ │ │ │ └── SkylineUtil.h
│ │ │ │ │ ├── SparseExtra/
│ │ │ │ │ │ ├── BlockOfDynamicSparseMatrix.h
│ │ │ │ │ │ ├── BlockSparseMatrix.h
│ │ │ │ │ │ ├── DynamicSparseMatrix.h
│ │ │ │ │ │ ├── MarketIO.h
│ │ │ │ │ │ ├── MatrixMarketIterator.h
│ │ │ │ │ │ └── RandomSetter.h
│ │ │ │ │ ├── SpecialFunctions/
│ │ │ │ │ │ ├── BesselFunctionsArrayAPI.h
│ │ │ │ │ │ ├── BesselFunctionsBFloat16.h
│ │ │ │ │ │ ├── BesselFunctionsFunctors.h
│ │ │ │ │ │ ├── BesselFunctionsHalf.h
│ │ │ │ │ │ ├── BesselFunctionsImpl.h
│ │ │ │ │ │ ├── BesselFunctionsPacketMath.h
│ │ │ │ │ │ ├── HipVectorCompatibility.h
│ │ │ │ │ │ ├── SpecialFunctionsArrayAPI.h
│ │ │ │ │ │ ├── SpecialFunctionsBFloat16.h
│ │ │ │ │ │ ├── SpecialFunctionsFunctors.h
│ │ │ │ │ │ ├── SpecialFunctionsHalf.h
│ │ │ │ │ │ ├── SpecialFunctionsImpl.h
│ │ │ │ │ │ ├── SpecialFunctionsPacketMath.h
│ │ │ │ │ │ └── arch/
│ │ │ │ │ │ ├── AVX/
│ │ │ │ │ │ │ ├── BesselFunctions.h
│ │ │ │ │ │ │ └── SpecialFunctions.h
│ │ │ │ │ │ ├── AVX512/
│ │ │ │ │ │ │ ├── BesselFunctions.h
│ │ │ │ │ │ │ └── SpecialFunctions.h
│ │ │ │ │ │ ├── GPU/
│ │ │ │ │ │ │ └── SpecialFunctions.h
│ │ │ │ │ │ └── NEON/
│ │ │ │ │ │ ├── BesselFunctions.h
│ │ │ │ │ │ └── SpecialFunctions.h
│ │ │ │ │ └── Splines/
│ │ │ │ │ ├── Spline.h
│ │ │ │ │ ├── SplineFitting.h
│ │ │ │ │ └── SplineFwd.h
│ │ │ │ ├── README.txt
│ │ │ │ ├── bench/
│ │ │ │ │ └── bench_svd.cpp
│ │ │ │ ├── doc/
│ │ │ │ │ ├── CMakeLists.txt
│ │ │ │ │ ├── Overview.dox
│ │ │ │ │ ├── SYCL.dox
│ │ │ │ │ ├── eigendoxy_layout.xml.in
│ │ │ │ │ ├── examples/
│ │ │ │ │ │ ├── BVH_Example.cpp
│ │ │ │ │ │ ├── CMakeLists.txt
│ │ │ │ │ │ ├── EulerAngles.cpp
│ │ │ │ │ │ ├── FFT.cpp
│ │ │ │ │ │ ├── MatrixExponential.cpp
│ │ │ │ │ │ ├── MatrixFunction.cpp
│ │ │ │ │ │ ├── MatrixLogarithm.cpp
│ │ │ │ │ │ ├── MatrixPower.cpp
│ │ │ │ │ │ ├── MatrixPower_optimal.cpp
│ │ │ │ │ │ ├── MatrixSine.cpp
│ │ │ │ │ │ ├── MatrixSinh.cpp
│ │ │ │ │ │ ├── MatrixSquareRoot.cpp
│ │ │ │ │ │ ├── PolynomialSolver1.cpp
│ │ │ │ │ │ ├── PolynomialUtils1.cpp
│ │ │ │ │ │ └── SYCL/
│ │ │ │ │ │ ├── CMakeLists.txt
│ │ │ │ │ │ └── CwiseMul.cpp
│ │ │ │ │ └── snippets/
│ │ │ │ │ └── CMakeLists.txt
│ │ │ │ └── test/
│ │ │ │ ├── BVH.cpp
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── EulerAngles.cpp
│ │ │ │ ├── FFT.cpp
│ │ │ │ ├── FFTW.cpp
│ │ │ │ ├── NonLinearOptimization.cpp
│ │ │ │ ├── NumericalDiff.cpp
│ │ │ │ ├── alignedvector3.cpp
│ │ │ │ ├── autodiff.cpp
│ │ │ │ ├── autodiff_scalar.cpp
│ │ │ │ ├── bessel_functions.cpp
│ │ │ │ ├── cxx11_eventcount.cpp
│ │ │ │ ├── cxx11_maxsizevector.cpp
│ │ │ │ ├── cxx11_meta.cpp
│ │ │ │ ├── cxx11_non_blocking_thread_pool.cpp
│ │ │ │ ├── cxx11_runqueue.cpp
│ │ │ │ ├── cxx11_tensor_argmax.cpp
│ │ │ │ ├── cxx11_tensor_argmax_gpu.cu
│ │ │ │ ├── cxx11_tensor_argmax_sycl.cpp
│ │ │ │ ├── cxx11_tensor_assign.cpp
│ │ │ │ ├── cxx11_tensor_block_access.cpp
│ │ │ │ ├── cxx11_tensor_block_eval.cpp
│ │ │ │ ├── cxx11_tensor_block_io.cpp
│ │ │ │ ├── cxx11_tensor_broadcast_sycl.cpp
│ │ │ │ ├── cxx11_tensor_broadcasting.cpp
│ │ │ │ ├── cxx11_tensor_builtins_sycl.cpp
│ │ │ │ ├── cxx11_tensor_cast_float16_gpu.cu
│ │ │ │ ├── cxx11_tensor_casts.cpp
│ │ │ │ ├── cxx11_tensor_chipping.cpp
│ │ │ │ ├── cxx11_tensor_chipping_sycl.cpp
│ │ │ │ ├── cxx11_tensor_comparisons.cpp
│ │ │ │ ├── cxx11_tensor_complex_cwise_ops_gpu.cu
│ │ │ │ ├── cxx11_tensor_complex_gpu.cu
│ │ │ │ ├── cxx11_tensor_concatenation.cpp
│ │ │ │ ├── cxx11_tensor_concatenation_sycl.cpp
│ │ │ │ ├── cxx11_tensor_const.cpp
│ │ │ │ ├── cxx11_tensor_contract_gpu.cu
│ │ │ │ ├── cxx11_tensor_contract_sycl.cpp
│ │ │ │ ├── cxx11_tensor_contraction.cpp
│ │ │ │ ├── cxx11_tensor_convolution.cpp
│ │ │ │ ├── cxx11_tensor_convolution_sycl.cpp
│ │ │ │ ├── cxx11_tensor_custom_index.cpp
│ │ │ │ ├── cxx11_tensor_custom_op.cpp
│ │ │ │ ├── cxx11_tensor_custom_op_sycl.cpp
│ │ │ │ ├── cxx11_tensor_device.cu
│ │ │ │ ├── cxx11_tensor_device_sycl.cpp
│ │ │ │ ├── cxx11_tensor_dimension.cpp
│ │ │ │ ├── cxx11_tensor_empty.cpp
│ │ │ │ ├── cxx11_tensor_executor.cpp
│ │ │ │ ├── cxx11_tensor_expr.cpp
│ │ │ │ ├── cxx11_tensor_fft.cpp
│ │ │ │ ├── cxx11_tensor_fixed_size.cpp
│ │ │ │ ├── cxx11_tensor_forced_eval.cpp
│ │ │ │ ├── cxx11_tensor_forced_eval_sycl.cpp
│ │ │ │ ├── cxx11_tensor_generator.cpp
│ │ │ │ ├── cxx11_tensor_generator_sycl.cpp
│ │ │ │ ├── cxx11_tensor_gpu.cu
│ │ │ │ ├── cxx11_tensor_ifft.cpp
│ │ │ │ ├── cxx11_tensor_image_op_sycl.cpp
│ │ │ │ ├── cxx11_tensor_image_patch.cpp
│ │ │ │ ├── cxx11_tensor_image_patch_sycl.cpp
│ │ │ │ ├── cxx11_tensor_index_list.cpp
│ │ │ │ ├── cxx11_tensor_inflation.cpp
│ │ │ │ ├── cxx11_tensor_inflation_sycl.cpp
│ │ │ │ ├── cxx11_tensor_intdiv.cpp
│ │ │ │ ├── cxx11_tensor_io.cpp
│ │ │ │ ├── cxx11_tensor_layout_swap.cpp
│ │ │ │ ├── cxx11_tensor_layout_swap_sycl.cpp
│ │ │ │ ├── cxx11_tensor_lvalue.cpp
│ │ │ │ ├── cxx11_tensor_map.cpp
│ │ │ │ ├── cxx11_tensor_math.cpp
│ │ │ │ ├── cxx11_tensor_math_sycl.cpp
│ │ │ │ ├── cxx11_tensor_mixed_indices.cpp
│ │ │ │ ├── cxx11_tensor_morphing.cpp
│ │ │ │ ├── cxx11_tensor_morphing_sycl.cpp
│ │ │ │ ├── cxx11_tensor_move.cpp
│ │ │ │ ├── cxx11_tensor_notification.cpp
│ │ │ │ ├── cxx11_tensor_of_complex.cpp
│ │ │ │ ├── cxx11_tensor_of_const_values.cpp
│ │ │ │ ├── cxx11_tensor_of_float16_gpu.cu
│ │ │ │ ├── cxx11_tensor_of_strings.cpp
│ │ │ │ ├── cxx11_tensor_padding.cpp
│ │ │ │ ├── cxx11_tensor_padding_sycl.cpp
│ │ │ │ ├── cxx11_tensor_patch.cpp
│ │ │ │ ├── cxx11_tensor_patch_sycl.cpp
│ │ │ │ ├── cxx11_tensor_random.cpp
│ │ │ │ ├── cxx11_tensor_random_gpu.cu
│ │ │ │ ├── cxx11_tensor_random_sycl.cpp
│ │ │ │ ├── cxx11_tensor_reduction.cpp
│ │ │ │ ├── cxx11_tensor_reduction_gpu.cu
│ │ │ │ ├── cxx11_tensor_reduction_sycl.cpp
│ │ │ │ ├── cxx11_tensor_ref.cpp
│ │ │ │ ├── cxx11_tensor_reverse.cpp
│ │ │ │ ├── cxx11_tensor_reverse_sycl.cpp
│ │ │ │ ├── cxx11_tensor_roundings.cpp
│ │ │ │ ├── cxx11_tensor_scan.cpp
│ │ │ │ ├── cxx11_tensor_scan_gpu.cu
│ │ │ │ ├── cxx11_tensor_scan_sycl.cpp
│ │ │ │ ├── cxx11_tensor_shuffling.cpp
│ │ │ │ ├── cxx11_tensor_shuffling_sycl.cpp
│ │ │ │ ├── cxx11_tensor_simple.cpp
│ │ │ │ ├── cxx11_tensor_striding.cpp
│ │ │ │ ├── cxx11_tensor_striding_sycl.cpp
│ │ │ │ ├── cxx11_tensor_sugar.cpp
│ │ │ │ ├── cxx11_tensor_sycl.cpp
│ │ │ │ ├── cxx11_tensor_symmetry.cpp
│ │ │ │ ├── cxx11_tensor_thread_local.cpp
│ │ │ │ ├── cxx11_tensor_thread_pool.cpp
│ │ │ │ ├── cxx11_tensor_trace.cpp
│ │ │ │ ├── cxx11_tensor_uint128.cpp
│ │ │ │ ├── cxx11_tensor_volume_patch.cpp
│ │ │ │ ├── cxx11_tensor_volume_patch_sycl.cpp
│ │ │ │ ├── dgmres.cpp
│ │ │ │ ├── forward_adolc.cpp
│ │ │ │ ├── gmres.cpp
│ │ │ │ ├── idrs.cpp
│ │ │ │ ├── kronecker_product.cpp
│ │ │ │ ├── levenberg_marquardt.cpp
│ │ │ │ ├── matrix_exponential.cpp
│ │ │ │ ├── matrix_function.cpp
│ │ │ │ ├── matrix_functions.h
│ │ │ │ ├── matrix_power.cpp
│ │ │ │ ├── matrix_square_root.cpp
│ │ │ │ ├── minres.cpp
│ │ │ │ ├── mpreal/
│ │ │ │ │ └── mpreal.h
│ │ │ │ ├── mpreal_support.cpp
│ │ │ │ ├── openglsupport.cpp
│ │ │ │ ├── polynomialsolver.cpp
│ │ │ │ ├── polynomialutils.cpp
│ │ │ │ ├── sparse_extra.cpp
│ │ │ │ ├── special_functions.cpp
│ │ │ │ ├── special_packetmath.cpp
│ │ │ │ └── splines.cpp
│ │ │ ├── examples/
│ │ │ │ ├── __init__.py
│ │ │ │ ├── core/
│ │ │ │ │ ├── data_readers/
│ │ │ │ │ │ ├── __init__.py
│ │ │ │ │ │ ├── augmentation.py
│ │ │ │ │ │ ├── base.py
│ │ │ │ │ │ ├── eth3d.py
│ │ │ │ │ │ ├── factory.py
│ │ │ │ │ │ ├── nyu2.py
│ │ │ │ │ │ ├── rgbd_utils.py
│ │ │ │ │ │ ├── scannet.py
│ │ │ │ │ │ ├── stream.py
│ │ │ │ │ │ ├── tartan.py
│ │ │ │ │ │ └── tum.py
│ │ │ │ │ ├── geom/
│ │ │ │ │ │ ├── __init__.py
│ │ │ │ │ │ ├── ba.py
│ │ │ │ │ │ ├── chol.py
│ │ │ │ │ │ ├── graph_utils.py
│ │ │ │ │ │ ├── losses.py
│ │ │ │ │ │ ├── projective_ops.py
│ │ │ │ │ │ └── sampler_utils.py
│ │ │ │ │ ├── logger.py
│ │ │ │ │ └── networks/
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ ├── modules/
│ │ │ │ │ │ ├── __init__.py
│ │ │ │ │ │ ├── clipping.py
│ │ │ │ │ │ ├── corr.py
│ │ │ │ │ │ ├── extractor.py
│ │ │ │ │ │ ├── gru.py
│ │ │ │ │ │ └── unet.py
│ │ │ │ │ ├── rslam.py
│ │ │ │ │ ├── sim3_net.py
│ │ │ │ │ └── slam_system.py
│ │ │ │ ├── pgo/
│ │ │ │ │ ├── main.py
│ │ │ │ │ └── readme.md
│ │ │ │ ├── readme.md
│ │ │ │ ├── registration/
│ │ │ │ │ ├── assets/
│ │ │ │ │ │ ├── depth1.npy
│ │ │ │ │ │ ├── depth2.npy
│ │ │ │ │ │ ├── depth3.npy
│ │ │ │ │ │ ├── depth4.npy
│ │ │ │ │ │ ├── renderoption.json
│ │ │ │ │ │ └── tartan_test.txt
│ │ │ │ │ ├── demo.py
│ │ │ │ │ ├── main.py
│ │ │ │ │ ├── readme.md
│ │ │ │ │ └── viz.py
│ │ │ │ └── rgbdslam/
│ │ │ │ ├── assets/
│ │ │ │ │ └── renderoption.json
│ │ │ │ ├── demo.py
│ │ │ │ ├── evaluate.py
│ │ │ │ ├── readme.md
│ │ │ │ ├── reprojection_test.py
│ │ │ │ ├── rgbd_benchmark/
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ ├── associate.py
│ │ │ │ │ ├── evaluate_ate.py
│ │ │ │ │ └── evaluate_rpe.py
│ │ │ │ ├── train.py
│ │ │ │ └── viz.py
│ │ │ ├── lietorch/
│ │ │ │ ├── __init__.py
│ │ │ │ ├── broadcasting.py
│ │ │ │ ├── extras/
│ │ │ │ │ ├── altcorr_kernel.cu
│ │ │ │ │ ├── corr_index_kernel.cu
│ │ │ │ │ ├── extras.cpp
│ │ │ │ │ ├── se3_builder.cu
│ │ │ │ │ ├── se3_inplace_builder.cu
│ │ │ │ │ └── se3_solver.cu
│ │ │ │ ├── gradcheck.py
│ │ │ │ ├── group_ops.py
│ │ │ │ ├── groups.py
│ │ │ │ ├── include/
│ │ │ │ │ ├── common.h
│ │ │ │ │ ├── dispatch.h
│ │ │ │ │ ├── lietorch_cpu.h
│ │ │ │ │ ├── lietorch_gpu.h
│ │ │ │ │ ├── rxso3.h
│ │ │ │ │ ├── se3.h
│ │ │ │ │ ├── sim3.h
│ │ │ │ │ └── so3.h
│ │ │ │ ├── run_tests.py
│ │ │ │ └── src/
│ │ │ │ ├── lietorch.cpp
│ │ │ │ ├── lietorch_cpu.cpp
│ │ │ │ └── lietorch_gpu.cu
│ │ │ ├── run_tests.sh
│ │ │ └── setup.py
│ │ └── tartanair_tools/
│ │ ├── LICENSE
│ │ ├── README.md
│ │ ├── TartanAir_Sample.ipynb
│ │ ├── data_type.md
│ │ ├── download_cvpr_slam_test.txt
│ │ ├── download_training.py
│ │ ├── download_training_zipfiles.txt
│ │ ├── evaluation/
│ │ │ ├── __init__.py
│ │ │ ├── evaluate_ate_scale.py
│ │ │ ├── evaluate_kitti.py
│ │ │ ├── evaluate_rpe.py
│ │ │ ├── evaluator_base.py
│ │ │ ├── pose_est.txt
│ │ │ ├── pose_gt.txt
│ │ │ ├── tartanair_evaluator.py
│ │ │ ├── trajectory_transform.py
│ │ │ └── transformation.py
│ │ └── seg_rgbs.txt
│ ├── tools/
│ │ ├── generate_demo.py
│ │ ├── vis.py
│ │ ├── vis_2.py
│ │ └── vis_ori.py
│ └── train.py
├── VPS_Module/
│ ├── .circleci/
│ │ └── config.yml
│ ├── .clang-format
│ ├── .flake8
│ ├── README.md
│ ├── configs/
│ │ ├── Base-RCNN-C4.yaml
│ │ ├── Base-RCNN-DilatedC5.yaml
│ │ ├── Base-RCNN-FPN.yaml
│ │ ├── Base-RetinaNet.yaml
│ │ ├── COCO-Detection/
│ │ │ ├── fast_rcnn_R_50_FPN_1x.yaml
│ │ │ ├── faster_rcnn_R_101_C4_3x.yaml
│ │ │ ├── faster_rcnn_R_101_DC5_3x.yaml
│ │ │ ├── faster_rcnn_R_101_FPN_3x.yaml
│ │ │ ├── faster_rcnn_R_50_C4_1x.yaml
│ │ │ ├── faster_rcnn_R_50_C4_3x.yaml
│ │ │ ├── faster_rcnn_R_50_DC5_1x.yaml
│ │ │ ├── faster_rcnn_R_50_DC5_3x.yaml
│ │ │ ├── faster_rcnn_R_50_FPN_1x.yaml
│ │ │ ├── faster_rcnn_R_50_FPN_3x.yaml
│ │ │ ├── faster_rcnn_X_101_32x8d_FPN_3x.yaml
│ │ │ ├── fcos_R_50_FPN_1x.py
│ │ │ ├── retinanet_R_101_FPN_3x.yaml
│ │ │ ├── retinanet_R_50_FPN_1x.py
│ │ │ ├── retinanet_R_50_FPN_1x.yaml
│ │ │ ├── retinanet_R_50_FPN_3x.yaml
│ │ │ ├── rpn_R_50_C4_1x.yaml
│ │ │ └── rpn_R_50_FPN_1x.yaml
│ │ ├── COCO-InstanceSegmentation/
│ │ │ ├── mask_rcnn_R_101_C4_3x.yaml
│ │ │ ├── mask_rcnn_R_101_DC5_3x.yaml
│ │ │ ├── mask_rcnn_R_101_FPN_3x.yaml
│ │ │ ├── mask_rcnn_R_50_C4_1x.py
│ │ │ ├── mask_rcnn_R_50_C4_1x.yaml
│ │ │ ├── mask_rcnn_R_50_C4_3x.yaml
│ │ │ ├── mask_rcnn_R_50_DC5_1x.yaml
│ │ │ ├── mask_rcnn_R_50_DC5_3x.yaml
│ │ │ ├── mask_rcnn_R_50_FPN_1x.py
│ │ │ ├── mask_rcnn_R_50_FPN_1x.yaml
│ │ │ ├── mask_rcnn_R_50_FPN_1x_giou.yaml
│ │ │ ├── mask_rcnn_R_50_FPN_3x.yaml
│ │ │ ├── mask_rcnn_X_101_32x8d_FPN_3x.yaml
│ │ │ ├── mask_rcnn_regnetx_4gf_dds_fpn_1x.py
│ │ │ └── mask_rcnn_regnety_4gf_dds_fpn_1x.py
│ │ ├── COCO-Keypoints/
│ │ │ ├── Base-Keypoint-RCNN-FPN.yaml
│ │ │ ├── keypoint_rcnn_R_101_FPN_3x.yaml
│ │ │ ├── keypoint_rcnn_R_50_FPN_1x.py
│ │ │ ├── keypoint_rcnn_R_50_FPN_1x.yaml
│ │ │ ├── keypoint_rcnn_R_50_FPN_3x.yaml
│ │ │ └── keypoint_rcnn_X_101_32x8d_FPN_3x.yaml
│ │ ├── COCO-PanopticSegmentation/
│ │ │ ├── Base-Panoptic-FPN.yaml
│ │ │ ├── panoptic_fpn_R_101_3x.yaml
│ │ │ ├── panoptic_fpn_R_50_1x.py
│ │ │ ├── panoptic_fpn_R_50_1x.yaml
│ │ │ ├── panoptic_fpn_R_50_3x.yaml
│ │ │ ├── panoptic_fpn_R_50_3x_vkitti_511.yaml
│ │ │ ├── panoptic_fpn_R_50_3x_vkitti_init_clone.yaml
│ │ │ └── panoptic_fpn_R_50_3x_vkitti_init_test.yaml
│ │ ├── Cityscapes/
│ │ │ └── mask_rcnn_R_50_FPN.yaml
│ │ ├── Detectron1-Comparisons/
│ │ │ ├── README.md
│ │ │ ├── faster_rcnn_R_50_FPN_noaug_1x.yaml
│ │ │ ├── keypoint_rcnn_R_50_FPN_1x.yaml
│ │ │ └── mask_rcnn_R_50_FPN_noaug_1x.yaml
│ │ ├── LVISv0.5-InstanceSegmentation/
│ │ │ ├── mask_rcnn_R_101_FPN_1x.yaml
│ │ │ ├── mask_rcnn_R_50_FPN_1x.yaml
│ │ │ └── mask_rcnn_X_101_32x8d_FPN_1x.yaml
│ │ ├── LVISv1-InstanceSegmentation/
│ │ │ ├── mask_rcnn_R_101_FPN_1x.yaml
│ │ │ ├── mask_rcnn_R_50_FPN_1x.yaml
│ │ │ └── mask_rcnn_X_101_32x8d_FPN_1x.yaml
│ │ ├── Misc/
│ │ │ ├── cascade_mask_rcnn_R_50_FPN_1x.yaml
│ │ │ ├── cascade_mask_rcnn_R_50_FPN_3x.yaml
│ │ │ ├── cascade_mask_rcnn_X_152_32x8d_FPN_IN5k_gn_dconv.yaml
│ │ │ ├── mask_rcnn_R_50_FPN_1x_cls_agnostic.yaml
│ │ │ ├── mask_rcnn_R_50_FPN_1x_dconv_c3-c5.yaml
│ │ │ ├── mask_rcnn_R_50_FPN_3x_dconv_c3-c5.yaml
│ │ │ ├── mask_rcnn_R_50_FPN_3x_gn.yaml
│ │ │ ├── mask_rcnn_R_50_FPN_3x_syncbn.yaml
│ │ │ ├── mmdet_mask_rcnn_R_50_FPN_1x.py
│ │ │ ├── panoptic_fpn_R_101_dconv_cascade_gn_3x.yaml
│ │ │ ├── scratch_mask_rcnn_R_50_FPN_3x_gn.yaml
│ │ │ ├── scratch_mask_rcnn_R_50_FPN_9x_gn.yaml
│ │ │ ├── scratch_mask_rcnn_R_50_FPN_9x_syncbn.yaml
│ │ │ ├── semantic_R_50_FPN_1x.yaml
│ │ │ └── torchvision_imagenet_R_50.py
│ │ ├── PascalVOC-Detection/
│ │ │ ├── faster_rcnn_R_50_C4.yaml
│ │ │ └── faster_rcnn_R_50_FPN.yaml
│ │ ├── common/
│ │ │ ├── README.md
│ │ │ ├── coco_schedule.py
│ │ │ ├── models/
│ │ │ │ ├── cascade_rcnn.py
│ │ │ │ ├── fcos.py
│ │ │ │ ├── keypoint_rcnn_fpn.py
│ │ │ │ ├── mask_rcnn_c4.py
│ │ │ │ ├── mask_rcnn_fpn.py
│ │ │ │ ├── panoptic_fpn.py
│ │ │ │ └── retinanet.py
│ │ │ ├── optim.py
│ │ │ └── train.py
│ │ ├── new_baselines/
│ │ │ ├── mask_rcnn_R_101_FPN_100ep_LSJ.py
│ │ │ ├── mask_rcnn_R_101_FPN_200ep_LSJ.py
│ │ │ ├── mask_rcnn_R_101_FPN_400ep_LSJ.py
│ │ │ ├── mask_rcnn_R_50_FPN_100ep_LSJ.py
│ │ │ ├── mask_rcnn_R_50_FPN_200ep_LSJ.py
│ │ │ ├── mask_rcnn_R_50_FPN_400ep_LSJ.py
│ │ │ ├── mask_rcnn_R_50_FPN_50ep_LSJ.py
│ │ │ ├── mask_rcnn_regnetx_4gf_dds_FPN_100ep_LSJ.py
│ │ │ ├── mask_rcnn_regnetx_4gf_dds_FPN_200ep_LSJ.py
│ │ │ ├── mask_rcnn_regnetx_4gf_dds_FPN_400ep_LSJ.py
│ │ │ ├── mask_rcnn_regnety_4gf_dds_FPN_100ep_LSJ.py
│ │ │ ├── mask_rcnn_regnety_4gf_dds_FPN_200ep_LSJ.py
│ │ │ └── mask_rcnn_regnety_4gf_dds_FPN_400ep_LSJ.py
│ │ └── quick_schedules/
│ │ ├── README.md
│ │ ├── cascade_mask_rcnn_R_50_FPN_inference_acc_test.yaml
│ │ ├── cascade_mask_rcnn_R_50_FPN_instant_test.yaml
│ │ ├── fast_rcnn_R_50_FPN_inference_acc_test.yaml
│ │ ├── fast_rcnn_R_50_FPN_instant_test.yaml
│ │ ├── keypoint_rcnn_R_50_FPN_inference_acc_test.yaml
│ │ ├── keypoint_rcnn_R_50_FPN_instant_test.yaml
│ │ ├── keypoint_rcnn_R_50_FPN_normalized_training_acc_test.yaml
│ │ ├── keypoint_rcnn_R_50_FPN_training_acc_test.yaml
│ │ ├── mask_rcnn_R_50_C4_GCV_instant_test.yaml
│ │ ├── mask_rcnn_R_50_C4_inference_acc_test.yaml
│ │ ├── mask_rcnn_R_50_C4_instant_test.yaml
│ │ ├── mask_rcnn_R_50_C4_training_acc_test.yaml
│ │ ├── mask_rcnn_R_50_DC5_inference_acc_test.yaml
│ │ ├── mask_rcnn_R_50_FPN_inference_acc_test.yaml
│ │ ├── mask_rcnn_R_50_FPN_instant_test.yaml
│ │ ├── mask_rcnn_R_50_FPN_pred_boxes_training_acc_test.yaml
│ │ ├── mask_rcnn_R_50_FPN_training_acc_test.yaml
│ │ ├── panoptic_fpn_R_50_inference_acc_test.yaml
│ │ ├── panoptic_fpn_R_50_instant_test.yaml
│ │ ├── panoptic_fpn_R_50_training_acc_test.yaml
│ │ ├── retinanet_R_50_FPN_inference_acc_test.yaml
│ │ ├── retinanet_R_50_FPN_instant_test.yaml
│ │ ├── rpn_R_50_FPN_inference_acc_test.yaml
│ │ ├── rpn_R_50_FPN_instant_test.yaml
│ │ ├── semantic_R_50_FPN_inference_acc_test.yaml
│ │ ├── semantic_R_50_FPN_instant_test.yaml
│ │ └── semantic_R_50_FPN_training_acc_test.yaml
│ ├── demo/
│ │ ├── README.md
│ │ ├── demo.py
│ │ └── predictor.py
│ ├── detectron2/
│ │ ├── __init__.py
│ │ ├── aot_modules/
│ │ │ ├── __init__.py
│ │ │ ├── aot_config.py
│ │ │ ├── decoders/
│ │ │ │ ├── __init__.py
│ │ │ │ └── fpn.py
│ │ │ ├── encoders/
│ │ │ │ ├── __init__.py
│ │ │ │ ├── mobilenetv2.py
│ │ │ │ ├── mobilenetv3.py
│ │ │ │ ├── resnest/
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ ├── resnest.py
│ │ │ │ │ ├── resnet.py
│ │ │ │ │ └── splat.py
│ │ │ │ ├── resnet.py
│ │ │ │ └── swin/
│ │ │ │ ├── __init__.py
│ │ │ │ ├── build.py
│ │ │ │ └── swin_transformer.py
│ │ │ ├── engines/
│ │ │ │ ├── __init__.py
│ │ │ │ └── aot_engine.py
│ │ │ ├── layers/
│ │ │ │ ├── __init__.py
│ │ │ │ ├── attention.py
│ │ │ │ ├── basic.py
│ │ │ │ ├── loss.py
│ │ │ │ ├── normalization.py
│ │ │ │ ├── position.py
│ │ │ │ └── transformer.py
│ │ │ ├── models/
│ │ │ │ ├── __init__.py
│ │ │ │ └── aot.py
│ │ │ └── utils/
│ │ │ ├── __init__.py
│ │ │ ├── checkpoint.py
│ │ │ ├── ema.py
│ │ │ ├── eval.py
│ │ │ ├── image.py
│ │ │ ├── learning.py
│ │ │ ├── math.py
│ │ │ ├── meters.py
│ │ │ └── metric.py
│ │ ├── checkpoint/
│ │ │ ├── __init__.py
│ │ │ ├── c2_model_loading.py
│ │ │ ├── catalog.py
│ │ │ └── detection_checkpoint.py
│ │ ├── config/
│ │ │ ├── __init__.py
│ │ │ ├── compat.py
│ │ │ ├── config.py
│ │ │ ├── defaults.py
│ │ │ ├── instantiate.py
│ │ │ └── lazy.py
│ │ ├── engine/
│ │ │ ├── __init__.py
│ │ │ ├── defaults.py
│ │ │ ├── hooks.py
│ │ │ ├── launch.py
│ │ │ └── train_loop.py
│ │ ├── evaluation/
│ │ │ ├── __init__.py
│ │ │ ├── cityscapes_evaluation.py
│ │ │ ├── coco_evaluation.py
│ │ │ ├── evaluator.py
│ │ │ ├── fast_eval_api.py
│ │ │ ├── lvis_evaluation.py
│ │ │ ├── panoptic_evaluation.py
│ │ │ ├── pascal_voc_evaluation.py
│ │ │ ├── pq_compute.py
│ │ │ ├── rotated_coco_evaluation.py
│ │ │ ├── sem_seg_evaluation.py
│ │ │ └── testing.py
│ │ ├── export/
│ │ │ ├── README.md
│ │ │ ├── __init__.py
│ │ │ ├── api.py
│ │ │ ├── c10.py
│ │ │ ├── caffe2_export.py
│ │ │ ├── caffe2_inference.py
│ │ │ ├── caffe2_modeling.py
│ │ │ ├── caffe2_patch.py
│ │ │ ├── flatten.py
│ │ │ ├── shared.py
│ │ │ ├── torchscript.py
│ │ │ └── torchscript_patch.py
│ │ ├── layers/
│ │ │ ├── __init__.py
│ │ │ ├── aspp.py
│ │ │ ├── batch_norm.py
│ │ │ ├── blocks.py
│ │ │ ├── csrc/
│ │ │ │ ├── README.md
│ │ │ │ ├── ROIAlignRotated/
│ │ │ │ │ ├── ROIAlignRotated.h
│ │ │ │ │ ├── ROIAlignRotated_cpu.cpp
│ │ │ │ │ └── ROIAlignRotated_cuda.cu
│ │ │ │ ├── box_iou_rotated/
│ │ │ │ │ ├── box_iou_rotated.h
│ │ │ │ │ ├── box_iou_rotated_cpu.cpp
│ │ │ │ │ ├── box_iou_rotated_cuda.cu
│ │ │ │ │ └── box_iou_rotated_utils.h
│ │ │ │ ├── cocoeval/
│ │ │ │ │ ├── cocoeval.cpp
│ │ │ │ │ └── cocoeval.h
│ │ │ │ ├── cuda_version.cu
│ │ │ │ ├── deformable/
│ │ │ │ │ ├── deform_conv.h
│ │ │ │ │ ├── deform_conv_cuda.cu
│ │ │ │ │ └── deform_conv_cuda_kernel.cu
│ │ │ │ ├── nms_rotated/
│ │ │ │ │ ├── nms_rotated.h
│ │ │ │ │ ├── nms_rotated_cpu.cpp
│ │ │ │ │ └── nms_rotated_cuda.cu
│ │ │ │ └── vision.cpp
│ │ │ ├── deform_conv.py
│ │ │ ├── losses.py
│ │ │ ├── mask_ops.py
│ │ │ ├── nms.py
│ │ │ ├── roi_align.py
│ │ │ ├── roi_align_rotated.py
│ │ │ ├── rotated_boxes.py
│ │ │ ├── shape_spec.py
│ │ │ └── wrappers.py
│ │ ├── model_zoo/
│ │ │ ├── __init__.py
│ │ │ ├── configs
│ │ │ └── model_zoo.py
│ │ ├── modeling/
│ │ │ ├── __init__.py
│ │ │ ├── anchor_generator.py
│ │ │ ├── backbone/
│ │ │ │ ├── __init__.py
│ │ │ │ ├── backbone.py
│ │ │ │ ├── build.py
│ │ │ │ ├── fpn.py
│ │ │ │ ├── regnet.py
│ │ │ │ └── resnet.py
│ │ │ ├── box_regression.py
│ │ │ ├── matcher.py
│ │ │ ├── meta_arch/
│ │ │ │ ├── __init__.py
│ │ │ │ ├── build.py
│ │ │ │ ├── dense_detector.py
│ │ │ │ ├── fcos.py
│ │ │ │ ├── panoptic_fpn.py
│ │ │ │ ├── panoptic_fpn_train.py
│ │ │ │ ├── rcnn.py
│ │ │ │ ├── retinanet.py
│ │ │ │ └── semantic_seg.py
│ │ │ ├── mmdet_wrapper.py
│ │ │ ├── poolers.py
│ │ │ ├── postprocessing.py
│ │ │ ├── proposal_generator/
│ │ │ │ ├── __init__.py
│ │ │ │ ├── build.py
│ │ │ │ ├── proposal_utils.py
│ │ │ │ ├── rpn.py
│ │ │ │ └── rrpn.py
│ │ │ ├── roi_heads/
│ │ │ │ ├── __init__.py
│ │ │ │ ├── box_head.py
│ │ │ │ ├── cascade_rcnn.py
│ │ │ │ ├── fast_rcnn.py
│ │ │ │ ├── keypoint_head.py
│ │ │ │ ├── mask_head.py
│ │ │ │ ├── roi_heads.py
│ │ │ │ └── rotated_fast_rcnn.py
│ │ │ ├── sampling.py
│ │ │ └── test_time_augmentation.py
│ │ ├── projects/
│ │ │ ├── README.md
│ │ │ └── __init__.py
│ │ ├── solver/
│ │ │ ├── __init__.py
│ │ │ ├── build.py
│ │ │ └── lr_scheduler.py
│ │ ├── structures/
│ │ │ ├── __init__.py
│ │ │ ├── boxes.py
│ │ │ ├── image_list.py
│ │ │ ├── instances.py
│ │ │ ├── keypoints.py
│ │ │ ├── masks.py
│ │ │ └── rotated_boxes.py
│ │ └── utils/
│ │ ├── README.md
│ │ ├── __init__.py
│ │ ├── analysis.py
│ │ ├── collect_env.py
│ │ ├── colormap.py
│ │ ├── comm.py
│ │ ├── env.py
│ │ ├── events.py
│ │ ├── file_io.py
│ │ ├── logger.py
│ │ ├── memory.py
│ │ ├── registry.py
│ │ ├── serialize.py
│ │ ├── testing.py
│ │ ├── video_visualizer.py
│ │ └── visualizer.py
│ ├── dev/
│ │ ├── README.md
│ │ ├── linter.sh
│ │ ├── packaging/
│ │ │ ├── README.md
│ │ │ ├── build_all_wheels.sh
│ │ │ ├── build_wheel.sh
│ │ │ ├── gen_install_table.py
│ │ │ ├── gen_wheel_index.sh
│ │ │ └── pkg_helpers.bash
│ │ ├── parse_results.sh
│ │ ├── run_inference_tests.sh
│ │ └── run_instant_tests.sh
│ ├── docker/
│ │ ├── Dockerfile
│ │ ├── README.md
│ │ ├── deploy.Dockerfile
│ │ └── docker-compose.yml
│ ├── docs/
│ │ ├── .gitignore
│ │ ├── Makefile
│ │ ├── README.md
│ │ ├── _static/
│ │ │ └── css/
│ │ │ └── custom.css
│ │ ├── conf.py
│ │ ├── index.rst
│ │ ├── modules/
│ │ │ ├── checkpoint.rst
│ │ │ ├── config.rst
│ │ │ ├── data.rst
│ │ │ ├── data_transforms.rst
│ │ │ ├── engine.rst
│ │ │ ├── evaluation.rst
│ │ │ ├── export.rst
│ │ │ ├── fvcore.rst
│ │ │ ├── index.rst
│ │ │ ├── layers.rst
│ │ │ ├── model_zoo.rst
│ │ │ ├── modeling.rst
│ │ │ ├── solver.rst
│ │ │ ├── structures.rst
│ │ │ └── utils.rst
│ │ ├── notes/
│ │ │ ├── benchmarks.md
│ │ │ ├── changelog.md
│ │ │ ├── compatibility.md
│ │ │ ├── contributing.md
│ │ │ └── index.rst
│ │ ├── requirements.txt
│ │ └── tutorials/
│ │ ├── README.md
│ │ ├── augmentation.md
│ │ ├── builtin_datasets.md
│ │ ├── configs.md
│ │ ├── data_loading.md
│ │ ├── datasets.md
│ │ ├── deployment.md
│ │ ├── evaluation.md
│ │ ├── extend.md
│ │ ├── getting_started.md
│ │ ├── index.rst
│ │ ├── install.md
│ │ ├── lazyconfigs.md
│ │ ├── models.md
│ │ ├── training.md
│ │ └── write-models.md
│ ├── projects/
│ │ ├── DeepLab/
│ │ │ ├── README.md
│ │ │ ├── configs/
│ │ │ │ └── Cityscapes-SemanticSegmentation/
│ │ │ │ ├── Base-DeepLabV3-OS16-Semantic.yaml
│ │ │ │ ├── deeplab_v3_R_103_os16_mg124_poly_90k_bs16.yaml
│ │ │ │ └── deeplab_v3_plus_R_103_os16_mg124_poly_90k_bs16.yaml
│ │ │ ├── deeplab/
│ │ │ │ ├── __init__.py
│ │ │ │ ├── build_solver.py
│ │ │ │ ├── config.py
│ │ │ │ ├── loss.py
│ │ │ │ ├── lr_scheduler.py
│ │ │ │ ├── resnet.py
│ │ │ │ └── semantic_seg.py
│ │ │ └── train_net.py
│ │ ├── DensePose/
│ │ │ ├── README.md
│ │ │ ├── apply_net.py
│ │ │ ├── configs/
│ │ │ │ ├── Base-DensePose-RCNN-FPN.yaml
│ │ │ │ ├── HRNet/
│ │ │ │ │ ├── densepose_rcnn_HRFPN_HRNet_w32_s1x.yaml
│ │ │ │ │ ├── densepose_rcnn_HRFPN_HRNet_w40_s1x.yaml
│ │ │ │ │ └── densepose_rcnn_HRFPN_HRNet_w48_s1x.yaml
│ │ │ │ ├── cse/
│ │ │ │ │ ├── Base-DensePose-RCNN-FPN-Human.yaml
│ │ │ │ │ ├── Base-DensePose-RCNN-FPN.yaml
│ │ │ │ │ ├── densepose_rcnn_R_101_FPN_DL_s1x.yaml
│ │ │ │ │ ├── densepose_rcnn_R_101_FPN_DL_soft_s1x.yaml
│ │ │ │ │ ├── densepose_rcnn_R_101_FPN_s1x.yaml
│ │ │ │ │ ├── densepose_rcnn_R_101_FPN_soft_s1x.yaml
│ │ │ │ │ ├── densepose_rcnn_R_50_FPN_DL_s1x.yaml
│ │ │ │ │ ├── densepose_rcnn_R_50_FPN_DL_soft_s1x.yaml
│ │ │ │ │ ├── densepose_rcnn_R_50_FPN_s1x.yaml
│ │ │ │ │ ├── densepose_rcnn_R_50_FPN_soft_animals_CA_finetune_16k.yaml
│ │ │ │ │ ├── densepose_rcnn_R_50_FPN_soft_animals_CA_finetune_4k.yaml
│ │ │ │ │ ├── densepose_rcnn_R_50_FPN_soft_animals_I0_finetune_16k.yaml
│ │ │ │ │ ├── densepose_rcnn_R_50_FPN_soft_animals_I0_finetune_i2m_16k.yaml
│ │ │ │ │ ├── densepose_rcnn_R_50_FPN_soft_animals_I0_finetune_m2m_16k.yaml
│ │ │ │ │ ├── densepose_rcnn_R_50_FPN_soft_animals_finetune_16k.yaml
│ │ │ │ │ ├── densepose_rcnn_R_50_FPN_soft_animals_finetune_4k.yaml
│ │ │ │ │ ├── densepose_rcnn_R_50_FPN_soft_animals_finetune_maskonly_24k.yaml
│ │ │ │ │ ├── densepose_rcnn_R_50_FPN_soft_chimps_finetune_4k.yaml
│ │ │ │ │ └── densepose_rcnn_R_50_FPN_soft_s1x.yaml
│ │ │ │ ├── densepose_rcnn_R_101_FPN_DL_WC1M_s1x.yaml
│ │ │ │ ├── densepose_rcnn_R_101_FPN_DL_WC1_s1x.yaml
│ │ │ │ ├── densepose_rcnn_R_101_FPN_DL_WC2M_s1x.yaml
│ │ │ │ ├── densepose_rcnn_R_101_FPN_DL_WC2_s1x.yaml
│ │ │ │ ├── densepose_rcnn_R_101_FPN_DL_s1x.yaml
│ │ │ │ ├── densepose_rcnn_R_101_FPN_WC1M_s1x.yaml
│ │ │ │ ├── densepose_rcnn_R_101_FPN_WC1_s1x.yaml
│ │ │ │ ├── densepose_rcnn_R_101_FPN_WC2M_s1x.yaml
│ │ │ │ ├── densepose_rcnn_R_101_FPN_WC2_s1x.yaml
│ │ │ │ ├── densepose_rcnn_R_101_FPN_s1x.yaml
│ │ │ │ ├── densepose_rcnn_R_101_FPN_s1x_legacy.yaml
│ │ │ │ ├── densepose_rcnn_R_50_FPN_DL_WC1M_s1x.yaml
│ │ │ │ ├── densepose_rcnn_R_50_FPN_DL_WC1_s1x.yaml
│ │ │ │ ├── densepose_rcnn_R_50_FPN_DL_WC2M_s1x.yaml
│ │ │ │ ├── densepose_rcnn_R_50_FPN_DL_WC2_s1x.yaml
│ │ │ │ ├── densepose_rcnn_R_50_FPN_DL_s1x.yaml
│ │ │ │ ├── densepose_rcnn_R_50_FPN_WC1M_s1x.yaml
│ │ │ │ ├── densepose_rcnn_R_50_FPN_WC1_s1x.yaml
│ │ │ │ ├── densepose_rcnn_R_50_FPN_WC2M_s1x.yaml
│ │ │ │ ├── densepose_rcnn_R_50_FPN_WC2_s1x.yaml
│ │ │ │ ├── densepose_rcnn_R_50_FPN_s1x.yaml
│ │ │ │ ├── densepose_rcnn_R_50_FPN_s1x_legacy.yaml
│ │ │ │ ├── evolution/
│ │ │ │ │ ├── Base-RCNN-FPN-Atop10P_CA.yaml
│ │ │ │ │ ├── densepose_R_50_FPN_DL_WC1M_3x_Atop10P_CA.yaml
│ │ │ │ │ ├── densepose_R_50_FPN_DL_WC1M_3x_Atop10P_CA_B_coarsesegm.yaml
│ │ │ │ │ ├── densepose_R_50_FPN_DL_WC1M_3x_Atop10P_CA_B_finesegm.yaml
│ │ │ │ │ ├── densepose_R_50_FPN_DL_WC1M_3x_Atop10P_CA_B_uniform.yaml
│ │ │ │ │ └── densepose_R_50_FPN_DL_WC1M_3x_Atop10P_CA_B_uv.yaml
│ │ │ │ └── quick_schedules/
│ │ │ │ ├── cse/
│ │ │ │ │ ├── densepose_rcnn_R_50_FPN_DL_instant_test.yaml
│ │ │ │ │ └── densepose_rcnn_R_50_FPN_soft_animals_finetune_instant_test.yaml
│ │ │ │ ├── densepose_rcnn_HRFPN_HRNet_w32_instant_test.yaml
│ │ │ │ ├── densepose_rcnn_R_50_FPN_DL_instant_test.yaml
│ │ │ │ ├── densepose_rcnn_R_50_FPN_TTA_inference_acc_test.yaml
│ │ │ │ ├── densepose_rcnn_R_50_FPN_WC1_instant_test.yaml
│ │ │ │ ├── densepose_rcnn_R_50_FPN_WC2_instant_test.yaml
│ │ │ │ ├── densepose_rcnn_R_50_FPN_inference_acc_test.yaml
│ │ │ │ ├── densepose_rcnn_R_50_FPN_instant_test.yaml
│ │ │ │ └── densepose_rcnn_R_50_FPN_training_acc_test.yaml
│ │ │ ├── densepose/
│ │ │ │ ├── __init__.py
│ │ │ │ ├── config.py
│ │ │ │ ├── converters/
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ ├── base.py
│ │ │ │ │ ├── builtin.py
│ │ │ │ │ ├── chart_output_hflip.py
│ │ │ │ │ ├── chart_output_to_chart_result.py
│ │ │ │ │ ├── hflip.py
│ │ │ │ │ ├── segm_to_mask.py
│ │ │ │ │ ├── to_chart_result.py
│ │ │ │ │ └── to_mask.py
│ │ │ │ ├── engine/
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ └── trainer.py
│ │ │ │ ├── evaluation/
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ ├── d2_evaluator_adapter.py
│ │ │ │ │ ├── densepose_coco_evaluation.py
│ │ │ │ │ ├── evaluator.py
│ │ │ │ │ ├── mesh_alignment_evaluator.py
│ │ │ │ │ └── tensor_storage.py
│ │ │ │ ├── modeling/
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ ├── build.py
│ │ │ │ │ ├── confidence.py
│ │ │ │ │ ├── cse/
│ │ │ │ │ │ ├── __init__.py
│ │ │ │ │ │ ├── embedder.py
│ │ │ │ │ │ ├── utils.py
│ │ │ │ │ │ ├── vertex_direct_embedder.py
│ │ │ │ │ │ └── vertex_feature_embedder.py
│ │ │ │ │ ├── densepose_checkpoint.py
│ │ │ │ │ ├── filter.py
│ │ │ │ │ ├── hrfpn.py
│ │ │ │ │ ├── hrnet.py
│ │ │ │ │ ├── inference.py
│ │ │ │ │ ├── losses/
│ │ │ │ │ │ ├── __init__.py
│ │ │ │ │ │ ├── chart.py
│ │ │ │ │ │ ├── chart_with_confidences.py
│ │ │ │ │ │ ├── cse.py
│ │ │ │ │ │ ├── cycle_pix2shape.py
│ │ │ │ │ │ ├── cycle_shape2shape.py
│ │ │ │ │ │ ├── embed.py
│ │ │ │ │ │ ├── embed_utils.py
│ │ │ │ │ │ ├── mask.py
│ │ │ │ │ │ ├── mask_or_segm.py
│ │ │ │ │ │ ├── registry.py
│ │ │ │ │ │ ├── segm.py
│ │ │ │ │ │ ├── soft_embed.py
│ │ │ │ │ │ └── utils.py
│ │ │ │ │ ├── predictors/
│ │ │ │ │ │ ├── __init__.py
│ │ │ │ │ │ ├── chart.py
│ │ │ │ │ │ ├── chart_confidence.py
│ │ │ │ │ │ ├── chart_with_confidence.py
│ │ │ │ │ │ ├── cse.py
│ │ │ │ │ │ ├── cse_confidence.py
│ │ │ │ │ │ ├── cse_with_confidence.py
│ │ │ │ │ │ └── registry.py
│ │ │ │ │ ├── roi_heads/
│ │ │ │ │ │ ├── __init__.py
│ │ │ │ │ │ ├── deeplab.py
│ │ │ │ │ │ ├── registry.py
│ │ │ │ │ │ ├── roi_head.py
│ │ │ │ │ │ └── v1convx.py
│ │ │ │ │ ├── test_time_augmentation.py
│ │ │ │ │ └── utils.py
│ │ │ │ ├── structures/
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ ├── chart.py
│ │ │ │ │ ├── chart_confidence.py
│ │ │ │ │ ├── chart_result.py
│ │ │ │ │ ├── cse.py
│ │ │ │ │ ├── cse_confidence.py
│ │ │ │ │ ├── data_relative.py
│ │ │ │ │ ├── list.py
│ │ │ │ │ ├── mesh.py
│ │ │ │ │ └── transform_data.py
│ │ │ │ ├── utils/
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ ├── dbhelper.py
│ │ │ │ │ ├── logger.py
│ │ │ │ │ └── transform.py
│ │ │ │ └── vis/
│ │ │ │ ├── __init__.py
│ │ │ │ ├── base.py
│ │ │ │ ├── bounding_box.py
│ │ │ │ ├── densepose_data_points.py
│ │ │ │ ├── densepose_outputs_iuv.py
│ │ │ │ ├── densepose_outputs_vertex.py
│ │ │ │ ├── densepose_results.py
│ │ │ │ ├── densepose_results_textures.py
│ │ │ │ └── extractor.py
│ │ │ ├── dev/
│ │ │ │ ├── README.md
│ │ │ │ ├── run_inference_tests.sh
│ │ │ │ └── run_instant_tests.sh
│ │ │ ├── doc/
│ │ │ │ ├── BOOTSTRAPPING_PIPELINE.md
│ │ │ │ ├── DENSEPOSE_CSE.md
│ │ │ │ ├── DENSEPOSE_DATASETS.md
│ │ │ │ ├── DENSEPOSE_IUV.md
│ │ │ │ ├── GETTING_STARTED.md
│ │ │ │ ├── RELEASE_2020_04.md
│ │ │ │ ├── RELEASE_2021_03.md
│ │ │ │ ├── RELEASE_2021_06.md
│ │ │ │ ├── TOOL_APPLY_NET.md
│ │ │ │ └── TOOL_QUERY_DB.md
│ │ │ ├── query_db.py
│ │ │ ├── setup.py
│ │ │ └── train_net.py
│ │ ├── Panoptic-DeepLab/
│ │ │ ├── README.md
│ │ │ ├── configs/
│ │ │ │ ├── COCO-PanopticSegmentation/
│ │ │ │ │ └── panoptic_deeplab_R_52_os16_mg124_poly_200k_bs64_crop_640_640_coco_dsconv.yaml
│ │ │ │ └── Cityscapes-PanopticSegmentation/
│ │ │ │ ├── Base-PanopticDeepLab-OS16.yaml
│ │ │ │ ├── panoptic_deeplab_R_52_os16_mg124_poly_90k_bs32_crop_512_1024.yaml
│ │ │ │ └── panoptic_deeplab_R_52_os16_mg124_poly_90k_bs32_crop_512_1024_dsconv.yaml
│ │ │ ├── panoptic_deeplab/
│ │ │ │ ├── __init__.py
│ │ │ │ ├── config.py
│ │ │ │ ├── dataset_mapper.py
│ │ │ │ ├── panoptic_seg.py
│ │ │ │ ├── post_processing.py
│ │ │ │ └── target_generator.py
│ │ │ └── train_net.py
│ │ ├── PointRend/
│ │ │ ├── README.md
│ │ │ ├── configs/
│ │ │ │ ├── InstanceSegmentation/
│ │ │ │ │ ├── Base-Implicit-PointRend.yaml
│ │ │ │ │ ├── Base-PointRend-RCNN-FPN.yaml
│ │ │ │ │ ├── implicit_pointrend_R_50_FPN_1x_coco.yaml
│ │ │ │ │ ├── implicit_pointrend_R_50_FPN_3x_coco.yaml
│ │ │ │ │ ├── pointrend_rcnn_R_101_FPN_3x_coco.yaml
│ │ │ │ │ ├── pointrend_rcnn_R_50_FPN_1x_cityscapes.yaml
│ │ │ │ │ ├── pointrend_rcnn_R_50_FPN_1x_coco.yaml
│ │ │ │ │ ├── pointrend_rcnn_R_50_FPN_3x_coco.yaml
│ │ │ │ │ └── pointrend_rcnn_X_101_32x8d_FPN_3x_coco.yaml
│ │ │ │ └── SemanticSegmentation/
│ │ │ │ ├── Base-PointRend-Semantic-FPN.yaml
│ │ │ │ └── pointrend_semantic_R_101_FPN_1x_cityscapes.yaml
│ │ │ ├── point_rend/
│ │ │ │ ├── __init__.py
│ │ │ │ ├── color_augmentation.py
│ │ │ │ ├── config.py
│ │ │ │ ├── mask_head.py
│ │ │ │ ├── point_features.py
│ │ │ │ ├── point_head.py
│ │ │ │ ├── roi_heads.py
│ │ │ │ └── semantic_seg.py
│ │ │ └── train_net.py
│ │ ├── PointSup/
│ │ │ ├── README.md
│ │ │ ├── configs/
│ │ │ │ ├── implicit_pointrend_R_50_FPN_3x_point_sup_point_aug_coco.yaml
│ │ │ │ ├── mask_rcnn_R_50_FPN_3x_point_sup_coco.yaml
│ │ │ │ └── mask_rcnn_R_50_FPN_3x_point_sup_point_aug_coco.yaml
│ │ │ ├── point_sup/
│ │ │ │ ├── __init__.py
│ │ │ │ ├── config.py
│ │ │ │ ├── dataset_mapper.py
│ │ │ │ ├── detection_utils.py
│ │ │ │ ├── mask_head.py
│ │ │ │ ├── point_utils.py
│ │ │ │ └── register_point_annotations.py
│ │ │ ├── tools/
│ │ │ │ └── prepare_coco_point_annotations_without_masks.py
│ │ │ └── train_net.py
│ │ ├── README.md
│ │ ├── Rethinking-BatchNorm/
│ │ │ ├── README.md
│ │ │ ├── configs/
│ │ │ │ ├── mask_rcnn_BNhead.py
│ │ │ │ ├── mask_rcnn_BNhead_batch_stats.py
│ │ │ │ ├── mask_rcnn_BNhead_shuffle.py
│ │ │ │ ├── mask_rcnn_SyncBNhead.py
│ │ │ │ ├── retinanet_SyncBNhead.py
│ │ │ │ └── retinanet_SyncBNhead_SharedTraining.py
│ │ │ └── retinanet-eval-domain-specific.py
│ │ ├── TensorMask/
│ │ │ ├── README.md
│ │ │ ├── configs/
│ │ │ │ ├── Base-TensorMask.yaml
│ │ │ │ ├── tensormask_R_50_FPN_1x.yaml
│ │ │ │ └── tensormask_R_50_FPN_6x.yaml
│ │ │ ├── setup.py
│ │ │ ├── tensormask/
│ │ │ │ ├── __init__.py
│ │ │ │ ├── arch.py
│ │ │ │ ├── config.py
│ │ │ │ └── layers/
│ │ │ │ ├── __init__.py
│ │ │ │ ├── csrc/
│ │ │ │ │ ├── SwapAlign2Nat/
│ │ │ │ │ │ ├── SwapAlign2Nat.h
│ │ │ │ │ │ └── SwapAlign2Nat_cuda.cu
│ │ │ │ │ └── vision.cpp
│ │ │ │ └── swap_align2nat.py
│ │ │ └── train_net.py
│ │ └── TridentNet/
│ │ ├── README.md
│ │ ├── configs/
│ │ │ ├── Base-TridentNet-Fast-C4.yaml
│ │ │ ├── tridentnet_fast_R_101_C4_3x.yaml
│ │ │ ├── tridentnet_fast_R_50_C4_1x.yaml
│ │ │ └── tridentnet_fast_R_50_C4_3x.yaml
│ │ ├── train_net.py
│ │ └── tridentnet/
│ │ ├── __init__.py
│ │ ├── config.py
│ │ ├── trident_backbone.py
│ │ ├── trident_conv.py
│ │ ├── trident_rcnn.py
│ │ └── trident_rpn.py
│ ├── setup.cfg
│ ├── setup.py
│ └── tools/
│ ├── 1_tracking.py
│ ├── 2_matching.py
│ ├── 3_preparing.py
│ ├── 4_eval_vpq.py
│ ├── README.md
│ ├── __init__.py
│ ├── analyze_model.py
│ ├── benchmark.py
│ ├── convert-torchvision-to-d2.py
│ ├── default.py
│ ├── deploy/
│ │ ├── CMakeLists.txt
│ │ ├── README.md
│ │ ├── export_model.py
│ │ └── torchscript_mask_rcnn.cpp
│ ├── lazyconfig_train_net.py
│ ├── lightning_train_net.py
│ ├── plain_train_net.py
│ ├── train_net.py
│ ├── visualize_data.py
│ └── visualize_json_results.py
├── prepare.md
└── tools/
├── initial_segmentation.sh
├── split_init_segm.py
├── test_vo_scene.sh
└── test_vps.sh
================================================
FILE CONTENTS
================================================
================================================
FILE: .gitignore
================================================
a# Byte-compiled / optimized / DLL files
__pycache__/
*.py[cod]
*$py.class
# C extensions
*.so
checkpoints/
datasets/
shared_data/
# Distribution / packaging
.Python
build/
develop-eggs/
dist/
downloads/
eggs/
.eggs/
lib/
lib64/
parts/
sdist/
var/
wheels/
share/python-wheels/
*.egg-info/
.installed.cfg
*.egg
MANIFEST
# PyInstaller
# Usually these files are written by a python script from a template
# before PyInstaller builds the exe, so as to inject date/other infos into it.
*.manifest
*.spec
# Installer logs
pip-log.txt
pip-delete-this-directory.txt
# Unit test / coverage reports
htmlcov/
.tox/
.nox/
.coverage
.coverage.*
.cache
nosetests.xml
coverage.xml
*.cover
*.py,cover
.hypothesis/
.pytest_cache/
cover/
# Translations
*.mo
*.pot
# Django stuff:
*.log
local_settings.py
db.sqlite3
db.sqlite3-journal
# Flask stuff:
instance/
.webassets-cache
# Scrapy stuff:
.scrapy
# Sphinx documentation
docs/_build/
# PyBuilder
.pybuilder/
target/
# Jupyter Notebook
.ipynb_checkpoints
# IPython
profile_default/
ipython_config.py
# pyenv
# For a library or package, you might want to ignore these files since the code is
# intended to run in multiple environments; otherwise, check them in:
# .python-version
# pipenv
# According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
# However, in case of collaboration, if having platform-specific dependencies or dependencies
# having no cross-platform support, pipenv may install dependencies that don't work, or not
# install all needed dependencies.
#Pipfile.lock
# PEP 582; used by e.g. github.com/David-OConnor/pyflow
__pypackages__/
# Celery stuff
celerybeat-schedule
celerybeat.pid
# SageMath parsed files
*.sage.py
# Environments
.env
.venv
env/
venv/
ENV/
env.bak/
venv.bak/
# Spyder project settings
.spyderproject
.spyproject
# Rope project settings
.ropeproject
# mkdocs documentation
/site
# mypy
.mypy_cache/
.dmypy.json
dmypy.json
# Pyre type checker
.pyre/
# pytype static type analyzer
.pytype/
# Cython debug symbols
cython_debug/
__pycache__
build
dist
*.egg-info
*.vscode/
*.pth
tests
checkpoints
datasets
runs
cache
*.out
*.o
data
figures/*.pdf
test_codes/
tensorboard.sh
visualize/results/
visualize/traj_results
================================================
FILE: README.md
================================================
# PVO: Panoptic Visual Odometry
### [Project Page](https://zju3dv.github.io/pvo/) | [Paper](https://arxiv.org/abs/2207.01610)
<br/>
> PVO: Panoptic Visual Odometry
> [[Weicai Ye](https://ywcmaike.github.io/), [Xinyue Lan](https://github.com/siyisan)]<sup>Co-Authors</sup>, [Shuo Chen](https://github.com/Eric3778), [Yuhang Ming](https://github.com/YuhangMing), [Xinyuan Yu](https://github.com/RickyYXY), [Hujun Bao](http://www.cad.zju.edu.cn/home/bao/), [Zhaopeng Cui](https://zhpcui.github.io/), [Guofeng Zhang](http://www.cad.zju.edu.cn/home/gfzhang)
> CVPR 2023
## Test on vkitti 15-deg-left datasets.
0) prepare.
follow [prepare.md](prepare.md)
```
conda activate droidenv
```
1) generate inital panoptic segmentation.
```
sh tools/initial_segmentation.sh
```
2) vps->vo，vo Module generate pose, flow and depth.
```
sh tools/test_vo_scene.sh
```
3) vo->vps, vps Module use flow and depth from vo Module and generate final video panoptic segmentation results and vpq.
```
sh tools/test_vps.sh
```
## Metrics on Virtual_KITTI2
|Scene|RMSE|vpq_all/vpq_thing/vpq_stuff|
|-----|----|---------------------------|
|Scene01|0.371|40.39/26.43/44.57|
|Scene02|0.058|68.84/88.83/62.18|
|Scene06|0.113|66.38/79.99/62.97|
|Scene18|0.951|68.35/83.86/63.92|
|Scene20|3.503|35.11/16.83/40.59|
You can get the results in the paper by iterating multiple times.
## Train on vkitti 15-deg-left datasets.
1) To train VPS_Module, you can refer to [Detectron2](https://detectron2.readthedocs.io/en/latest/tutorials/getting_started.html) for more training details.
Here for example, you can train vkitti 15-deg-left on 4 GPUs, and training results are saved on `output/vps_training/`. You can modify the config-file according to the hardware conditions.
```
python3 -W ignore VPS_Module/tools/train_net.py \
--config-file VPS_Module/configs/COCO-PanopticSegmentation/panoptic_fpn_R_50_3x_vkitti_511.yaml --num-gpu 4 \
MODEL.WEIGHTS checkpoints/panFPN.pth \
OUTPUT_DIR output/vps_training/
```
2) To train VO_Module, you can refer to [DROID-SLAM](https://github.com/princeton-vl/DROID-SLAM) for more training details.
Here for example, you can train vkitti on 4 GPUs.
```
python VO_Module/train.py --gpus=4 --lr=0.00025
```
## Visualization
You can refer to [DROID-SLAM](https://github.com/princeton-vl/DROID-SLAM) for visualization.
All demos can be run on a GPU with 11G of memory. While running, press the "s" key to increase the filtering threshold (= more points) and "a" to decrease the filtering threshold (= fewer points).
```
python VO_Module/evaluation_scripts/test_vo.py --datapath=datasets/Virtual_KITTI2/Scene01 --segm_filter True
```
## Citation
If you find this code useful for your research, please use the following BibTeX entry.
```bibtex
@inproceedings{Ye2023PVO,
title={{PVO: Panoptic visual odometry}},
author={Ye, Weicai and Lan, Xinyue and Chen, Shuo and Ming, Yuhang and Yu, Xingyuan and Bao, Hujun and Cui, Zhaopeng and Zhang, Guofeng},
booktitle={Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition},
pages={9579--9589},
year={2023}
}
```
## Acknowledgement
Some code snippets are borrowed from [DROID-SLAM](https://github.com/princeton-vl/DROID-SLAM) and [Detectron2](https://github.com/facebookresearch/detectron2). Thanks for these great projects.
================================================
FILE: VO_Module/README.md
================================================
## Requirements
To run the code you will need ...
* **Inference:** Running the demos will require a GPU with at least 11G of memory.
* **Training:** Training requires a GPU with at least 24G of memory. We train on 4 x RTX-3090 GPUs.
## Getting Started
1. Creating a new anaconda environment using the provided .yaml file. Use `environment_novis.yaml` to if you do not want to use the visualization
```Bash
conda env create -f environment.yml
pip install evo --upgrade --no-binary evo
pip install gdown
```
2. Compile the extensions (takes about 10 minutes)
```Bash
python setup.py install
```
## Acknowledgements
We additionally use evaluation tools from [evo](https://github.com/MichaelGrupp/evo) and [tartanair_tools](https://github.com/castacks/tartanair_tools). Our code is based on the code provided by [DROID-SLAM](https://github.com/princeton-vl/DROID-SLAM).
<center><img src="misc/DROID.png" width="640" style="center"></center>
[DROID-SLAM: Deep Visual SLAM for Monocular, Stereo, and RGB-D Cameras](https://arxiv.org/abs/2108.10869)
Zachary Teed and Jia Deng
```
@article{teed2021droid,
title={{DROID-SLAM: Deep Visual SLAM for Monocular, Stereo, and RGB-D Cameras}},
author={Teed, Zachary and Deng, Jia},
journal={arXiv preprint arXiv:2108.10869},
year={2021}
}
```
================================================
FILE: VO_Module/calib/barn.txt
================================================
1161.545689 1161.545689 960.000000 540.000000 -0.025158 0.0 0.0 0.0
================================================
FILE: VO_Module/calib/eth.txt
================================================
726.21081542969 726.21081542969 359.2048034668 202.47247314453
================================================
FILE: VO_Module/calib/euroc.txt
================================================
458.654 457.296 367.215 248.375 -0.28340811 0.07395907 0.00019359 1.76187114e-05
================================================
FILE: VO_Module/calib/kitti.txt
================================================
7.070912000000e+02 7.070912000000e+02 6.018873000000e+02 1.831104000000e+02
================================================
FILE: VO_Module/calib/replica.txt
================================================
600.0 600.0 599.5 339.5
================================================
FILE: VO_Module/calib/tartan.txt
================================================
320.0 320.0 320.0 240.0
================================================
FILE: VO_Module/calib/tum3.txt
================================================
535.4 539.2 320.1 247.6
================================================
FILE: VO_Module/demo.py
================================================
import sys
sys.path.append('droid_slam')
from tqdm import tqdm
import numpy as np
import torch
import lietorch
import cv2
import os
import glob
import time
import argparse
from torch.multiprocessing import Process
from droid import Droid
import torch.nn.functional as F
def show_image(image):
image = image.permute(1, 2, 0).cpu().numpy()
cv2.imshow('image', image / 255.0)
cv2.waitKey(1)
def image_stream(imagedir, calib, stride):
""" image generator """
calib = np.loadtxt(calib, delimiter=" ")
fx, fy, cx, cy = calib[:4]
K = np.eye(3)
K[0,0] = fx
K[0,2] = cx
K[1,1] = fy
K[1,2] = cy
image_list = sorted(os.listdir(imagedir))[::stride]
for t, imfile in enumerate(image_list):
image = cv2.imread(os.path.join(imagedir, imfile))
if len(calib) > 4:
image = cv2.undistort(image, K, calib[4:])
h0, w0, _ = image.shape
h1 = int(h0 * np.sqrt((384 * 512) / (h0 * w0)))
w1 = int(w0 * np.sqrt((384 * 512) / (h0 * w0)))
image = cv2.resize(image, (w1, h1))
image = image[:h1-h1%8, :w1-w1%8]
image = torch.as_tensor(image).permute(2, 0, 1)
intrinsics = torch.as_tensor([fx, fy, cx, cy])
intrinsics[0:2] *= (w1 / w0)
intrinsics[2:4] *= (h1 / h0)
yield t, image, intrinsics
if __name__ == '__main__':
parser = argparse.ArgumentParser()
parser.add_argument("--imagedir", type=str, help="path to image directory")
parser.add_argument("--calib", type=str, help="path to calibration file")
parser.add_argument("--t0", default=0, type=int, help="starting frame")
parser.add_argument("--stride", default=3, type=int, help="frame stride")
parser.add_argument("--weights", default="droid.pth")
parser.add_argument("--buffer", type=int, default=512)
parser.add_argument("--image_size", default=[240, 320])
parser.add_argument("--disable_vis", action="store_true")
parser.add_argument("--beta", type=float, default=0.3, help="weight for translation / rotation components of flow")
parser.add_argument("--filter_thresh", type=float, default=2.4, help="how much motion before considering new keyframe")
parser.add_argument("--warmup", type=int, default=8, help="number of warmup frames")
parser.add_argument("--keyframe_thresh", type=float, default=4.0, help="threshold to create a new keyframe")
parser.add_argument("--frontend_thresh", type=float, default=16.0, help="add edges between frames whithin this distance")
parser.add_argument("--frontend_window", type=int, default=25, help="frontend optimization window")
parser.add_argument("--frontend_radius", type=int, default=2, help="force edges between frames within radius")
parser.add_argument("--frontend_nms", type=int, default=1, help="non-maximal supression of edges")
parser.add_argument("--backend_thresh", type=float, default=22.0)
parser.add_argument("--backend_radius", type=int, default=2)
parser.add_argument("--backend_nms", type=int, default=3)
args = parser.parse_args()
torch.multiprocessing.set_start_method('spawn')
droid = None
tstamps = []
for (t, image, intrinsics) in tqdm(image_stream(args.imagedir, args.calib, args.stride)):
if t < args.t0:
continue
if not args.disable_vis:
show_image(image)
if droid is None:
args.image_size = [image.shape[1], image.shape[2]]
droid = Droid(args)
droid.track(t, image, intrinsics=intrinsics)
traj_est = droid.terminate(image_stream(args.imagedir, args.calib, args.stride))
================================================
FILE: VO_Module/droid_slam/data_readers/__init__.py
================================================
================================================
FILE: VO_Module/droid_slam/data_readers/augmentation.py
================================================
import torch
import torchvision.transforms as transforms
import numpy as np
import torch.nn.functional as F
class RGBDAugmentor:
""" perform augmentation on RGB-D video """
def __init__(self, crop_size):
self.crop_size = crop_size
self.augcolor = transforms.Compose([
transforms.ToPILImage(),
transforms.ColorJitter(
brightness=0.25, contrast=0.25, saturation=0.25, hue=0.4/3.14),
transforms.RandomGrayscale(p=0.1),
transforms.ToTensor()])
self.max_scale = 0.25
def resize_sparse_flow_map(self, flow, valid, fx=1.0, fy=1.0):
"""from RAFT"""
N, ht, wd = flow.shape[:3]
coords = np.meshgrid(np.arange(wd), np.arange(ht))
coords = np.stack(coords, axis=-1)
coords = torch.from_numpy(coords).expand_as(flow)
coords = coords.reshape(N, -1, 2).float()
flow = flow.reshape(N, -1, 2).float()
valid = valid.reshape(N, -1).float()
coords0 = coords[valid >= 1]
flow0 = flow[valid >= 1]
ht1 = int(round(ht * fy))
wd1 = int(round(wd * fx))
coords1 = coords0 * torch.tensor([fx, fy])
flow1 = flow0 * torch.tensor([fx, fy])
xx = torch.round(coords1[..., 0]).long()
yy = torch.round(coords1[..., 1]).long()
v = (xx > 0) & (xx < wd1) & (yy > 0) & (yy < ht1)
xx = xx[v]
yy = yy[v]
flow1 = flow1[v]
flow_img = torch.zeros([N, ht1, wd1, 2], dtype=torch.float)
valid_img = torch.zeros([N, ht1, wd1], dtype=torch.int)
flow_img[:, yy, xx] = flow1
valid_img[:, yy, xx] = 1
return flow_img, valid_img
def spatial_transform(self, images, depths, poses, intrinsics,
fo_flows=None, fo_vals=None, ba_flows=None, ba_vals=None,
fo_masks=None, ba_masks=None, gt_masks=None, gt_vals=None,
segments=None):
""" cropping and resizing """
ht, wd = images.shape[2:]
max_scale = self.max_scale
min_scale = np.log2(np.maximum(
(self.crop_size[0] + 1) / float(ht),
(self.crop_size[1] + 1) / float(wd)))
scale = 2 ** np.random.uniform(min_scale, max_scale)
intrinsics = scale * intrinsics
depths = depths.unsqueeze(dim=1)
images = F.interpolate(images, scale_factor=scale, mode='bilinear',
align_corners=False, recompute_scale_factor=True)
depths = F.interpolate(depths, scale_factor=scale,
recompute_scale_factor=True)
if fo_flows != None:
fo_flows, fo_vals = self.resize_sparse_flow_map(
fo_flows, fo_vals, fx=scale, fy=scale)
fo_flows = torch.cat([fo_flows, fo_vals.unsqueeze(-1)], dim=-1)
ba_flows, ba_vals = self.resize_sparse_flow_map(
ba_flows, ba_vals, fx=scale, fy=scale)
ba_flows = torch.cat([ba_flows, ba_vals.unsqueeze(-1)], dim=-1)
fo_masks = fo_masks.unsqueeze(1)
ba_masks = ba_masks.unsqueeze(1)
fo_masks = F.interpolate(fo_masks, scale_factor=scale,
recompute_scale_factor=True)
ba_masks = F.interpolate(ba_masks, scale_factor=scale,
recompute_scale_factor=True)
else:
gt_masks = gt_masks.unsqueeze(1)
gt_vals = gt_vals.unsqueeze(1)
segments = segments.unsqueeze(1)
gt_masks = F.interpolate(gt_masks, scale_factor=scale,
recompute_scale_factor=True)
gt_vals = F.interpolate(gt_vals, scale_factor=scale,
recompute_scale_factor=True)
segments = F.interpolate(segments, scale_factor=scale,
recompute_scale_factor=True)
# always perform center crop (TODO: try non-center crops)
y0 = (images.shape[2] - self.crop_size[0]) // 2
x0 = (images.shape[3] - self.crop_size[1]) // 2
intrinsics = intrinsics - torch.tensor([0.0, 0.0, x0, y0])
images = images[:, :, y0:y0+self.crop_size[0], x0:x0+self.crop_size[1]]
depths = depths[:, :, y0:y0+self.crop_size[0], x0:x0+self.crop_size[1]]
if fo_flows != None:
fo_flows = fo_flows[:, y0:y0 +
self.crop_size[0], x0:x0+self.crop_size[1], :]
ba_flows = ba_flows[:, y0:y0 +
self.crop_size[0], x0:x0+self.crop_size[1], :]
fo_masks = fo_masks[:, :, y0:y0 +
self.crop_size[0], x0:x0+self.crop_size[1]]
ba_masks = ba_masks[:, :, y0:y0 +
self.crop_size[0], x0:x0+self.crop_size[1]]
else:
gt_masks = gt_masks[:, :, y0:y0 +
self.crop_size[0], x0:x0+self.crop_size[1]]
gt_vals = gt_vals[:, :, y0:y0 +
self.crop_size[0], x0:x0+self.crop_size[1]]
segments = segments[:, :, y0:y0 +
self.crop_size[0], x0:x0+self.crop_size[1]]
depths = depths.squeeze(dim=1)
if fo_flows != None:
fo_masks = fo_masks.squeeze(1)
ba_masks = ba_masks.squeeze(1)
return images, poses, depths, intrinsics, fo_flows, ba_flows, fo_masks, ba_masks
else:
gt_masks = gt_masks.squeeze(1)
gt_vals = gt_vals.squeeze(1)
segments = F.interpolate(segments, scale_factor=1/8,
recompute_scale_factor=True)
segments = segments.squeeze(1).int()
return images, poses, depths, intrinsics, gt_masks, gt_vals, segments
def spatial_transform_only_pose(self, images, poses, intrinsics):
""" cropping and resizing """
ht, wd = images.shape[2:]
max_scale = self.max_scale
min_scale = np.log2(np.maximum(
(self.crop_size[0] + 1) / float(ht),
(self.crop_size[1] + 1) / float(wd)))
scale = 2 ** np.random.uniform(min_scale, max_scale)
intrinsics = scale * intrinsics
images = F.interpolate(images, scale_factor=scale, mode='bilinear',
align_corners=False, recompute_scale_factor=True)
# always perform center crop (TODO: try non-center crops)
y0 = (images.shape[2] - self.crop_size[0]) // 2
x0 = (images.shape[3] - self.crop_size[1]) // 2
intrinsics = intrinsics - torch.tensor([0.0, 0.0, x0, y0])
images = images[:, :, y0:y0+self.crop_size[0], x0:x0+self.crop_size[1]]
return images, poses, intrinsics
def color_transform(self, images):
""" color jittering """
num, ch, ht, wd = images.shape
images = images.permute(1, 2, 3, 0).reshape(ch, ht, wd*num)
images = 255 * self.augcolor(images[[2, 1, 0]] / 255.0)
return images[[2, 1, 0]].reshape(ch, ht, wd, num).permute(3, 0, 1, 2).contiguous()
def __call__(self, images, poses, depths, intrinsics,
fo_flows=None, fo_vals=None, ba_flows=None, ba_vals=None,
fo_masks=None, ba_masks=None, gt_masks=None, gt_vals=None,
segments=None):
if depths == None:
images = self.color_transform(images)
return self.spatial_transform_only_pose(images, poses, intrinsics)
else:
images = self.color_transform(images)
return self.spatial_transform(images, depths, poses, intrinsics,
fo_flows, fo_vals, ba_flows, ba_vals,
fo_masks, ba_masks, gt_masks, gt_vals,
segments)
================================================
FILE: VO_Module/droid_slam/data_readers/base.py
================================================
import numpy as np
import torch
import torch.utils.data as data
import torch.nn.functional as F
import sys
import csv
import os
import cv2
import math
import random
import json
import pickle
import os.path as osp
from collections import OrderedDict
from lietorch import SE3
from .augmentation import RGBDAugmentor
from .rgbd_utils import *
from geom.projective_ops import projective_transform, coords_grid
from geom.graph_utils import graph_to_edge_list
class RGBDDataset(data.Dataset):
def __init__(self, name, datapath, n_frames=4, crop_size=[384, 512],
fmin=8.0, fmax=75.0, do_aug=True, flow_label=False, aug_graph=False,
need_inv=True, build_mask=False, mode='sup', rebuild=False):
""" Base class for RGBD dataset """
self.aug = None
self.root = datapath
self.name = name
self.mode = mode
self.n_frames = n_frames
self.fmin = fmin # exclude very easy examples
self.fmax = fmax # exclude very hard examples
self.flow_label = flow_label
self.aug_graph = aug_graph
self.need_inv = need_inv
self.build_mask = build_mask
self.only_pose = False
if do_aug:
self.aug = RGBDAugmentor(crop_size=crop_size)
# building dataset is expensive, cache so only needs to be performed once
cur_path = osp.dirname(osp.abspath(__file__))
if not os.path.isdir(osp.join(cur_path, 'cache')):
os.mkdir(osp.join(cur_path, 'cache'))
cache_path = osp.join(cur_path, 'cache', '{}.pickle'.format(self.name))
print("cache_path: ",cache_path)
if osp.isfile(cache_path) and rebuild==False:
scene_info = pickle.load(open(cache_path, 'rb'))[0]
else:
scene_info = self._build_dataset()
with open(cache_path, 'wb') as cachefile:
pickle.dump((scene_info,), cachefile)
self.scene_info = scene_info
self._build_dataset_index()
self.has_segm = False
def _build_dataset_index(self):
self.dataset_index = []
for scene in self.scene_info:
# if not self.__class__.is_test_scene(scene):
if not self.is_test_scene(scene):
if self.aug_graph:
graph = self.scene_info[scene]['graph']
for i in graph:
if len(graph[i][0]) > self.n_frames:
self.dataset_index.append((scene, i))
else:
for i in range(len(self.scene_info[scene]['images'])-self.n_frames+1):
self.dataset_index.append((scene, i))
else:
print("Reserving {} for validation".format(scene))
@staticmethod
def image_read(image_file):
return cv2.imread(image_file)
@staticmethod
def depth_read(depth_file):
return np.load(depth_file)
def build_frame_graph(self, poses, depths, intrinsics, f=16, max_flow=256):
""" compute optical flow distance between all pairs of frames """
def read_disp(fn):
depth = self.__class__.depth_read(fn)[f//2::f, f//2::f]
depth[depth < 0.01] = np.mean(depth)
return 1.0 / depth
poses = np.array(poses)
intrinsics = np.array(intrinsics) / f
disps = np.stack(list(map(read_disp, depths)), 0)
# need_inv = False for vkitti2
d = f * \
compute_distance_matrix_flow(
poses, disps, intrinsics, need_inv=self.need_inv)
graph = {}
for i in range(d.shape[0]):
j, = np.where(d[i] < max_flow)
graph[i] = (j, d[i, j])
return graph
def __getitem__(self, index):
""" return training video """
index = index % len(self.dataset_index)
scene_id, ix = self.dataset_index[index]
if self.aug_graph:
frame_graph = self.scene_info[scene_id]['graph']
if self.flow_label:
fo_flow_list = self.scene_info[scene_id]['fo_flows']
ba_flow_list = self.scene_info[scene_id]['ba_flows']
if 'segments' in self.scene_info[scene_id]:
self.has_segm = True
segments_list = self.scene_info[scene_id]['segments']
else:
if not self.only_pose:
dymask_list = self.scene_info[scene_id]['dymasks']
segments_list = self.scene_info[scene_id]['segments']
self.has_segm = True
images_list = self.scene_info[scene_id]['images']
if not self.only_pose:
depths_list = self.scene_info[scene_id]['depths']
poses_list = self.scene_info[scene_id]['poses']
intrinsics_list = self.scene_info[scene_id]['intrinsics']
if self.aug_graph:
inds = [ix]
while len(inds) < self.n_frames:
# get other frames within flow threshold
k = (frame_graph[ix][1] > self.fmin) & (
frame_graph[ix][1] < self.fmax)
frames = frame_graph[ix][0][k]
# prefer frames forward in time
if np.count_nonzero(frames[frames > ix]):
ix = np.random.choice(frames[frames > ix])
elif np.count_nonzero(frames):
ix = np.random.choice(frames)
inds += [ix]
else:
inds = []
for i in range(self.n_frames):
inds.append(ix + i)
images, depths, poses, intrinsics = [], [], [], []
fo_flows, ba_flows = [], []
fo_vals, ba_vals = [], []
gt_masks, gt_vals = [], []
segments = []
filename_list = []
for num, i in enumerate(inds):
images.append(self.__class__.image_read(images_list[i]))
if not self.only_pose:
depths.append(self.__class__.depth_read(depths_list[i]))
poses.append(poses_list[i])
intrinsics.append(intrinsics_list[i])
filename_list.append(images_list[i].rsplit('/')[-1])
if self.flow_label and num < len(inds)-1:
# 每组flow比图片少一项
f, v = self.__class__.flow_read(fo_flow_list[i])
fo_flows.append(f)
fo_vals.append(v)
f, v = self.__class__.flow_read(ba_flow_list[i])
ba_flows.append(f)
ba_vals.append(v)
if self.has_segm:
seg = self.__class__.segment_read(segments_list[i])
segments.append(seg)
if not self.flow_label :
if not self.only_pose:
mask, v = self.__class__.dymask_read(dymask_list[i])
gt_masks.append(mask)
gt_vals.append(v)
seg = self.__class__.segment_read(segments_list[i])
segments.append(seg)
images = np.stack(images).astype(np.float32)
if not self.only_pose:
depths = np.stack(depths).astype(np.float32)
poses = np.stack(poses).astype(np.float32)
intrinsics = np.stack(intrinsics).astype(np.float32)
if self.flow_label:
fo_flows = np.stack(fo_flows).astype(np.float32)
ba_flows = np.stack(ba_flows).astype(np.float32)
fo_flows = torch.from_numpy(fo_flows)
ba_flows = torch.from_numpy(ba_flows)
fo_vals = np.stack(fo_vals).astype(np.float32)
ba_vals = np.stack(ba_vals).astype(np.float32)
fo_vals = torch.from_numpy(fo_vals)
ba_vals = torch.from_numpy(ba_vals)
if self.has_segm:
segments = np.stack(segments).astype(np.float32)
segments = torch.from_numpy(segments)
else:
if not self.only_pose:
gt_masks = np.stack(gt_masks).astype(np.float32)
gt_masks = torch.from_numpy(gt_masks)
gt_vals = np.stack(gt_vals).astype(np.float32)
gt_vals = torch.from_numpy(gt_vals)
segments = np.stack(segments).astype(np.float32)
segments = torch.from_numpy(segments)
images = torch.from_numpy(images).float()
images = images.permute(0, 3, 1, 2)
if not self.only_pose:
disps = torch.from_numpy(1.0 / depths)
poses = torch.from_numpy(poses)
intrinsics = torch.from_numpy(intrinsics)
if self.only_pose:
return filename_list, images, poses, intrinsics
if self.aug is not None:
if self.flow_label:
fo_masks, ba_masks = self.build_motion_masks(poses, disps, intrinsics,
fo_flows, ba_flows)
# Only use when build dymasks' labels
if self.build_mask:
return fo_masks.unsqueeze(-1), ba_masks.unsqueeze(-1), \
fo_vals.unsqueeze(-1), ba_vals.unsqueeze(-1)
images, poses, disps, intrinsics, \
fo_flows, ba_flows, fo_masks, ba_masks = self.aug(images, poses, disps, intrinsics,
fo_flows, fo_vals, ba_flows, ba_vals,
fo_masks, ba_masks)
else:
images, poses, disps, intrinsics, \
gt_masks, gt_vals, segments = self.aug(images, poses, disps, intrinsics,
gt_masks=gt_masks, gt_vals=gt_vals,
segments=segments)
if len(disps[disps > 0.01]) > 0:
s = disps[disps > 0.01].mean()
disps = disps / s
poses[..., :3] *= s
if self.flow_label:
if self.has_segm:
return images, poses, disps, intrinsics, fo_flows, ba_flows, segments
else:
return images, poses, disps, intrinsics, fo_flows, ba_flows
else:
gt_masks, gt_vals = gt_masks.unsqueeze(-1), gt_vals.unsqueeze(-1)
if self.mode == 'sup':
return images, poses, disps, intrinsics, gt_masks, gt_vals
elif self.mode == 'semisup':
return filename_list, images, poses, disps, intrinsics, gt_masks, gt_vals, segments
elif self.mode == 'unsup':
return images, poses, disps, intrinsics
else:
raise Exception('ERROR: Unknown mode!')
def __len__(self):
return len(self.dataset_index)
def __imul__(self, x):
self.dataset_index *= x
return self
def build_motion_masks(self, poses, disps, intrinsics, fo_flows, ba_flows, thresh=0.5):
N, ht, wd = poses.shape[0], fo_flows.shape[1], fo_flows.shape[2]
graph = OrderedDict()
for i in range(N):
graph[i] = [j for j in range(N) if abs(i-j) == 1]
ii, jj, _ = graph_to_edge_list(graph)
poses, disps = poses.unsqueeze(0), disps.unsqueeze(0)
intrinsics = intrinsics.unsqueeze(0)
fo_flows, ba_flows = fo_flows.unsqueeze(0), ba_flows.unsqueeze(0)
# use w2c for vkitti2
poses = SE3(poses)
coords_cam, _ = projective_transform(poses, disps, intrinsics, ii, jj)
cam_flows = coords_cam - coords_grid(ht, wd, device=poses.device)
fo_masks = ((cam_flows[:, 0::2, ...] -
fo_flows[..., 0:2]).norm(dim=-1) <= thresh).float()
ba_masks = ((cam_flows[:, 1::2, ...] -
ba_flows[..., 0:2]).norm(dim=-1) <= thresh).float()
return fo_masks.squeeze(0), ba_masks.squeeze(0)
================================================
FILE: VO_Module/droid_slam/data_readers/factory.py
================================================
import pickle
import os
import os.path as osp
# RGBD-Dataset
from .tartan import TartanAir
from .replica import Replica
from .vkitti2 import VKitti2
from .stream import ImageStream
from .stream import StereoStream
from .stream import RGBDStream
# streaming datasets for inference
from .tartan import TartanAirStream
from .tartan import TartanAirTestStream
def dataset_factory(dataset_list, **kwargs):
""" create a combined dataset """
from torch.utils.data import ConcatDataset
dataset_map = {'tartan': (TartanAir, ),
'replica': (Replica, ),
'vkitti2': (VKitti2, ), }
db_list = []
for key in dataset_list:
# cache datasets for faster future loading
db = dataset_map[key][0](**kwargs)
print("Dataset {} has {} images".format(key, len(db)))
db_list.append(db)
return ConcatDataset(db_list)
def create_datastream(dataset_path, **kwargs):
""" create data_loader to stream images 1 by 1 """
from torch.utils.data import DataLoader
if osp.isfile(osp.join(dataset_path, 'calibration.txt')):
db = ETH3DStream(dataset_path, **kwargs)
elif osp.isdir(osp.join(dataset_path, 'image_left')):
db = TartanAirStream(dataset_path, **kwargs)
elif osp.isfile(osp.join(dataset_path, 'rgb.txt')):
db = TUMStream(dataset_path, **kwargs)
elif osp.isdir(osp.join(dataset_path, 'mav0')):
db = EurocStream(dataset_path, **kwargs)
elif osp.isfile(osp.join(dataset_path, 'calib.txt')):
db = KITTIStream(dataset_path, **kwargs)
else:
# db = TartanAirStream(dataset_path, **kwargs)
db = TartanAirTestStream(dataset_path, **kwargs)
stream = DataLoader(db, shuffle=False, batch_size=1, num_workers=4)
return stream
def create_imagestream(dataset_path, **kwargs):
""" create data_loader to stream images 1 by 1 """
from torch.utils.data import DataLoader
db = ImageStream(dataset_path, **kwargs)
return DataLoader(db, shuffle=False, batch_size=1, num_workers=4)
def create_stereostream(dataset_path, **kwargs):
""" create data_loader to stream images 1 by 1 """
from torch.utils.data import DataLoader
db = StereoStream(dataset_path, **kwargs)
return DataLoader(db, shuffle=False, batch_size=1, num_workers=4)
def create_rgbdstream(dataset_path, **kwargs):
""" create data_loader to stream images 1 by 1 """
from torch.utils.data import DataLoader
db = RGBDStream(dataset_path, **kwargs)
return DataLoader(db, shuffle=False, batch_size=1, num_workers=4)
================================================
FILE: VO_Module/droid_slam/data_readers/replica.py
================================================
import numpy as np
import torch
import glob
import cv2
import os
import os.path as osp
from lietorch import SE3
from .base import RGBDDataset
from .stream import RGBDStream
cur_path = osp.dirname(osp.abspath(__file__))
test_split = osp.join(cur_path, 'replica_test.txt')
test_split = open(test_split).read().split()
class Replica(RGBDDataset):
# scale depths to balance rot & trans
# Replica: 1.0 or even smaller?
DEPTH_SCALE = 1.0
def __init__(self, mode='training', **kwargs):
self.mode = mode
self.n_frames = 2
super(Replica, self).__init__(name='Replica', **kwargs)
@staticmethod
def is_test_scene(scene):
# print(scene, any(x in scene for x in test_split))
return any(x in scene for x in test_split)
def _build_dataset(self):
from tqdm import tqdm
print("Building Replica dataset")
scene_info = {}
scenes = glob.glob(osp.join(self.root, '*'))
for scene in tqdm(sorted(scenes)):
images = sorted(glob.glob(osp.join(scene, 'image_left/*.jpg')))
depths = sorted(glob.glob(osp.join(scene, 'depth_left/*.npy')))
poses = np.loadtxt(osp.join(scene, 'pose_left.txt'), delimiter=' ')
# tx,ty,tz,qx,qy,qz,qw
# poses = poses[:, [1, 2, 0, 4, 5, 3, 6]] # 交换是因为NED frame, 修改坐标轴
poses[:,:3] /= Replica.DEPTH_SCALE
intrinsics = [Replica.calib_read()] * len(images)
# graph of co-visible frames based on flow
graph = self.build_frame_graph(poses, depths, intrinsics)
scene = '/'.join(scene.split('/'))
scene_info[scene] = {'images': images, 'depths': depths,
'poses': poses, 'intrinsics': intrinsics, 'graph': graph}
return scene_info
@staticmethod
def calib_read():
return np.array([600.0, 600.0, 599.5, 339.5])
@staticmethod
def image_read(image_file):
return cv2.imread(image_file)
@staticmethod
def depth_read(depth_file):
depth = np.load(depth_file) / Replica.DEPTH_SCALE
depth[depth==np.nan] = 1.0
depth[depth==np.inf] = 1.0
return depth
class ReplicaStream(RGBDStream):
def __init__(self, datapath, **kwargs):
super(ReplicaStream, self).__init__(datapath=datapath, **kwargs)
def _build_dataset_index(self):
""" build list of images, poses, depths, and intrinsics """
self.root = 'datasets/Replica'
scene = osp.join(self.root, self.datapath)
image_glob = osp.join(scene, 'image_left/*.jpg')
images = sorted(glob.glob(image_glob))
poses = np.loadtxt(osp.join(scene, 'pose_left.txt'), delimiter=' ')
poses = poses[:, [1, 2, 0, 4, 5, 3, 6]]
poses = SE3(torch.as_tensor(poses))
poses = poses[[0]].inv() * poses
poses = poses.data.cpu().numpy()
intrinsic = self.calib_read(self.datapath)
intrinsics = np.tile(intrinsic[None], (len(images), 1))
self.images = images[::int(self.frame_rate)]
self.poses = poses[::int(self.frame_rate)]
self.intrinsics = intrinsics[::int(self.frame_rate)]
@staticmethod
def calib_read(datapath):
return np.array([600.0, 600.0, 599.5, 339.5])
@staticmethod
def image_read(image_file):
return cv2.imread(image_file)
class ReplicaTestStream(RGBDStream):
def __init__(self, datapath, **kwargs):
super(ReplicaStream, self).__init__(datapath=datapath, **kwargs)
def _build_dataset_index(self):
""" build list of images, poses, depths, and intrinsics """
self.root = 'datasets/mono'
image_glob = osp.join(self.root, self.datapath, '*.jpg')
images = sorted(glob.glob(image_glob))
poses = np.loadtxt(osp.join(self.root, 'mono_gt', self.datapath + '.txt'), delimiter=' ')
poses = poses[:, [1, 2, 0, 4, 5, 3, 6]]
poses = SE3(torch.as_tensor(poses))
poses = poses[[0]].inv() * poses
poses = poses.data.cpu().numpy()
intrinsic = self.calib_read(self.datapath)
intrinsics = np.tile(intrinsic[None], (len(images), 1))
self.images = images[::int(self.frame_rate)]
self.poses = poses[::int(self.frame_rate)]
self.intrinsics = intrinsics[::int(self.frame_rate)]
@staticmethod
def calib_read(datapath):
return np.array([600.0, 600.0, 599.5, 339.5])
@staticmethod
def image_read(image_file):
return cv2.imread(image_file)
================================================
FILE: VO_Module/droid_slam/data_readers/replica_test.txt
================================================
room1
office1
room2
office2
office3
office4
================================================
FILE: VO_Module/droid_slam/data_readers/replica_utils.py
================================================
from scipy.spatial.transform import Rotation as R
import numpy as np
import glob
import imageio
import os.path as osp
def get_replica_cam_list(cam_list_dir, base_dir):
"""
direactly get cam matrix
"""
cam_list = []
with open(osp.join(base_dir, cam_list_dir), 'r') as f:
for line in f.readlines():
if line[0] == '#':
continue
data = line.strip('\n').split(' ')
cam_mat = np.array([float(x) for x in data[:-4]]).reshape(3, 4)
cam_list.append(cam_mat)
return cam_list
def quat_to_rmat(quat):
"""
input:
quat 四元数
list/numpy
output:
rot matrix 旋转矩阵
numpy mat
using numpy
"""
r = R.from_quat(quat)
mat = r.as_matrix()
return mat
def rmat_to_quad(mat):
r = R.from_matrix(mat)
quat = r.as_quat()
return quat
def get_trajectories_quad(cam_list, norm_val=1):
trajectories = []
for cam in cam_list:
if not isinstance(cam, np.ndarray):
np_cam = cam.detach().cpu().numpy()
else:
np_cam = cam
np_cam[:3] /= norm_val
trajectories.append(np_cam)
return trajectories
def get_trajectories_mat(cam_list, norm_val=1):
trajectories = []
for cam in cam_list:
if not isinstance(cam, np.ndarray):
np_cam = cam.detach().cpu().numpy()
else:
np_cam = cam
rot_mat = np_cam[:, 0:3]
t_vec = np_cam[:, 3]/norm_val
quad = rmat_to_quad(rot_mat)
trajectories.append(np.append(t_vec, quad))
return trajectories
def build_track_pred_file(gt_time_dir, pred_dir, trajectories, keyframe_freq=1):
time_stamp = []
with open(gt_time_dir, 'r') as f:
for line in f.readlines():
if line[0] == '#':
continue
time_stamp.append(line.strip('\n').split(' ')[0])
# time_stamp = time_stamp[::keyframe_freq]
trajectories = trajectories[::keyframe_freq]
cnt = min(len(trajectories), len(time_stamp))
with open(pred_dir, 'w') as f:
for i in range(cnt):
data = ''
for j in range(7):
data += (' '+str(trajectories[i][j]))
data = time_stamp[i]+data+'\n'
f.write(data)
def build_track_pred_file_notime(pred_dir, trajectories, keyframe_freq=1):
trajectories = trajectories[::keyframe_freq]
cnt = len(trajectories)
with open(pred_dir, 'w') as f:
for i in range(cnt):
s = []
for j in range(7):
s.append(str(trajectories[i][j]))
data = ' '.join(s)
data = data+'\n'
f.write(data)
def build_timestamps(file_dir, time_num, interval=0.05):
cur_time = 0.
with open(file_dir, 'w') as f:
for _ in range(time_num):
s = str(cur_time)+'\n'
cur_time += interval
f.write(s)
def build_depth_npy(root_dir, scene_dir, dep_scale):
depths = glob.glob(osp.join(root_dir, scene_dir, 'depth_left/*.png'))
for dep in depths:
dep_np = imageio.imread(dep)
dep_np = dep_np.astype(np.float32)
dep_np /= dep_scale
dep_np[dep_np == 0] = 1
npy_dir = dep.split('.')[0]+'.npy'
np.save(npy_dir, dep_np)
if __name__ == '__main__':
root_dir = 'datasets/Replica'
scene_dir = 'office4'
# cam_list = get_replica_cam_list('traj.txt', osp.join(root_dir, scene_dir))
# gt_traj = get_trajectories_mat(cam_list)
# build_track_pred_file_notime(osp.join(root_dir, scene_dir, 'pose_left.txt'),
# gt_traj, 1)
# timestamps_dir = osp.join(root_dir, scene_dir, 'timestamp.txt')
# build_timestamps(timestamps_dir, 2000, 0.025)
# build_track_pred_file(timestamps_dir, osp.join(root_dir, scene_dir, 'pose_left_tum.txt'),
# gt_traj, 1)
# dep_scale = 6553.5
# build_depth_npy(root_dir, scene_dir, dep_scale)
mat = np.array([-3.205696220032456800e-01, 4.480551946958012954e-01, -8.345547674986967257e-01, 3.452987416406734678e+00,
9.472249560947475500e-01, 1.516354520391845484e-01, -
2.824386167580063001e-01, 4.546110134135947223e-01,
1.078977932490423164e-16, -8.810523436158487209e-01, -
4.730187816662466682e-01, 5.936285447159415085e-01,
0.000000000000000000e+00, 0.000000000000000000e+00, 0.000000000000000000e+00, 1.000000000000000000e+00,
]).reshape(4, 4)
mat2 = mat.copy()
mats = np.stack([mat, mat2], axis=0)
quads = rmat_to_quad(mats[:, 0:3, 0:3])
print(quads.shape)
================================================
FILE: VO_Module/droid_slam/data_readers/rgbd_utils.py
================================================
import numpy as np
import os.path as osp
import torch
from lietorch import SE3
import geom.projective_ops as pops
from scipy.spatial.transform import Rotation
def parse_list(filepath, skiprows=0):
""" read list data """
data = np.loadtxt(filepath, delimiter=' ',
dtype=np.unicode_, skiprows=skiprows)
return data
def associate_frames(tstamp_image, tstamp_depth, tstamp_pose, max_dt=1.0):
""" pair images, depths, and poses """
associations = []
for i, t in enumerate(tstamp_image):
if tstamp_pose is None:
j = np.argmin(np.abs(tstamp_depth - t))
if (np.abs(tstamp_depth[j] - t) < max_dt):
associations.append((i, j))
else:
j = np.argmin(np.abs(tstamp_depth - t))
k = np.argmin(np.abs(tstamp_pose - t))
if (np.abs(tstamp_depth[j] - t) < max_dt) and \
(np.abs(tstamp_pose[k] - t) < max_dt):
associations.append((i, j, k))
return associations
def loadtum(datapath, frame_rate=-1):
""" read video data in tum-rgbd format """
if osp.isfile(osp.join(datapath, 'groundtruth.txt')):
pose_list = osp.join(datapath, 'groundtruth.txt')
elif osp.isfile(osp.join(datapath, 'pose.txt')):
pose_list = osp.join(datapath, 'pose.txt')
else:
return None, None, None, None
image_list = osp.join(datapath, 'rgb.txt')
depth_list = osp.join(datapath, 'depth.txt')
calib_path = osp.join(datapath, 'calibration.txt')
intrinsic = None
if osp.isfile(calib_path):
intrinsic = np.loadtxt(calib_path, delimiter=' ')
intrinsic = intrinsic.astype(np.float64)
image_data = parse_list(image_list)
depth_data = parse_list(depth_list)
pose_data = parse_list(pose_list, skiprows=1)
pose_vecs = pose_data[:, 1:].astype(np.float64)
tstamp_image = image_data[:, 0].astype(np.float64)
tstamp_depth = depth_data[:, 0].astype(np.float64)
tstamp_pose = pose_data[:, 0].astype(np.float64)
associations = associate_frames(tstamp_image, tstamp_depth, tstamp_pose)
# print(len(tstamp_image))
# print(len(associations))
indicies = range(len(associations))[::5]
# indicies = [ 0 ]
# for i in range(1, len(associations)):
# t0 = tstamp_image[associations[indicies[-1]][0]]
# t1 = tstamp_image[associations[i][0]]
# if t1 - t0 > 1.0 / frame_rate:
# indicies += [ i ]
images, poses, depths, intrinsics, tstamps = [], [], [], [], []
for ix in indicies:
(i, j, k) = associations[ix]
images += [osp.join(datapath, image_data[i, 1])]
depths += [osp.join(datapath, depth_data[j, 1])]
poses += [pose_vecs[k]]
tstamps += [tstamp_image[i]]
if intrinsic is not None:
intrinsics += [intrinsic]
return images, depths, poses, intrinsics, tstamps
def all_pairs_distance_matrix(poses, beta=2.5):
""" compute distance matrix between all pairs of poses """
poses = np.array(poses, dtype=np.float32)
poses[:, :3] *= beta # scale to balence rot + trans
poses = SE3(torch.from_numpy(poses))
r = (poses[:, None].inv() * poses[None, :]).log()
return r.norm(dim=-1).cpu().numpy()
def pose_matrix_to_quaternion(pose):
""" convert 4x4 pose matrix to (t, q) """
q = Rotation.from_matrix(pose[:3, :3]).as_quat()
return np.concatenate([pose[:3, 3], q], axis=0)
def compute_distance_matrix_flow(poses, disps, intrinsics, need_inv=True):
""" compute flow magnitude between all pairs of frames """
if not isinstance(poses, SE3):
poses = torch.from_numpy(poses).float().cuda()[None]
if need_inv:
poses = SE3(poses).inv()
else:
poses = SE3(poses)
disps = torch.from_numpy(disps).float().cuda()[None]
intrinsics = torch.from_numpy(intrinsics).float().cuda()[None]
N = poses.shape[1]
ii, jj = torch.meshgrid(torch.arange(N), torch.arange(N))
ii = ii.reshape(-1).cuda()
jj = jj.reshape(-1).cuda()
MAX_FLOW = 100.0
matrix = np.zeros((N, N), dtype=np.float32)
s = 2048
for i in range(0, ii.shape[0], s):
flow1, val1 = pops.induced_flow(
poses, disps, intrinsics, ii[i:i+s], jj[i:i+s])
flow2, val2 = pops.induced_flow(
poses, disps, intrinsics, jj[i:i+s], ii[i:i+s])
flow = torch.stack([flow1, flow2], dim=2)
val = torch.stack([val1, val2], dim=2)
mag = flow.norm(dim=-1).clamp(max=MAX_FLOW)
mag = mag.view(mag.shape[1], -1)
val = val.view(val.shape[1], -1)
mag = (mag * val).mean(-1) / val.mean(-1)
mag[val.mean(-1) < 0.7] = np.inf
i1 = ii[i:i+s].cpu().numpy()
j1 = jj[i:i+s].cpu().numpy()
matrix[i1, j1] = mag.cpu().numpy()
return matrix
def compute_distance_matrix_flow2(poses, disps, intrinsics, beta=0.4):
""" compute flow magnitude between all pairs of frames """
# if not isinstance(poses, SE3):
# poses = torch.from_numpy(poses).float().cuda()[None]
# poses = SE3(poses).inv()
# disps = torch.from_numpy(disps).float().cuda()[None]
# intrinsics = torch.from_numpy(intrinsics).float().cuda()[None]
N = poses.shape[1]
ii, jj = torch.meshgrid(torch.arange(N), torch.arange(N))
ii = ii.reshape(-1)
jj = jj.reshape(-1)
MAX_FLOW = 128.0
matrix = np.zeros((N, N), dtype=np.float32)
s = 2048
for i in range(0, ii.shape[0], s):
flow1a, val1a = pops.induced_flow(
poses, disps, intrinsics, ii[i:i+s], jj[i:i+s], tonly=True)
flow1b, val1b = pops.induced_flow(
poses, disps, intrinsics, ii[i:i+s], jj[i:i+s])
flow2a, val2a = pops.induced_flow(
poses, disps, intrinsics, jj[i:i+s], ii[i:i+s], tonly=True)
flow2b, val2b = pops.induced_flow(
poses, disps, intrinsics, ii[i:i+s], jj[i:i+s])
flow1 = flow1a + beta * flow1b
val1 = val1a * val2b
flow2 = flow2a + beta * flow2b
val2 = val2a * val2b
flow = torch.stack([flow1, flow2], dim=2)
val = torch.stack([val1, val2], dim=2)
mag = flow.norm(dim=-1).clamp(max=MAX_FLOW)
mag = mag.view(mag.shape[1], -1)
val = val.view(val.shape[1], -1)
mag = (mag * val).mean(-1) / val.mean(-1)
mag[val.mean(-1) < 0.8] = np.inf
i1 = ii[i:i+s].cpu().numpy()
j1 = jj[i:i+s].cpu().numpy()
matrix[i1, j1] = mag.cpu().numpy()
return matrix
================================================
FILE: VO_Module/droid_slam/data_readers/stream.py
================================================
import numpy as np
import torch
import torch.utils.data as data
import torch.nn.functional as F
import csv
import os
import cv2
import math
import random
import json
import pickle
import os.path as osp
from .rgbd_utils import *
class RGBDStream(data.Dataset):
def __init__(self, datapath, frame_rate=-1, image_size=[384,512], crop_size=[0,0]):
self.datapath = datapath
self.frame_rate = frame_rate
self.image_size = image_size
self.crop_size = crop_size
self._build_dataset_index()
@staticmethod
def image_read(image_file):
return cv2.imread(image_file)
@staticmethod
def depth_read(depth_file):
return np.load(depth_file)
def __len__(self):
return len(self.images)
def __getitem__(self, index):
""" return training video """
image = self.__class__.image_read(self.images[index])
image = torch.from_numpy(image).float()
image = image.permute(2, 0, 1)
try:
tstamp = self.tstamps[index]
except:
tstamp = index
pose = torch.from_numpy(self.poses[index]).float()
intrinsic = torch.from_numpy(self.intrinsics[index]).float()
# resize image
sx = self.image_size[1] / image.shape[2]
sy = self.image_size[0] / image.shape[1]
image = F.interpolate(image[None], self.image_size, mode='bilinear', align_corners=False)[0]
fx, fy, cx, cy = intrinsic.unbind(dim=0)
fx, cx = sx * fx, sx * cx
fy, cy = sy * fy, sy * cy
# crop image
if self.crop_size[0] > 0:
cy = cy - self.crop_size[0]
image = image[:,self.crop_size[0]:-self.crop_size[0],:]
if self.crop_size[1] > 0:
cx = cx - self.crop_size[1]
image = image[:,:,self.crop_size[1]:-self.crop_size[1]]
intrinsic = torch.stack([fx, fy, cx, cy])
return tstamp, image, pose, intrinsic
class ImageStream(data.Dataset):
def __init__(self, datapath, intrinsics, rate=1, image_size=[384,512]):
rgb_list = osp.join(datapath, 'rgb.txt')
if os.path.isfile(rgb_list):
rgb_list = np.loadtxt(rgb_list, delimiter=' ', dtype=np.unicode_)
self.timestamps = rgb_list[:,0].astype(np.float)
self.images = [os.path.join(datapath, x) for x in rgb_list[:,1]]
self.images = self.images[::rate]
self.timestamps = self.timestamps[::rate]
else:
import glob
self.images = sorted(glob.glob(osp.join(datapath, '*.jpg'))) + sorted(glob.glob(osp.join(datapath, '*.png')))
self.images = self.images[::rate]
self.intrinsics = intrinsics
self.image_size = image_size
def __len__(self):
return len(self.images)
@staticmethod
def image_read(imfile):
return cv2.imread(imfile)
def __getitem__(self, index):
""" return training video """
image = self.__class__.image_read(self.images[index])
try:
tstamp = self.timestamps[index]
except:
tstamp = index
ht0, wd0 = image.shape[:2]
ht1, wd1 = self.image_size
intrinsics = torch.as_tensor(self.intrinsics)
intrinsics[0] *= wd1 / wd0
intrinsics[1] *= ht1 / ht0
intrinsics[2] *= wd1 / wd0
intrinsics[3] *= ht1 / ht0
# resize image
ikwargs = {'mode': 'bilinear', 'align_corners': True}
image = torch.from_numpy(image).float().permute(2, 0, 1)
image = F.interpolate(image[None], self.image_size, **ikwargs)[0]
return tstamp, image, intrinsics
class StereoStream(data.Dataset):
def __init__(self, datapath, intrinsics, rate=1, image_size=[384,512],
map_left=None, map_right=None, left_root='image_left', right_root='image_right'):
import glob
self.intrinsics = intrinsics
self.image_size = image_size
imgs = sorted(glob.glob(osp.join(datapath, left_root, '*.png')))[::rate]
self.images_l = []
self.images_r = []
self.tstamps = []
for img_l in imgs:
img_r = img_l.replace(left_root, right_root)
if os.path.isfile(img_r):
t = np.float(img_l.split('/')[-1].replace('.png', ''))
self.tstamps.append(t)
self.images_l += [ img_l ]
self.images_r += [ img_r ]
self.map_left = map_left
self.map_right = map_right
def __len__(self):
return len(self.images_l)
@staticmethod
def image_read(imfile, imap=None):
image = cv2.imread(imfile)
if imap is not None:
image = cv2.remap(image, imap[0], imap[1], interpolation=cv2.INTER_LINEAR)
return image
def __getitem__(self, index):
""" return training video """
tstamp = self.tstamps[index]
image_l = self.__class__.image_read(self.images_l[index], self.map_left)
image_r = self.__class__.image_read(self.images_r[index], self.map_right)
ht0, wd0 = image_l.shape[:2]
ht1, wd1 = self.image_size
intrinsics = torch.as_tensor(self.intrinsics)
intrinsics[0] *= wd1 / wd0
intrinsics[1] *= ht1 / ht0
intrinsics[2] *= wd1 / wd0
intrinsics[3] *= ht1 / ht0
image_l = torch.from_numpy(image_l).float().permute(2, 0, 1)
image_r = torch.from_numpy(image_r).float().permute(2, 0, 1)
# resize image
ikwargs = {'mode': 'bilinear', 'align_corners': True}
image_l = F.interpolate(image_l[None], self.image_size, **ikwargs)[0]
image_r = F.interpolate(image_r[None], self.image_size, **ikwargs)[0]
return tstamp, image_l, image_r, intrinsics
# class RGBDStream(data.Dataset):
# def __init__(self, datapath, intrinsics=None, rate=1, image_size=[384,512]):
# assoc_file = osp.join(datapath, 'associated.txt')
# assoc_list = np.loadtxt(assoc_file, delimiter=' ', dtype=np.unicode_)
# self.intrinsics = intrinsics
# self.image_size = image_size
# self.timestamps = assoc_list[:,0].astype(np.float)[::rate]
# self.images = [os.path.join(datapath, x) for x in assoc_list[:,1]][::rate]
# self.depths = [os.path.join(datapath, x) for x in assoc_list[:,3]][::rate]
# def __len__(self):
# return len(self.images)
# @staticmethod
# def image_read(imfile):
# return cv2.imread(imfile)
# @staticmethod
# def depth_read(depth_file):
# depth = cv2.imread(depth_file, cv2.IMREAD_ANYDEPTH)
# return depth.astype(np.float32) / 5000.0
# def __getitem__(self, index):
# """ return training video """
# tstamp = self.timestamps[index]
# image = self.__class__.image_read(self.images[index])
# depth = self.__class__.depth_read(self.depths[index])
# ht0, wd0 = image.shape[:2]
# ht1, wd1 = self.image_size
# intrinsics = torch.as_tensor(self.intrinsics)
# intrinsics[0] *= wd1 / wd0
# intrinsics[1] *= ht1 / ht0
# intrinsics[2] *= wd1 / wd0
# intrinsics[3] *= ht1 / ht0
# # resize image
# ikwargs = {'mode': 'bilinear', 'align_corners': True}
# image = torch.from_numpy(image).float().permute(2, 0, 1)
# image = F.interpolate(image[None], self.image_size, **ikwargs)[0]
# depth = torch.from_numpy(depth).float()[None,None]
# depth = F.interpolate(depth, self.image_size, mode='nearest').squeeze()
# return tstamp, image, depth, intrinsics
================================================
FILE: VO_Module/droid_slam/data_readers/tartan.py
================================================
import numpy as np
import torch
import glob
import cv2
import os
import os.path as osp
from lietorch import SE3
from .base import RGBDDataset
from .stream import RGBDStream
cur_path = osp.dirname(osp.abspath(__file__))
test_split = osp.join(cur_path, 'tartan_test.txt')
test_split = open(test_split).read().split()
class TartanAir(RGBDDataset):
# scale depths to balance rot & trans
DEPTH_SCALE = 5.0
def __init__(self, mode='training', **kwargs):
self.mode = mode
self.n_frames = 2
super(TartanAir, self).__init__(name='TartanAir', **kwargs)
@staticmethod
def is_test_scene(scene):
# print(scene, any(x in scene for x in test_split))
return any(x in scene for x in test_split)
def _build_dataset(self):
from tqdm import tqdm
print("Building TartanAir dataset")
scene_info = {}
scenes = glob.glob(osp.join(self.root, '*/*/*/*'))
for scene in tqdm(sorted(scenes)):
# [:-1]为了与mask对齐
images = sorted(
glob.glob(osp.join(scene, 'image_left/*.png')))[:-1]
depths = sorted(
glob.glob(osp.join(scene, 'depth_left/*.npy')))[:-1]
poses = np.loadtxt(
osp.join(scene, 'pose_left.txt'), delimiter=' ')
poses = poses[:-1, [1, 2, 0, 4, 5, 3, 6]]
poses[:, :3] /= TartanAir.DEPTH_SCALE
intrinsics = [TartanAir.calib_read()] * len(images)
# graph of co-visible frames based on flow
graph = self.build_frame_graph(poses, depths, intrinsics)
masks = sorted(glob.glob(osp.join(scene, 'flow/*mask.npy')))
scene = '/'.join(scene.split('/'))
scene_info[scene] = {'images': images, 'depths': depths, 'dymasks': masks,
'poses': poses, 'intrinsics': intrinsics, 'graph': graph}
return scene_info
@staticmethod
def calib_read():
return np.array([320.0, 320.0, 320.0, 240.0])
@staticmethod
def image_read(image_file):
return cv2.imread(image_file)
@staticmethod
def depth_read(depth_file):
depth = np.load(depth_file) / TartanAir.DEPTH_SCALE
depth[depth == np.nan] = 1.0
depth[depth == np.inf] = 1.0
return depth
@staticmethod
def dymask_read(mask_file):
content1 = (np.load(mask_file) <= 0).astype(np.float32)
content2 = np.ones_like(content1)
return content1, content2
class TartanAirStream(RGBDStream):
def __init__(self, datapath, **kwargs):
super(TartanAirStream, self).__init__(datapath=datapath, **kwargs)
def _build_dataset_index(self):
""" build list of images, poses, depths, and intrinsics """
self.root = 'datasets/TartanAir'
scene = osp.join(self.root, self.datapath)
image_glob = osp.join(scene, 'image_left/*.png')
images = sorted(glob.glob(image_glob))
poses = np.loadtxt(osp.join(scene, 'pose_left.txt'), delimiter=' ')
poses = poses[:, [1, 2, 0, 4, 5, 3, 6]]
poses = SE3(torch.as_tensor(poses))
poses = poses[[0]].inv() * poses
poses = poses.data.cpu().numpy()
intrinsic = self.calib_read(self.datapath)
intrinsics = np.tile(intrinsic[None], (len(images), 1))
self.images = images[::int(self.frame_rate)]
self.poses = poses[::int(self.frame_rate)]
self.intrinsics = intrinsics[::int(self.frame_rate)]
@staticmethod
def calib_read(datapath):
return np.array([320.0, 320.0, 320.0, 240.0])
@staticmethod
def image_read(image_file):
return cv2.imread(image_file)
class TartanAirTestStream(RGBDStream):
def __init__(self, datapath, **kwargs):
super(TartanAirTestStream, self).__init__(datapath=datapath, **kwargs)
def _build_dataset_index(self):
""" build list of images, poses, depths, and intrinsics """
self.root = 'datasets/mono'
image_glob = osp.join(self.root, self.datapath, '*.png')
images = sorted(glob.glob(image_glob))
poses = np.loadtxt(osp.join(self.root, 'mono_gt',
self.datapath + '.txt'), delimiter=' ')
poses = poses[:, [1, 2, 0, 4, 5, 3, 6]]
poses = SE3(torch.as_tensor(poses))
poses = poses[[0]].inv() * poses
poses = poses.data.cpu().numpy()
intrinsic = self.calib_read(self.datapath)
intrinsics = np.tile(intrinsic[None], (len(images), 1))
self.images = images[::int(self.frame_rate)]
self.poses = poses[::int(self.frame_rate)]
self.intrinsics = intrinsics[::int(self.frame_rate)]
@staticmethod
def calib_read(datapath):
return np.array([320.0, 320.0, 320.0, 240.0])
@staticmethod
def image_read(image_file):
return cv2.imread(image_file)
================================================
FILE: VO_Module/droid_slam/data_readers/tartan_test.txt
================================================
abandonedfactory/abandonedfactory/Easy/P011
abandonedfactory/abandonedfactory/Hard/P011
abandonedfactory_night/abandonedfactory_night/Easy/P013
abandonedfactory_night/abandonedfactory_night/Hard/P014
amusement/amusement/Easy/P008
amusement/amusement/Hard/P007
carwelding/carwelding/Easy/P007
endofworld/endofworld/Easy/P009
gascola/gascola/Easy/P008
gascola/gascola/Hard/P009
hospital/hospital/Easy/P036
hospital/hospital/Hard/P049
japanesealley/japanesealley/Easy/P007
japanesealley/japanesealley/Hard/P005
neighborhood/neighborhood/Easy/P021
neighborhood/neighborhood/Hard/P017
ocean/ocean/Easy/P013
ocean/ocean/Hard/P009
office2/office2/Easy/P011
office2/office2/Hard/P010
office/office/Hard/P007
oldtown/oldtown/Easy/P007
oldtown/oldtown/Hard/P008
seasidetown/seasidetown/Easy/P009
seasonsforest/seasonsforest/Easy/P011
seasonsforest/seasonsforest/Hard/P006
seasonsforest_winter/seasonsforest_winter/Easy/P009
seasonsforest_winter/seasonsforest_winter/Hard/P018
soulcity/soulcity/Easy/P012
soulcity/soulcity/Hard/P009
westerndesert/westerndesert/Easy/P013
westerndesert/westerndesert/Hard/P007
================================================
FILE: VO_Module/droid_slam/data_readers/vkitti2.py
================================================
import numpy as np
import torch
import glob
import cv2
import os
import os.path as osp
from scipy.spatial.transform import Rotation as R
from lietorch import SE3
from torch.functional import split
from .base import RGBDDataset
from .stream import RGBDStream
from panopticapi.utils import rgb2id
import PIL.Image as Image
def rmat_to_quad(mat):
r = R.from_matrix(mat)
quat = r.as_quat()
return quat
class VKitti2(RGBDDataset):
# scale depths to balance rot & trans
DEPTH_SCALE = 5.0
split = {
'train': 'clone',
'val': '15-deg-left',
'test': '30-deg-right'
}
scenes = ['Scene18', 'Scene20' , 'Scene06', 'Scene02', 'Scene01']
print(scenes)
def __init__(self, split_mode='train', foo=False, scene_id='Scene01', **kwargs):
self.split_mode = split_mode
self.n_frames = 2
self.foo = foo
self.test_split = [x for x in VKitti2.scenes if x != scene_id]
super(VKitti2, self).__init__(name='VKitti2', **kwargs)
# @staticmethod
def is_test_scene(self, scene):
return any(x in scene for x in self.test_split)
def _build_dataset(self):
from tqdm import tqdm
print("Building VKitti2 dataset")
scenes = VKitti2.scenes
scene_info = {}
for scene in tqdm(sorted(scenes)):
scene = osp.join(self.root, scene)
images = sorted(
glob.glob(osp.join(scene, VKitti2.split[self.split_mode], 'frames/rgb/Camera_0/*.jpg')))
depths = sorted(
glob.glob(osp.join( scene, VKitti2.split[self.split_mode], 'frames/depth/Camera_0/*.png')))
poses = np.loadtxt(
osp.join(scene, VKitti2.split[self.split_mode], 'extrinsic.txt'), delimiter=' ', skiprows=1)[::2, 2:]
if self.foo:
images = np.array(images)
depths = np.array(depths)
val_num = images.shape[0] // 7
train_num = images.shape[0] - val_num - val_num
print(val_num,'\n',images[train_num], "\n", images[train_num+val_num-1])
images = images[train_num:train_num + val_num]
depths = depths[train_num:train_num + val_num]
poses = poses[train_num:train_num + val_num]
print(poses.shape)
images.tolist()
depths.tolist()
poses = poses.reshape(-1, 4, 4)
r = rmat_to_quad(poses[:, 0:3, 0:3])
t = poses[:, :3, 3] / VKitti2.DEPTH_SCALE
poses = np.concatenate((t, r), axis=1)
intrinsics = [VKitti2.calib_read()] * len(images)
scene = '/'.join(scene.split('/'))
# graph of co-visible frames based on flow
graph = None
if self.aug_graph:
graph = self.build_frame_graph(poses, depths, intrinsics)
if self.flow_label:
fo_flows = sorted(
glob.glob(osp.join(scene, VKitti2.split[self.split_mode], 'frames/forwardFlow/Camera_0/*.png')))
ba_flows = sorted(
glob.glob(osp.join(scene, VKitti2.split[self.split_mode], 'frames/backwardFlow/Camera_0/*.png')))
segments = sorted(
glob.glob(osp.join(scene, VKitti2.split[self.split_mode], 'panoptic_gt_id/*.png')))
scene_info[scene] = {'images': images, 'depths': depths, 'fo_flows': fo_flows,
'ba_flows': ba_flows, 'poses': poses, 'intrinsics': intrinsics, 'segments' : segments}
else:
masks = sorted(
glob.glob(osp.join(scene, VKitti2.split[self.split_mode], 'frames/dynamicMask/Camera_0/*.npy')))
segments = sorted(
glob.glob(osp.join(scene, VKitti2.split[self.split_mode], 'panFPN_segm/*.png')))
scene_info[scene] = {'images': images, 'depths': depths, 'dymasks': masks,
'poses': poses, 'intrinsics': intrinsics, 'graph': graph, 'segments': segments, }
print('segments' in scene_info[scene])
return scene_info
@staticmethod
def calib_read():
return np.array([725.0087, 725.0087, 620.5, 187])
@staticmethod
def image_read(image_file):
return cv2.imread(image_file)
@staticmethod
def depth_read(depth_file):
depth = cv2.imread(depth_file, cv2.IMREAD_ANYCOLOR |
cv2.IMREAD_ANYDEPTH) / (VKitti2.DEPTH_SCALE*100)
depth[depth == np.nan] = 1.0
depth[depth == np.inf] = 1.0
depth[depth == 0] = 1.0
return depth
@staticmethod
def flow_read(flow_file):
bgr = cv2.imread(flow_file, cv2.IMREAD_ANYCOLOR | cv2.IMREAD_ANYDEPTH)
h, w, _c = bgr.shape
out_flow = 2.0 / (2**16 - 1.0) * bgr[..., 2:0:-1].astype('f4') - 1
out_flow[..., 0] *= w - 1
out_flow[..., 1] *= h - 1
val = (bgr[..., 0] > 0).astype(np.float32)
return out_flow, val
@staticmethod
def dymask_read(mask_file):
content = np.load(mask_file)
return content[..., 0], content[..., 1]
@staticmethod
def segment_read(segment_file):
segment = rgb2id(np.array(Image.open(segment_file)))
return segment
class VKitti2Stream(RGBDStream):
def __init__(self, datapath, **kwargs):
super(VKitti2Stream, self).__init__(datapath=datapath, **kwargs)
def _build_dataset_index(self):
""" build list of images, poses, depths, and intrinsics """
self.root = 'datasets/VKitti2'
scene = osp.join(self.root, self.datapath)
image_glob = osp.join(scene, 'image_left/*.png')
images = sorted(glob.glob(image_glob))
poses = np.loadtxt(osp.join(scene, 'pose_left.txt'), delimiter=' ')
poses = poses[:, [1, 2, 0, 4, 5, 3, 6]]
poses = SE3(torch.as_tensor(poses))
poses = poses[[0]].inv() * poses
poses = poses.data.cpu().numpy()
intrinsic = self.calib_read(self.datapath)
intrinsics = np.tile(intrinsic[None], (len(images), 1))
self.images = images[::int(self.frame_rate)]
self.poses = poses[::int(self.frame_rate)]
self.intrinsics = intrinsics[::int(self.frame_rate)]
@staticmethod
def calib_read(datapath):
return np.array([320.0, 320.0, 320.0, 240.0])
@staticmethod
def image_read(image_file):
return cv2.imread(image_file)
class VKitti2TestStream(RGBDStream):
def __init__(self, datapath, **kwargs):
super(VKitti2TestStream, self).__init__(datapath=datapath, **kwargs)
def _build_dataset_index(self):
""" build list of images, poses, depths, and intrinsics """
self.root = 'datasets/mono'
image_glob = osp.join(self.root, self.datapath, '*.png')
images = sorted(glob.glob(image_glob))
poses = np.loadtxt(osp.join(self.root, 'mono_gt',
self.datapath + '.txt'), delimiter=' ')
poses = poses[:, [1, 2, 0, 4, 5, 3, 6]]
poses = SE3(torch.as_tensor(poses))
poses = poses[[0]].inv() * poses
poses = poses.data.cpu().numpy()
intrinsic = self.calib_read(self.datapath)
intrinsics = np.tile(intrinsic[None], (len(images), 1))
self.images = images[::int(self.frame_rate)]
self.poses = poses[::int(self.frame_rate)]
self.intrinsics = intrinsics[::int(self.frame_rate)]
@staticmethod
def calib_read(datapath):
return np.array([320.0, 320.0, 320.0, 240.0])
@staticmethod
def image_read(image_file):
return cv2.imread(image_file)
================================================
FILE: VO_Module/droid_slam/depth_video.py
================================================
import numpy as np
import torch
import lietorch
import droid_backends
from torch.multiprocessing import Process, Queue, Lock, Value
from collections import OrderedDict
from droid_net import cvx_upsample
import geom.projective_ops as pops
from geom.ba import BA
from lietorch import SO3, SE3, Sim3
class DepthVideo:
def __init__(self, image_size=[480, 640], buffer=1024, device="cuda:0", segm_filter=False, thresh=0.8):
# current keyframe count
self.counter = Value('i', 0)
self.ready = Value('i', 0)
self.ht = ht = image_size[0]
self.wd = wd = image_size[1]
self.device = device
### state attributes ###
self.tstamp = torch.zeros(
buffer, device=device, dtype=torch.float).share_memory_()
self.images = torch.zeros(
buffer, 3, ht, wd, device=device, dtype=torch.uint8)
self.dirty = torch.zeros(
buffer, device=device, dtype=torch.bool).share_memory_()
self.red = torch.zeros(buffer, device=device,
dtype=torch.bool).share_memory_()
self.poses = torch.zeros(
buffer, 7, device=device, dtype=torch.float).share_memory_()
self.disps = torch.ones(
buffer, ht//8, wd//8, device=device, dtype=torch.float).share_memory_()
self.disps_up = torch.zeros(
buffer, ht, wd, device=device, dtype=torch.float).share_memory_()
self.intrinsics = torch.zeros(
buffer, 4, device=device, dtype=torch.float).share_memory_()
### feature attributes ###
self.fmaps = torch.zeros(
buffer, 128, ht//8, wd//8, dtype=torch.half, device=device).share_memory_()
self.nets = torch.zeros(
buffer, 128, ht//8, wd//8, dtype=torch.half, device=device).share_memory_()
self.inps = torch.zeros(
buffer, 128, ht//8, wd//8,dtype=torch.half, device=device).share_memory_()
# initialize poses to identity transformation
self.poses[:] = torch.as_tensor(
[0, 0, 0, 0, 0, 0, 1], dtype=torch.float, device=device)
# new adding
self.segms = torch.zeros(
buffer, 1, ht//8, wd//8,dtype=torch.int, device=device).share_memory_()
self.full_flow = torch.ones(
buffer, ht//8, wd//8, 2,device=device, dtype=torch.float).share_memory_()
self.segm_filter = segm_filter
self.thresh = thresh
def get_lock(self):
return self.counter.get_lock()
def __item_setter(self, index, item):
if isinstance(index, int) and index >= self.counter.value:
self.counter.value = index + 1
elif isinstance(index, torch.Tensor) and index.max().item() > self.counter.value:
self.counter.value = index.max().item() + 1
# self.dirty[index] = True
self.tstamp[index] = item[0]
self.images[index] = item[1]
if item[2] is not None:
self.poses[index] = item[2]
if item[3] is not None:
self.disps[index] = item[3]
if item[4] is not None:
self.intrinsics[index] = item[4]
if len(item) > 5:
self.fmaps[index] = item[5]
if len(item) > 6:
self.nets[index] = item[6]
if len(item) > 7:
self.inps[index] = item[7]
if self.segm_filter and len(item) > 8:
self.segms[index] = item[8]
def __setitem__(self, index, item):
with self.get_lock():
self.__item_setter(index, item)
def __getitem__(self, index):
""" index the depth video """
with self.get_lock():
# support negative indexing
if isinstance(index, int) and index < 0:
index = self.counter.value + index
item = (
self.poses[index],
self.disps[index],
self.intrinsics[index],
self.fmaps[index],
self.nets[index],
self.inps[index])
return item
def append(self, *item):
with self.get_lock():
self.__item_setter(self.counter.value, item)
### geometric operations ###
@staticmethod
def format_indicies(ii, jj, device):
""" to device, long, {-1} """
if not isinstance(ii, torch.Tensor):
ii = torch.as_tensor(ii)
if not isinstance(jj, torch.Tensor):
jj = torch.as_tensor(jj)
ii = ii.to(device=device, dtype=torch.long).reshape(-1)
jj = jj.to(device=device, dtype=torch.long).reshape(-1)
return ii, jj
def upsample(self, ix, mask):
""" upsample disparity """
disps_up = cvx_upsample(self.disps[ix].unsqueeze(-1), mask)
self.disps_up[ix] = disps_up.squeeze()
def normalize(self):
""" normalize depth and poses """
with self.get_lock():
s = self.disps[:self.counter.value].mean()
self.disps[:self.counter.value] /= s
self.poses[:self.counter.value, :3] *= s
self.dirty[:self.counter.value] = True
def reproject(self, ii, jj):
""" project points from ii -> jj """
ii, jj = DepthVideo.format_indicies(ii, jj, self.device)
Gs = lietorch.SE3(self.poses[None])
coords, valid_mask = \
pops.projective_transform(
Gs, self.disps[None], self.intrinsics[None], ii, jj)
return coords, valid_mask
def distance(self, ii=None, jj=None, beta=0.3, bidirectional=True):
""" frame distance metric """
return_matrix = False
if ii is None:
return_matrix = True
N = self.counter.value
ii, jj = torch.meshgrid(torch.arange(N), torch.arange(N))
ii, jj = DepthVideo.format_indicies(ii, jj, self.device)
if bidirectional:
poses = self.poses[:self.counter.value].clone()
d1 = droid_backends.frame_distance(
poses, self.disps, self.intrinsics[0], ii, jj, beta)
d2 = droid_backends.frame_distance(
poses, self.disps, self.intrinsics[0], jj, ii, beta)
d = .5 * (d1 + d2)
else:
d = droid_backends.frame_distance(
self.poses, self.disps, self.intrinsics[0], ii, jj, beta)
if return_matrix:
return d.reshape(N, N)
return d
def ba(self, target, weight, eta, ii, jj, t0=1, t1=None, itrs=2, lm=1e-4, ep=0.1, motion_only=False):
""" dense bundle adjustment (DBA) """
with self.get_lock():
# [t0, t1] window of bundle adjustment optimization
if t1 is None:
t1 = max(ii.max().item(), jj.max().item()) + 1
if eta is None:
k = torch.unique(torch.cat([ii, jj], 0)).shape[0]
eta = 1e-7 * \
torch.ones([k, self.ht//8, self.wd//8], device=self.device)
droid_backends.ba(self.poses, self.disps, self.intrinsics[0],
target, weight, eta, ii, jj, t0, t1, itrs, lm, ep, motion_only)
self.disps.clamp_(min=0.001)
================================================
FILE: VO_Module/droid_slam/droid.py
================================================
import torch
import torch.nn.functional as F
import lietorch
import numpy as np
from droid_net import DroidNet
from depth_video import DepthVideo
from motion_filter import MotionFilter
from droid_frontend import DroidFrontend
from droid_backend import DroidBackend
from trajectory_filler import PoseTrajectoryFiller
from collections import OrderedDict
from torch.multiprocessing import Process
import lietorch
from lietorch import SE3
class Droid:
def __init__(self, args):
super(Droid, self).__init__()
self.args = args
self.load_weights(args.weights, args.use_aff_bri)
self.disable_vis = args.disable_vis
# store images, depth, poses, intrinsics (shared between processes)
print( "use segment filter:",args.segm_filter)
self.video = DepthVideo(args.image_size, args.buffer, args.device, args.segm_filter, args.thresh)
# filter incoming frames so that there is enough motion
self.filterx = MotionFilter(
self.net, self.video, thresh=args.filter_thresh, device=args.device)
# frontend process
self.frontend = DroidFrontend(self.net, self.video, self.args)
# backend process
self.backend = DroidBackend(self.net, self.video, self.args)
# visualizer
if not self.disable_vis:
from visualization import droid_visualization
self.visualizer = Process(
target=droid_visualization, args=(self.video, args.device))
self.visualizer.start()
# post processor - fill in poses for non-keyframes
self.traj_filler = PoseTrajectoryFiller(
self.net, self.video, args.device)
def load_weights(self, weights, use_aff_bri=False):
""" load trained model weights """
self.net = DroidNet(use_aff_bri)
state_dict = OrderedDict([
(k.replace("module.", ""), v) for (k, v) in torch.load(weights, self.args.device).items()])
self.net.load_state_dict(state_dict)
self.net.to(self.args.device).eval()
def track(self, tstamp, image, depth=None, intrinsics=None, segments=None):
""" main thread - update map """
with torch.no_grad():
# check there is enough motion
self.filterx.track(tstamp, image, depth, intrinsics, segments)
# local bundle adjustment
self.frontend()
# global bundle adjustment
# self.backend()
def terminate(self, stream=None, need_inv=True):
""" terminate the visualization process, return poses [t, q] """
del self.frontend
torch.cuda.empty_cache()
print("#" * 32)
self.backend(7)
torch.cuda.empty_cache()
print("#" * 32)
self.backend(12)
camera_trajectory = self.traj_filler(stream)
if need_inv:
return camera_trajectory.inv().data.cpu().numpy()
else:
# for vkitti2(already w2c)
return camera_trajectory.data.cpu().numpy()
def get_traj(self):
Gs = SE3(self.video.poses[:self.video.counter.value])
return lietorch.cat([Gs], 0).data.cpu().numpy()
def get_depth(self):
depth = upsample_inter(self.video.disps[:self.video.counter.value].unsqueeze(0).unsqueeze(4)).squeeze(4).squeeze(0)
return depth
def get_flow(self):
flow = upsample_inter(self.video.full_flow[:self.video.counter.value].unsqueeze(0)*8)
return flow
def upsample_inter(mask):
batch, num, ht, wd, dim = mask.shape
mask = mask.permute(0, 1, 4, 2, 3).contiguous()
mask = mask.view(batch*num, dim, ht, wd)
mask = F.interpolate(mask, scale_factor=8, mode='bilinear',
align_corners=True, recompute_scale_factor=True)
mask = mask.permute(0, 2, 3, 1).contiguous()
return mask.view(batch, num, 8*ht, 8*wd, dim)
================================================
FILE: VO_Module/droid_slam/droid_backend.py
================================================
import torch
import lietorch
import numpy as np
from lietorch import SE3
from factor_graph import FactorGraph
class DroidBackend:
def __init__(self, net, video, args):
self.video = video
self.update_op = net.update
self.device = args.device
# global optimization window
self.t0 = 0
self.t1 = 0
self.beta = args.beta
self.backend_thresh = args.backend_thresh
self.backend_radius = args.backend_radius
self.backend_nms = args.backend_nms
@torch.no_grad()
def __call__(self, steps=12):
""" main update """
t = self.video.counter.value
self.video.normalize()
graph = FactorGraph(self.video, self.update_op,
self.device, corr_impl="alt", max_factors=100000)
graph.add_proximity_factors(rad=self.backend_radius,
nms=self.backend_nms,
thresh=self.backend_thresh,
beta=self.beta)
graph.update_lowmem(steps=steps)
graph.clear_edges()
self.video.dirty[:t] = True
================================================
FILE: VO_Module/droid_slam/droid_frontend.py
================================================
import torch
import lietorch
import numpy as np
from lietorch import SE3
from factor_graph import FactorGraph
class DroidFrontend:
def __init__(self, net, video, args):
self.video = video
self.update_op = net.update
self.graph = FactorGraph(
video, net.update, args.device, max_factors=48)
# local optimization window
self.t0 = 0
self.t1 = 0
# frontent variables
self.is_initialized = False
self.count = 0
self.max_age = 25
self.iters1 = 4
self.iters2 = 2
self.warmup = args.warmup
self.beta = args.beta
self.frontend_nms = args.frontend_nms
self.keyframe_thresh = args.keyframe_thresh
self.frontend_window = args.frontend_window
self.frontend_thresh = args.frontend_thresh
self.frontend_radius = args.frontend_radius
def __update(self):
""" add edges, perform update """
self.count += 1
self.t1 += 1
if self.graph.corr is not None:
self.graph.rm_factors(self.graph.age > self.max_age, store=True)
self.graph.add_proximity_factors(self.t1-5, max(self.t1-self.frontend_window, 0),
rad=self.frontend_radius, nms=self.frontend_nms, thresh=self.frontend_thresh, beta=self.beta, remove=True)
for itr in range(self.iters1):
self.graph.update(None, None, use_inactive=True)
# set initial pose for next frame ------------ 删除 帧 -----------------
poses = SE3(self.video.poses)
d = self.video.distance(
[self.t1-3], [self.t1-2], beta=self.beta, bidirectional=True)
if d.item() < self.keyframe_thresh:
self.graph.rm_keyframe(self.t1 - 2)
with self.video.get_lock():
self.video.counter.value -= 1
self.t1 -= 1
else:
for itr in range(self.iters2):
self.graph.update(None, None, use_inactive=True)
# set pose for next itration
self.video.poses[self.t1] = self.video.poses[self.t1-1]
self.video.disps[self.t1] = self.video.disps[self.t1-1].mean()
# self.video.full_flow[self.graph.ii] = self.graph.full_flow
# update visualization
self.video.dirty[self.graph.ii.min():self.t1] = True
def __initialize(self):
""" initialize the SLAM system """
self.t0 = 0
self.t1 = self.video.counter.value
self.graph.add_neighborhood_factors(self.t0, self.t1, r=3)
for itr in range(8):
self.graph.update(1, use_inactive=True)
self.graph.add_proximity_factors(
0, 0, rad=2, nms=2, thresh=self.frontend_thresh)
for itr in range(12):
self.graph.update(1, use_inactive=True)
# self.video.normalize()
self.video.poses[self.t1] = self.video.poses[self.t1-1].clone()
self.video.disps[self.t1] = self.video.disps[self.t1-4:self.t1].mean()
# initialization complete
self.is_initialized = True
self.last_pose = self.video.poses[self.t1-1].clone()
self.last_disp = self.video.disps[self.t1-1].clone()
self.last_time = self.video.tstamp[self.t1-1].clone()
with self.video.get_lock():
self.video.ready.value = 1
self.video.dirty[:self.t1] = True
def __call__(self):
""" main update """
# do initialization
if not self.is_initialized and self.video.counter.value == self.warmup:
self.__initialize()
# do update
elif self.is_initialized and self.t1 < self.video.counter.value:
self.__update()
================================================
FILE: VO_Module/droid_slam/droid_net.py
================================================
import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F
from collections import OrderedDict
from torch.nn.modules.activation import Sigmoid
from modules.extractor import BasicEncoder
from modules.corr import CorrBlock
from modules.gru import ConvGRU
from modules.clipping import GradientClip
from lietorch import SE3
from geom.ba import BA
import geom.projective_ops as pops
from geom.graph_utils import graph_to_edge_list, keyframe_indicies
from torch_scatter import scatter_mean
def cvx_upsample(data, mask):
""" upsample pixel-wise transformation field """
batch, ht, wd, dim = data.shape
data = data.permute(0, 3, 1, 2)
mask = mask.view(batch, 1, 9, 8, 8, ht, wd)
mask = torch.softmax(mask, dim=2)
up_data = F.unfold(data, [3, 3], padding=1)
up_data = up_data.view(batch, dim, 9, 1, 1, ht, wd)
up_data = torch.sum(mask * up_data, dim=2)
up_data = up_data.permute(0, 4, 2, 5, 3, 1)
up_data = up_data.reshape(batch, 8*ht, 8*wd, dim)
return up_data
def upsample_dim_1(disp, mask):
batch, num, ht, wd = disp.shape
disp = disp.view(batch*num, ht, wd, 1)
mask = mask.view(batch*num, -1, ht, wd)
return cvx_upsample(disp, mask).view(batch, num, 8*ht, 8*wd)
def upsample_dim_x(flow, mask):
batch, num, ht, wd, dim = flow.shape
flow = flow.view(batch*num, ht, wd, dim)
mask = mask.view(batch*num, -1, ht, wd)
return cvx_upsample(flow, mask).view(batch, num, 8*ht, 8*wd, dim)
def upsample_inter(mask):
batch, num, ht, wd, dim = mask.shape
mask = mask.permute(0, 1, 4, 2, 3).contiguous()
mask = mask.view(batch*num, dim, ht, wd)
mask = F.interpolate(mask, scale_factor=8, mode='bilinear',
align_corners=True, recompute_scale_factor=True)
mask = mask.permute(0, 2, 3, 1).contiguous()
return mask.view(batch, num, 8*ht, 8*wd, dim)
class GraphAgg(nn.Module):
def __init__(self):
super(GraphAgg, self).__init__()
self.conv1 = nn.Conv2d(128, 128, 3, padding=1)
self.conv2 = nn.Conv2d(128, 128, 3, padding=1)
self.relu = nn.ReLU(inplace=True)
self.eta = nn.Sequential(
nn.Conv2d(128, 1, 3, padding=1),
GradientClip(),
nn.Softplus())
self.upmask_disp = nn.Sequential(
nn.Conv2d(128, 8*8*9, 1, padding=0))
def forward(self, net, ii):
batch, num, ch, ht, wd = net.shape
net = net.view(batch*num, ch, ht, wd)
_, ix = torch.unique(ii, return_inverse=True)
net = self.relu(self.conv1(net))
net = net.view(batch, num, 128, ht, wd)
net_less = scatter_mean(net, ix, dim=1)
net_less = net_less.view(-1, 128, ht, wd)
net_less = self.relu(self.conv2(net_less))
eta = self.eta(net_less).view(batch, -1, ht, wd)
upmask_disp = self.upmask_disp(net_less).view(batch, -1, 8*8*9, ht, wd)
return .01 * eta, upmask_disp, None, None
class UpdateModule(nn.Module):
def __init__(self):
super(UpdateModule, self).__init__()
cor_planes = 4 * (2*3 + 1)**2
self.corr_encoder = nn.Sequential(
nn.Conv2d(cor_planes, 128, 1, padding=0),
nn.ReLU(inplace=True),
nn.Conv2d(128, 128, 3, padding=1),
nn.ReLU(inplace=True))
self.flow_encoder = nn.Sequential(
nn.Conv2d(4, 128, 7, padding=3),
nn.ReLU(inplace=True),
nn.Conv2d(128, 64, 3, padding=1),
nn.ReLU(inplace=True))
self.weight = nn.Sequential(
nn.Conv2d(128, 128, 3, padding=1),
nn.ReLU(inplace=True),
nn.Conv2d(128, 2, 3, padding=1),
GradientClip(),
nn.Sigmoid())
self.delta = nn.Sequential(
nn.Conv2d(128, 128, 3, padding=1),
nn.ReLU(inplace=True),
nn.Conv2d(128, 2, 3, padding=1),
GradientClip())
self.gru = ConvGRU(128, 128+128+64)
self.agg = GraphAgg()
def forward(self, net, inp, corr, flow=None, ii=None, jj=None):
""" RaftSLAM update operator """
batch, num, ch, ht, wd = net.shape
if flow is None:
flow = torch.zeros(batch, num, 4, ht, wd, device=net.device)
output_dim = (batch, num, -1, ht, wd)
net = net.view(batch*num, -1, ht, wd)
inp = inp.view(batch*num, -1, ht, wd)
corr = corr.view(batch*num, -1, ht, wd)
flow = flow.view(batch*num, -1, ht, wd)
corr = self.corr_encoder(corr)
flow = self.flow_encoder(flow)
net = self.gru(net, inp, corr, flow)
### update variables ###
delta = self.delta(net).view(*output_dim)
weight = self.weight(net).view(*output_dim)
delta = delta.permute(0, 1, 3, 4, 2)[..., :2].contiguous()
weight = weight.permute(0, 1, 3, 4, 2)[..., :2].contiguous()
net = net.view(*output_dim)
if ii is not None:
eta, upmask = self.agg(net, ii.to(net.device))
return net, delta, weight, eta, upmask
else:
return net, delta, weight
class DynamicUpdateModule(nn.Module):
def __init__(self, use_aff_bri=False):
super(DynamicUpdateModule, self).__init__()
cor_planes = 4 * (2*3 + 1)**2
self.mask_num = 2
self.corr_encoder = nn.Sequential(
nn.Conv2d(cor_planes, 128, 1, padding=0),
nn.ReLU(inplace=True),
nn.Conv2d(128, 128, 3, padding=1),
nn.ReLU(inplace=True))
self.flow_encoder = nn.Sequential(
nn.Conv2d(4+self.mask_num+2, 128, 7, padding=3),
nn.ReLU(inplace=True),
nn.Conv2d(128, 64, 3, padding=1),
nn.ReLU(inplace=True))
self.weight = nn.Sequential(
nn.Conv2d(128, 128, 3, padding=1),
nn.ReLU(inplace=True),
nn.Conv2d(128, 2, 3, padding=1),
GradientClip(),
)
self.delta = nn.Sequential(
nn.Conv2d(128, 128, 3, padding=1),
nn.ReLU(inplace=True),
nn.Conv2d(128, 2, 3, padding=1),
GradientClip())
self.delta_dy = nn.Sequential(
nn.Conv2d(128, 128, 3, padding=1),
nn.ReLU(inplace=True),
nn.Conv2d(128, 2, 3, padding=1),
GradientClip())
# 动静mask: 1->static, 0->dynamic
# this is a delta mask
self.delta_mask = nn.Sequential(
nn.Conv2d(128, 128, 3, padding=1),
nn.ReLU(inplace=True),
nn.Conv2d(128, self.mask_num, 3, padding=1),
GradientClip(),
)
if use_aff_bri:
self.global_avg_pool = nn.Sequential(
nn.Conv2d(128, 128, 3, padding=1),
nn.ReLU(inplace=True),
nn.AdaptiveAvgPool2d((1, 1)),
GradientClip(),
)
self.param_linear = nn.Sequential(
nn.Linear(128, 2),
nn.Sigmoid()
)
self.gru = ConvGRU(128, 128+128+64)
self.agg = GraphAgg()
def do_filter(self, lay, weight, delta_dy, delta_m, segments):
segments = lay * 1e4 + segments
encode = segments * 1e4 + ((delta_dy[...,0] + delta_dy[...,1]) > 0.5).int()
ky, cnt = torch.unique(encode, return_counts=True)
cat = ky // 1e4
sig = ky % 1e4
cat0 = cat[sig==0].detach().cpu().numpy.tolist()
cat1 = cat[sig==1].detach().cpu().numpy.tolist()
cnt0 = cnt[sig==0]
cnt1 = cnt[sig==1]
ori_cls = torch.unique(cat)
for i in ori_cls:
if i not in cat0:
prob = 0
elif i not in cat1:
prob = 1
else:
n0 = cnt0[cat0.index(i)]
n1 = cnt1[cat1.index(i)]
prob = n0 / (n0 + n1)
if prob > 0.5:
fil = segments[0, i//1e4,...] == i
lay[0, i//1e4 ,...] = lay[0, i//1e4 ,...] * (1-fil*1)
weight[...,0] = weight[...,0] * lay
weight[...,1] = weight[...,1] * lay
return weight
def forward(self, net, inp, corr, flow=None,
ii=None, jj=None, use_aff_bri=False, raw_mask=None, segments=None):
""" RaftSLAM update operator """
batch, num, ch, ht, wd = net.shape
if flow is None:
# add mask channel
flow = torch.zeros(batch, num, 4+self.mask_num+2,
ht, wd, device=net.device)
if raw_mask is None:
raw_mask = torch.zeros(
batch, num, self.mask_num, ht, wd, device=net.device)
output_dim = (batch, num, -1, ht, wd)
net = net.view(batch*num, -1, ht, wd)
inp = inp.view(batch*num, -1, ht, wd)
corr = corr.view(batch*num, -1, ht, wd)
flow = flow.view(batch*num, -1, ht, wd)
corr = self.corr_encoder(corr)
flow = self.flow_encoder(flow)
net = self.gru(net, inp, corr, flow)
### update variables ###
delta = self.delta(net).view(*output_dim)
delta_dy = self.delta_dy(net).view(*output_dim)
weight = self.weight(net).view(*output_dim)
delta_m = self.delta_mask(net).view(*output_dim)
if use_aff_bri:
tmp = self.global_avg_pool(net).view(batch*num, -1)
aff_params = self.param_linear(tmp).view(batch, num, -1)
delta = delta.permute(0, 1, 3, 4, 2).contiguous()
delta_dy = delta_dy.permute(0, 1, 3, 4, 2).contiguous()
weight = weight.permute(0, 1, 3, 4, 2).contiguous()
delta_m = delta_m.permute(0, 1, 3, 4, 2).contiguous()
lay = torch.as_tensor(np.range(1, num+1).repeat(ht*wd).reshape(num,ht,wd)).unsqueeze(0)
# weight = self.do_filter(lay, weight, delta_dy, delta_m, segments)
net = net.view(*output_dim)
delta = torch.cat([delta, delta_dy], dim=-1)
if ii is not None:
eta, upmask_disp, \
upmask_flow, upmask_dymask = self.agg(net, ii.to(net.device))
upmask = {
'disp': upmask_disp,
'flow': upmask_flow,
'dy_mask': upmask_dymask,
}
if use_aff_bri:
return net, delta, weight, eta, upmask, delta_m, aff_params
else:
return net, delta, weight, eta, upmask, delta_m
else:
return net, delta, weight, delta_m
class DroidNet(nn.Module):
def __init__(self, use_aff_bri=False):
super(DroidNet, self).__init__()
self.fnet = BasicEncoder(output_dim=128, norm_fn='instance')
self.cnet = BasicEncoder(output_dim=256, norm_fn='none')
self.update = DynamicUpdateModule(use_aff_bri)
self.use_aff_bri = use_aff_bri
def extract_features(self, images):
""" run feeature extraction networks """
# normalize images
images = images[:, :, [2, 1, 0]] / 255.0
mean = torch.as_tensor([0.485, 0.456, 0.406], device=images.device)
std = torch.as_tensor([0.229, 0.224, 0.225], device=images.device)
images = images.sub_(mean[:, None, None]).div_(std[:, None, None])
fmaps = self.fnet(images)
net = self.cnet(images)
net, inp = net.split([128, 128], dim=2)
net = torch.tanh(net)
inp = torch.relu(inp)
return fmaps, net, inp
def forward(self, Gs, images, disps, intrinsics, graph=None, num_steps=12,
fixedp=2, ret_flow=False, downsample=False, segments=None):
""" Estimates SE3 or Sim3 between pair of frames """
u = keyframe_indicies(graph)
ii, jj, kk = graph_to_edge_list(graph)
ii = ii.to(device=images.device, dtype=torch.long)
jj = jj.to(device=images.device, dtype=torch.long)
dy_thresh = 0.5
mask_num = 2
fmaps, net, inp = self.extract_features(images)
segm_all = None
if segments != None:
segm_all = segments[:,ii]
net, inp = net[:, ii], inp[:, ii]
corr_fn = CorrBlock(fmaps[:, ii], fmaps[:, jj], num_levels=4, radius=3)
ht, wd = images.shape[-2:]
coords0 = pops.coords_grid(ht//8, wd//8, device=images.device)
coords1, _ = pops.projective_transform(Gs, disps, intrinsics, ii, jj)
target_cam = coords1.clone()
delta_dy = torch.zeros_like(coords1)
raw_mask = torch.zeros_like(coords1)[..., 0:mask_num]
Gs_list, disp_list, residual_list = [], [], []
full_flow_list, mask_list = [], []
if self.use_aff_bri:
aff_params_list = []
for step in range(num_steps):
Gs = Gs.detach()
disps = disps.detach()
coords1 = coords1.detach()
target_cam = target_cam.detach()
delta_dy = delta_dy.detach()
raw_mask = raw_mask.detach()
corr = corr_fn(coords1)
resd = (target_cam - coords1)
cam_flow = coords1 - coords0
flow = cam_flow + delta_dy
motion = torch.cat([cam_flow, flow, resd, raw_mask], dim=-1)
motion = motion.permute(0, 1, 4, 2, 3).clamp(-64.0, 64.0)
if self.use_aff_bri:
net, delta, weight, eta, upmask, \
delta_m, aff_params = \
self.update(net, inp, corr, motion,
ii, jj, self.use_aff_bri)
else:
net, delta, weight, eta, upmask, delta_m = \
self.update(net, inp, corr, motion, ii, jj)
# (1:static 0:dynamic)
raw_mask = raw_mask + delta_m
mask = torch.sigmoid(raw_mask)
bin_mask = (mask >= dy_thresh).float()
target_cam = coords1 + delta[..., 0:2]
weight = torch.sigmoid(weight + (1-bin_mask)*10)
for i in range(2):
Gs, disps = BA(target_cam, weight, eta, Gs, disps,
intrinsics, ii, jj, fixedp=2)
coords1, valid_mask = pops.projective_transform(
Gs, disps, intrinsics, ii, jj)
residual = (target_cam - coords1) * valid_mask
delta_dy = delta[..., 2:4] * (1-bin_mask)
target_all = coords1 + delta_dy
Gs_list.append(Gs)
disp_list.append(upsample_dim_1(disps, upmask['disp']))
residual_list.append(residual)
mask_list.append(upsample_inter(mask))
if ret_flow:
if downsample:
full_flow_list.append(target_all - coords0)
else:
full_flow_list.append(
upsample_inter((target_all - coords0)*8))
if self.use_aff_bri:
aff_params_list.append(aff_params)
if ret_flow:
if self.use_aff_bri:
return Gs_list, disp_list, residual_list, full_flow_list, mask_list, aff_params_list
else:
return Gs_list, disp_list, residual_list, full_flow_list, mask_list
else:
return Gs_list, disp_list, residual_list, mask_list
================================================
FILE: VO_Module/droid_slam/factor_graph.py
================================================
import torch
import lietorch
import numpy as np
import matplotlib.pyplot as plt
import torch.nn.functional as F
from lietorch import SE3
from modules.corr import CorrBlock, AltCorrBlock
import geom.projective_ops as pops
class FactorGraph:
def __init__(self, video, update_op, device="cuda:0", corr_impl="volume", max_factors=-1):
self.video = video
self.update_op = update_op
self.device = device
self.max_factors = max_factors
self.corr_impl = corr_impl
# operator at 1/8 resolution
self.ht = ht = video.ht // 8
self.wd = wd = video.wd // 8
self.dy_thresh = 0.5
self.mask_num = 2
self.coords0 = pops.coords_grid(ht, wd, device=device)
self.ii = torch.as_tensor([], dtype=torch.long, device=device)
self.jj = torch.as_tensor([], dtype=torch.long, device=device)
self.age = torch.as_tensor([], dtype=torch.long, device=device)
self.corr, self.net, self.inp = None, None, None
self.segm = None
self.damping = 1e-6 * torch.ones_like(self.video.disps)
self.target_cam = torch.zeros(
[1, 0, ht, wd, 2], device=device, dtype=torch.float)
self.weight = torch.zeros(
[1, 0, ht, wd, 2], device=device, dtype=torch.float)
self.raw_mask = torch.zeros(
[1, 0, ht, wd, self.mask_num], device=device, dtype=torch.float)
self.delta_dy = torch.zeros(
[1, 0, ht, wd, 2], device=device, dtype=torch.float)
self.full_flow = torch.zeros(
[1, 0, ht, wd, 2], device=device, dtype=torch.float)
# inactive factors
self.ii_inac = torch.as_tensor([], dtype=torch.long, device=device)
self.jj_inac = torch.as_tensor([], dtype=torch.long, device=device)
self.ii_bad = torch.as_tensor([], dtype=torch.long, device=device)
self.jj_bad = torch.as_tensor([], dtype=torch.long, device=device)
self.target_cam_inac = torch.zeros(
[1, 0, ht, wd, 2], device=device, dtype=torch.float)
self.weight_inac = torch.zeros(
[1, 0, ht, wd, 2], device=device, dtype=torch.float)
self.raw_mask_inac = torch.zeros(
[1, 0, ht, wd, self.mask_num], device=device, dtype=torch.float)
self.delta_dy_inac = torch.zeros(
[1, 0, ht, wd, 2], device=device, dtype=torch.float)
self.full_flow_inac = torch.zeros(
[1, 0, ht, wd, 2], device=device, dtype=torch.float)
def __filter_repeated_edges(self, ii, jj):
""" remove duplicate edges """
keep = torch.zeros(ii.shape[0], dtype=torch.bool, device=ii.device)
eset = set(
[(i.item(), j.item()) for i, j in zip(self.ii, self.jj)] +
[(i.item(), j.item()) for i, j in zip(self.ii_inac, self.jj_inac)])
for k, (i, j) in enumerate(zip(ii, jj)):
keep[k] = (i.item(), j.item()) not in eset
return ii[keep], jj[keep]
def print_edges(self):
ii = self.ii.cpu().numpy()
jj = self.jj.cpu().numpy()
ix = np.argsort(ii)
ii = ii[ix]
jj = jj[ix]
w = torch.mean(self.weight, dim=[0, 2, 3, 4]).cpu().numpy()
w = w[ix]
for e in zip(ii, jj, w):
print(e)
print()
def filter_edges(self):
""" remove bad edges """
conf = torch.mean(self.weight, dim=[0, 2, 3, 4])
mask = (torch.abs(self.ii-self.jj) > 2) & (conf < 0.001)
self.ii_bad = torch.cat([self.ii_bad, self.ii[mask]])
self.jj_bad = torch.cat([self.jj_bad, self.jj[mask]])
self.rm_factors(mask, store=False)
def clear_edges(self):
self.rm_factors(self.ii >= 0)
self.net = None
self.inp = None
@torch.cuda.amp.autocast(enabled=True)
def add_factors(self, ii, jj, remove=False):
""" add edges to factor graph """
if not isinstance(ii, torch.Tensor):
ii = torch.as_tensor(ii, dtype=torch.long, device=self.device)
if not isinstance(jj, torch.Tensor):
jj = torch.as_tensor(jj, dtype=torch.long, device=self.device)
# remove duplicate edges
ii, jj = self.__filter_repeated_edges(ii, jj)
if ii.shape[0] == 0:
return
# place limit on number of factors
if self.max_factors > 0 and self.ii.shape[0] + ii.shape[0] > self.max_factors \
and self.corr is not None and remove:
ix = torch.arange(len(self.age))[torch.argsort(self.age).cpu()]
self.rm_factors(ix >= self.max_factors - ii.shape[0], store=True)
net = self.video.nets[ii].to(self.device).unsqueeze(0)
# correlation volume for new edges
if self.corr_impl == "volume":
fmap1 = self.video.fmaps[ii].to(self.device).unsqueeze(0)
fmap2 = self.video.fmaps[jj].to(self.device).unsqueeze(0)
corr = CorrBlock(fmap1, fmap2)
self.corr = corr if self.corr is None else self.corr.cat(corr)
inp = self.video.inps[ii].to(self.device).unsqueeze(0)
self.inp = inp if self.inp is None else torch.cat([self.inp, inp], 1)
with torch.cuda.amp.autocast(enabled=False):
target, _ = self.video.reproject(ii, jj)
weight = torch.zeros_like(target)
raw_mask = torch.zeros_like(target)[..., 0:self.mask_num]
delta_dy = torch.zeros_like(target)
self.ii = torch.cat([self.ii, ii], 0)
self.jj = torch.cat([self.jj, jj], 0)
self.age = torch.cat([self.age, torch.zeros_like(ii)], 0)
# reprojection factors
self.net = net if self.net is None else torch.cat([self.net, net], 1)
self.target_cam = torch.cat([self.target_cam, target], 1)
self.weight = torch.cat([self.weight, weight], 1)
self.raw_mask = torch.cat([self.raw_mask, raw_mask], 1)
self.delta_dy = torch.cat([self.delta_dy, delta_dy], 1)
# segmentations
segm = self.video.segms[ii].to(self.device).unsqueeze(0)
self.segm = segm if self.segm is None else torch.cat([self.segm, segm], 1)
@torch.cuda.amp.autocast(enabled=True)
def rm_factors(self, mask, store=False):
""" drop edges from factor graph """
# store estimated factors
if store:
self.ii_inac = torch.cat([self.ii_inac, self.ii[mask]], 0)
self.jj_inac = torch.cat([self.jj_inac, self.jj[mask]], 0)
self.target_cam_inac = torch.cat(
[self.target_cam_inac, self.target_cam[:, mask]], 1)
self.weight_inac = torch.cat(
[self.weight_inac, self.weight[:, mask]], 1)
self.raw_mask_inac = torch.cat(
[self.raw_mask_inac, self.raw_mask[:, mask]], 1)
self.delta_dy_inac = torch.cat(
[self.delta_dy_inac, self.delta_dy[:, mask]], 1)
self.ii = self.ii[~mask]
self.jj = self.jj[~mask]
self.age = self.age[~mask]
if self.corr_impl == "volume":
self.corr = self.corr[~mask]
if self.net is not None:
self.net = self.net[:, ~mask]
if self.inp is not None:
self.inp = self.inp[:, ~mask]
if self.segm is not None:
self.segm = self.segm[:, ~mask]
self.target_cam = self.target_cam[:, ~mask]
self.weight = self.weight[:, ~mask]
self.raw_mask = self.raw_mask[:, ~mask]
self.delta_dy = self.delta_dy[:, ~mask]
@torch.cuda.amp.autocast(enabled=True)
def rm_keyframe(self, ix):
""" drop edges from factor graph """
with self.video.get_lock():
self.video.poses[ix] = self.video.poses[ix+1]
self.video.disps[ix] = self.video.disps[ix+1]
self.video.intrinsics[ix] = self.video.intrinsics[ix+1]
self.video.nets[ix] = self.video.nets[ix+1]
self.video.inps[ix] = self.video.inps[ix+1]
self.video.fmaps[ix] = self.video.fmaps[ix+1]
if self.video.segm_filter:
self.video.segms[ix] = self.video.segms[ix+1]
m = (self.ii == ix) | (self.jj == ix)
self.ii[self.ii >= ix] -= 1
self.jj[self.jj >= ix] -= 1
self.ii_inac[self.ii_inac >= ix] -= 1
self.jj_inac[self.jj_inac >= ix] -= 1
self.rm_factors(m, store=False)
@torch.cuda.amp.autocast(enabled=True)
def update(self, t0=None, t1=None, itrs=2, use_inactive=False, EP=1e-7, motion_only=False):
""" run update operator on factor graph """
# motion features
with torch.cuda.amp.autocast(enabled=False):
coords1, mask = self.video.reproject(self.ii, self.jj)
motn = torch.cat(
[self.target_cam - self.coords0, self.target_cam - self.coords0 + self.delta_dy,
self.target_cam - coords1, self.raw_mask*torch.ones_like(coords1)[..., 0:self.mask_num]], dim=-1)
motn = motn.permute(0, 1, 4, 2, 3).clamp(-64.0, 64.0)
# correlation features
corr = self.corr(coords1)
self.net, delta, weight, damping, upmask, delta_m = \
self.update_op(self.net, self.inp, corr,
motn, self.ii, self.jj, False)
if t0 is None:
t0 = max(1, self.ii.min().item()+1)
with torch.cuda.amp.autocast(enabled=False):
self.target_cam = coords1 + delta[..., 0:2].to(dtype=torch.float)
self.weight = weight.to(dtype=torch.float)
self.raw_mask = self.raw_mask + delta_m
bin_mask = ( torch.sigmoid(self.raw_mask) >= self.dy_thresh)
# filter with segm
if self.video.segm_filter:
ht = weight.shape[2]
wd = weight.shape[3]
lay = np.arange(1, weight.shape[1]+1).repeat(ht*wd).reshape(1,-1,ht,wd)
segments = (lay * 1e6 + self.segm.squeeze(2).detach().cpu().numpy()).astype(np.int32)
dynamic_m = ( (bin_mask[...,0] == 0).__or__(bin_mask[...,1] == 0) ).detach().cpu().numpy()
ori_ky, ori_cnt = np.unique(segments, return_counts=True)
ori_dic = dict(zip(ori_ky, ori_cnt))
dy_fields = segments * dynamic_m
dy_ky, dy_cnt = np.unique(dy_fields, return_counts=True)
for (label, dy_n) in zip(dy_ky, dy_cnt):
if label % 1e6 == 0:
continue
if (dy_n / ori_dic[label]) > self.video.thresh: # 0.8
dim = int(label // 1e6) -1
fil = segments[0,dim,...] == label
lay[0,dim,...] = lay[0,dim,...] * (1-fil*1)
lay = torch.as_tensor(lay).to(self.device)
bin_mask[...,0] = bin_mask[...,0] * (lay > 0)
bin_mask[...,1] = bin_mask[...,1] * (lay > 0)
bin_mask = bin_mask.float()
self.delta_dy = delta[..., 2:4] * (1-bin_mask)
self.weight = torch.sigmoid(self.weight + (1-bin_mask)*10)
ht, wd = self.coords0.shape[0:2]
self.damping[torch.unique(self.ii)] = damping
if use_inactive:
m = (self.ii_inac >= t0 - 3) & (self.jj_inac >= t0 - 3)
ii = torch.cat([self.ii_inac[m], self.ii], 0)
jj = torch.cat([self.jj_inac[m], self.jj], 0)
target_cam = torch.cat(
[self.target_cam_inac[:, m], self.target_cam], 1)
weight = torch.cat([self.weight_inac[:, m], self.weight], 1)
else:
ii, jj, target_cam, weight = self.ii, self.jj, self.target_cam, self.weight
damping = .2 * self.damping[torch.unique(ii)].contiguous() + EP
target_cam = target_cam.view(-1, ht, wd, 2).permute(0,
3, 1, 2).contiguous()
weight = weight.view(-1, ht, wd, 2).permute(0,
3, 1, 2).contiguous()
# dense bundle adjustment
self.video.ba(target_cam, weight, damping, ii, jj, t0, t1,
itrs=itrs, lm=1e-4, ep=0.1, motion_only=motion_only)
target_all = coords1 + self.delta_dy
self.full_flow = target_all - self.coords0
self.age += 1
@torch.cuda.amp.autocast(enabled=False)
def update_lowmem(self, t0=None, t1=None, itrs=2, use_inactive=False, EP=1e-7, steps=8):
""" run update operator on factor graph - reduced memory implementation """
# alternate corr implementation
t = self.video.counter.value
corr_op = AltCorrBlock(self.video.fmaps[None, :t])
for step in range(steps):
print("Global BA Iteration #{}".format(step+1))
with torch.cuda.amp.autocast(enabled=False):
coords1, mask = self.video.reproject(self.ii, self.jj)
motn = torch.cat(
[self.target_cam - self.coords0, self.target_cam - self.coords0 + self.delta_dy,
self.target_cam - coords1, self.raw_mask*torch.ones_like(coords1)[..., 0:self.mask_num]], dim=-1)
motn = motn.permute(0, 1, 4, 2, 3).clamp(-64.0, 64.0)
s = 8
for i in range(0, self.jj.max()+1, s):
v = (self.ii >= i) & (self.ii < i + s)
iis = self.ii[v]
jjs = self.jj[v]
ht, wd = self.coords0.shape[0:2]
corr1 = corr_op(coords1[:, v], iis, jjs)
with torch.cuda.amp.autocast(enabled=True):
net, delta, weight, damping, _, delta_m = self.update_op(
self.net[:, v], self.video.inps[None, iis], corr1, motn[:, v], iis, jjs, False)
self.net[:, v] = net
self.target_cam[:, v] = coords1[:, v] + delta[..., 0:2].float()
self.weight[:, v] = weight.float()
self.damping[torch.unique(iis)] = damping
self.raw_mask[:, v] = self.raw_mask[:, v] + delta_m.float()
bin_mask = (torch.sigmoid(
self.raw_mask[:, v]) >= self.dy_thresh).float()
self.delta_dy[:, v] = delta[..., 2:4] * (1-bin_mask)
self.weight[:, v] = torch.sigmoid(
self.weight[:, v] + (1-bin_mask)*10)
damping = self.damping[torch.unique(self.ii)].contiguous() + EP
target_cam = self.target_cam.view(-1, ht, wd,
2).permute(0, 3, 1, 2).contiguous()
weight = self.weight.view(-1, ht, wd,
2).permute(0, 3, 1, 2).contiguous()
# dense bundle adjustment
self.video.ba(target_cam, weight, damping, self.ii, self.jj, 1, t,
itrs=itrs, lm=1e-5, ep=1e-2, motion_only=False)
self.video.dirty[:t] = True
def add_neighborhood_factors(self, t0, t1, r=3):
""" add edges between neighboring frames within radius r """
ii, jj = torch.meshgrid(torch.arange(t0, t1), torch.arange(t0, t1))
ii = ii.reshape(-1).to(dtype=torch.long, device=self.device)
jj = jj.reshape(-1).to(dtype=torch.long, device=self.device)
keep = ((ii - jj).abs() > 0) & ((ii - jj).abs() <= r)
self.add_factors(ii[keep], jj[keep])
def add_proximity_factors(self, t0=0, t1=0, rad=2, nms=2, beta=0.25, thresh=16.0, remove=False):
""" add edges to the factor graph based on distance """
t = self.video.counter.value
ix = torch.arange(t0, t)
jx = torch.arange(t1, t)
ii, jj = torch.meshgrid(ix, jx)
ii = ii.reshape(-1)
jj = jj.reshape(-1)
d = self.video.distance(ii, jj, beta=beta)
d[ii - rad < jj] = np.inf
d[d > 100] = np.inf
ii1 = torch.cat([self.ii, self.ii_bad, self.ii_inac], 0)
jj1 = torch.cat([self.jj, self.jj_bad, self.jj_inac], 0)
for i, j in zip(ii1.cpu().numpy(), jj1.cpu().numpy()):
if abs(i - j) <= 2:
continue
for di in range(-nms, nms+1):
for dj in range(-nms, nms+1):
if abs(di) + abs(dj) <= max(min(abs(i-j)-2, nms), 0):
i1 = i + di
j1 = j + dj
if (t0 <= i1 < t) and (t1 <= j1 < t):
d[(i1-t0)*(t-t1) + (j1-t1)] = np.inf
es = []
for i in range(t0, t):
for j in range(i+1, min(i+rad+1, t)):
es.append((i, j))
es.append((j, i))
ix = torch.argsort(d)
for k in ix:
if d[k].item() > thresh:
continue
i = ii[k]
j = jj[k]
# bidirectional
es.append((i, j))
es.append((j, i))
for di in range(-nms, nms+1):
for dj in range(-nms, nms+1):
if abs(di) + abs(dj) <= max(min(abs(i-j)-2, nms), 0):
i1 = i + di
j1 = j + dj
if (t0 <= i1 < t) and (t1 <= j1 < t):
d[(i1-t0)*(t-t1) + (j1-t1)] = np.inf
ii, jj = torch.as_tensor(es, device=self.device).unbind(dim=-1)
self.add_factors(ii, jj, remove)
def upsample_inter(mask):
batch, num, ht, wd, dim = mask.shape
mask = mask.permute(0, 1, 4, 2, 3).contiguous()
mask = mask.view(batch*num, dim, ht, wd)
mask = F.interpolate(mask, scale_factor=8, mode='bilinear',
align_corners=True, recompute_scale_factor=True)
mask = mask.permute(0, 2, 3, 1).contiguous()
return mask.view(batch, num, 8*ht, 8*wd, dim)
================================================
FILE: VO_Module/droid_slam/geom/__init__.py
================================================
================================================
FILE: VO_Module/droid_slam/geom/ba.py
================================================
import lietorch
import torch
import torch.nn.functional as F
from .chol import block_solve, schur_solve
import geom.projective_ops as pops
from torch_scatter import scatter_sum
# utility functions for scattering ops
def safe_scatter_add_mat(A, ii, jj, n, m):
v = (ii >= 0) & (jj >= 0) & (ii < n) & (jj < m)
return scatter_sum(A[:,v], ii[v]*m + jj[v], dim=1, dim_size=n*m)
def safe_scatter_add_vec(b, ii, n):
v = (ii >= 0) & (ii < n)
return scatter_sum(b[:,v], ii[v], dim=1, dim_size=n)
# apply retraction operator to inv-depth maps
def disp_retr(disps, dz, ii):
ii = ii.to(device=dz.device)
return disps + scatter_sum(dz, ii, dim=1, dim_size=disps.shape[1])
# apply retraction operator to poses
def pose_retr(poses, dx, ii):
ii = ii.to(device=dx.device)
return poses.retr(scatter_sum(dx, ii, dim=1, dim_size=poses.shape[1]))
def BA(target, weight, eta, poses, disps, intrinsics, ii, jj, fixedp=1, rig=1):
""" Full Bundle Adjustment """
B, P, ht, wd = disps.shape
N = ii.shape[0]
D = poses.manifold_dim
### 1: commpute jacobians and residuals ###
coords, valid, (Ji, Jj, Jz) = pops.projective_transform(
poses, disps, intrinsics, ii, jj, jacobian=True)
r = (target - coords).view(B, N, -1, 1)
w = .001 * (valid * weight).view(B, N, -1, 1)
### 2: construct linear system ###
Ji = Ji.reshape(B, N, -1, D)
Jj = Jj.reshape(B, N, -1, D)
wJiT = (w * Ji).transpose(2,3)
wJjT = (w * Jj).transpose(2,3)
Jz = Jz.reshape(B, N, ht*wd, -1)
Hii = torch.matmul(wJiT, Ji)
Hij = torch.matmul(wJiT, Jj)
Hji = torch.matmul(wJjT, Ji)
Hjj = torch.matmul(wJjT, Jj)
vi = torch.matmul(wJiT, r).squeeze(-1)
vj = torch.matmul(wJjT, r).squeeze(-1)
Ei = (wJiT.view(B,N,D,ht*wd,-1) * Jz[:,:,None]).sum(dim=-1)
Ej = (wJjT.view(B,N,D,ht*wd,-1) * Jz[:,:,None]).sum(dim=-1)
w = w.view(B, N, ht*wd, -1)
r = r.view(B, N, ht*wd, -1)
wk = torch.sum(w*r*Jz, dim=-1)
Ck = torch.sum(w*Jz*Jz, dim=-1)
kx, kk = torch.unique(ii, return_inverse=True)
M = kx.shape[0]
# only optimize keyframe poses
P = P // rig - fixedp
ii = ii // rig - fixedp
jj = jj // rig - fixedp
H = safe_scatter_add_mat(Hii, ii, ii, P, P) + \
safe_scatter_add_mat(Hij, ii, jj, P, P) + \
safe_scatter_add_mat(Hji, jj, ii, P, P) + \
safe_scatter_add_mat(Hjj, jj, jj, P, P)
E = safe_scatter_add_mat(Ei, ii, kk, P, M) + \
safe_scatter_add_mat(Ej, jj, kk, P, M)
v = safe_scatter_add_vec(vi, ii, P) + \
safe_scatter_add_vec(vj, jj, P)
C = safe_scatter_add_vec(Ck, kk, M)
w = safe_scatter_add_vec(wk, kk, M)
C = C + eta.view(*C.shape) + 1e-7
H = H.view(B, P, P, D, D)
E = E.view(B, P, M, D, ht*wd)
### 3: solve the system ###
dx, dz = schur_solve(H, E, C, v, w)
### 4: apply retraction ###
poses = pose_retr(poses, dx, torch.arange(P) + fixedp)
disps = disp_retr(disps, dz.view(B,-1,ht,wd), kx)
disps = torch.where(disps > 10, torch.zeros_like(disps), disps)
disps = disps.clamp(min=0.0)
return poses, disps
def MoBA(target, weight, eta, poses, disps, intrinsics, ii, jj, fixedp=1, rig=1):
""" Motion only bundle adjustment """
B, P, ht, wd = disps.shape
N = ii.shape[0]
D = poses.manifold_dim
### 1: commpute jacobians and residuals ###
coords, valid, (Ji, Jj, Jz) = pops.projective_transform(
poses, disps, intrinsics, ii, jj, jacobian=True)
r = (target - coords).view(B, N, -1, 1)
w = .001 * (valid * weight).view(B, N, -1, 1)
### 2: construct linear system ###
Ji = Ji.reshape(B, N, -1, D)
Jj = Jj.reshape(B, N, -1, D)
wJiT = (w * Ji).transpose(2,3)
wJjT = (w * Jj).transpose(2,3)
Hii = torch.matmul(wJiT, Ji)
Hij = torch.matmul(wJiT, Jj)
Hji = torch.matmul(wJjT, Ji)
Hjj = torch.matmul(wJjT, Jj)
vi = torch.matmul(wJiT, r).squeeze(-1)
vj = torch.matmul(wJjT, r).squeeze(-1)
# only optimize keyframe poses
P = P // rig - fixedp
ii = ii // rig - fixedp
jj = jj // rig - fixedp
H = safe_scatter_add_mat(Hii, ii, ii, P, P) + \
safe_scatter_add_mat(Hij, ii, jj, P, P) + \
safe_scatter_add_mat(Hji, jj, ii, P, P) + \
safe_scatter_add_mat(Hjj, jj, jj, P, P)
v = safe_scatter_add_vec(vi, ii, P) + \
safe_scatter_add_vec(vj, jj, P)
H = H.view(B, P, P, D, D)
### 3: solve the system ###
dx = block_solve(H, v)
### 4: apply retraction ###
poses = pose_retr(poses, dx, torch.arange(P) + fixedp)
return poses
================================================
FILE: VO_Module/droid_slam/geom/chol.py
================================================
import torch
import torch.nn.functional as F
import geom.projective_ops as pops
class CholeskySolver(torch.autograd.Function):
@staticmethod
def forward(ctx, H, b):
# don't crash training if cholesky decomp fails
try:
U = torch.linalg.cholesky(H)
xs = torch.cholesky_solve(b, U)
ctx.save_for_backward(U, xs)
ctx.failed = False
except Exception as e:
print(e)
ctx.failed = True
xs = torch.zeros_like(b)
return xs
@staticmethod
def backward(ctx, grad_x):
if ctx.failed:
return None, None
U, xs = ctx.saved_tensors
dz = torch.cholesky_solve(grad_x, U)
dH = -torch.matmul(xs, dz.transpose(-1,-2))
return dH, dz
def block_solve(H, b, ep=0.1, lm=0.0001):
""" solve normal equations """
B, N, _, D, _ = H.shape
I = torch.eye(D).to(H.device)
H = H + (ep + lm*H) * I
H = H.permute(0,1,3,2,4)
H = H.reshape(B, N*D, N*D)
b = b.reshape(B, N*D, 1)
x = CholeskySolver.apply(H,b)
return x.reshape(B, N, D)
def schur_solve(H, E, C, v, w, ep=0.1, lm=0.0001, sless=False):
""" solve using shur complement """
B, P, M, D, HW = E.shape
H = H.permute(0,1,3,2,4).reshape(B, P*D, P*D)
E = E.permute(0,1,3,2,4).reshape(B, P*D, M*HW)
Q = (1.0 / C).view(B, M*HW, 1)
# damping
I = torch.eye(P*D).to(H.device)
H = H + (ep + lm*H) * I
v = v.reshape(B, P*D, 1)
w = w.reshape(B, M*HW, 1)
Et = E.transpose(1,2)
S = H - torch.matmul(E, Q*Et)
v = v - torch.matmul(E, Q*w)
dx = CholeskySolver.apply(S, v)
if sless:
return dx.reshape(B, P, D)
dz = Q * (w - Et @ dx)
dx = dx.reshape(B, P, D)
dz = dz.reshape(B, M, HW)
return dx, dz
================================================
FILE: VO_Module/droid_slam/geom/graph_utils.py
================================================
import torch
import numpy as np
from collections import OrderedDict
import lietorch
from data_readers.rgbd_utils import compute_distance_matrix_flow, compute_distance_matrix_flow2
def graph_to_edge_list(graph):
ii, jj, kk = [], [], []
for s, u in enumerate(graph):
for v in graph[u]:
ii.append(u)
jj.append(v)
kk.append(s)
ii = torch.as_tensor(ii)
jj = torch.as_tensor(jj)
kk = torch.as_tensor(kk)
return ii, jj, kk
def keyframe_indicies(graph):
return torch.as_tensor([u for u in graph])
def meshgrid(m, n, device='cuda'):
ii, jj = torch.meshgrid(torch.arange(m), torch.arange(n))
return ii.reshape(-1).to(device), jj.reshape(-1).to(device)
def neighbourhood_graph(n, r):
ii, jj = meshgrid(n, n)
d = (ii - jj).abs()
keep = (d >= 1) & (d <= r)
return ii[keep], jj[keep]
def build_frame_graph(poses, disps, intrinsics, num=16, thresh=24.0, r=2, need_inv=True):
""" construct a frame graph between co-visible frames """
N = poses.shape[1]
poses = poses[0].cpu().numpy()
disps = disps[0][:,3::8,3::8].cpu().numpy()
intrinsics = intrinsics[0].cpu().numpy() / 8.0
d = compute_distance_matrix_flow(poses, disps, intrinsics, need_inv)
count = 0
graph = OrderedDict()
for i in range(N):
graph[i] = []
d[i,i] = np.inf
for j in range(i-r, i+r+1):
if 0 <= j < N and i != j:
graph[i].append(j)
d[i,j] = np.inf
count += 1
while count < num:
ix = np.argmin(d)
i, j = ix // N, ix % N
if d[i,j] < thresh:
graph[i].append(j)
d[i,j] = np.inf
count += 1
else:
break
return graph
def build_frame_graph_v2(poses, disps, intrinsics, num=16, thresh=24.0, r=2):
""" construct a frame graph between co-visible frames """
N = poses.shape[1]
# poses = poses[0].cpu().numpy()
# disps = disps[0].cpu().numpy()
# intrinsics = intrinsics[0].cpu().numpy()
d = compute_distance_matrix_flow2(poses, disps, intrinsics)
# import matplotlib.pyplot as plt
# plt.imshow(d)
# plt.show()
count = 0
graph = OrderedDict()
for i in range(N):
graph[i] = []
d[i,i] = np.inf
for j in range(i-r, i+r+1):
if 0 <= j < N and i != j:
graph[i].append(j)
d[i,j] = np.inf
count += 1
while 1:
ix = np.argmin(d)
i, j = ix // N, ix % N
if d[i,j] < thresh:
graph[i].append(j)
for i1 in range(i-1, i+2):
for j1 in range(j-1, j+2):
if 0 <= i1 < N and 0 <= j1 < N:
d[i1, j1] = np.inf
count += 1
else:
break
return graph
================================================
FILE: VO_Module/droid_slam/geom/losses.py
================================================
from collections import OrderedDict
import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F
from lietorch import SO3, SE3, Sim3
from .graph_utils import graph_to_edge_list
from .projective_ops import projective_transform, coords_valid, coords_grid, projective_transform_unsup
def pose_metrics(dE):
""" Translation/Rotation/Scaling metrics from Sim3 """
t, q, s = dE.data.split([3, 4, 1], -1)
ang = SO3(q).log().norm(dim=-1)
# convert radians to degrees
r_err = (180 / np.pi) * ang
t_err = t.norm(dim=-1)
s_err = (s - 1.0).abs()
return r_err, t_err, s_err
def fit_scale(Ps, Gs):
b = Ps.shape[0]
t1 = Ps.data[..., :3].detach().reshape(b, -1)
t2 = Gs.data[..., :3].detach().reshape(b, -1)
s = (t1*t2).sum(-1) / ((t2*t2).sum(-1) + 1e-8)
return s
def geodesic_loss(Ps, Gs, graph, gamma=0.9, do_scale=True):
""" Loss function for training network """
# relative pose
ii, jj, kk = graph_to_edge_list(graph)
dP = Ps[:, jj] * Ps[:, ii].inv()
n = len(Gs)
geodesic_loss = 0.0
for i in range(n):
w = gamma ** (n - i - 1)
dG = Gs[i][:, jj] * Gs[i][:, ii].inv()
if do_scale:
s = fit_scale(dP, dG)
dG = dG.scale(s[:, None])
# pose error
d = (dG * dP.inv()).log()
if isinstance(dG, SE3):
tau, phi = d.split([3, 3], dim=-1)
geodesic_loss += w * (
tau.norm(dim=-1).mean() +
phi.norm(dim=-1).mean())
elif isinstance(dG, Sim3):
tau, phi, sig = d.split([3, 3, 1], dim=-1)
geodesic_loss += w * (
tau.norm(dim=-1).mean() +
phi.norm(dim=-1).mean() +
0.05 * sig.norm(dim=-1).mean())
dE = Sim3(dG * dP.inv()).detach()
r_err, t_err, s_err = pose_metrics(dE)
metrics = {
'rot_error': r_err.mean().item(),
'tr_error': t_err.mean().item(),
'bad_rot': (r_err < .1).float().mean().item(),
'bad_tr': (t_err < .01).float().mean().item(),
}
return geodesic_loss, metrics
def residual_loss(residuals, gamma=0.9):
""" loss on system residuals """
residual_loss = 0.0
n = len(residuals)
for i in range(n):
w = gamma ** (n - i - 1)
residual_loss += w * residuals[i].abs().mean()
return residual_loss, {'residual': residual_loss.item()}
def cam_flow_loss(Ps, disps, poses_est, disps_est, intrinsics, graph, gamma=0.9):
""" optical flow loss """
N = Ps.shape[1]
graph = OrderedDict()
for i in range(N):
graph[i] = [j for j in range(N) if abs(i-j) == 1]
ii, jj, kk = graph_to_edge_list(graph)
coords0, val0 = projective_transform(Ps, disps, intrinsics, ii, jj)
val0 = val0 * (disps[:, ii] > 0).float().unsqueeze(dim=-1)
n = len(poses_est)
cam_flow_loss = 0.0
for i in range(n):
w = gamma ** (n - i - 1)
coords1, val1 = projective_transform(
poses_est[i], disps_est[i], intrinsics, ii, jj)
v = (val0 * val1).squeeze(dim=-1)
epe = v * (coords1 - coords0).norm(dim=-1)
cam_flow_loss += w * epe.mean()
epe = epe.reshape(-1)[v.reshape(-1) > 0.5]
metrics = {
'f_error': epe.mean().item(),
'1px': (epe < 1.0).float().mean().item(),
}
return cam_flow_loss, metrics
def flow_loss(fo_flows, ba_flows, full_flows, graph, gamma=0.9):
"""flow loss"""
fo_vals = fo_flows[..., 2]
ba_vals = ba_flows[..., 2]
n = len(full_flows)
flow_loss = 0
for i in range(n):
w = gamma ** (n - i - 1)
fo_e = ((full_flows[i][:, 0::2, ...] -
fo_flows[..., 0:2]).norm(dim=-1) * fo_vals).mean()
ba_e = ((full_flows[i][:, 1::2, ...] -
ba_flows[..., 0:2]).norm(dim=-1) * ba_vals).mean()
f_e = (fo_e + ba_e) / 2
flow_loss += w * f_e
metrics = {
'pure_f_error': f_e.item()
}
return flow_loss, metrics
def photo_loss(images, full_flows, vals, graph, mode, gamma=0.9, ssim=None,
mean_mask=False, aff_params=None, downsample=False):
"""direct photometric loss"""
N, C, L = images.shape[1], images.shape[2], full_flows[0].shape[1]
ii, jj, kk = graph_to_edge_list(graph)
if downsample:
images = images[..., 3::8, 3::8]
ht, wd = images.shape[-2:]
if mode != 'unsup':
vals = vals[..., 3::8, 3::8, :]
# vals = torch.ones_like(images)[:, :, 0, ..., None]
vals_all = vals[:, ii].view(-1, ht, wd)
images0 = images[:, ii].reshape(-1, C, ht, wd) / 255.0
images1 = images[:, jj].reshape(-1, C, ht, wd) / 255.0
coords0 = coords_grid(ht, wd, device=images.device)
n = len(full_flows)
ph_loss = 0.0
for i in range(n):
w = gamma ** (n - i - 1)
coords_flow = coords0 + full_flows[i]
grid_x = coords_flow[..., 0]/(wd-1)
grid_y = coords_flow[..., 1]/(ht-1)
grid = torch.stack([grid_x, grid_y], dim=-1).view(-1, ht, wd, 2)
grid = grid * 2 - 1
# valid
if mode == 'unsup':
vals_all = vals[i].cuda().view(-1, ht, wd)
val_pix = (grid.abs().max(-1)[0] <= 1).float() * vals_all
# val_pix = (grid.abs().max(-1)[0] <= 1).float()
warped_image0 = F.grid_sample(
images1, grid, padding_mode="border", align_corners=True)
# warped_image0 = F.grid_sample(
# images1, grid, padding_mode="zeros", align_corners=False)
if aff_params is not None:
aff_a = aff_params[i][..., 0].view(-1, 1, 1, 1)
aff_b = (aff_params[i][..., 1] - 0.5).view(-1, 1, 1, 1)
warped_image0 = warped_image0*aff_a + aff_b
diff = compute_reprojection_loss(images0, warped_image0, ssim)
if mean_mask:
p_e = mean_on_mask(diff, val_pix)
else:
p_e = (diff*val_pix).mean()
ph_loss += w * p_e
metrics = {
'ph_error': p_e.item(),
'0.01color': mean_on_mask((diff < 0.01).float(), val_pix).item(),
}
return ph_loss, metrics
def photo_loss_cam(images, poses_est, disps_est, intrinsics,
graph, mode, masks, gamma=0.9, ssim=None):
"""supervise cam flow in ph_loss"""
N, C = images.shape[1], images.shape[2]
ht, wd = images.shape[-2:]
graph = OrderedDict()
for i in range(N):
graph[i] = [j for j in range(N) if abs(i-j) == 1]
ii, jj, kk = graph_to_edge_list(graph)
images0 = images[:, ii].reshape(-1, C, ht, wd)/255.0
images1 = images[:, jj].reshape(-1, C, ht, wd)/255.0
if mode != "unsup":
masks_all = masks[:, ii].view(-1, ht, wd)
n = len(poses_est)
ph_loss = 0
for i in range(n):
w = gamma ** (n - i - 1)
coords_cam, val0 = projective_transform(
poses_est[i], disps_est[i], intrinsics, ii, jj)
grid_x = coords_cam[..., 0]/(wd-1)
grid_y = coords_cam[..., 1]/(ht-1)
grid = torch.stack([grid_x, grid_y], dim=-1).view(-1, ht, wd, 2)
grid = grid * 2 - 1
val_pix = (grid.abs().max(-1)[0] <= 1).float()
val_pix = val_pix * val0.view(-1, ht, wd)
if mode == 'unsup':
masks_all = masks[i].cuda().view(-1, ht, wd)
val_pix = val_pix * masks_all
warped_image0 = F.grid_sample(
images1, grid, padding_mode="border", align_corners=True)
diff = compute_reprojection_loss(images0, warped_image0, ssim)
p_e = (diff*val_pix).mean()
ph_loss += w * p_e
metrics = {
'ph_cam_error': p_e.item(),
'0.01color_cam': mean_on_mask((diff < 0.01).float(), val_pix).item(),
}
return ph_loss, metrics
def unsup_occ_vals(poses_est, disps_est, intrinsics,
downsample, graph, loss, use_one=False):
"""occlusion and dynamic obj valid masks in unsup"""
N = disps_est[0].shape[1]
n = len(poses_est)
if graph == None:
graph = OrderedDict()
for i in range(N):
graph[i] = [j for j in range(N) if abs(i-j) == 1]
ii, jj, kk = graph_to_edge_list(graph)
intrinsics = intrinsics.cpu()
if downsample:
intrinsics /= 8
val_list = []
for i in range(n):
disp_est = disps_est[i].detach().cpu()
pose_est = poses_est[i].detach().cpu()
if downsample:
disp_est = disp_est[:, :, 3::8, 3::8]
ht, wd = disp_est.shape[2], disp_est.shape[3]
if use_one:
val = torch.ones_like(disp_est[:, jj].view(-1, 1, ht, wd))
val_list.append(val)
continue
coords_cam, disp0, _ = projective_transform_unsup(
pose_est, disp_est, intrinsics, ii, jj)
disp0 = disp0.view(-1, 1, ht, wd)
disp1 = disp_est[:, jj].view(-1, 1, ht, wd)
grid_x = coords_cam[..., 0]/(wd-1)
grid_y = coords_cam[..., 1]/(ht-1)
grid = torch.stack([grid_x, grid_y], dim=-1).view(-1, ht, wd, 2)
grid = grid * 2 - 1
warped_disp0 = F.grid_sample(
disp1, grid, padding_mode="border", align_corners=True)
if loss == 'ph_loss':
val = ((1/warped_disp0 - 1/disp0) > -0.005).float()
else:
val = ((1/disp0 - 1/warped_disp0).abs() <= 0.005).float()
val_list.append(val)
return val_list
def unsup_dy_vals(vals, dy_masks, graph):
ii, jj, kk = graph_to_edge_list(graph)
if not isinstance(dy_masks, list):
dy_masks = dy_masks.detach().cpu()
dy_masks = dy_masks[:, :, 3::8, 3::8]
ht, wd = dy_masks.shape[2], dy_masks.shape[3]
dy_val = dy_masks[:, ii].view(-1, 1, ht, wd)
n = len(vals)
val_list = []
for i in range(n):
if isinstance(dy_masks, list):
dy_val = dy_masks[i]
ht, wd = dy_val.shape[2], dy_val.shape[3]
dy_val = dy_val.view(-1, 1, ht, wd)
dy_val = 1 - dy_val
val = torch.clamp(vals[i]+dy_val, min=0, max=1)
val_list.append(val)
return val_list
def compute_reprojection_loss(pred, target, ssim):
"""
From many-depth
Computes reprojection loss between a batch of predicted and target images
"""
abs_diff = torch.abs(target - pred)
l1_loss = abs_diff.mean(1)
if ssim is None:
reprojection_loss = l1_loss
else:
ssim_loss = ssim(pred, target).mean(1)
reprojection_loss = 0.85 * ssim_loss + 0.15 * l1_loss
return reprojection_loss
class SSIM(nn.Module):
"""Layer to compute the SSIM loss between a pair of images
"""
def __init__(self):
super(SSIM, self).__init__()
self.mu_x_pool = nn.AvgPool2d(3, 1)
self.mu_y_pool = nn.AvgPool2d(3, 1)
self.sig_x_pool = nn.AvgPool2d(3, 1)
self.sig_y_pool = nn.AvgPool2d(3, 1)
self.sig_xy_pool = nn.AvgPool2d(3, 1)
self.refl = nn.ReflectionPad2d(1)
self.C1 = 0.01 ** 2
self.C2 = 0.03 ** 2
def forward(self, x, y):
x = self.refl(x)
y = self.refl(y)
mu_x = self.mu_x_pool(x)
mu_y = self.mu_y_pool(y)
sigma_x = self.sig_x_pool(x ** 2) - mu_x ** 2
sigma_y = self.sig_y_pool(y ** 2) - mu_y ** 2
sigma_xy = self.sig_xy_pool(x * y) - mu_x * mu_y
SSIM_n = (2 * mu_x * mu_y + self.C1) * (2 * sigma_xy + self.C2)
SSIM_d = (mu_x ** 2 + mu_y ** 2 + self.C1) * \
(sigma_x + sigma_y + self.C2)
return torch.clamp((1 - SSIM_n / SSIM_d) / 2, 0, 1)
def mean_on_mask(diff, val_pix):
mask = val_pix.expand_as(diff)
if mask.sum() > 10000:
mean_value = (diff * mask).sum() / mask.sum()
else:
print('warning - most pixels are masked.')
mean_value = torch.tensor(0).float().type_as(mask)
return mean_value
def ce_reg_loss(preds, gamma=0.9):
n = len(preds)
entry_loss = 0
for i in range(n):
w = gamma ** (n - i - 1)
e_e = -preds[i] * torch.log(preds[i] + 1e-10)
e_e = e_e.sum(-1).mean()
entry_loss += w*e_e
metrics = {
'mask_entro_error': e_e.item(),
}
return entry_loss, metrics
def unsup_art_label(poses_est, disps_est, intrinsics, full_flows, graph, thresh=0.5,
downsample=True):
ht, wd = full_flows[0].shape[2], full_flows[0].shape[3]
ii, jj, kk = graph_to_edge_list(graph)
intrinsics = intrinsics.cpu()
if downsample:
intrinsics /= 8
coords0 = coords_grid(ht, wd)
n = len(full_flows)
art_list = []
for i in range(n):
full_flow = full_flows[i].detach().cpu()
pose_est = poses_est[i].detach().cpu()
disp_est = disps_est[i].detach().cpu()
if downsample:
disp_est = disp_est[:, :, 3::8, 3::8]
coords_flow = coords0 + full_flow
coords_cam, _ = projective_transform(
pose_est, disp_est, intrinsics, ii, jj)
delta = (coords_flow - coords_cam).norm(dim=-1)
art_mask = (delta <= thresh).float().unsqueeze(-1)
art_list.append(art_mask)
return art_list
def upsample_inter(mask):
batch, num, ht, wd, dim = mask.shape
mask = mask.permute(0, 1, 4, 2, 3).contiguous()
mask = mask.view(batch*num, dim, ht, wd)
mask = F.interpolate(mask, scale_factor=8, mode='bilinear',
align_corners=True, recompute_scale_factor=True)
mask = mask.permute(0, 2, 3, 1).contiguous()
return mask.view(batch, num, 8*ht, 8*wd, dim)
def art_label_loss(art_masks, masks, gamma=0.9, downsample=True):
"""Artificial Labels Loss"""
# ht, wd = masks[0].shape[2], masks[0].shape[3]
# ii, jj, kk = graph_to_edge_list(graph)
# gt_vals_all = gt_vals[:, ii]
n = len(masks)
al_loss = 0.0
for i in range(n):
w = gamma ** (n - i - 1)
if downsample:
art_mask = upsample_inter(art_masks[i]).cuda()
else:
art_mask = art_masks[i].cuda()
diff = ce_func(art_mask, masks[i])
# al_e = (diff*gt_vals_all).mean()
al_e = diff.mean()
al_loss += w * al_e
metrics = {
'art_mask_error': al_e.item(),
'static_px_rate': art_mask.mean().item(),
'dynamic_px_rate': (1 - art_mask).mean().item()
}
return al_loss, metrics
def gt_label_loss(gt_masks, gt_vals, masks, graph, gamma=0.9, mean_mask=False):
"""gt static/dynamic mask loss"""
ii, jj, kk = graph_to_edge_list(graph)
gt_masks_all = gt_masks[:, ii]
gt_vals_all = gt_vals[:, ii]
n = len(masks)
gt_l_loss = 0.0
for i in range(n):
w = gamma ** (n - i - 1)
diff = ce_func(gt_masks_all, masks[i])
if mean_mask:
gt_l_e = mean_on_mask(diff, gt_vals_all)
else:
gt_l_e = (diff*gt_vals_all).mean()
gt_l_loss += w * gt_l_e
metrics = {
'gt_mask_error': gt_l_e.item(),
'static_px_rate': (gt_masks_all*gt_vals_all).mean().item(),
'dynamic_px_rate': ((1-gt_masks_all)*gt_vals_all).mean().item(),
}
return gt_l_loss, metrics
def ce_func(labels, inputs):
pos = labels * torch.log(inputs+1e-10)
neg = (1-labels) * torch.log(1-inputs+1e-10)
return -(pos + neg)
def consistency_loss(masks, n_frames, graph, gamma=0.9):
"""consistency loss to help mask be the same"""
ii, jj, kk = graph_to_edge_list(graph)
edge_cnt = [0]*(n_frames+1)
for i in ii:
edge_cnt[i+1] += 1
for i in ii:
edge_cnt[i+1] += edge_cnt[i]
n = len(masks)
con_loss = 0
for i in range(n):
w = gamma ** (n - i - 1)
con_e = 0
for j in range(n_frames):
tmp_mask = masks[i][:, edge_cnt[j]:edge_cnt[j+1]]
tmp_mask_m = tmp_mask.mean(1, keepdim=True)
con_e += (tmp_mask-tmp_mask_m).mean()
con_e /= n_frames
con_loss += con_e*w
metrics = {
'con_error': con_e.item()
}
return con_loss, metrics
================================================
FILE: VO_Module/droid_slam/geom/projective_ops.py
================================================
import torch
import torch.nn.functional as F
from lietorch import SE3, Sim3
MIN_DEPTH = 0.2
def extract_intrinsics(intrinsics):
return intrinsics[..., None, None, :].unbind(dim=-1)
def coords_grid(ht, wd, **kwargs):
y, x = torch.meshgrid(
torch.arange(ht).to(**kwargs).float(),
torch.arange(wd).to(**kwargs).float())
return torch.stack([x, y], dim=-1)
def iproj(disps, intrinsics, jacobian=False):
""" pinhole camera inverse projection """
ht, wd = disps.shape[2:]
fx, fy, cx, cy = extract_intrinsics(intrinsics)
y, x = torch.meshgrid(
torch.arange(ht).to(disps.device).float(),
torch.arange(wd).to(disps.device).float())
i = torch.ones_like(disps)
X = (x - cx) / fx
Y = (y - cy) / fy
pts = torch.stack([X, Y, i, disps], dim=-1)
if jacobian:
J = torch.zeros_like(pts)
J[..., -1] = 1.0
return pts, J
return pts, None
def proj(Xs, intrinsics, jacobian=False, return_depth=False):
""" pinhole camera projection """
fx, fy, cx, cy = extract_intrinsics(intrinsics)
X, Y, Z, D = Xs.unbind(dim=-1)
Z = torch.where(Z < 0.5*MIN_DEPTH, torch.ones_like(Z), Z)
d = 1.0 / Z
x = fx * (X * d) + cx
y = fy * (Y * d) + cy
if return_depth:
coords = torch.stack([x, y, D*d], dim=-1)
else:
coords = torch.stack([x, y], dim=-1)
if jacobian:
B, N, H, W = d.shape
o = torch.zeros_like(d)
proj_jac = torch.stack([
fx*d, o, -fx*X*d*d, o,
o, fy*d, -fy*Y*d*d, o,
# o, o, -D*d*d, d,
], dim=-1).view(B, N, H, W, 2, 4)
return coords, proj_jac
return coords, None
def actp(Gij, X0, jacobian=False):
""" action on point cloud """
X1 = Gij[:, :, None, None] * X0
if jacobian:
X, Y, Z, d = X1.unbind(dim=-1)
o = torch.zeros_like(d)
B, N, H, W = d.shape
if isinstance(Gij, SE3):
Ja = torch.stack([
d, o, o, o, Z, -Y,
o, d, o, -Z, o, X,
o, o, d, Y, -X, o,
o, o, o, o, o, o,
], dim=-1).view(B, N, H, W, 4, 6)
elif isinstance(Gij, Sim3):
Ja = torch.stack([
d, o, o, o, Z, -Y, X,
o, d, o, -Z, o, X, Y,
o, o, d, Y, -X, o, Z,
o, o, o, o, o, o, o
], dim=-1).view(B, N, H, W, 4, 7)
return X1, Ja
return X1, None
def projective_transform(poses, depths, intrinsics, ii, jj, jacobian=False, return_depth=False):
""" map points from ii->jj """
# inverse project (pinhole)
X0, Jz = iproj(depths[:, ii], intrinsics[:, ii], jacobian=jacobian)
# transform: both pose i and j are w2c
Gij = poses[:, jj] * poses[:, ii].inv()
X1, Ja = actp(Gij, X0, jacobian=jacobian)
# project (pinhole)
x1, Jp = proj(X1, intrinsics[:, jj],
jacobian=jacobian, return_depth=return_depth)
# exclude points too close to camera
valid = ((X1[..., 2] > MIN_DEPTH) & (X0[..., 2] > MIN_DEPTH)).float()
valid = valid.unsqueeze(-1)
if jacobian:
# Ji transforms according to dual adjoint
Jj = torch.matmul(Jp, Ja)
Ji = -Gij[:, :, None, None, None].adjT(Jj)
Jz = Gij[:, :, None, None] * Jz
Jz = torch.matmul(Jp, Jz.unsqueeze(-1))
return x1, valid, (Ji, Jj, Jz)
return x1, valid
def projective_transform_unsup(poses, depths, intrinsics, ii, jj, jacobian=False, return_depth=True):
""" map points from ii->jj """
# inverse project (pinhole)
X0, Jz = iproj(depths[:, ii], intrinsics[:, ii], jacobian=jacobian)
# transform: both pose i and j are w2c
Gij = poses[:, jj] * poses[:, ii].inv()
X1, Ja = actp(Gij, X0, jacobian=jacobian)
# project (pinhole)
# 返回的深度是逆深度
coords_disp, Jp = proj(X1, intrinsics[:, jj],
jacobian=jacobian, return_depth=return_depth)
x1, disp0 = coords_disp[..., 0:2], coords_disp[..., 2:3]
# exclude points too close to camera
valid = ((X1[..., 2] > MIN_DEPTH) & (X0[..., 2] > MIN_DEPTH)).float()
valid = valid.unsqueeze(-1)
if jacobian:
# Ji transforms according to dual adjoint
Jj = torch.matmul(Jp, Ja)
Ji = -Gij[:, :, None, None, None].adjT(Jj)
Jz = Gij[:, :, None, None] * Jz
Jz = torch.matmul(Jp, Jz.unsqueeze(-1))
return x1, disp0, valid, (Ji, Jj, Jz)
return x1, disp0, valid
def induced_flow(poses, disps, intrinsics, ii, jj):
""" optical flow induced by camera motion """
ht, wd = disps.shape[2:]
y, x = torch.meshgrid(
torch.arange(ht).to(disps.device).float(),
torch.arange(wd).to(disps.device).float())
coords0 = torch.stack([x, y], dim=-1)
coords1, valid = projective_transform(
poses, disps, intrinsics, ii, jj, False)
return coords1[..., :2] - coords0, valid
def coords_clamp(coords, h_max, w_max, h_min=0, w_min=0):
x_clamp = torch.clamp(coords[..., 0], w_min, w_max)
y_clamp = torch.clamp(coords[..., 1], h_min, h_max)
return torch.stack([x_clamp, y_clamp], dim=-1)
def coords_valid(coords, h_max, w_max, h_min=0, w_min=0, neg_fac=0.1):
val_p = ((coords[..., 0] < w_max) & (coords[..., 0] >= w_min) &
(coords[..., 1] < h_max) & (coords[..., 1] >= h_min)).float().unsqueeze(-1)
val_n = ((coords[..., 0] >= w_max) | (coords[..., 0] < w_min) |
(coords[..., 1] >= h_max) | (coords[..., 1] < h_min)).float().unsqueeze(-1)*neg_fac
val = val_p+val_n
return val
================================================
FILE: VO_Module/droid_slam/logger.py
================================================
import torch
from torch.utils.tensorboard import SummaryWriter
SUM_FREQ = 100
class Logger:
def __init__(self, name, scheduler):
self.total_steps = 0
self.running_loss = {}
self.writer = None
self.name = name
self.scheduler = scheduler
def _print_training_status(self):
if self.writer is None:
self.writer = SummaryWriter('runs/%s' % self.name)
print([k for k in self.running_loss])
lr = self.scheduler.get_lr().pop()
metrics_data = [self.running_loss[k]/SUM_FREQ for k in self.running_loss.keys()]
training_str = "[{:6d}, {:10.7f}] ".format(self.total_steps+1, lr)
metrics_str = ("{:10.4f}, "*len(metrics_data)).format(*metrics_data)
# print the training status
print(training_str + metrics_str)
for key in self.running_loss:
val = self.running_loss[key] / SUM_FREQ
self.writer.add_scalar(key, val, self.total_steps)
self.running_loss[key] = 0.0
def push(self, metrics):
for key in metrics:
if key not in self.running_loss:
self.running_loss[key] = 0.0
self.running_loss[key] += metrics[key]
if self.total_steps % SUM_FREQ == SUM_FREQ-1:
self._print_training_status()
self.running_loss = {}
self.total_steps += 1
def write_dict(self, results):
for key in results:
self.writer.add_scalar(key, results[key], self.total_steps)
def close(self):
self.writer.close()
================================================
FILE: VO_Module/droid_slam/modules/__init__.py
================================================
================================================
FILE: VO_Module/droid_slam/modules/clipping.py
================================================
import torch
import torch.nn as nn
import torch.nn.functional as F
GRAD_CLIP = .01
class GradClip(torch.autograd.Function):
@staticmethod
def forward(ctx, x):
return x
@staticmethod
def backward(ctx, grad_x):
o = torch.zeros_like(grad_x)
grad_x = torch.where(grad_x.abs()>GRAD_CLIP, o, grad_x)
grad_x = torch.where(torch.isnan(grad_x), o, grad_x)
return grad_x
class GradientClip(nn.Module):
def __init__(self):
super(GradientClip, self).__init__()
def forward(self, x):
return GradClip.apply(x)
================================================
FILE: VO_Module/droid_slam/modules/corr.py
================================================
import torch
import torch.nn.functional as F
import droid_backends
class CorrSampler(torch.autograd.Function):
@staticmethod
def forward(ctx, volume, coords, radius):
ctx.save_for_backward(volume,coords)
ctx.radius = radius
corr, = droid_backends.corr_index_forward(volume, coords, radius)
return corr
@staticmethod
def backward(ctx, grad_output):
volume, coords = ctx.saved_tensors
grad_output = grad_output.contiguous()
grad_volume, = droid_backends.corr_index_backward(volume, coords, grad_output, ctx.radius)
return grad_volume, None, None
class CorrBlock:
def __init__(self, fmap1, fmap2, num_levels=4, radius=3):
self.num_levels = num_levels
self.radius = radius
self.corr_pyramid = []
# all pairs correlation
corr = CorrBlock.corr(fmap1, fmap2)
batch, num, h1, w1, h2, w2 = corr.shape
corr = corr.reshape(batch*num*h1*w1, 1, h2, w2)
for i in range(self.num_levels):
self.corr_pyramid.append(
corr.view(batch*num, h1, w1, h2//2**i, w2//2**i))
corr = F.avg_pool2d(corr, 2, stride=2)
def __call__(self, coords):
out_pyramid = []
batch, num, ht, wd, _ = coords.shape
coords = coords.permute(0,1,4,2,3)
coords = coords.contiguous().view(batch*num, 2, ht, wd)
for i in range(self.num_levels):
corr = CorrSampler.apply(self.corr_pyramid[i], coords/2**i, self.radius)
out_pyramid.append(corr.view(batch, num, -1, ht, wd))
return torch.cat(out_pyramid, dim=2)
def cat(self, other):
for i in range(self.num_levels):
self.corr_pyramid[i] = torch.cat([self.corr_pyramid[i], other.corr_pyramid[i]], 0)
return self
def __getitem__(self, index):
for i in range(self.num_levels):
self.corr_pyramid[i] = self.corr_pyramid[i][index]
return self
@staticmethod
def corr(fmap1, fmap2):
""" all-pairs correlation """
batch, num, dim, ht, wd = fmap1.shape
fmap1 = fmap1.reshape(batch*num, dim, ht*wd) / 4.0
fmap2 = fmap2.reshape(batch*num, dim, ht*wd) / 4.0
corr = torch.matmul(fmap1.transpose(1,2), fmap2)
return corr.view(batch, num, ht, wd, ht, wd)
class CorrLayer(torch.autograd.Function):
@staticmethod
def forward(ctx, fmap1, fmap2, coords, r):
ctx.r = r
ctx.save_for_backward(fmap1, fmap2, coords)
corr, = droid_backends.altcorr_forward(fmap1, fmap2, coords, ctx.r)
return corr
@staticmethod
def backward(ctx, grad_corr):
fmap1, fmap2, coords = ctx.saved_tensors
grad_corr = grad_corr.contiguous()
fmap1_grad, fmap2_grad, coords_grad = \
droid_backends.altcorr_backward(fmap1, fmap2, coords, grad_corr, ctx.r)
return fmap1_grad, fmap2_grad, coords_grad, None
class AltCorrBlock:
def __init__(self, fmaps, num_levels=4, radius=3):
self.num_levels = num_levels
self.radius = radius
B, N, C, H, W = fmaps.shape
fmaps = fmaps.view(B*N, C, H, W) / 4.0
self.pyramid = []
for i in range(self.num_levels):
sz = (B, N, H//2**i, W//2**i, C)
fmap_lvl = fmaps.permute(0, 2, 3, 1).contiguous()
self.pyramid.append(fmap_lvl.view(*sz))
fmaps = F.avg_pool2d(fmaps, 2, stride=2)
def corr_fn(self, coords, ii, jj):
B, N, H, W, S, _ = coords.shape
coords = coords.permute(0, 1, 4, 2, 3, 5)
corr_list = []
for i in range(self.num_levels):
r = self.radius
fmap1_i = self.pyramid[0][:, ii]
fmap2_i = self.pyramid[i][:, jj]
coords_i = (coords / 2**i).reshape(B*N, S, H, W, 2).contiguous()
fmap1_i = fmap1_i.reshape((B*N,) + fmap1_i.shape[2:])
fmap2_i = fmap2_i.reshape((B*N,) + fmap2_i.shape[2:])
corr = CorrLayer.apply(fmap1_i.float(), fmap2_i.float(), coords_i, self.radius)
corr = corr.view(B, N, S, -1, H, W).permute(0, 1, 3, 4, 5, 2)
corr_list.append(corr)
corr = torch.cat(corr_list, dim=2)
return corr
def __call__(self, coords, ii, jj):
squeeze_output = False
if len(coords.shape) == 5:
coords = coords.unsqueeze(dim=-2)
squeeze_output = True
corr = self.corr_fn(coords, ii, jj)
if squeeze_output:
corr = corr.squeeze(dim=-1)
return corr.contiguous()
================================================
FILE: VO_Module/droid_slam/modules/extractor.py
================================================
import torch
import torch.nn as nn
import torch.nn.functional as F
class ResidualBlock(nn.Module):
def __init__(self, in_planes, planes, norm_fn='group', stride=1):
super(ResidualBlock, self).__init__()
self.conv1 = nn.Conv2d(in_planes, planes, kernel_size=3, padding=1, stride=stride)
self.conv2 = nn.Conv2d(planes, planes, kernel_size=3, padding=1)
self.relu = nn.ReLU(inplace=True)
num_groups = planes // 8
if norm_fn == 'group':
self.norm1 = nn.GroupNorm(num_groups=num_groups, num_channels=planes)
self.norm2 = nn.GroupNorm(num_groups=num_groups, num_channels=planes)
if not stride == 1:
self.norm3 = nn.GroupNorm(num_groups=num_groups, num_channels=planes)
elif norm_fn == 'batch':
self.norm1 = nn.BatchNorm2d(planes)
self.norm2 = nn.BatchNorm2d(planes)
if not stride == 1:
self.norm3 = nn.BatchNorm2d(planes)
elif norm_fn == 'instance':
self.norm1 = nn.InstanceNorm2d(planes)
self.norm2 = nn.InstanceNorm2d(planes)
if not stride == 1:
self.norm3 = nn.InstanceNorm2d(planes)
elif norm_fn == 'none':
self.norm1 = nn.Sequential()
self.norm2 = nn.Sequential()
if not stride == 1:
self.norm3 = nn.Sequential()
if stride == 1:
self.downsample = None
else:
self.downsample = nn.Sequential(
nn.Conv2d(in_planes, planes, kernel_size=1, stride=stride), self.norm3)
def forward(self, x):
y = x
y = self.relu(self.norm1(self.conv1(y)))
y = self.relu(self.norm2(self.conv2(y)))
if self.downsample is not None:
x = self.downsample(x)
return self.relu(x+y)
class BottleneckBlock(nn.Module):
def __init__(self, in_planes, planes, norm_fn='group', stride=1):
super(BottleneckBlock, self).__init__()
self.conv1 = nn.Conv2d(in_planes, planes//4, kernel_size=1, padding=0)
self.conv2 = nn.Conv2d(planes//4, planes//4, kernel_size=3, padding=1, stride=stride)
self.conv3 = nn.Conv2d(planes//4, planes, kernel_size=1, padding=0)
self.relu = nn.ReLU(inplace=True)
num_groups = planes // 8
if norm_fn == 'group':
self.norm1 = nn.GroupNorm(num_groups=num_groups, num_channels=planes//4)
self.norm2 = nn.GroupNorm(num_groups=num_groups, num_channels=planes//4)
self.norm3 = nn.GroupNorm(num_groups=num_groups, num_channels=planes)
if not stride == 1:
self.norm4 = nn.GroupNorm(num_groups=num_groups, num_channels=planes)
elif norm_fn == 'batch':
self.norm1 = nn.BatchNorm2d(planes//4)
self.norm2 = nn.BatchNorm2d(planes//4)
self.norm3 = nn.BatchNorm2d(planes)
if not stride == 1:
self.norm4 = nn.BatchNorm2d(planes)
elif norm_fn == 'instance':
self.norm1 = nn.InstanceNorm2d(planes//4)
self.norm2 = nn.InstanceNorm2d(planes//4)
self.norm3 = nn.InstanceNorm2d(planes)
if not stride == 1:
self.norm4 = nn.InstanceNorm2d(planes)
elif norm_fn == 'none':
self.norm1 = nn.Sequential()
self.norm2 = nn.Sequential()
self.norm3 = nn.Sequential()
if not stride == 1:
self.norm4 = nn.Sequential()
if stride == 1:
self.downsample = None
else:
self.downsample = nn.Sequential(
nn.Conv2d(in_planes, planes, kernel_size=1, stride=stride), self.norm4)
def forward(self, x):
y = x
y = self.relu(self.norm1(self.conv1(y)))
y = self.relu(self.norm2(self.conv2(y)))
y = self.relu(self.norm3(self.conv3(y)))
if self.downsample is not None:
x = self.downsample(x)
return self.relu(x+y)
DIM=32
class BasicEncoder(nn.Module):
def __init__(self, output_dim=128, norm_fn='batch', dropout=0.0, multidim=False):
super(BasicEncoder, self).__init__()
self.norm_fn = norm_fn
self.multidim = multidim
if self.norm_fn == 'group':
self.norm1 = nn.GroupNorm(num_groups=8, num_channels=DIM)
elif self.norm_fn == 'batch':
self.norm1 = nn.BatchNorm2d(DIM)
elif self.norm_fn == 'instance':
self.norm1 = nn.InstanceNorm2d(DIM)
elif self.norm_fn == 'none':
self.norm1 = nn.Sequential()
self.conv1 = nn.Conv2d(3, DIM, kernel_size=7, stride=2, padding=3)
self.relu1 = nn.ReLU(inplace=True)
self.in_planes = DIM
self.layer1 = self._make_layer(DIM, stride=1)
self.layer2 = self._make_layer(2*DIM, stride=2)
self.layer3 = self._make_layer(4*DIM, stride=2)
# output convolution
self.conv2 = nn.Conv2d(4*DIM, output_dim, kernel_size=1)
if self.multidim:
self.layer4 = self._make_layer(256, stride=2)
self.layer5 = self._make_layer(512, stride=2)
self.in_planes = 256
self.layer6 = self._make_layer(256, stride=1)
self.in_planes = 128
self.layer7 = self._make_layer(128, stride=1)
self.up1 = nn.Conv2d(512, 256, 1)
self.up2 = nn.Conv2d(256, 128, 1)
self.conv3 = nn.Conv2d(128, output_dim, kernel_size=1)
if dropout > 0:
self.dropout = nn.Dropout2d(p=dropout)
else:
self.dropout = None
for m in self.modules():
if isinstance(m, nn.Conv2d):
nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')
elif isinstance(m, (nn.BatchNorm2d, nn.InstanceNorm2d, nn.GroupNorm)):
if m.weight is not None:
nn.init.constant_(m.weight, 1)
if m.bias is not None:
nn.init.constant_(m.bias, 0)
def _make_layer(self, dim, stride=1):
layer1 = ResidualBlock(self.in_planes, dim, self.norm_fn, stride=stride)
layer2 = ResidualBlock(dim, dim, self.norm_fn, stride=1)
layers = (layer1, layer2)
self.in_planes = dim
return nn.Sequential(*layers)
def forward(self, x):
b, n, c1, h1, w1 = x.shape
x = x.view(b*n, c1, h1, w1)
x = self.conv1(x)
x = self.norm1(x)
x = self.relu1(x)
x = self.layer1(x)
x = self.layer2(x)
x = self.layer3(x)
x = self.conv2(x)
_, c2, h2, w2 = x.shape
return x.view(b, n, c2, h2, w2)
================================================
FILE: VO_Module/droid_slam/modules/gru.py
================================================
import torch
import torch.nn as nn
class ConvGRU(nn.Module):
def __init__(self, h_planes=128, i_planes=128):
super(ConvGRU, self).__init__()
self.do_checkpoint = False
self.convz = nn.Conv2d(h_planes+i_planes, h_planes, 3, padding=1)
self.convr = nn.Conv2d(h_planes+i_planes, h_planes, 3, padding=1)
self.convq = nn.Conv2d(h_planes+i_planes, h_planes, 3, padding=1)
self.w = nn.Conv2d(h_planes, h_planes, 1, padding=0)
self.convz_glo = nn.Conv2d(h_planes, h_planes, 1, padding=0)
self.convr_glo = nn.Conv2d(h_planes, h_planes, 1, padding=0)
self.convq_glo = nn.Conv2d(h_planes, h_planes, 1, padding=0)
def forward(self, net, *inputs):
inp = torch.cat(inputs, dim=1)
net_inp = torch.cat([net, inp], dim=1)
b, c, h, w = net.shape
glo = torch.sigmoid(self.w(net)) * net
glo = glo.view(b, c, h*w).mean(-1).view(b, c, 1, 1)
z = torch.sigmoid(self.convz(net_inp) + self.convz_glo(glo))
r = torch.sigmoid(self.convr(net_inp) + self.convr_glo(glo))
q = torch.tanh(self.convq(torch.cat([r*net, inp], dim=1)) + self.convq_glo(glo))
net = (1-z) * net + z * q
return net
================================================
FILE: VO_Module/droid_slam/motion_filter.py
================================================
import cv2
import torch
import lietorch
from collections import OrderedDict
from droid_net import DroidNet
import geom.projective_ops as pops
from modules.corr import CorrBlock
import time
class MotionFilter:
""" This class is used to filter incoming frames and extract features """
def __init__(self, net, video, thresh=2.5, device="cuda:0"):
# split net modules
self.cnet = net.cnet
self.fnet = net.fnet
self.update = net.update
self.video = video
self.thresh = thresh
self.device = device
self.count = 0
# mean, std for image normalization
self.MEAN = torch.as_tensor([0.485, 0.456, 0.406], device=self.device)[
:, None, None]
self.STDV = torch.as_tensor([0.229, 0.224, 0.225], device=self.device)[
:, None, None]
@torch.cuda.amp.autocast(enabled=True)
def __context_encoder(self, image):
""" context features """
x = self.cnet(image)
net, inp = self.cnet(image).split([128, 128], dim=2)
return net.tanh().squeeze(0), inp.relu().squeeze(0)
@torch.cuda.amp.autocast(enabled=True)
def __feature_encoder(self, image):
""" features for correlation volume """
return self.fnet(image).squeeze(0)
@torch.cuda.amp.autocast(enabled=True)
@torch.no_grad()
def track(self, tstamp, image, depth=None, intrinsics=None, segments=None):
""" main update operation - run on every frame in video """
Id = lietorch.SE3.Identity(1,).data.squeeze()
ht = image.shape[-2] // 8
wd = image.shape[-1] // 8
# normalize images
inputs = image[None, None, [2, 1, 0]].to(self.device) / 255.0
inputs = inputs.sub_(self.MEAN).div_(self.STDV)
# extract features
gmap = self.__feature_encoder(inputs)
### always add first frame to the depth video ###
if self.video.counter.value == 0:
net, inp = self.__context_encoder(inputs)
self.net, self.inp, self.fmap = net, inp, gmap
self.video.append(tstamp, image, Id, 1.0,
intrinsics / 8.0, gmap[0], net[0], inp[0], segments)
### only add new frame if there is enough motion ###
else:
# index correlation volume
coords0 = pops.coords_grid(ht, wd, device=self.device)[None, None]
corr = CorrBlock(self.fmap[None], gmap[None])(coords0)
# approximate flow magnitude using 1 update iteration
_, delta, weight, _ = self.update(
self.net[None], self.inp[None], corr, segments=None)
# check motion magnitue / add new frame to video
if delta[..., 0:2].norm(dim=-1).mean().item() > self.thresh:
self.count = 0
net, inp = self.__context_encoder(inputs)
self.net, self.inp, self.fmap = net, inp, gmap
self.video.append(tstamp, image, None, None,
intrinsics / 8.0, gmap[0], net[0], inp[0], segments)
else:
self.count += 1
@torch.cuda.amp.autocast(enabled=True)
@torch.no_grad()
def track_vo(self, tstamp, image, depth=None, intrinsics=None, segments=None):
""" main update operation - run on every frame in video """
Id = lietorch.SE3.Identity(1,).data.squeeze()
ht = image.shape[-2] // 8
wd = image.shape[-1] // 8
inputs = image[None, None, [2, 1, 0]].to(self.device) / 255.0
inputs = inputs.sub_(self.MEAN).div_(self.STDV)
gmap = self.__feature_encoder(inputs)
net, inp = self.__context_encoder(inputs)
if self.video.counter.value == 0:
self.video.append(tstamp, image, Id, 1.0,
intrinsics / 8.0, gmap[0], net[0], inp[0], segments)
else:
self.video.append(tstamp, image, None, None,
intrinsics / 8.0, gmap[0], net[0], inp[0], segments)
================================================
FILE: VO_Module/droid_slam/trajectory_filler.py
================================================
import cv2
import torch
import lietorch
from lietorch import SE3
from collections import OrderedDict
from factor_graph import FactorGraph
from droid_net import DroidNet
import geom.projective_ops as pops
class PoseTrajectoryFiller:
""" This class is used to fill in non-keyframe poses """
def __init__(self, net, video, device="cuda:0"):
# split net modules
self.cnet = net.cnet
self.fnet = net.fnet
self.update = net.update
self.count = 0
self.video = video
self.device = device
# mean, std for image normalization
self.MEAN = torch.as_tensor([0.485, 0.456, 0.406], device=self.device)[:, None, None]
self.STDV = torch.as_tensor([0.229, 0.224, 0.225], device=self.device)[:, None, None]
@torch.cuda.amp.autocast(enabled=True)
def __feature_encoder(self, image):
""" features for correlation volume """
return self.fnet(image).squeeze(0)
def __fill(self, tstamps, images, intrinsics):
""" fill operator """
tt = torch.as_tensor(tstamps, device=self.device)
images = torch.stack(images, 0)
intrinsics = torch.stack(intrinsics, 0)
inputs = images[None,:,[2,1,0]].to(self.device) / 255.0
### linear pose interpolation ###
N = self.video.counter.value
M = len(tstamps)
ts = self.video.tstamp[:N]
Ps = SE3(self.video.poses[:N])
t0 = torch.as_tensor([ts[ts<=t].shape[0] - 1 for t in tstamps])
t1 = torch.where(t0<N-1, t0+1, t0)
dt = ts[t1] - ts[t0] + 1e-3
dP = Ps[t1] * Ps[t0].inv()
v = dP.log() / dt.unsqueeze(-1)
w = v * (tt - ts[t0]).unsqueeze(-1)
Gs = SE3.exp(w) * Ps[t0]
# extract features (no need for context features)
inputs = inputs.sub_(self.MEAN).div_(self.STDV)
fmap = self.__feature_encoder(inputs)
self.video.counter.value += M
self.video[N:N+M] = (tt, images, Gs.data, 1, intrinsics / 8.0, fmap)
graph = FactorGraph(self.video, self.update)
graph.add_factors(t0.to(self.device), torch.arange(N, N+M).to(self.device))
graph.add_factors(t1.to(self.device), torch.arange(N, N+M).to(self.device))
for itr in range(6):
graph.update(N, N+M, motion_only=True)
Gs = SE3(self.video.poses[N:N+M].clone())
self.video.counter.value -= M
return [ Gs ]
@torch.no_grad()
def __call__(self, image_stream):
""" fill in poses of non-keyframe images """
# store all camera poses
pose_list = []
tstamps = []
images = []
intrinsics = []
for (tstamp, image, intrinsic, segments) in image_stream:
tstamps.append(tstamp)
images.append(image)
intrinsics.append(intrinsic)
if len(tstamps) == 16:
pose_list += self.__fill(tstamps, images, intrinsics)
tstamps, images, intrinsics = [], [], []
if len(tstamps) > 0:
pose_list += self.__fill(tstamps, images, intrinsics)
# stitch pose segments together
return lietorch.cat(pose_list, 0)
================================================
FILE: VO_Module/droid_slam/visualization.py
================================================
import torch
import cv2
import lietorch
import droid_backends
import time
import argparse
import numpy as np
import open3d as o3d
from lietorch import SE3
import geom.projective_ops as pops
CAM_POINTS = np.array([
[ 0, 0, 0],
[-1, -1, 1.5],
[ 1, -1, 1.5],
[ 1, 1, 1.5],
[-1, 1, 1.5],
[-0.5, 1, 1.5],
[ 0.5, 1, 1.5],
[ 0, 1.2, 1.5]])
CAM_LINES = np.array([
[1,2], [2,3], [3,4], [4,1], [1,0], [0,2], [3,0], [0,4], [5,7], [7,6]])
def white_balance(img):
# from https://stackoverflow.com/questions/46390779/automatic-white-balancing-with-grayworld-assumption
result = cv2.cvtColor(img, cv2.COLOR_BGR2LAB)
avg_a = np.average(result[:, :, 1])
avg_b = np.average(result[:, :, 2])
result[:, :, 1] = result[:, :, 1] - ((avg_a - 128) * (result[:, :, 0] / 255.0) * 1.1)
result[:, :, 2] = result[:, :, 2] - ((avg_b - 128) * (result[:, :, 0] / 255.0) * 1.1)
result = cv2.cvtColor(result, cv2.COLOR_LAB2BGR)
return result
def create_camera_actor(g, scale=0.05):
""" build open3d camera polydata """
camera_actor = o3d.geometry.LineSet(
points=o3d.utility.Vector3dVector(scale * CAM_POINTS),
lines=o3d.utility.Vector2iVector(CAM_LINES))
color = (g * 1.0, 0.5 * (1-g), 0.9 * (1-g))
camera_actor.paint_uniform_color(color)
return camera_actor
def create_point_actor(points, colors):
""" open3d point cloud from numpy array """
point_cloud = o3d.geometry.PointCloud()
point_cloud.points = o3d.utility.Vector3dVector(points)
point_cloud.colors = o3d.utility.Vector3dVector(colors)
return point_cloud
def droid_visualization(video, device="cuda:0"):
""" DROID visualization frontend """
torch.cuda.set_device(device)
droid_visualization.video = video
droid_visualization.cameras = {}
droid_visualization.points = {}
droid_visualization.warmup = 8
droid_visualization.scale = 1.0
droid_visualization.ix = 0
droid_visualization.filter_thresh = 0.005
def increase_filter(vis):
droid_visualization.filter_thresh *= 2
with droid_visualization.video.get_lock():
droid_visualization.video.dirty[:droid_visualization.video.counter.value] = True
def decrease_filter(vis):
droid_visualization.filter_thresh *= 0.5
with droid_visualization.video.get_lock():
droid_visualization.video.dirty[:droid_visualization.video.counter.value] = True
def animation_callback(vis):
cam = vis.get_view_control().convert_to_pinhole_camera_parameters()
with torch.no_grad():
with video.get_lock():
t = video.counter.value
dirty_index, = torch.where(video.dirty.clone())
dirty_index = dirty_index
if len(dirty_index) == 0:
return
video.dirty[dirty_index] = False
# convert poses to 4x4 matrix
poses = torch.index_select(video.poses, 0, dirty_index)
disps = torch.index_select(video.disps, 0, dirty_index)
Ps = SE3(poses).inv().matrix().cpu().numpy()
images = torch.index_select(video.images, 0, dirty_index)
images = images.cpu()[:,[2,1,0],3::8,3::8].permute(0,2,3,1) / 255.0
points = droid_backends.iproj(SE3(poses).inv().data, disps, video.intrinsics[0]).cpu()
thresh = droid_visualization.filter_thresh * torch.ones_like(disps.mean(dim=[1,2]))
count = droid_backends.depth_filter(
video.poses, video.disps, video.intrinsics[0], dirty_index, thresh)
count = count.cpu()
disps = disps.cpu()
masks = ((count >= 2) & (disps > .5*disps.mean(dim=[1,2], keepdim=True)))
for i in range(len(dirty_index)):
pose = Ps[i]
ix = dirty_index[i].item()
if ix in droid_visualization.cameras:
vis.remove_geometry(droid_visualization.cameras[ix])
del droid_visualization.cameras[ix]
if ix in droid_visualization.points:
vis.remove_geometry(droid_visualization.points[ix])
del droid_visualization.points[ix]
### add camera actor ###
cam_actor = create_camera_actor(True)
cam_actor.transform(pose)
vis.add_geometry(cam_actor)
droid_visualization.cameras[ix] = cam_actor
mask = masks[i].reshape(-1)
pts = points[i].reshape(-1, 3)[mask].cpu().numpy()
clr = images[i].reshape(-1, 3)[mask].cpu().numpy()
## add point actor ###
point_actor = create_point_actor(pts, clr)
vis.add_geometry(point_actor)
droid_visualization.points[ix] = point_actor
# hack to allow interacting with vizualization during inference
if len(droid_visualization.cameras) >= droid_visualization.warmup:
cam = vis.get_view_control().convert_from_pinhole_camera_parameters(cam)
droid_visualization.ix += 1
vis.poll_events()
vis.update_renderer()
### create Open3D visualization ###
vis = o3d.visualization.VisualizerWithKeyCallback()
vis.register_animation_callback(animation_callback)
vis.register_key_callback(ord("S"), increase_filter)
vis.register_key_callback(ord("A"), decrease_filter)
vis.create_window(height=540, width=960)
vis.get_render_option().load_from_json("misc/renderoption.json")
vis.run()
vis.destroy_window()
================================================
FILE: VO_Module/environment.yaml
================================================
name: droidenv
channels:
- rusty1s
- pytorch
- open3d-admin
- nvidia
- conda-forge
- defaults
dependencies:
- pytorch-scatter
- torchaudio
- torchvision
- open3d
- pytorch
- cudatoolkit
- tensorboard
- scipy
- opencv
- tqdm
- suitesparse
- matplotlib
- pyyaml
================================================
FILE: VO_Module/environment_novis.yaml
================================================
name: droidenv
channels:
- rusty1s
- pytorch
- nvidia
- conda-forge
- defaults
dependencies:
- pytorch-scatter
- torchaudio
- torchvision
- pytorch
- cudatoolkit=11.1
- tensorboard
- scipy
- opencv
- tqdm
- suitesparse
- matplotlib
- pyyaml
================================================
FILE: VO_Module/evaluation_scripts/flow_vis_utils.py
================================================
# Flow visualization code used from https://github.com/tomrunia/OpticalFlow_Visualization
# MIT License
#
# Copyright (c) 2018 Tom Runia
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to conditions.
#
# Author: Tom Runia
# Date Created: 2018-08-03
import numpy as np
def make_colorwheel():
"""
Generates a color wheel for optical flow visualization as presented in:
Baker et al. "A Database and Evaluation Methodology for Optical Flow" (ICCV, 2007)
URL: http://vision.middlebury.edu/flow/flowEval-iccv07.pdf
Code follows the original C++ source code of Daniel Scharstein.
Code follows the the Matlab source code of Deqing Sun.
Returns:
np.ndarray: Color wheel
"""
RY = 15
YG = 6
GC = 4
CB = 11
BM = 13
MR = 6
ncols = RY + YG + GC + CB + BM + MR
colorwheel = np.zeros((ncols, 3))
col = 0
# RY
colorwheel[0:RY, 0] = 255
colorwheel[0:RY, 1] = np.floor(255*np.arange(0,RY)/RY)
col = col+RY
# YG
colorwheel[col:col+YG, 0] = 255 - np.floor(255*np.arange(0,YG)/YG)
colorwheel[col:col+YG, 1] = 255
col = col+YG
# GC
colorwheel[col:col+GC, 1] = 255
colorwheel[col:col+GC, 2] = np.floor(255*np.arange(0,GC)/GC)
col = col+GC
# CB
colorwheel[col:col+CB, 1] = 255 - np.floor(255*np.arange(CB)/CB)
colorwheel[col:col+CB, 2] = 255
col = col+CB
# BM
colorwheel[col:col+BM, 2] = 255
colorwheel[col:col+BM, 0] = np.floor(255*np.arange(0,BM)/BM)
col = col+BM
# MR
colorwheel[col:col+MR, 2] = 255 - np.floor(255*np.arange(MR)/MR)
colorwheel[col:col+MR, 0] = 255
return colorwheel
def flow_uv_to_colors(u, v, convert_to_bgr=False):
"""
Applies the flow color wheel to (possibly clipped) flow components u and v.
According to the C++ source code of Daniel Scharstein
According to the Matlab source code of Deqing Sun
Args:
u (np.ndarray): Input horizontal flow of shape [H,W]
v (np.ndarray): Input vertical flow of shape [H,W]
convert_to_bgr (bool, optional): Convert output image to BGR. Defaults to False.
Returns:
np.ndarray: Flow visualization image of shape [H,W,3]
"""
flow_image = np.zeros((u.shape[0], u.shape[1], 3), np.uint8)
colorwheel = make_colorwheel() # shape [55x3]
ncols = colorwheel.shape[0]
rad = np.sqrt(np.square(u) + np.square(v))
a = np.arctan2(-v, -u)/np.pi
fk = (a+1) / 2*(ncols-1)
k0 = np.floor(fk).astype(np.int32)
k1 = k0 + 1
k1[k1 == ncols] = 0
f = fk - k0
for i in range(colorwheel.shape[1]):
tmp = colorwheel[:,i]
col0 = tmp[k0] / 255.0
col1 = tmp[k1] / 255.0
col = (1-f)*col0 + f*col1
idx = (rad <= 1)
col[idx] = 1 - rad[idx] * (1-col[idx])
col[~idx] = col[~idx] * 0.75 # out of range
# Note the 2-i => BGR instead of RGB
ch_idx = 2-i if convert_to_bgr else i
flow_image[:,:,ch_idx] = np.floor(255 * col)
return flow_image
def flow_to_image(flow_uv, clip_flow=None, convert_to_bgr=False):
"""
Expects a two dimensional flow image of shape.
Args:
flow_uv (np.ndarray): Flow UV image of shape [H,W,2]
clip_flow (float, optional): Clip maximum of flow values. Defaults to None.
convert_to_bgr (bool, optional): Convert output image to BGR. Defaults to False.
Returns:
np.ndarray: Flow visualization image of shape [H,W,3]
"""
assert flow_uv.ndim == 3, 'input flow must have three dimensions'
assert flow_uv.shape[2] == 2, 'input flow must have shape [H,W,2]'
if clip_flow is not None:
flow_uv = np.clip(flow_uv, 0, clip_flow)
u = flow_uv[:,:,0]
v = flow_uv[:,:,1]
rad = np.sqrt(np.square(u) + np.square(v))
rad_max = np.max(rad)
epsilon = 1e-5
u = u / (rad_max + epsilon)
v = v / (rad_max + epsilon)
# print(np.unique(u))
return flow_uv_to_colors(u, v, convert_to_bgr)
def writeFlow(filename,uv,v=None):
""" Write optical flow to file.
If v is None, uv is assumed to contain both u and v channels,
stacked in depth.
Original code by Deqing Sun, adapted from Daniel Scharstein.
"""
nBands = 2
if v is None:
assert(uv.ndim == 3)
assert(uv.shape[2] == 2)
u = uv[:,:,0]
v = uv[:,:,1]
else:
u = uv
assert(u.shape == v.shape)
height,width = u.shape
f = open(filename,'wb')
# write the header
f.write(TAG_CHAR)
np.array(width).astype(np.int32).tofile(f)
np.array(height).astype(np.int32).tofile(f)
# arrange into matrix form
tmp = np.zeros((height, width*nBands))
tmp[:,np.arange(width)*2] = u
tmp[:,np.arange(width)*2 + 1] = v
tmp.astype(np.float32).tofile(f)
f.close()
================================================
FILE: VO_Module/evaluation_scripts/test_vo.py
================================================
import sys
sys.path.append('VO_Module/droid_slam')
from droid import Droid
import glob
import torch.nn.functional as F
import argparse
import time
import os
import cv2
import lietorch
import torch
import numpy as np
from tqdm import tqdm
from panopticapi.utils import rgb2id, id2rgb
import PIL.Image as Image
def image_stream(datapath, image_size=[240, 808], mode='train', args=None): # -------------------------------------------
""" image generator """
fx, fy, cx, cy = 725.0087, 725.0087, 620.5, 187
split = {
'train': 'clone',
'val': '15-deg-left',
'test': '30-deg-right'
}
images = np.array(sorted(glob.glob(os.path.join(datapath, split[mode], 'frames/rgb/Camera_0/*.jpg'))))
segments_list = sorted(glob.glob(os.path.join(datapath, split[mode], 'panFPN_segm/*.png')))
images_list = images.tolist()
print("-----test images :", len(images_list))
segm = None
for t, imfile in enumerate(images_list):
image = cv2.imread(imfile)
h0, w0, _ = image.shape
h1, w1 = image_size[0], image_size[1]
image = cv2.resize(image, (w1, h1))
image = image[:h1-h1 % 8, :w1-w1 % 8]
image = torch.as_tensor(image).int().permute(2, 0, 1)
if args.segm_filter:
segm = rgb2id(np.array(Image.open(segments_list[t])))
segm = torch.as_tensor(segm).unsqueeze(0).unsqueeze(0).float()
segm = F.interpolate(segm, size=(h1,w1))
segm = segm[:h1-h1 % 8, :w1-w1 % 8]
segm = F.interpolate(segm, scale_factor=1/8,
recompute_scale_factor=True).int()
intrinsics = torch.as_tensor([fx, fy, cx, cy])
intrinsics[0:2] *= (w1 / w0)
intrinsics[2:4] *= (h1 / h0)
yield t, image, intrinsics , segm
def init():
parser = argparse.ArgumentParser()
parser.add_argument('--datapath')
parser.add_argument("--device", default="cuda:0")
parser.add_argument("--weights", default="checkpoints/vkitti2_dy_train_semiv4_080000.pth")
parser.add_argument("--buffer", type=int, default=1024)
parser.add_argument("--image_size", default=[240, 808])
parser.add_argument("--disable_vis", action="store_true")
parser.add_argument("--use_aff_bri", type=bool, default=False)
parser.add_argument("--beta", type=float, default=0.6)
parser.add_argument("--filter_thresh", type=float, default=1.75)
parser.add_argument("--warmup", type=int, default=12)
parser.add_argument("--keyframe_thresh", type=float, default=2.25)
parser.add_argument("--frontend_thresh", type=float, default=12.0)
parser.add_argument("--frontend_window", type=int, default=25)
# 2
parser.add_argument("--frontend_radius", type=int, default=2)
parser.add_argument("--frontend_nms", type=int, default=1)
parser.add_argument("--backend_thresh", type=float, default=15.0)
parser.add_argument("--backend_radius", type=int, default=2)
parser.add_argument("--backend_nms", type=int, default=3)
parser.add_argument("--segm_filter", type=bool, default=False, help="if filter weight with segmentaion in factory graph")
parser.add_argument("--thresh", type=float, default=0.8)
args = parser.parse_args()
return args
if __name__ == '__main__':
args = init()
# os.environ["CUDA_VISIBLE_DEVICES"] = args.device.split(':')[-1]
torch.multiprocessing.set_start_method('spawn')
print("Running evaluation on {}".format(args.datapath))
print(args)
if args.datapath[-2:] == "20":
args.thresh = 0.9
droid = Droid(args)
time.sleep(5)
print("segm_filter: ",args.segm_filter)
for (t, image, intrinsics, segm) in tqdm(image_stream(args.datapath, mode='val', args=args)):
droid.track(t, image, intrinsics=intrinsics, segments=segm)
print("video frames: ", droid.video.counter.value)
traj_est = droid.terminate(image_stream(args.datapath, mode='val', args=args), need_inv=True)
### run evaluation ###
print("#"*20 + " Results...")
import evo
from evo.core.trajectory import PoseTrajectory3D
from evo.core.trajectory import PosePath3D
from evo.tools import file_interface
from evo.core import sync
import evo.main_ape as main_ape
from evo.core.metrics import PoseRelation
def read_vkitti2_poses_file(file_path, args) -> PosePath3D:
"""
parses pose file in Virtual KITTI 2 format (first 3 rows of SE(3) matrix per line)
:param file_path: the trajectory file path (or file handle)
:return: trajectory.PosePath3D
"""
raw_mat = np.loadtxt(file_path, delimiter=' ', skiprows=1)[::2, 2:]
error_msg = ("Virtual KITTI 2 pose files must have 16 entries per row "
"and no trailing delimiter at the end of the rows (space)")
if raw_mat is None or (len(raw_mat) > 0 and len(raw_mat[0]) != 16):
raise file_interface.FileInterfaceException(error_msg)
try:
mat = np.array(raw_mat).astype(float)
except ValueError:
raise file_interface.FileInterfaceException(error_msg)
poses = [np.linalg.inv(np.array([[r[0], r[1], r[2], r[3]],
[r[4], r[5], r[6], r[7]],
[r[8], r[9], r[10], r[11]],
[r[12], r[13], r[14], r[15]]])) for r in mat]
# yapf: enable
if not hasattr(file_path, 'read'): # if not file handle
print("Loaded {} poses from: {}".format(len(poses), file_path))
return PosePath3D(poses_se3=poses)
gt_file = os.path.join(args.datapath, '15-deg-left/extrinsic.txt')
traj_ref = read_vkitti2_poses_file(gt_file, args)
traj_est = PosePath3D(
positions_xyz=traj_est[:, :3],
orientations_quat_wxyz=traj_est[:, 3:])
root = 'shared_data/traj/'
root = os.path.join(root, args.datapath.rsplit('/')[-1])
root = os.path.join(root, '15-deg-left')
if not os.path.isdir(root):
os.makedirs(root)
est_file = os.path.join(root, 'pvo_traj.txt')
print(est_file)
file_interface.write_kitti_poses_file(est_file, traj_est)
result = main_ape.ape(traj_ref, traj_est, est_name='traj',
pose_relation=PoseRelation.translation_part, align=True, correct_scale=True)
print(result)
================================================
FILE: VO_Module/evaluation_scripts/test_vo2.py
================================================
import sys
sys.path.append('VO_Module/droid_slam')
import torch
from torch.utils.data import DataLoader
import glob
import os
import os.path as osp
import cv2
import numpy as np
import torch.nn.functional as F
from scipy.spatial.transform import Rotation as R
from collections import OrderedDict
from lietorch import SE3
from flow_vis_utils import flow_to_image
from geom.projective_ops import projective_transform, coords_grid
from geom.graph_utils import graph_to_edge_list
from droid_net import DroidNet, upsample_inter
from data_readers.factory import dataset_factory
import data_readers.vkitti2
import argparse
def resize(mask, size, need_permute):
if need_permute:
mask = mask.permute(0, 1, 4, 2, 3).contiguous()
batch, num, dim, ht, wd = mask.shape
mask = mask.view(batch*num, dim, ht, wd)
mask = F.interpolate(mask, size=size, mode='bilinear', align_corners=True)
if need_permute:
mask = mask.permute(0, 2, 3, 1).contiguous()
return mask.view(batch, num, size[0], size[1], dim)
else:
return mask.view(batch, num, dim, size[0], size[1])
dic = { "Scene01":"0001",
"Scene02":"0002",
"Scene06":"0006",
"Scene18":"0018",
"Scene20":"0020",}
def init():
parser = argparse.ArgumentParser()
parser.add_argument("--n_frames", type=int, default=2)
parser.add_argument("--save_npy", type=bool, default=True, help="save flow and depth")
parser.add_argument("--image_size", default=[376, 1248])
parser.add_argument("--scene", default="Scene02")
parser.add_argument("--full_flow_dir", default="shared_data/full_flow")
parser.add_argument("--depth_dir", default="shared_data/depth")
parser.add_argument("--weights_file", default="checkpoints/vkitti2_dy_train_semiv4_080000.pth")
args = parser.parse_args()
return args
if __name__ == '__main__':
args = init()
full_flow_dir = args.full_flow_dir
depth_dir = args.depth_dir
img_size = args.image_size
n_frames = args.n_frames
scene_id = args.scene
save_npy = args.save_npy
if not osp.exists(full_flow_dir):
os.makedirs(full_flow_dir)
if not osp.exists(depth_dir):
os.makedirs(depth_dir)
db = dataset_factory(['vkitti2'], datapath='datasets/Virtual_KITTI2', do_aug=False,
n_frames=n_frames, flow_label=False, aug_graph=False, split_mode='train', foo=True,
scene_id = scene_id,
need_inv=False, build_mask=False, crop_size=img_size, mode='semisup',
rebuild=Tru
Showing preview only (262K chars total). Download the full file or copy to clipboard to get everything.
gitextract_fb98d_ml/
├── .gitignore
├── README.md
├── VO_Module/
│ ├── README.md
│ ├── calib/
│ │ ├── barn.txt
│ │ ├── eth.txt
│ │ ├── euroc.txt
│ │ ├── kitti.txt
│ │ ├── replica.txt
│ │ ├── tartan.txt
│ │ └── tum3.txt
│ ├── demo.py
│ ├── droid_slam/
│ │ ├── data_readers/
│ │ │ ├── __init__.py
│ │ │ ├── augmentation.py
│ │ │ ├── base.py
│ │ │ ├── factory.py
│ │ │ ├── replica.py
│ │ │ ├── replica_test.txt
│ │ │ ├── replica_utils.py
│ │ │ ├── rgbd_utils.py
│ │ │ ├── stream.py
│ │ │ ├── tartan.py
│ │ │ ├── tartan_test.txt
│ │ │ └── vkitti2.py
│ │ ├── depth_video.py
│ │ ├── droid.py
│ │ ├── droid_backend.py
│ │ ├── droid_frontend.py
│ │ ├── droid_net.py
│ │ ├── factor_graph.py
│ │ ├── geom/
│ │ │ ├── __init__.py
│ │ │ ├── ba.py
│ │ │ ├── chol.py
│ │ │ ├── graph_utils.py
│ │ │ ├── losses.py
│ │ │ └── projective_ops.py
│ │ ├── logger.py
│ │ ├── modules/
│ │ │ ├── __init__.py
│ │ │ ├── clipping.py
│ │ │ ├── corr.py
│ │ │ ├── extractor.py
│ │ │ └── gru.py
│ │ ├── motion_filter.py
│ │ ├── trajectory_filler.py
│ │ └── visualization.py
│ ├── environment.yaml
│ ├── environment_novis.yaml
│ ├── evaluation_scripts/
│ │ ├── flow_vis_utils.py
│ │ ├── test_vo.py
│ │ └── test_vo2.py
│ ├── setup.py
│ ├── src/
│ │ ├── altcorr_kernel.cu
│ │ ├── correlation_kernels.cu
│ │ ├── droid.cpp
│ │ └── droid_kernels.cu
│ ├── thirdparty/
│ │ ├── eigen/
│ │ │ ├── .gitignore
│ │ │ ├── .gitlab/
│ │ │ │ ├── issue_templates/
│ │ │ │ │ ├── Bug Report.md
│ │ │ │ │ └── Feature Request.md
│ │ │ │ └── merge_request_templates/
│ │ │ │ └── Merge Request Template.md
│ │ │ ├── .gitlab-ci.yml
│ │ │ ├── .hgeol
│ │ │ ├── CMakeLists.txt
│ │ │ ├── COPYING.APACHE
│ │ │ ├── COPYING.BSD
│ │ │ ├── COPYING.GPL
│ │ │ ├── COPYING.LGPL
│ │ │ ├── COPYING.MINPACK
│ │ │ ├── COPYING.MPL2
│ │ │ ├── COPYING.README
│ │ │ ├── CTestConfig.cmake
│ │ │ ├── CTestCustom.cmake.in
│ │ │ ├── Eigen/
│ │ │ │ ├── Cholesky
│ │ │ │ ├── CholmodSupport
│ │ │ │ ├── Dense
│ │ │ │ ├── Eigen
│ │ │ │ ├── Eigenvalues
│ │ │ │ ├── Geometry
│ │ │ │ ├── Householder
│ │ │ │ ├── IterativeLinearSolvers
│ │ │ │ ├── Jacobi
│ │ │ │ ├── KLUSupport
│ │ │ │ ├── LU
│ │ │ │ ├── MetisSupport
│ │ │ │ ├── OrderingMethods
│ │ │ │ ├── PaStiXSupport
│ │ │ │ ├── PardisoSupport
│ │ │ │ ├── QR
│ │ │ │ ├── QtAlignedMalloc
│ │ │ │ ├── SPQRSupport
│ │ │ │ ├── SVD
│ │ │ │ ├── Sparse
│ │ │ │ ├── SparseCholesky
│ │ │ │ ├── SparseCore
│ │ │ │ ├── SparseLU
│ │ │ │ ├── SparseQR
│ │ │ │ ├── StdDeque
│ │ │ │ ├── StdList
│ │ │ │ ├── StdVector
│ │ │ │ ├── SuperLUSupport
│ │ │ │ ├── UmfPackSupport
│ │ │ │ └── src/
│ │ │ │ ├── Cholesky/
│ │ │ │ │ ├── LDLT.h
│ │ │ │ │ ├── LLT.h
│ │ │ │ │ └── LLT_LAPACKE.h
│ │ │ │ ├── CholmodSupport/
│ │ │ │ │ └── CholmodSupport.h
│ │ │ │ ├── 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_SIMD.h
│ │ │ │ ├── Householder/
│ │ │ │ │ ├── BlockHouseholder.h
│ │ │ │ │ ├── Householder.h
│ │ │ │ │ └── HouseholderSequence.h
│ │ │ │ ├── IterativeLinearSolvers/
│ │ │ │ │ ├── BasicPreconditioners.h
│ │ │ │ │ ├── BiCGSTAB.h
│ │ │ │ │ ├── ConjugateGradient.h
│ │ │ │ │ ├── IncompleteCholesky.h
│ │ │ │ │ ├── IncompleteLUT.h
│ │ │ │ │ ├── IterativeSolverBase.h
│ │ │ │ │ ├── LeastSquareConjugateGradient.h
│ │ │ │ │ └── SolveWithGuess.h
│ │ │ │ ├── Jacobi/
│ │ │ │ │ └── Jacobi.h
│ │ │ │ ├── KLUSupport/
│ │ │ │ │ └── KLUSupport.h
│ │ │ │ ├── LU/
│ │ │ │ │ ├── Determinant.h
│ │ │ │ │ ├── FullPivLU.h
│ │ │ │ │ ├── InverseImpl.h
│ │ │ │ │ ├── PartialPivLU.h
│ │ │ │ │ ├── PartialPivLU_LAPACKE.h
│ │ │ │ │ └── arch/
│ │ │ │ │ └── InverseSize4.h
│ │ │ │ ├── MetisSupport/
│ │ │ │ │ └── MetisSupport.h
│ │ │ │ ├── OrderingMethods/
│ │ │ │ │ ├── Amd.h
│ │ │ │ │ ├── Eigen_Colamd.h
│ │ │ │ │ └── Ordering.h
│ │ │ │ ├── PaStiXSupport/
│ │ │ │ │ └── PaStiXSupport.h
│ │ │ │ ├── PardisoSupport/
│ │ │ │ │ └── PardisoSupport.h
│ │ │ │ ├── QR/
│ │ │ │ │ ├── ColPivHouseholderQR.h
│ │ │ │ │ ├── ColPivHouseholderQR_LAPACKE.h
│ │ │ │ │ ├── CompleteOrthogonalDecomposition.h
│ │ │ │ │ ├── FullPivHouseholderQR.h
│ │ │ │ │ ├── HouseholderQR.h
│ │ │ │ │ └── HouseholderQR_LAPACKE.h
│ │ │ │ ├── SPQRSupport/
│ │ │ │ │ └── SuiteSparseQRSupport.h
│ │ │ │ ├── SVD/
│ │ │ │ │ ├── BDCSVD.h
│ │ │ │ │ ├── JacobiSVD.h
│ │ │ │ │ ├── JacobiSVD_LAPACKE.h
│ │ │ │ │ ├── SVDBase.h
│ │ │ │ │ └── UpperBidiagonalization.h
│ │ │ │ ├── SparseCholesky/
│ │ │ │ │ ├── SimplicialCholesky.h
│ │ │ │ │ └── SimplicialCholesky_impl.h
│ │ │ │ ├── SparseCore/
│ │ │ │ │ ├── AmbiVector.h
│ │ │ │ │ ├── CompressedStorage.h
│ │ │ │ │ ├── ConservativeSparseSparseProduct.h
│ │ │ │ │ ├── MappedSparseMatrix.h
│ │ │ │ │ ├── SparseAssign.h
│ │ │ │ │ ├── SparseBlock.h
│ │ │ │ │ ├── SparseColEtree.h
│ │ │ │ │ ├── SparseCompressedBase.h
│ │ │ │ │ ├── SparseCwiseBinaryOp.h
│ │ │ │ │ ├── SparseCwiseUnaryOp.h
│ │ │ │ │ ├── SparseDenseProduct.h
│ │ │ │ │ ├── SparseDiagonalProduct.h
│ │ │ │ │ ├── SparseDot.h
│ │ │ │ │ ├── SparseFuzzy.h
│ │ │ │ │ ├── SparseMap.h
│ │ │ │ │ ├── SparseMatrix.h
│ │ │ │ │ ├── SparseMatrixBase.h
│ │ │ │ │ ├── SparsePermutation.h
│ │ │ │ │ ├── SparseProduct.h
│ │ │ │ │ ├── SparseRedux.h
│ │ │ │ │ ├── SparseRef.h
│ │ │ │ │ ├── SparseSelfAdjointView.h
│ │ │ │ │ ├── SparseSolverBase.h
│ │ │ │ │ ├── SparseSparseProductWithPruning.h
│ │ │ │ │ ├── SparseTranspose.h
│ │ │ │ │ ├── SparseTriangularView.h
│ │ │ │ │ ├── SparseUtil.h
│ │ │ │ │ ├── SparseVector.h
│ │ │ │ │ ├── SparseView.h
│ │ │ │ │ └── TriangularSolver.h
│ │ │ │ ├── SparseLU/
│ │ │ │ │ ├── SparseLU.h
│ │ │ │ │ ├── SparseLUImpl.h
│ │ │ │ │ ├── SparseLU_Memory.h
│ │ │ │ │ ├── SparseLU_Structs.h
│ │ │ │ │ ├── SparseLU_SupernodalMatrix.h
│ │ │ │ │ ├── SparseLU_Utils.h
│ │ │ │ │ ├── SparseLU_column_bmod.h
│ │ │ │ │ ├── SparseLU_column_dfs.h
│ │ │ │ │ ├── SparseLU_copy_to_ucol.h
│ │ │ │ │ ├── SparseLU_gemm_kernel.h
│ │ │ │ │ ├── SparseLU_heap_relax_snode.h
│ │ │ │ │ ├── SparseLU_kernel_bmod.h
│ │ │ │ │ ├── SparseLU_panel_bmod.h
│ │ │ │ │ ├── SparseLU_panel_dfs.h
│ │ │ │ │ ├── SparseLU_pivotL.h
│ │ │ │ │ ├── SparseLU_pruneL.h
│ │ │ │ │ └── SparseLU_relax_snode.h
│ │ │ │ ├── SparseQR/
│ │ │ │ │ └── SparseQR.h
│ │ │ │ ├── StlSupport/
│ │ │ │ │ ├── StdDeque.h
│ │ │ │ │ ├── StdList.h
│ │ │ │ │ ├── StdVector.h
│ │ │ │ │ └── details.h
│ │ │ │ ├── SuperLUSupport/
│ │ │ │ │ └── SuperLUSupport.h
│ │ │ │ ├── UmfPackSupport/
│ │ │ │ │ └── UmfPackSupport.h
│ │ │ │ ├── misc/
│ │ │ │ │ ├── Image.h
│ │ │ │ │ ├── Kernel.h
│ │ │ │ │ ├── RealSvd2x2.h
│ │ │ │ │ ├── blas.h
│ │ │ │ │ ├── lapack.h
│ │ │ │ │ ├── lapacke.h
│ │ │ │ │ └── lapacke_mangling.h
│ │ │ │ └── plugins/
│ │ │ │ ├── ArrayCwiseBinaryOps.h
│ │ │ │ ├── ArrayCwiseUnaryOps.h
│ │ │ │ ├── BlockMethods.h
│ │ │ │ ├── CommonCwiseBinaryOps.h
│ │ │ │ ├── CommonCwiseUnaryOps.h
│ │ │ │ ├── IndexedViewMethods.h
│ │ │ │ ├── MatrixCwiseBinaryOps.h
│ │ │ │ ├── MatrixCwiseUnaryOps.h
│ │ │ │ └── ReshapedMethods.h
│ │ │ ├── INSTALL
│ │ │ ├── README.md
│ │ │ ├── bench/
│ │ │ │ ├── BenchSparseUtil.h
│ │ │ │ ├── BenchTimer.h
│ │ │ │ ├── BenchUtil.h
│ │ │ │ ├── README.txt
│ │ │ │ ├── analyze-blocking-sizes.cpp
│ │ │ │ ├── basicbench.cxxlist
│ │ │ │ ├── basicbenchmark.cpp
│ │ │ │ ├── basicbenchmark.h
│ │ │ │ ├── benchBlasGemm.cpp
│ │ │ │ ├── benchCholesky.cpp
│ │ │ │ ├── benchEigenSolver.cpp
│ │ │ │ ├── benchFFT.cpp
│ │ │ │ ├── benchGeometry.cpp
│ │ │ │ ├── benchVecAdd.cpp
│ │ │ │ ├── bench_gemm.cpp
│ │ │ │ ├── bench_move_semantics.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/
│ │ │ │ │ ├── changesets.txt
│ │ │ │ │ ├── gemm.cpp
│ │ │ │ │ ├── gemm_common.h
│ │ │ │ │ ├── gemm_settings.txt
│ │ │ │ │ ├── gemm_square_settings.txt
│ │ │ │ │ ├── gemv.cpp
│ │ │ │ │ ├── gemv_common.h
│ │ │ │ │ ├── gemv_settings.txt
│ │ │ │ │ ├── gemv_square_settings.txt
│ │ │ │ │ ├── gemvt.cpp
│ │ │ │ │ ├── lazy_gemm.cpp
│ │ │ │ │ ├── lazy_gemm_settings.txt
│ │ │ │ │ ├── llt.cpp
│ │ │ │ │ ├── make_plot.sh
│ │ │ │ │ ├── resources/
│ │ │ │ │ │ ├── chart_footer.html
│ │ │ │ │ │ ├── chart_header.html
│ │ │ │ │ │ ├── footer.html
│ │ │ │ │ │ ├── header.html
│ │ │ │ │ │ ├── s1.js
│ │ │ │ │ │ └── s2.js
│ │ │ │ │ ├── run.sh
│ │ │ │ │ ├── runall.sh
│ │ │ │ │ ├── trmv_lo.cpp
│ │ │ │ │ ├── trmv_lot.cpp
│ │ │ │ │ ├── trmv_up.cpp
│ │ │ │ │ └── trmv_upt.cpp
│ │ │ │ ├── product_threshold.cpp
│ │ │ │ ├── quat_slerp.cpp
│ │ │ │ ├── quatmul.cpp
│ │ │ │ ├── sparse_cholesky.cpp
│ │ │ │ ├── sparse_dense_product.cpp
│ │ │ │ ├── sparse_lu.cpp
│ │ │ │ ├── sparse_product.cpp
│ │ │ │ ├── sparse_randomsetter.cpp
│ │ │ │ ├── sparse_setter.cpp
│ │ │ │ ├── sparse_transpose.cpp
│ │ │ │ ├── sparse_trisolver.cpp
│ │ │ │ ├── spbench/
│ │ │ │ │ ├── CMakeLists.txt
│ │ │ │ │ ├── sp_solver.cpp
│ │ │ │ │ ├── spbench.dtd
│ │ │ │ │ ├── spbenchsolver.cpp
│ │ │ │ │ ├── spbenchsolver.h
│ │ │ │ │ ├── spbenchstyle.h
│ │ │ │ │ └── test_sparseLU.cpp
│ │ │ │ ├── spmv.cpp
│ │ │ │ ├── tensors/
│ │ │ │ │ ├── README
│ │ │ │ │ ├── benchmark.h
│ │ │ │ │ ├── benchmark_main.cc
│ │ │ │ │ ├── contraction_benchmarks_cpu.cc
│ │ │ │ │ ├── eigen_sycl_bench.sh
│ │ │ │ │ ├── eigen_sycl_bench_contract.sh
│ │ │ │ │ ├── tensor_benchmarks.h
│ │ │ │ │ ├── tensor_benchmarks_cpu.cc
│ │ │ │ │ ├── tensor_benchmarks_fp16_gpu.cu
│ │ │ │ │ ├── tensor_benchmarks_gpu.cu
│ │ │ │ │ ├── tensor_benchmarks_sycl.cc
│ │ │ │ │ └── tensor_contract_sycl_bench.cc
│ │ │ │ └── vdw_new.cpp
│ │ │ ├── blas/
│ │ │ │ ├── BandTriangularSolver.h
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── GeneralRank1Update.h
│ │ │ │ ├── PackedSelfadjointProduct.h
│ │ │ │ ├── PackedTriangularMatrixVector.h
│ │ │ │ ├── PackedTriangularSolverVector.h
│ │ │ │ ├── README.txt
│ │ │ │ ├── Rank2Update.h
│ │ │ │ ├── common.h
│ │ │ │ ├── complex_double.cpp
│ │ │ │ ├── complex_single.cpp
│ │ │ │ ├── double.cpp
│ │ │ │ ├── f2c/
│ │ │ │ │ ├── chbmv.c
│ │ │ │ │ ├── chpmv.c
│ │ │ │ │ ├── complexdots.c
│ │ │ │ │ ├── ctbmv.c
│ │ │ │ │ ├── d_cnjg.c
│ │ │ │ │ ├── datatypes.h
│ │ │ │ │ ├── drotm.c
│ │ │ │ │ ├── drotmg.c
│ │ │ │ │ ├── dsbmv.c
│ │ │ │ │ ├── dspmv.c
│ │ │ │ │ ├── dtbmv.c
│ │ │ │ │ ├── lsame.c
│ │ │ │ │ ├── r_cnjg.c
│ │ │ │ │ ├── srotm.c
│ │ │ │ │ ├── srotmg.c
│ │ │ │ │ ├── ssbmv.c
│ │ │ │ │ ├── sspmv.c
│ │ │ │ │ ├── stbmv.c
│ │ │ │ │ ├── zhbmv.c
│ │ │ │ │ ├── zhpmv.c
│ │ │ │ │ └── ztbmv.c
│ │ │ │ ├── fortran/
│ │ │ │ │ └── complexdots.f
│ │ │ │ ├── level1_cplx_impl.h
│ │ │ │ ├── level1_impl.h
│ │ │ │ ├── level1_real_impl.h
│ │ │ │ ├── level2_cplx_impl.h
│ │ │ │ ├── level2_impl.h
│ │ │ │ ├── level2_real_impl.h
│ │ │ │ ├── level3_impl.h
│ │ │ │ ├── single.cpp
│ │ │ │ ├── testing/
│ │ │ │ │ ├── CMakeLists.txt
│ │ │ │ │ ├── cblat1.f
│ │ │ │ │ ├── cblat2.f
│ │ │ │ │ ├── cblat3.f
│ │ │ │ │ ├── dblat1.f
│ │ │ │ │ ├── dblat2.f
│ │ │ │ │ ├── dblat3.f
│ │ │ │ │ ├── runblastest.sh
│ │ │ │ │ ├── sblat1.f
│ │ │ │ │ ├── sblat2.f
│ │ │ │ │ ├── sblat3.f
│ │ │ │ │ ├── zblat1.f
│ │ │ │ │ ├── zblat2.f
│ │ │ │ │ └── zblat3.f
│ │ │ │ └── xerbla.cpp
│ │ │ ├── ci/
│ │ │ │ ├── CTest2JUnit.xsl
│ │ │ │ ├── README.md
│ │ │ │ ├── smoketests.gitlab-ci.yml
│ │ │ │ └── test.gitlab-ci.yml
│ │ │ ├── cmake/
│ │ │ │ ├── ComputeCppCompilerChecks.cmake
│ │ │ │ ├── ComputeCppIRMap.cmake
│ │ │ │ ├── Eigen3Config.cmake.in
│ │ │ │ ├── EigenConfigureTesting.cmake
│ │ │ │ ├── EigenDetermineOSVersion.cmake
│ │ │ │ ├── EigenDetermineVSServicePack.cmake
│ │ │ │ ├── EigenSmokeTestList.cmake
│ │ │ │ ├── EigenTesting.cmake
│ │ │ │ ├── EigenUninstall.cmake
│ │ │ │ ├── FindAdolc.cmake
│ │ │ │ ├── FindBLAS.cmake
│ │ │ │ ├── FindBLASEXT.cmake
│ │ │ │ ├── FindCHOLMOD.cmake
│ │ │ │ ├── FindComputeCpp.cmake
│ │ │ │ ├── FindFFTW.cmake
│ │ │ │ ├── FindGLEW.cmake
│ │ │ │ ├── FindGMP.cmake
│ │ │ │ ├── FindGSL.cmake
│ │ │ │ ├── FindGoogleHash.cmake
│ │ │ │ ├── FindHWLOC.cmake
│ │ │ │ ├── FindKLU.cmake
│ │ │ │ ├── FindLAPACK.cmake
│ │ │ │ ├── FindMPFR.cmake
│ │ │ │ ├── FindMPREAL.cmake
│ │ │ │ ├── FindMetis.cmake
│ │ │ │ ├── FindPASTIX.cmake
│ │ │ │ ├── FindPTSCOTCH.cmake
│ │ │ │ ├── FindSCOTCH.cmake
│ │ │ │ ├── FindSPQR.cmake
│ │ │ │ ├── FindStandardMathLibrary.cmake
│ │ │ │ ├── FindSuperLU.cmake
│ │ │ │ ├── FindTriSYCL.cmake
│ │ │ │ ├── FindUMFPACK.cmake
│ │ │ │ └── RegexUtils.cmake
│ │ │ ├── debug/
│ │ │ │ ├── gdb/
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ └── printers.py
│ │ │ │ └── msvc/
│ │ │ │ └── eigen.natvis
│ │ │ ├── demos/
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── mandelbrot/
│ │ │ │ │ ├── CMakeLists.txt
│ │ │ │ │ ├── README
│ │ │ │ │ ├── mandelbrot.cpp
│ │ │ │ │ └── mandelbrot.h
│ │ │ │ ├── mix_eigen_and_c/
│ │ │ │ │ ├── README
│ │ │ │ │ ├── binary_library.cpp
│ │ │ │ │ ├── binary_library.h
│ │ │ │ │ └── example.c
│ │ │ │ └── opengl/
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── README
│ │ │ │ ├── camera.cpp
│ │ │ │ ├── camera.h
│ │ │ │ ├── gpuhelper.cpp
│ │ │ │ ├── gpuhelper.h
│ │ │ │ ├── icosphere.cpp
│ │ │ │ ├── icosphere.h
│ │ │ │ ├── quaternion_demo.cpp
│ │ │ │ ├── quaternion_demo.h
│ │ │ │ ├── trackball.cpp
│ │ │ │ └── trackball.h
│ │ │ ├── doc/
│ │ │ │ ├── AsciiQuickReference.txt
│ │ │ │ ├── B01_Experimental.dox
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── ClassHierarchy.dox
│ │ │ │ ├── CoeffwiseMathFunctionsTable.dox
│ │ │ │ ├── CustomizingEigen_CustomScalar.dox
│ │ │ │ ├── CustomizingEigen_InheritingMatrix.dox
│ │ │ │ ├── CustomizingEigen_NullaryExpr.dox
│ │ │ │ ├── CustomizingEigen_Plugins.dox
│ │ │ │ ├── DenseDecompositionBenchmark.dox
│ │ │ │ ├── Doxyfile.in
│ │ │ │ ├── FixedSizeVectorizable.dox
│ │ │ │ ├── FunctionsTakingEigenTypes.dox
│ │ │ │ ├── HiPerformance.dox
│ │ │ │ ├── InplaceDecomposition.dox
│ │ │ │ ├── InsideEigenExample.dox
│ │ │ │ ├── LeastSquares.dox
│ │ │ │ ├── Manual.dox
│ │ │ │ ├── MatrixfreeSolverExample.dox
│ │ │ │ ├── NewExpressionType.dox
│ │ │ │ ├── Overview.dox
│ │ │ │ ├── PassingByValue.dox
│ │ │ │ ├── Pitfalls.dox
│ │ │ │ ├── PreprocessorDirectives.dox
│ │ │ │ ├── QuickReference.dox
│ │ │ │ ├── QuickStartGuide.dox
│ │ │ │ ├── SparseLinearSystems.dox
│ │ │ │ ├── SparseQuickReference.dox
│ │ │ │ ├── StlContainers.dox
│ │ │ │ ├── StorageOrders.dox
│ │ │ │ ├── StructHavingEigenMembers.dox
│ │ │ │ ├── TemplateKeyword.dox
│ │ │ │ ├── TopicAliasing.dox
│ │ │ │ ├── TopicAssertions.dox
│ │ │ │ ├── TopicCMakeGuide.dox
│ │ │ │ ├── TopicEigenExpressionTemplates.dox
│ │ │ │ ├── TopicLazyEvaluation.dox
│ │ │ │ ├── TopicLinearAlgebraDecompositions.dox
│ │ │ │ ├── TopicMultithreading.dox
│ │ │ │ ├── TopicResizing.dox
│ │ │ │ ├── TopicScalarTypes.dox
│ │ │ │ ├── TopicVectorization.dox
│ │ │ │ ├── TutorialAdvancedInitialization.dox
│ │ │ │ ├── TutorialArrayClass.dox
│ │ │ │ ├── TutorialBlockOperations.dox
│ │ │ │ ├── TutorialGeometry.dox
│ │ │ │ ├── TutorialLinearAlgebra.dox
│ │ │ │ ├── TutorialMapClass.dox
│ │ │ │ ├── TutorialMatrixArithmetic.dox
│ │ │ │ ├── TutorialMatrixClass.dox
│ │ │ │ ├── TutorialReductionsVisitorsBroadcasting.dox
│ │ │ │ ├── TutorialReshape.dox
│ │ │ │ ├── TutorialSTL.dox
│ │ │ │ ├── TutorialSlicingIndexing.dox
│ │ │ │ ├── TutorialSparse.dox
│ │ │ │ ├── TutorialSparse_example_details.dox
│ │ │ │ ├── UnalignedArrayAssert.dox
│ │ │ │ ├── UsingBlasLapackBackends.dox
│ │ │ │ ├── UsingIntelMKL.dox
│ │ │ │ ├── UsingNVCC.dox
│ │ │ │ ├── WrongStackAlignment.dox
│ │ │ │ ├── eigen_navtree_hacks.js
│ │ │ │ ├── eigendoxy.css
│ │ │ │ ├── eigendoxy_footer.html.in
│ │ │ │ ├── eigendoxy_header.html.in
│ │ │ │ ├── eigendoxy_layout.xml.in
│ │ │ │ ├── eigendoxy_tabs.css
│ │ │ │ ├── examples/
│ │ │ │ │ ├── .krazy
│ │ │ │ │ ├── CMakeLists.txt
│ │ │ │ │ ├── CustomizingEigen_Inheritance.cpp
│ │ │ │ │ ├── Cwise_erf.cpp
│ │ │ │ │ ├── Cwise_erfc.cpp
│ │ │ │ │ ├── Cwise_lgamma.cpp
│ │ │ │ │ ├── DenseBase_middleCols_int.cpp
│ │ │ │ │ ├── DenseBase_middleRows_int.cpp
│ │ │ │ │ ├── DenseBase_template_int_middleCols.cpp
│ │ │ │ │ ├── DenseBase_template_int_middleRows.cpp
│ │ │ │ │ ├── QuickStart_example.cpp
│ │ │ │ │ ├── QuickStart_example2_dynamic.cpp
│ │ │ │ │ ├── QuickStart_example2_fixed.cpp
│ │ │ │ │ ├── TemplateKeyword_flexible.cpp
│ │ │ │ │ ├── TemplateKeyword_simple.cpp
│ │ │ │ │ ├── TutorialInplaceLU.cpp
│ │ │ │ │ ├── TutorialLinAlgComputeTwice.cpp
│ │ │ │ │ ├── TutorialLinAlgExComputeSolveError.cpp
│ │ │ │ │ ├── TutorialLinAlgExSolveColPivHouseholderQR.cpp
│ │ │ │ │ ├── TutorialLinAlgExSolveLDLT.cpp
│ │ │ │ │ ├── TutorialLinAlgInverseDeterminant.cpp
│ │ │ │ │ ├── TutorialLinAlgRankRevealing.cpp
│ │ │ │ │ ├── TutorialLinAlgSVDSolve.cpp
│ │ │ │ │ ├── TutorialLinAlgSelfAdjointEigenSolver.cpp
│ │ │ │ │ ├── TutorialLinAlgSetThreshold.cpp
│ │ │ │ │ ├── Tutorial_ArrayClass_accessors.cpp
│ │ │ │ │ ├── Tutorial_ArrayClass_addition.cpp
│ │ │ │ │ ├── Tutorial_ArrayClass_cwise_other.cpp
│ │ │ │ │ ├── Tutorial_ArrayClass_interop.cpp
│ │ │ │ │ ├── Tutorial_ArrayClass_interop_matrix.cpp
│ │ │ │ │ ├── Tutorial_ArrayClass_mult.cpp
│ │ │ │ │ ├── Tutorial_BlockOperations_block_assignment.cpp
│ │ │ │ │ ├── Tutorial_BlockOperations_colrow.cpp
│ │ │ │ │ ├── Tutorial_BlockOperations_corner.cpp
│ │ │ │ │ ├── Tutorial_BlockOperations_print_block.cpp
│ │ │ │ │ ├── Tutorial_BlockOperations_vector.cpp
│ │ │ │ │ ├── Tutorial_PartialLU_solve.cpp
│ │ │ │ │ ├── Tutorial_ReductionsVisitorsBroadcasting_broadcast_1nn.cpp
│ │ │ │ │ ├── Tutorial_ReductionsVisitorsBroadcasting_broadcast_simple.cpp
│ │ │ │ │ ├── Tutorial_ReductionsVisitorsBroadcasting_broadcast_simple_rowwise.cpp
│ │ │ │ │ ├── Tutorial_ReductionsVisitorsBroadcasting_colwise.cpp
│ │ │ │ │ ├── Tutorial_ReductionsVisitorsBroadcasting_maxnorm.cpp
│ │ │ │ │ ├── Tutorial_ReductionsVisitorsBroadcasting_reductions_bool.cpp
│ │ │ │ │ ├── Tutorial_ReductionsVisitorsBroadcasting_reductions_norm.cpp
│ │ │ │ │ ├── Tutorial_ReductionsVisitorsBroadcasting_reductions_operatornorm.cpp
│ │ │ │ │ ├── Tutorial_ReductionsVisitorsBroadcasting_rowwise.cpp
│ │ │ │ │ ├── Tutorial_ReductionsVisitorsBroadcasting_visitors.cpp
│ │ │ │ │ ├── Tutorial_simple_example_dynamic_size.cpp
│ │ │ │ │ ├── Tutorial_simple_example_fixed_size.cpp
│ │ │ │ │ ├── class_Block.cpp
│ │ │ │ │ ├── class_CwiseBinaryOp.cpp
│ │ │ │ │ ├── class_CwiseUnaryOp.cpp
│ │ │ │ │ ├── class_CwiseUnaryOp_ptrfun.cpp
│ │ │ │ │ ├── class_FixedBlock.cpp
│ │ │ │ │ ├── class_FixedReshaped.cpp
│ │ │ │ │ ├── class_FixedVectorBlock.cpp
│ │ │ │ │ ├── class_Reshaped.cpp
│ │ │ │ │ ├── class_VectorBlock.cpp
│ │ │ │ │ ├── function_taking_eigenbase.cpp
│ │ │ │ │ ├── function_taking_ref.cpp
│ │ │ │ │ ├── make_circulant.cpp
│ │ │ │ │ ├── make_circulant.cpp.entry
│ │ │ │ │ ├── make_circulant.cpp.evaluator
│ │ │ │ │ ├── make_circulant.cpp.expression
│ │ │ │ │ ├── make_circulant.cpp.main
│ │ │ │ │ ├── make_circulant.cpp.preamble
│ │ │ │ │ ├── make_circulant.cpp.traits
│ │ │ │ │ ├── make_circulant2.cpp
│ │ │ │ │ ├── matrixfree_cg.cpp
│ │ │ │ │ ├── nullary_indexing.cpp
│ │ │ │ │ ├── tut_arithmetic_add_sub.cpp
│ │ │ │ │ ├── tut_arithmetic_dot_cross.cpp
│ │ │ │ │ ├── tut_arithmetic_matrix_mul.cpp
│ │ │ │ │ ├── tut_arithmetic_redux_basic.cpp
│ │ │ │ │ ├── tut_arithmetic_scalar_mul_div.cpp
│ │ │ │ │ ├── tut_matrix_coefficient_accessors.cpp
│ │ │ │ │ ├── tut_matrix_resize.cpp
│ │ │ │ │ └── tut_matrix_resize_fixed_size.cpp
│ │ │ │ ├── snippets/
│ │ │ │ │ ├── .krazy
│ │ │ │ │ ├── AngleAxis_mimic_euler.cpp
│ │ │ │ │ ├── Array_initializer_list_23_cxx11.cpp
│ │ │ │ │ ├── Array_initializer_list_vector_cxx11.cpp
│ │ │ │ │ ├── Array_variadic_ctor_cxx11.cpp
│ │ │ │ │ ├── BiCGSTAB_simple.cpp
│ │ │ │ │ ├── BiCGSTAB_step_by_step.cpp
│ │ │ │ │ ├── CMakeLists.txt
│ │ │ │ │ ├── ColPivHouseholderQR_solve.cpp
│ │ │ │ │ ├── ComplexEigenSolver_compute.cpp
│ │ │ │ │ ├── ComplexEigenSolver_eigenvalues.cpp
│ │ │ │ │ ├── ComplexEigenSolver_eigenvectors.cpp
│ │ │ │ │ ├── ComplexSchur_compute.cpp
│ │ │ │ │ ├── ComplexSchur_matrixT.cpp
│ │ │ │ │ ├── ComplexSchur_matrixU.cpp
│ │ │ │ │ ├── Cwise_abs.cpp
│ │ │ │ │ ├── Cwise_abs2.cpp
│ │ │ │ │ ├── Cwise_acos.cpp
│ │ │ │ │ ├── Cwise_arg.cpp
│ │ │ │ │ ├── Cwise_array_power_array.cpp
│ │ │ │ │ ├── Cwise_asin.cpp
│ │ │ │ │ ├── Cwise_atan.cpp
│ │ │ │ │ ├── Cwise_boolean_and.cpp
│ │ │ │ │ ├── Cwise_boolean_not.cpp
│ │ │ │ │ ├── Cwise_boolean_or.cpp
│ │ │ │ │ ├── Cwise_boolean_xor.cpp
│ │ │ │ │ ├── Cwise_ceil.cpp
│ │ │ │ │ ├── Cwise_cos.cpp
│ │ │ │ │ ├── Cwise_cosh.cpp
│ │ │ │ │ ├── Cwise_cube.cpp
│ │ │ │ │ ├── Cwise_equal_equal.cpp
│ │ │ │ │ ├── Cwise_exp.cpp
│ │ │ │ │ ├── Cwise_floor.cpp
│ │ │ │ │ ├── Cwise_greater.cpp
│ │ │ │ │ ├── Cwise_greater_equal.cpp
│ │ │ │ │ ├── Cwise_inverse.cpp
│ │ │ │ │ ├── Cwise_isFinite.cpp
│ │ │ │ │ ├── Cwise_isInf.cpp
│ │ │ │ │ ├── Cwise_isNaN.cpp
│ │ │ │ │ ├── Cwise_less.cpp
│ │ │ │ │ ├── Cwise_less_equal.cpp
│ │ │ │ │ ├── Cwise_log.cpp
│ │ │ │ │ ├── Cwise_log10.cpp
│ │ │ │ │ ├── Cwise_max.cpp
│ │ │ │ │ ├── Cwise_min.cpp
│ │ │ │ │ ├── Cwise_minus.cpp
│ │ │ │ │ ├── Cwise_minus_equal.cpp
│ │ │ │ │ ├── Cwise_not_equal.cpp
│ │ │ │ │ ├── Cwise_plus.cpp
│ │ │ │ │ ├── Cwise_plus_equal.cpp
│ │ │ │ │ ├── Cwise_pow.cpp
│ │ │ │ │ ├── Cwise_product.cpp
│ │ │ │ │ ├── Cwise_quotient.cpp
│ │ │ │ │ ├── Cwise_rint.cpp
│ │ │ │ │ ├── Cwise_round.cpp
│ │ │ │ │ ├── Cwise_scalar_power_array.cpp
│ │ │ │ │ ├── Cwise_sign.cpp
│ │ │ │ │ ├── Cwise_sin.cpp
│ │ │ │ │ ├── Cwise_sinh.cpp
│ │ │ │ │ ├── Cwise_slash_equal.cpp
│ │ │ │ │ ├── Cwise_sqrt.cpp
│ │ │ │ │ ├── Cwise_square.cpp
│ │ │ │ │ ├── Cwise_tan.cpp
│ │ │ │ │ ├── Cwise_tanh.cpp
│ │ │ │ │ ├── Cwise_times_equal.cpp
│ │ │ │ │ ├── DenseBase_LinSpaced.cpp
│ │ │ │ │ ├── DenseBase_LinSpacedInt.cpp
│ │ │ │ │ ├── DenseBase_LinSpaced_seq_deprecated.cpp
│ │ │ │ │ ├── DenseBase_setLinSpaced.cpp
│ │ │ │ │ ├── DirectionWise_hnormalized.cpp
│ │ │ │ │ ├── DirectionWise_replicate.cpp
│ │ │ │ │ ├── DirectionWise_replicate_int.cpp
│ │ │ │ │ ├── EigenSolver_EigenSolver_MatrixType.cpp
│ │ │ │ │ ├── EigenSolver_compute.cpp
│ │ │ │ │ ├── EigenSolver_eigenvalues.cpp
│ │ │ │ │ ├── EigenSolver_eigenvectors.cpp
│ │ │ │ │ ├── EigenSolver_pseudoEigenvectors.cpp
│ │ │ │ │ ├── FullPivHouseholderQR_solve.cpp
│ │ │ │ │ ├── FullPivLU_image.cpp
│ │ │ │ │ ├── FullPivLU_kernel.cpp
│ │ │ │ │ ├── FullPivLU_solve.cpp
│ │ │ │ │ ├── GeneralizedEigenSolver.cpp
│ │ │ │ │ ├── HessenbergDecomposition_compute.cpp
│ │ │ │ │ ├── HessenbergDecomposition_matrixH.cpp
│ │ │ │ │ ├── HessenbergDecomposition_packedMatrix.cpp
│ │ │ │ │ ├── HouseholderQR_householderQ.cpp
│ │ │ │ │ ├── HouseholderQR_solve.cpp
│ │ │ │ │ ├── HouseholderSequence_HouseholderSequence.cpp
│ │ │ │ │ ├── IOFormat.cpp
│ │ │ │ │ ├── JacobiSVD_basic.cpp
│ │ │ │ │ ├── Jacobi_makeGivens.cpp
│ │ │ │ │ ├── Jacobi_makeJacobi.cpp
│ │ │ │ │ ├── LLT_example.cpp
│ │ │ │ │ ├── LLT_solve.cpp
│ │ │ │ │ ├── LeastSquaresNormalEquations.cpp
│ │ │ │ │ ├── LeastSquaresQR.cpp
│ │ │ │ │ ├── Map_general_stride.cpp
│ │ │ │ │ ├── Map_inner_stride.cpp
│ │ │ │ │ ├── Map_outer_stride.cpp
│ │ │ │ │ ├── Map_placement_new.cpp
│ │ │ │ │ ├── Map_simple.cpp
│ │ │ │ │ ├── MatrixBase_adjoint.cpp
│ │ │ │ │ ├── MatrixBase_all.cpp
│ │ │ │ │ ├── MatrixBase_applyOnTheLeft.cpp
│ │ │ │ │ ├── MatrixBase_applyOnTheRight.cpp
│ │ │ │ │ ├── MatrixBase_array.cpp
│ │ │ │ │ ├── MatrixBase_array_const.cpp
│ │ │ │ │ ├── MatrixBase_asDiagonal.cpp
│ │ │ │ │ ├── MatrixBase_block_int_int.cpp
│ │ │ │ │ ├── MatrixBase_block_int_int_int_int.cpp
│ │ │ │ │ ├── MatrixBase_bottomLeftCorner_int_int.cpp
│ │ │ │ │ ├── MatrixBase_bottomRightCorner_int_int.cpp
│ │ │ │ │ ├── MatrixBase_bottomRows_int.cpp
│ │ │ │ │ ├── MatrixBase_cast.cpp
│ │ │ │ │ ├── MatrixBase_col.cpp
│ │ │ │ │ ├── MatrixBase_colwise.cpp
│ │ │ │ │ ├── MatrixBase_colwise_iterator_cxx11.cpp
│ │ │ │ │ ├── MatrixBase_computeInverseAndDetWithCheck.cpp
│ │ │ │ │ ├── MatrixBase_computeInverseWithCheck.cpp
│ │ │ │ │ ├── MatrixBase_cwiseAbs.cpp
│ │ │ │ │ ├── MatrixBase_cwiseAbs2.cpp
│ │ │ │ │ ├── MatrixBase_cwiseArg.cpp
│ │ │ │ │ ├── MatrixBase_cwiseEqual.cpp
│ │ │ │ │ ├── MatrixBase_cwiseInverse.cpp
│ │ │ │ │ ├── MatrixBase_cwiseMax.cpp
│ │ │ │ │ ├── MatrixBase_cwiseMin.cpp
│ │ │ │ │ ├── MatrixBase_cwiseNotEqual.cpp
│ │ │ │ │ ├── MatrixBase_cwiseProduct.cpp
│ │ │ │ │ ├── MatrixBase_cwiseQuotient.cpp
│ │ │ │ │ ├── MatrixBase_cwiseSign.cpp
│ │ │ │ │ ├── MatrixBase_cwiseSqrt.cpp
│ │ │ │ │ ├── MatrixBase_diagonal.cpp
│ │ │ │ │ ├── MatrixBase_diagonal_int.cpp
│ │ │ │ │ ├── MatrixBase_diagonal_template_int.cpp
│ │ │ │ │ ├── MatrixBase_eigenvalues.cpp
│ │ │ │ │ ├── MatrixBase_end_int.cpp
│ │ │ │ │ ├── MatrixBase_eval.cpp
│ │ │ │ │ ├── MatrixBase_fixedBlock_int_int.cpp
│ │ │ │ │ ├── MatrixBase_hnormalized.cpp
│ │ │ │ │ ├── MatrixBase_homogeneous.cpp
│ │ │ │ │ ├── MatrixBase_identity.cpp
│ │ │ │ │ ├── MatrixBase_identity_int_int.cpp
│ │ │ │ │ ├── MatrixBase_inverse.cpp
│ │ │ │ │ ├── MatrixBase_isDiagonal.cpp
│ │ │ │ │ ├── MatrixBase_isIdentity.cpp
│ │ │ │ │ ├── MatrixBase_isOnes.cpp
│ │ │ │ │ ├── MatrixBase_isOrthogonal.cpp
│ │ │ │ │ ├── MatrixBase_isUnitary.cpp
│ │ │ │ │ ├── MatrixBase_isZero.cpp
│ │ │ │ │ ├── MatrixBase_leftCols_int.cpp
│ │ │ │ │ ├── MatrixBase_noalias.cpp
│ │ │ │ │ ├── MatrixBase_ones.cpp
│ │ │ │ │ ├── MatrixBase_ones_int.cpp
│ │ │ │ │ ├── MatrixBase_ones_int_int.cpp
│ │ │ │ │ ├── MatrixBase_operatorNorm.cpp
│ │ │ │ │ ├── MatrixBase_prod.cpp
│ │ │ │ │ ├── MatrixBase_random.cpp
│ │ │ │ │ ├── MatrixBase_random_int.cpp
│ │ │ │ │ ├── MatrixBase_random_int_int.cpp
│ │ │ │ │ ├── MatrixBase_replicate.cpp
│ │ │ │ │ ├── MatrixBase_replicate_int_int.cpp
│ │ │ │ │ ├── MatrixBase_reshaped_auto.cpp
│ │ │ │ │ ├── MatrixBase_reshaped_fixed.cpp
│ │ │ │ │ ├── MatrixBase_reshaped_int_int.cpp
│ │ │ │ │ ├── MatrixBase_reshaped_to_vector.cpp
│ │ │ │ │ ├── MatrixBase_reverse.cpp
│ │ │ │ │ ├── MatrixBase_rightCols_int.cpp
│ │ │ │ │ ├── MatrixBase_row.cpp
│ │ │ │ │ ├── MatrixBase_rowwise.cpp
│ │ │ │ │ ├── MatrixBase_segment_int_int.cpp
│ │ │ │ │ ├── MatrixBase_select.cpp
│ │ │ │ │ ├── MatrixBase_selfadjointView.cpp
│ │ │ │ │ ├── MatrixBase_set.cpp
│ │ │ │ │ ├── MatrixBase_setIdentity.cpp
│ │ │ │ │ ├── MatrixBase_setOnes.cpp
│ │ │ │ │ ├── MatrixBase_setRandom.cpp
│ │ │ │ │ ├── MatrixBase_setZero.cpp
│ │ │ │ │ ├── MatrixBase_start_int.cpp
│ │ │ │ │ ├── MatrixBase_template_int_bottomRows.cpp
│ │ │ │ │ ├── MatrixBase_template_int_end.cpp
│ │ │ │ │ ├── MatrixBase_template_int_int_block_int_int_int_int.cpp
│ │ │ │ │ ├── MatrixBase_template_int_int_bottomLeftCorner.cpp
│ │ │ │ │ ├── MatrixBase_template_int_int_bottomLeftCorner_int_int.cpp
│ │ │ │ │ ├── MatrixBase_template_int_int_bottomRightCorner.cpp
│ │ │ │ │ ├── MatrixBase_template_int_int_bottomRightCorner_int_int.cpp
│ │ │ │ │ ├── MatrixBase_template_int_int_topLeftCorner.cpp
│ │ │ │ │ ├── MatrixBase_template_int_int_topLeftCorner_int_int.cpp
│ │ │ │ │ ├── MatrixBase_template_int_int_topRightCorner.cpp
│ │ │ │ │ ├── MatrixBase_template_int_int_topRightCorner_int_int.cpp
│ │ │ │ │ ├── MatrixBase_template_int_leftCols.cpp
│ │ │ │ │ ├── MatrixBase_template_int_rightCols.cpp
│ │ │ │ │ ├── MatrixBase_template_int_segment.cpp
│ │ │ │ │ ├── MatrixBase_template_int_start.cpp
│ │ │ │ │ ├── MatrixBase_template_int_topRows.cpp
│ │ │ │ │ ├── MatrixBase_topLeftCorner_int_int.cpp
│ │ │ │ │ ├── MatrixBase_topRightCorner_int_int.cpp
│ │ │ │ │ ├── MatrixBase_topRows_int.cpp
│ │ │ │ │ ├── MatrixBase_transpose.cpp
│ │ │ │ │ ├── MatrixBase_triangularView.cpp
│ │ │ │ │ ├── MatrixBase_zero.cpp
│ │ │ │ │ ├── MatrixBase_zero_int.cpp
│ │ │ │ │ ├── MatrixBase_zero_int_int.cpp
│ │ │ │ │ ├── Matrix_Map_stride.cpp
│ │ │ │ │ ├── Matrix_initializer_list_23_cxx11.cpp
│ │ │ │ │ ├── Matrix_initializer_list_vector_cxx11.cpp
│ │ │ │ │ ├── Matrix_resize_NoChange_int.cpp
│ │ │ │ │ ├── Matrix_resize_int.cpp
│ │ │ │ │ ├── Matrix_resize_int_NoChange.cpp
│ │ │ │ │ ├── Matrix_resize_int_int.cpp
│ │ │ │ │ ├── Matrix_setConstant_int.cpp
│ │ │ │ │ ├── Matrix_setConstant_int_int.cpp
│ │ │ │ │ ├── Matrix_setIdentity_int_int.cpp
│ │ │ │ │ ├── Matrix_setOnes_int.cpp
│ │ │ │ │ ├── Matrix_setOnes_int_int.cpp
│ │ │ │ │ ├── Matrix_setRandom_int.cpp
│ │ │ │ │ ├── Matrix_setRandom_int_int.cpp
│ │ │ │ │ ├── Matrix_setZero_int.cpp
│ │ │ │ │ ├── Matrix_setZero_int_int.cpp
│ │ │ │ │ ├── Matrix_variadic_ctor_cxx11.cpp
│ │ │ │ │ ├── PartialPivLU_solve.cpp
│ │ │ │ │ ├── PartialRedux_count.cpp
│ │ │ │ │ ├── PartialRedux_maxCoeff.cpp
│ │ │ │ │ ├── PartialRedux_minCoeff.cpp
│ │ │ │ │ ├── PartialRedux_norm.cpp
│ │ │ │ │ ├── PartialRedux_prod.cpp
│ │ │ │ │ ├── PartialRedux_squaredNorm.cpp
│ │ │ │ │ ├── PartialRedux_sum.cpp
│ │ │ │ │ ├── RealQZ_compute.cpp
│ │ │ │ │ ├── RealSchur_RealSchur_MatrixType.cpp
│ │ │ │ │ ├── RealSchur_compute.cpp
│ │ │ │ │ ├── SelfAdjointEigenSolver_SelfAdjointEigenSolver.cpp
│ │ │ │ │ ├── SelfAdjointEigenSolver_SelfAdjointEigenSolver_MatrixType.cpp
│ │ │ │ │ ├── SelfAdjointEigenSolver_SelfAdjointEigenSolver_MatrixType2.cpp
│ │ │ │ │ ├── SelfAdjointEigenSolver_compute_MatrixType.cpp
│ │ │ │ │ ├── SelfAdjointEigenSolver_compute_MatrixType2.cpp
│ │ │ │ │ ├── SelfAdjointEigenSolver_eigenvalues.cpp
│ │ │ │ │ ├── SelfAdjointEigenSolver_eigenvectors.cpp
│ │ │ │ │ ├── SelfAdjointEigenSolver_operatorInverseSqrt.cpp
│ │ │ │ │ ├── SelfAdjointEigenSolver_operatorSqrt.cpp
│ │ │ │ │ ├── SelfAdjointView_eigenvalues.cpp
│ │ │ │ │ ├── SelfAdjointView_operatorNorm.cpp
│ │ │ │ │ ├── Slicing_arrayexpr.cpp
│ │ │ │ │ ├── Slicing_custom_padding_cxx11.cpp
│ │ │ │ │ ├── Slicing_rawarray_cxx11.cpp
│ │ │ │ │ ├── Slicing_stdvector_cxx11.cpp
│ │ │ │ │ ├── SparseMatrix_coeffs.cpp
│ │ │ │ │ ├── TopicAliasing_block.cpp
│ │ │ │ │ ├── TopicAliasing_block_correct.cpp
│ │ │ │ │ ├── TopicAliasing_cwise.cpp
│ │ │ │ │ ├── TopicAliasing_mult1.cpp
│ │ │ │ │ ├── TopicAliasing_mult2.cpp
│ │ │ │ │ ├── TopicAliasing_mult3.cpp
│ │ │ │ │ ├── TopicAliasing_mult4.cpp
│ │ │ │ │ ├── TopicAliasing_mult5.cpp
│ │ │ │ │ ├── TopicStorageOrders_example.cpp
│ │ │ │ │ ├── Triangular_solve.cpp
│ │ │ │ │ ├── Tridiagonalization_Tridiagonalization_MatrixType.cpp
│ │ │ │ │ ├── Tridiagonalization_compute.cpp
│ │ │ │ │ ├── Tridiagonalization_decomposeInPlace.cpp
│ │ │ │ │ ├── Tridiagonalization_diagonal.cpp
│ │ │ │ │ ├── Tridiagonalization_householderCoefficients.cpp
│ │ │ │ │ ├── Tridiagonalization_packedMatrix.cpp
│ │ │ │ │ ├── Tutorial_AdvancedInitialization_Block.cpp
│ │ │ │ │ ├── Tutorial_AdvancedInitialization_CommaTemporary.cpp
│ │ │ │ │ ├── Tutorial_AdvancedInitialization_Join.cpp
│ │ │ │ │ ├── Tutorial_AdvancedInitialization_LinSpaced.cpp
│ │ │ │ │ ├── Tutorial_AdvancedInitialization_ThreeWays.cpp
│ │ │ │ │ ├── Tutorial_AdvancedInitialization_Zero.cpp
│ │ │ │ │ ├── Tutorial_Map_rowmajor.cpp
│ │ │ │ │ ├── Tutorial_Map_using.cpp
│ │ │ │ │ ├── Tutorial_ReshapeMat2Mat.cpp
│ │ │ │ │ ├── Tutorial_ReshapeMat2Vec.cpp
│ │ │ │ │ ├── Tutorial_SlicingCol.cpp
│ │ │ │ │ ├── Tutorial_SlicingVec.cpp
│ │ │ │ │ ├── Tutorial_commainit_01.cpp
│ │ │ │ │ ├── Tutorial_commainit_01b.cpp
│ │ │ │ │ ├── Tutorial_commainit_02.cpp
│ │ │ │ │ ├── Tutorial_range_for_loop_1d_cxx11.cpp
│ │ │ │ │ ├── Tutorial_range_for_loop_2d_cxx11.cpp
│ │ │ │ │ ├── Tutorial_reshaped_vs_resize_1.cpp
│ │ │ │ │ ├── Tutorial_reshaped_vs_resize_2.cpp
│ │ │ │ │ ├── Tutorial_solve_matrix_inverse.cpp
│ │ │ │ │ ├── Tutorial_solve_multiple_rhs.cpp
│ │ │ │ │ ├── Tutorial_solve_reuse_decomposition.cpp
│ │ │ │ │ ├── Tutorial_solve_singular.cpp
│ │ │ │ │ ├── Tutorial_solve_triangular.cpp
│ │ │ │ │ ├── Tutorial_solve_triangular_inplace.cpp
│ │ │ │ │ ├── Tutorial_std_sort.cpp
│ │ │ │ │ ├── Tutorial_std_sort_rows_cxx11.cpp
│ │ │ │ │ ├── VectorwiseOp_homogeneous.cpp
│ │ │ │ │ ├── Vectorwise_reverse.cpp
│ │ │ │ │ ├── class_FullPivLU.cpp
│ │ │ │ │ ├── compile_snippet.cpp.in
│ │ │ │ │ ├── tut_arithmetic_redux_minmax.cpp
│ │ │ │ │ ├── tut_arithmetic_transpose_aliasing.cpp
│ │ │ │ │ ├── tut_arithmetic_transpose_conjugate.cpp
│ │ │ │ │ ├── tut_arithmetic_transpose_inplace.cpp
│ │ │ │ │ └── tut_matrix_assignment_resizing.cpp
│ │ │ │ ├── special_examples/
│ │ │ │ │ ├── CMakeLists.txt
│ │ │ │ │ ├── Tutorial_sparse_example.cpp
│ │ │ │ │ ├── Tutorial_sparse_example_details.cpp
│ │ │ │ │ └── random_cpp11.cpp
│ │ │ │ └── tutorial.cpp
│ │ │ ├── eigen3.pc.in
│ │ │ ├── failtest/
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── bdcsvd_int.cpp
│ │ │ │ ├── block_nonconst_ctor_on_const_xpr_0.cpp
│ │ │ │ ├── block_nonconst_ctor_on_const_xpr_1.cpp
│ │ │ │ ├── block_nonconst_ctor_on_const_xpr_2.cpp
│ │ │ │ ├── block_on_const_type_actually_const_0.cpp
│ │ │ │ ├── block_on_const_type_actually_const_1.cpp
│ │ │ │ ├── colpivqr_int.cpp
│ │ │ │ ├── const_qualified_block_method_retval_0.cpp
│ │ │ │ ├── const_qualified_block_method_retval_1.cpp
│ │ │ │ ├── const_qualified_diagonal_method_retval.cpp
│ │ │ │ ├── const_qualified_transpose_method_retval.cpp
│ │ │ │ ├── cwiseunaryview_nonconst_ctor_on_const_xpr.cpp
│ │ │ │ ├── cwiseunaryview_on_const_type_actually_const.cpp
│ │ │ │ ├── diagonal_nonconst_ctor_on_const_xpr.cpp
│ │ │ │ ├── diagonal_on_const_type_actually_const.cpp
│ │ │ │ ├── eigensolver_cplx.cpp
│ │ │ │ ├── eigensolver_int.cpp
│ │ │ │ ├── failtest_sanity_check.cpp
│ │ │ │ ├── fullpivlu_int.cpp
│ │ │ │ ├── fullpivqr_int.cpp
│ │ │ │ ├── initializer_list_1.cpp
│ │ │ │ ├── initializer_list_2.cpp
│ │ │ │ ├── jacobisvd_int.cpp
│ │ │ │ ├── ldlt_int.cpp
│ │ │ │ ├── llt_int.cpp
│ │ │ │ ├── map_nonconst_ctor_on_const_ptr_0.cpp
│ │ │ │ ├── map_nonconst_ctor_on_const_ptr_1.cpp
│ │ │ │ ├── map_nonconst_ctor_on_const_ptr_2.cpp
│ │ │ │ ├── map_nonconst_ctor_on_const_ptr_3.cpp
│ │ │ │ ├── map_nonconst_ctor_on_const_ptr_4.cpp
│ │ │ │ ├── map_on_const_type_actually_const_0.cpp
│ │ │ │ ├── map_on_const_type_actually_const_1.cpp
│ │ │ │ ├── partialpivlu_int.cpp
│ │ │ │ ├── qr_int.cpp
│ │ │ │ ├── ref_1.cpp
│ │ │ │ ├── ref_2.cpp
│ │ │ │ ├── ref_3.cpp
│ │ │ │ ├── ref_4.cpp
│ │ │ │ ├── ref_5.cpp
│ │ │ │ ├── selfadjointview_nonconst_ctor_on_const_xpr.cpp
│ │ │ │ ├── selfadjointview_on_const_type_actually_const.cpp
│ │ │ │ ├── sparse_ref_1.cpp
│ │ │ │ ├── sparse_ref_2.cpp
│ │ │ │ ├── sparse_ref_3.cpp
│ │ │ │ ├── sparse_ref_4.cpp
│ │ │ │ ├── sparse_ref_5.cpp
│ │ │ │ ├── sparse_storage_mismatch.cpp
│ │ │ │ ├── swap_1.cpp
│ │ │ │ ├── swap_2.cpp
│ │ │ │ ├── ternary_1.cpp
│ │ │ │ ├── ternary_2.cpp
│ │ │ │ ├── transpose_nonconst_ctor_on_const_xpr.cpp
│ │ │ │ ├── transpose_on_const_type_actually_const.cpp
│ │ │ │ ├── triangularview_nonconst_ctor_on_const_xpr.cpp
│ │ │ │ └── triangularview_on_const_type_actually_const.cpp
│ │ │ ├── lapack/
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── cholesky.cpp
│ │ │ │ ├── clacgv.f
│ │ │ │ ├── cladiv.f
│ │ │ │ ├── clarf.f
│ │ │ │ ├── clarfb.f
│ │ │ │ ├── clarfg.f
│ │ │ │ ├── clarft.f
│ │ │ │ ├── complex_double.cpp
│ │ │ │ ├── complex_single.cpp
│ │ │ │ ├── dladiv.f
│ │ │ │ ├── dlamch.f
│ │ │ │ ├── dlapy2.f
│ │ │ │ ├── dlapy3.f
│ │ │ │ ├── dlarf.f
│ │ │ │ ├── dlarfb.f
│ │ │ │ ├── dlarfg.f
│ │ │ │ ├── dlarft.f
│ │ │ │ ├── double.cpp
│ │ │ │ ├── dsecnd_NONE.f
│ │ │ │ ├── eigenvalues.cpp
│ │ │ │ ├── ilaclc.f
│ │ │ │ ├── ilaclr.f
│ │ │ │ ├── iladlc.f
│ │ │ │ ├── iladlr.f
│ │ │ │ ├── ilaslc.f
│ │ │ │ ├── ilaslr.f
│ │ │ │ ├── ilazlc.f
│ │ │ │ ├── ilazlr.f
│ │ │ │ ├── lapack_common.h
│ │ │ │ ├── lu.cpp
│ │ │ │ ├── second_NONE.f
│ │ │ │ ├── single.cpp
│ │ │ │ ├── sladiv.f
│ │ │ │ ├── slamch.f
│ │ │ │ ├── slapy2.f
│ │ │ │ ├── slapy3.f
│ │ │ │ ├── slarf.f
│ │ │ │ ├── slarfb.f
│ │ │ │ ├── slarfg.f
│ │ │ │ ├── slarft.f
│ │ │ │ ├── svd.cpp
│ │ │ │ ├── zlacgv.f
│ │ │ │ ├── zladiv.f
│ │ │ │ ├── zlarf.f
│ │ │ │ ├── zlarfb.f
│ │ │ │ ├── zlarfg.f
│ │ │ │ └── zlarft.f
│ │ │ ├── scripts/
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── cdashtesting.cmake.in
│ │ │ │ ├── check.in
│ │ │ │ ├── debug.in
│ │ │ │ ├── eigen_gen_credits.cpp
│ │ │ │ ├── eigen_gen_docs
│ │ │ │ ├── eigen_gen_split_test_help.cmake
│ │ │ │ ├── eigen_monitor_perf.sh
│ │ │ │ ├── release.in
│ │ │ │ └── relicense.py
│ │ │ ├── signature_of_eigen3_matrix_library
│ │ │ ├── test/
│ │ │ │ ├── AnnoyingScalar.h
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── MovableScalar.h
│ │ │ │ ├── OffByOneScalar.h
│ │ │ │ ├── SafeScalar.h
│ │ │ │ ├── adjoint.cpp
│ │ │ │ ├── array_cwise.cpp
│ │ │ │ ├── array_for_matrix.cpp
│ │ │ │ ├── array_of_string.cpp
│ │ │ │ ├── array_replicate.cpp
│ │ │ │ ├── array_reverse.cpp
│ │ │ │ ├── bandmatrix.cpp
│ │ │ │ ├── basicstuff.cpp
│ │ │ │ ├── bdcsvd.cpp
│ │ │ │ ├── bfloat16_float.cpp
│ │ │ │ ├── bicgstab.cpp
│ │ │ │ ├── blasutil.cpp
│ │ │ │ ├── block.cpp
│ │ │ │ ├── boostmultiprec.cpp
│ │ │ │ ├── bug1213.cpp
│ │ │ │ ├── bug1213.h
│ │ │ │ ├── bug1213_main.cpp
│ │ │ │ ├── cholesky.cpp
│ │ │ │ ├── cholmod_support.cpp
│ │ │ │ ├── commainitializer.cpp
│ │ │ │ ├── conjugate_gradient.cpp
│ │ │ │ ├── conservative_resize.cpp
│ │ │ │ ├── constructor.cpp
│ │ │ │ ├── corners.cpp
│ │ │ │ ├── ctorleak.cpp
│ │ │ │ ├── denseLM.cpp
│ │ │ │ ├── dense_storage.cpp
│ │ │ │ ├── determinant.cpp
│ │ │ │ ├── diagonal.cpp
│ │ │ │ ├── diagonal_matrix_variadic_ctor.cpp
│ │ │ │ ├── diagonalmatrices.cpp
│ │ │ │ ├── dontalign.cpp
│ │ │ │ ├── dynalloc.cpp
│ │ │ │ ├── eigen2support.cpp
│ │ │ │ ├── eigensolver_complex.cpp
│ │ │ │ ├── eigensolver_generalized_real.cpp
│ │ │ │ ├── eigensolver_generic.cpp
│ │ │ │ ├── eigensolver_selfadjoint.cpp
│ │ │ │ ├── evaluator_common.h
│ │ │ │ ├── evaluators.cpp
│ │ │ │ ├── exceptions.cpp
│ │ │ │ ├── fastmath.cpp
│ │ │ │ ├── first_aligned.cpp
│ │ │ │ ├── geo_alignedbox.cpp
│ │ │ │ ├── geo_eulerangles.cpp
│ │ │ │ ├── geo_homogeneous.cpp
│ │ │ │ ├── geo_hyperplane.cpp
│ │ │ │ ├── geo_orthomethods.cpp
│ │ │ │ ├── geo_parametrizedline.cpp
│ │ │ │ ├── geo_quaternion.cpp
│ │ │ │ ├── geo_transformations.cpp
│ │ │ │ ├── gpu_basic.cu
│ │ │ │ ├── gpu_common.h
│ │ │ │ ├── half_float.cpp
│ │ │ │ ├── hessenberg.cpp
│ │ │ │ ├── householder.cpp
│ │ │ │ ├── incomplete_cholesky.cpp
│ │ │ │ ├── indexed_view.cpp
│ │ │ │ ├── initializer_list_construction.cpp
│ │ │ │ ├── inplace_decomposition.cpp
│ │ │ │ ├── integer_types.cpp
│ │ │ │ ├── inverse.cpp
│ │ │ │ ├── io.cpp
│ │ │ │ ├── is_same_dense.cpp
│ │ │ │ ├── jacobi.cpp
│ │ │ │ ├── jacobisvd.cpp
│ │ │ │ ├── klu_support.cpp
│ │ │ │ ├── linearstructure.cpp
│ │ │ │ ├── lscg.cpp
│ │ │ │ ├── lu.cpp
│ │ │ │ ├── main.h
│ │ │ │ ├── mapped_matrix.cpp
│ │ │ │ ├── mapstaticmethods.cpp
│ │ │ │ ├── mapstride.cpp
│ │ │ │ ├── meta.cpp
│ │ │ │ ├── metis_support.cpp
│ │ │ │ ├── miscmatrices.cpp
│ │ │ │ ├── mixingtypes.cpp
│ │ │ │ ├── mpl2only.cpp
│ │ │ │ ├── nestbyvalue.cpp
│ │ │ │ ├── nesting_ops.cpp
│ │ │ │ ├── nomalloc.cpp
│ │ │ │ ├── nullary.cpp
│ │ │ │ ├── num_dimensions.cpp
│ │ │ │ ├── numext.cpp
│ │ │ │ ├── packetmath.cpp
│ │ │ │ ├── packetmath_test_shared.h
│ │ │ │ ├── pardiso_support.cpp
│ │ │ │ ├── pastix_support.cpp
│ │ │ │ ├── permutationmatrices.cpp
│ │ │ │ ├── prec_inverse_4x4.cpp
│ │ │ │ ├── product.h
│ │ │ │ ├── product_extra.cpp
│ │ │ │ ├── product_large.cpp
│ │ │ │ ├── product_mmtr.cpp
│ │ │ │ ├── product_notemporary.cpp
│ │ │ │ ├── product_selfadjoint.cpp
│ │ │ │ ├── product_small.cpp
│ │ │ │ ├── product_symm.cpp
│ │ │ │ ├── product_syrk.cpp
│ │ │ │ ├── product_trmm.cpp
│ │ │ │ ├── product_trmv.cpp
│ │ │ │ ├── product_trsolve.cpp
│ │ │ │ ├── qr.cpp
│ │ │ │ ├── qr_colpivoting.cpp
│ │ │ │ ├── qr_fullpivoting.cpp
│ │ │ │ ├── qtvector.cpp
│ │ │ │ ├── rand.cpp
│ │ │ │ ├── random_matrix.cpp
│ │ │ │ ├── random_without_cast_overflow.h
│ │ │ │ ├── real_qz.cpp
│ │ │ │ ├── redux.cpp
│ │ │ │ ├── ref.cpp
│ │ │ │ ├── reshape.cpp
│ │ │ │ ├── resize.cpp
│ │ │ │ ├── rvalue_types.cpp
│ │ │ │ ├── schur_complex.cpp
│ │ │ │ ├── schur_real.cpp
│ │ │ │ ├── selfadjoint.cpp
│ │ │ │ ├── simplicial_cholesky.cpp
│ │ │ │ ├── sizeof.cpp
│ │ │ │ ├── sizeoverflow.cpp
│ │ │ │ ├── smallvectors.cpp
│ │ │ │ ├── solverbase.h
│ │ │ │ ├── sparse.h
│ │ │ │ ├── sparseLM.cpp
│ │ │ │ ├── sparse_basic.cpp
│ │ │ │ ├── sparse_block.cpp
│ │ │ │ ├── sparse_permutations.cpp
│ │ │ │ ├── sparse_product.cpp
│ │ │ │ ├── sparse_ref.cpp
│ │ │ │ ├── sparse_solver.h
│ │ │ │ ├── sparse_solvers.cpp
│ │ │ │ ├── sparse_vector.cpp
│ │ │ │ ├── sparselu.cpp
│ │ │ │ ├── sparseqr.cpp
│ │ │ │ ├── special_numbers.cpp
│ │ │ │ ├── split_test_helper.h
│ │ │ │ ├── spqr_support.cpp
│ │ │ │ ├── stable_norm.cpp
│ │ │ │ ├── stddeque.cpp
│ │ │ │ ├── stddeque_overload.cpp
│ │ │ │ ├── stdlist.cpp
│ │ │ │ ├── stdlist_overload.cpp
│ │ │ │ ├── stdvector.cpp
│ │ │ │ ├── stdvector_overload.cpp
│ │ │ │ ├── stl_iterators.cpp
│ │ │ │ ├── superlu_support.cpp
│ │ │ │ ├── svd_common.h
│ │ │ │ ├── svd_fill.h
│ │ │ │ ├── swap.cpp
│ │ │ │ ├── symbolic_index.cpp
│ │ │ │ ├── triangular.cpp
│ │ │ │ ├── type_alias.cpp
│ │ │ │ ├── umeyama.cpp
│ │ │ │ ├── umfpack_support.cpp
│ │ │ │ ├── unalignedcount.cpp
│ │ │ │ ├── upperbidiagonalization.cpp
│ │ │ │ ├── vectorization_logic.cpp
│ │ │ │ ├── vectorwiseop.cpp
│ │ │ │ ├── visitor.cpp
│ │ │ │ └── zerosized.cpp
│ │ │ └── unsupported/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── Eigen/
│ │ │ │ ├── AdolcForward
│ │ │ │ ├── AlignedVector3
│ │ │ │ ├── ArpackSupport
│ │ │ │ ├── AutoDiff
│ │ │ │ ├── BVH
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── CXX11/
│ │ │ │ │ ├── CMakeLists.txt
│ │ │ │ │ ├── Tensor
│ │ │ │ │ ├── TensorSymmetry
│ │ │ │ │ ├── ThreadPool
│ │ │ │ │ └── src/
│ │ │ │ │ ├── Tensor/
│ │ │ │ │ │ ├── README.md
│ │ │ │ │ │ ├── Tensor.h
│ │ │ │ │ │ ├── TensorArgMax.h
│ │ │ │ │ │ ├── TensorAssign.h
│ │ │ │ │ │ ├── TensorBase.h
│ │ │ │ │ │ ├── TensorBlock.h
│ │ │ │ │ │ ├── TensorBroadcasting.h
│ │ │ │ │ │ ├── TensorChipping.h
│ │ │ │ │ │ ├── TensorConcatenation.h
│ │ │ │ │ │ ├── TensorContraction.h
│ │ │ │ │ │ ├── TensorContractionBlocking.h
│ │ │ │ │ │ ├── TensorContractionCuda.h
│ │ │ │ │ │ ├── TensorContractionGpu.h
│ │ │ │ │ │ ├── TensorContractionMapper.h
│ │ │ │ │ │ ├── TensorContractionSycl.h
│ │ │ │ │ │ ├── TensorContractionThreadPool.h
│ │ │ │ │ │ ├── TensorConversion.h
│ │ │ │ │ │ ├── TensorConvolution.h
│ │ │ │ │ │ ├── TensorConvolutionSycl.h
│ │ │ │ │ │ ├── TensorCostModel.h
│ │ │ │ │ │ ├── TensorCustomOp.h
│ │ │ │ │ │ ├── TensorDevice.h
│ │ │ │ │ │ ├── TensorDeviceCuda.h
│ │ │ │ │ │ ├── TensorDeviceDefault.h
│ │ │ │ │ │ ├── TensorDeviceGpu.h
│ │ │ │ │ │ ├── TensorDeviceSycl.h
│ │ │ │ │ │ ├── TensorDeviceThreadPool.h
│ │ │ │ │ │ ├── TensorDimensionList.h
│ │ │ │ │ │ ├── TensorDimensions.h
│ │ │ │ │ │ ├── TensorEvalTo.h
│ │ │ │ │ │ ├── TensorEvaluator.h
│ │ │ │ │ │ ├── TensorExecutor.h
│ │ │ │ │ │ ├── TensorExpr.h
│ │ │ │ │ │ ├── TensorFFT.h
│ │ │ │ │ │ ├── TensorFixedSize.h
│ │ │ │ │ │ ├── TensorForcedEval.h
│ │ │ │ │ │ ├── TensorForwardDeclarations.h
│ │ │ │ │ │ ├── TensorFunctors.h
│ │ │ │ │ │ ├── TensorGenerator.h
│ │ │ │ │ │ ├── TensorGlobalFunctions.h
│ │ │ │ │ │ ├── TensorGpuHipCudaDefines.h
│ │ │ │ │ │ ├── TensorGpuHipCudaUndefines.h
│ │ │ │ │ │ ├── TensorIO.h
│ │ │ │ │ │ ├── TensorImagePatch.h
│ │ │ │ │ │ ├── TensorIndexList.h
│ │ │ │ │ │ ├── TensorInflation.h
│ │ │ │ │ │ ├── TensorInitializer.h
│ │ │ │ │ │ ├── TensorIntDiv.h
│ │ │ │ │ │ ├── TensorLayoutSwap.h
│ │ │ │ │ │ ├── TensorMacros.h
│ │ │ │ │ │ ├── TensorMap.h
│ │ │ │ │ │ ├── TensorMeta.h
│ │ │ │ │ │ ├── TensorMorphing.h
│ │ │ │ │ │ ├── TensorPadding.h
│ │ │ │ │ │ ├── TensorPatch.h
│ │ │ │ │ │ ├── TensorRandom.h
│ │ │ │ │ │ ├── TensorReduction.h
│ │ │ │ │ │ ├── TensorReductionCuda.h
│ │ │ │ │ │ ├── TensorReductionGpu.h
│ │ │ │ │ │ ├── TensorReductionSycl.h
│ │ │ │ │ │ ├── TensorRef.h
│ │ │ │ │ │ ├── TensorReverse.h
│ │ │ │ │ │ ├── TensorScan.h
│ │ │ │ │ │ ├── TensorScanSycl.h
│ │ │ │ │ │ ├── TensorShuffling.h
│ │ │ │ │ │ ├── TensorStorage.h
│ │ │ │ │ │ ├── TensorStriding.h
│ │ │ │ │ │ ├── TensorTrace.h
│ │ │ │ │ │ ├── TensorTraits.h
│ │ │ │ │ │ ├── TensorUInt128.h
│ │ │ │ │ │ └── TensorVolumePatch.h
│ │ │ │ │ ├── TensorSymmetry/
│ │ │ │ │ │ ├── DynamicSymmetry.h
│ │ │ │ │ │ ├── StaticSymmetry.h
│ │ │ │ │ │ ├── Symmetry.h
│ │ │ │ │ │ └── util/
│ │ │ │ │ │ └── TemplateGroupTheory.h
│ │ │ │ │ ├── ThreadPool/
│ │ │ │ │ │ ├── Barrier.h
│ │ │ │ │ │ ├── EventCount.h
│ │ │ │ │ │ ├── NonBlockingThreadPool.h
│ │ │ │ │ │ ├── RunQueue.h
│ │ │ │ │ │ ├── ThreadCancel.h
│ │ │ │ │ │ ├── ThreadEnvironment.h
│ │ │ │ │ │ ├── ThreadLocal.h
│ │ │ │ │ │ ├── ThreadPoolInterface.h
│ │ │ │ │ │ └── ThreadYield.h
│ │ │ │ │ └── util/
│ │ │ │ │ ├── CXX11Meta.h
│ │ │ │ │ ├── CXX11Workarounds.h
│ │ │ │ │ ├── EmulateArray.h
│ │ │ │ │ └── MaxSizeVector.h
│ │ │ │ ├── EulerAngles
│ │ │ │ ├── FFT
│ │ │ │ ├── IterativeSolvers
│ │ │ │ ├── KroneckerProduct
│ │ │ │ ├── LevenbergMarquardt
│ │ │ │ ├── MPRealSupport
│ │ │ │ ├── MatrixFunctions
│ │ │ │ ├── MoreVectorization
│ │ │ │ ├── NonLinearOptimization
│ │ │ │ ├── NumericalDiff
│ │ │ │ ├── OpenGLSupport
│ │ │ │ ├── Polynomials
│ │ │ │ ├── Skyline
│ │ │ │ ├── SparseExtra
│ │ │ │ ├── SpecialFunctions
│ │ │ │ ├── Splines
│ │ │ │ └── src/
│ │ │ │ ├── AutoDiff/
│ │ │ │ │ ├── AutoDiffJacobian.h
│ │ │ │ │ ├── AutoDiffScalar.h
│ │ │ │ │ └── AutoDiffVector.h
│ │ │ │ ├── BVH/
│ │ │ │ │ ├── BVAlgorithms.h
│ │ │ │ │ └── KdBVH.h
│ │ │ │ ├── Eigenvalues/
│ │ │ │ │ └── ArpackSelfAdjointEigenSolver.h
│ │ │ │ ├── EulerAngles/
│ │ │ │ │ ├── CMakeLists.txt
│ │ │ │ │ ├── EulerAngles.h
│ │ │ │ │ └── EulerSystem.h
│ │ │ │ ├── FFT/
│ │ │ │ │ ├── ei_fftw_impl.h
│ │ │ │ │ └── ei_kissfft_impl.h
│ │ │ │ ├── IterativeSolvers/
│ │ │ │ │ ├── ConstrainedConjGrad.h
│ │ │ │ │ ├── DGMRES.h
│ │ │ │ │ ├── GMRES.h
│ │ │ │ │ ├── IDRS.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/
│ │ │ │ │ ├── BlockSparseMatrix.h
│ │ │ │ │ ├── MarketIO.h
│ │ │ │ │ ├── MatrixMarketIterator.h
│ │ │ │ │ └── RandomSetter.h
│ │ │ │ ├── SpecialFunctions/
│ │ │ │ │ ├── BesselFunctionsArrayAPI.h
│ │ │ │ │ ├── BesselFunctionsBFloat16.h
│ │ │ │ │ ├── BesselFunctionsFunctors.h
│ │ │ │ │ ├── BesselFunctionsHalf.h
│ │ │ │ │ ├── BesselFunctionsImpl.h
│ │ │ │ │ ├── BesselFunctionsPacketMath.h
│ │ │ │ │ ├── HipVectorCompatibility.h
│ │ │ │ │ ├── SpecialFunctionsArrayAPI.h
│ │ │ │ │ ├── SpecialFunctionsBFloat16.h
│ │ │ │ │ ├── SpecialFunctionsFunctors.h
│ │ │ │ │ ├── SpecialFunctionsHalf.h
│ │ │ │ │ ├── SpecialFunctionsImpl.h
│ │ │ │ │ ├── SpecialFunctionsPacketMath.h
│ │ │ │ │ └── arch/
│ │ │ │ │ ├── AVX/
│ │ │ │ │ │ ├── BesselFunctions.h
│ │ │ │ │ │ └── SpecialFunctions.h
│ │ │ │ │ ├── AVX512/
│ │ │ │ │ │ ├── BesselFunctions.h
│ │ │ │ │ │ └── SpecialFunctions.h
│ │ │ │ │ ├── GPU/
│ │ │ │ │ │ └── SpecialFunctions.h
│ │ │ │ │ └── NEON/
│ │ │ │ │ ├── BesselFunctions.h
│ │ │ │ │ └── SpecialFunctions.h
│ │ │ │ └── Splines/
│ │ │ │ ├── Spline.h
│ │ │ │ ├── SplineFitting.h
│ │ │ │ └── SplineFwd.h
│ │ │ ├── README.txt
│ │ │ ├── bench/
│ │ │ │ └── bench_svd.cpp
│ │ │ ├── doc/
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── Overview.dox
│ │ │ │ ├── SYCL.dox
│ │ │ │ ├── eigendoxy_layout.xml.in
│ │ │ │ ├── examples/
│ │ │ │ │ ├── BVH_Example.cpp
│ │ │ │ │ ├── CMakeLists.txt
│ │ │ │ │ ├── EulerAngles.cpp
│ │ │ │ │ ├── FFT.cpp
│ │ │ │ │ ├── MatrixExponential.cpp
│ │ │ │ │ ├── MatrixFunction.cpp
│ │ │ │ │ ├── MatrixLogarithm.cpp
│ │ │ │ │ ├── MatrixPower.cpp
│ │ │ │ │ ├── MatrixPower_optimal.cpp
│ │ │ │ │ ├── MatrixSine.cpp
│ │ │ │ │ ├── MatrixSinh.cpp
│ │ │ │ │ ├── MatrixSquareRoot.cpp
│ │ │ │ │ ├── PolynomialSolver1.cpp
│ │ │ │ │ ├── PolynomialUtils1.cpp
│ │ │ │ │ └── SYCL/
│ │ │ │ │ ├── CMakeLists.txt
│ │ │ │ │ └── CwiseMul.cpp
│ │ │ │ └── snippets/
│ │ │ │ └── CMakeLists.txt
│ │ │ └── test/
│ │ │ ├── BVH.cpp
│ │ │ ├── CMakeLists.txt
│ │ │ ├── EulerAngles.cpp
│ │ │ ├── FFT.cpp
│ │ │ ├── FFTW.cpp
│ │ │ ├── NonLinearOptimization.cpp
│ │ │ ├── NumericalDiff.cpp
│ │ │ ├── alignedvector3.cpp
│ │ │ ├── autodiff.cpp
│ │ │ ├── autodiff_scalar.cpp
│ │ │ ├── bessel_functions.cpp
│ │ │ ├── cxx11_eventcount.cpp
│ │ │ ├── cxx11_maxsizevector.cpp
│ │ │ ├── cxx11_meta.cpp
│ │ │ ├── cxx11_non_blocking_thread_pool.cpp
│ │ │ ├── cxx11_runqueue.cpp
│ │ │ ├── cxx11_tensor_argmax.cpp
│ │ │ ├── cxx11_tensor_argmax_gpu.cu
│ │ │ ├── cxx11_tensor_argmax_sycl.cpp
│ │ │ ├── cxx11_tensor_assign.cpp
│ │ │ ├── cxx11_tensor_block_access.cpp
│ │ │ ├── cxx11_tensor_block_eval.cpp
│ │ │ ├── cxx11_tensor_block_io.cpp
│ │ │ ├── cxx11_tensor_broadcast_sycl.cpp
│ │ │ ├── cxx11_tensor_broadcasting.cpp
│ │ │ ├── cxx11_tensor_builtins_sycl.cpp
│ │ │ ├── cxx11_tensor_cast_float16_gpu.cu
│ │ │ ├── cxx11_tensor_casts.cpp
│ │ │ ├── cxx11_tensor_chipping.cpp
│ │ │ ├── cxx11_tensor_chipping_sycl.cpp
│ │ │ ├── cxx11_tensor_comparisons.cpp
│ │ │ ├── cxx11_tensor_complex_cwise_ops_gpu.cu
│ │ │ ├── cxx11_tensor_complex_gpu.cu
│ │ │ ├── cxx11_tensor_concatenation.cpp
│ │ │ ├── cxx11_tensor_concatenation_sycl.cpp
│ │ │ ├── cxx11_tensor_const.cpp
│ │ │ ├── cxx11_tensor_contract_gpu.cu
│ │ │ ├── cxx11_tensor_contract_sycl.cpp
│ │ │ ├── cxx11_tensor_contraction.cpp
│ │ │ ├── cxx11_tensor_convolution.cpp
│ │ │ ├── cxx11_tensor_convolution_sycl.cpp
│ │ │ ├── cxx11_tensor_custom_index.cpp
│ │ │ ├── cxx11_tensor_custom_op.cpp
│ │ │ ├── cxx11_tensor_custom_op_sycl.cpp
│ │ │ ├── cxx11_tensor_device.cu
│ │ │ ├── cxx11_tensor_device_sycl.cpp
│ │ │ ├── cxx11_tensor_dimension.cpp
│ │ │ ├── cxx11_tensor_empty.cpp
│ │ │ ├── cxx11_tensor_executor.cpp
│ │ │ ├── cxx11_tensor_expr.cpp
│ │ │ ├── cxx11_tensor_fft.cpp
│ │ │ ├── cxx11_tensor_fixed_size.cpp
│ │ │ ├── cxx11_tensor_forced_eval.cpp
│ │ │ ├── cxx11_tensor_forced_eval_sycl.cpp
│ │ │ ├── cxx11_tensor_generator.cpp
│ │ │ ├── cxx11_tensor_generator_sycl.cpp
│ │ │ ├── cxx11_tensor_gpu.cu
│ │ │ ├── cxx11_tensor_ifft.cpp
│ │ │ ├── cxx11_tensor_image_op_sycl.cpp
│ │ │ ├── cxx11_tensor_image_patch.cpp
│ │ │ ├── cxx11_tensor_image_patch_sycl.cpp
│ │ │ ├── cxx11_tensor_index_list.cpp
│ │ │ ├── cxx11_tensor_inflation.cpp
│ │ │ ├── cxx11_tensor_inflation_sycl.cpp
│ │ │ ├── cxx11_tensor_intdiv.cpp
│ │ │ ├── cxx11_tensor_io.cpp
│ │ │ ├── cxx11_tensor_layout_swap.cpp
│ │ │ ├── cxx11_tensor_layout_swap_sycl.cpp
│ │ │ ├── cxx11_tensor_lvalue.cpp
│ │ │ ├── cxx11_tensor_map.cpp
│ │ │ ├── cxx11_tensor_math.cpp
│ │ │ ├── cxx11_tensor_math_sycl.cpp
│ │ │ ├── cxx11_tensor_mixed_indices.cpp
│ │ │ ├── cxx11_tensor_morphing.cpp
│ │ │ ├── cxx11_tensor_morphing_sycl.cpp
│ │ │ ├── cxx11_tensor_move.cpp
│ │ │ ├── cxx11_tensor_notification.cpp
│ │ │ ├── cxx11_tensor_of_complex.cpp
│ │ │ ├── cxx11_tensor_of_const_values.cpp
│ │ │ ├── cxx11_tensor_of_float16_gpu.cu
│ │ │ ├── cxx11_tensor_of_strings.cpp
│ │ │ ├── cxx11_tensor_padding.cpp
│ │ │ ├── cxx11_tensor_padding_sycl.cpp
│ │ │ ├── cxx11_tensor_patch.cpp
│ │ │ ├── cxx11_tensor_patch_sycl.cpp
│ │ │ ├── cxx11_tensor_random.cpp
│ │ │ ├── cxx11_tensor_random_gpu.cu
│ │ │ ├── cxx11_tensor_random_sycl.cpp
│ │ │ ├── cxx11_tensor_reduction.cpp
│ │ │ ├── cxx11_tensor_reduction_gpu.cu
│ │ │ ├── cxx11_tensor_reduction_sycl.cpp
│ │ │ ├── cxx11_tensor_ref.cpp
│ │ │ ├── cxx11_tensor_reverse.cpp
│ │ │ ├── cxx11_tensor_reverse_sycl.cpp
│ │ │ ├── cxx11_tensor_roundings.cpp
│ │ │ ├── cxx11_tensor_scan.cpp
│ │ │ ├── cxx11_tensor_scan_gpu.cu
│ │ │ ├── cxx11_tensor_scan_sycl.cpp
│ │ │ ├── cxx11_tensor_shuffling.cpp
│ │ │ ├── cxx11_tensor_shuffling_sycl.cpp
│ │ │ ├── cxx11_tensor_simple.cpp
│ │ │ ├── cxx11_tensor_striding.cpp
│ │ │ ├── cxx11_tensor_striding_sycl.cpp
│ │ │ ├── cxx11_tensor_sugar.cpp
│ │ │ ├── cxx11_tensor_sycl.cpp
│ │ │ ├── cxx11_tensor_symmetry.cpp
│ │ │ ├── cxx11_tensor_thread_local.cpp
│ │ │ ├── cxx11_tensor_thread_pool.cpp
│ │ │ ├── cxx11_tensor_trace.cpp
│ │ │ ├── cxx11_tensor_uint128.cpp
│ │ │ ├── cxx11_tensor_volume_patch.cpp
│ │ │ ├── cxx11_tensor_volume_patch_sycl.cpp
│ │ │ ├── dgmres.cpp
│ │ │ ├── forward_adolc.cpp
│ │ │ ├── gmres.cpp
│ │ │ ├── idrs.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_support.cpp
│ │ │ ├── openglsupport.cpp
│ │ │ ├── polynomialsolver.cpp
│ │ │ ├── polynomialutils.cpp
│ │ │ ├── sparse_extra.cpp
│ │ │ ├── special_functions.cpp
│ │ │ ├── special_packetmath.cpp
│ │ │ └── splines.cpp
│ │ ├── lietorch/
│ │ │ ├── .gitignore
│ │ │ ├── .gitmodules
│ │ │ ├── LICENSE
│ │ │ ├── README.md
│ │ │ ├── eigen/
│ │ │ │ ├── .gitignore
│ │ │ │ ├── .gitlab-ci.yml
│ │ │ │ ├── .hgeol
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── COPYING.APACHE
│ │ │ │ ├── COPYING.BSD
│ │ │ │ ├── COPYING.GPL
│ │ │ │ ├── COPYING.LGPL
│ │ │ │ ├── COPYING.MINPACK
│ │ │ │ ├── COPYING.MPL2
│ │ │ │ ├── COPYING.README
│ │ │ │ ├── CTestConfig.cmake
│ │ │ │ ├── CTestCustom.cmake.in
│ │ │ │ ├── Eigen/
│ │ │ │ │ ├── Cholesky
│ │ │ │ │ ├── CholmodSupport
│ │ │ │ │ ├── Dense
│ │ │ │ │ ├── Eigen
│ │ │ │ │ ├── Eigenvalues
│ │ │ │ │ ├── Geometry
│ │ │ │ │ ├── Householder
│ │ │ │ │ ├── IterativeLinearSolvers
│ │ │ │ │ ├── Jacobi
│ │ │ │ │ ├── KLUSupport
│ │ │ │ │ ├── LU
│ │ │ │ │ ├── MetisSupport
│ │ │ │ │ ├── OrderingMethods
│ │ │ │ │ ├── PaStiXSupport
│ │ │ │ │ ├── PardisoSupport
│ │ │ │ │ ├── QR
│ │ │ │ │ ├── QtAlignedMalloc
│ │ │ │ │ ├── SPQRSupport
│ │ │ │ │ ├── SVD
│ │ │ │ │ ├── Sparse
│ │ │ │ │ ├── SparseCholesky
│ │ │ │ │ ├── SparseCore
│ │ │ │ │ ├── SparseLU
│ │ │ │ │ ├── SparseQR
│ │ │ │ │ ├── StdDeque
│ │ │ │ │ ├── StdList
│ │ │ │ │ ├── StdVector
│ │ │ │ │ ├── SuperLUSupport
│ │ │ │ │ ├── UmfPackSupport
│ │ │ │ │ └── src/
│ │ │ │ │ ├── Cholesky/
│ │ │ │ │ │ ├── LDLT.h
│ │ │ │ │ │ ├── LLT.h
│ │ │ │ │ │ └── LLT_LAPACKE.h
│ │ │ │ │ ├── CholmodSupport/
│ │ │ │ │ │ └── CholmodSupport.h
│ │ │ │ │ ├── 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_SIMD.h
│ │ │ │ │ ├── Householder/
│ │ │ │ │ │ ├── BlockHouseholder.h
│ │ │ │ │ │ ├── Householder.h
│ │ │ │ │ │ └── HouseholderSequence.h
│ │ │ │ │ ├── IterativeLinearSolvers/
│ │ │ │ │ │ ├── BasicPreconditioners.h
│ │ │ │ │ │ ├── BiCGSTAB.h
│ │ │ │ │ │ ├── ConjugateGradient.h
│ │ │ │ │ │ ├── IncompleteCholesky.h
│ │ │ │ │ │ ├── IncompleteLUT.h
│ │ │ │ │ │ ├── IterativeSolverBase.h
│ │ │ │ │ │ ├── LeastSquareConjugateGradient.h
│ │ │ │ │ │ └── SolveWithGuess.h
│ │ │ │ │ ├── Jacobi/
│ │ │ │ │ │ └── Jacobi.h
│ │ │ │ │ ├── KLUSupport/
│ │ │ │ │ │ └── KLUSupport.h
│ │ │ │ │ ├── LU/
│ │ │ │ │ │ ├── Determinant.h
│ │ │ │ │ │ ├── FullPivLU.h
│ │ │ │ │ │ ├── InverseImpl.h
│ │ │ │ │ │ ├── PartialPivLU.h
│ │ │ │ │ │ ├── PartialPivLU_LAPACKE.h
│ │ │ │ │ │ └── arch/
│ │ │ │ │ │ └── InverseSize4.h
│ │ │ │ │ ├── MetisSupport/
│ │ │ │ │ │ └── MetisSupport.h
│ │ │ │ │ ├── OrderingMethods/
│ │ │ │ │ │ ├── Amd.h
│ │ │ │ │ │ ├── Eigen_Colamd.h
│ │ │ │ │ │ └── Ordering.h
│ │ │ │ │ ├── PaStiXSupport/
│ │ │ │ │ │ └── PaStiXSupport.h
│ │ │ │ │ ├── PardisoSupport/
│ │ │ │ │ │ └── PardisoSupport.h
│ │ │ │ │ ├── QR/
│ │ │ │ │ │ ├── ColPivHouseholderQR.h
│ │ │ │ │ │ ├── ColPivHouseholderQR_LAPACKE.h
│ │ │ │ │ │ ├── CompleteOrthogonalDecomposition.h
│ │ │ │ │ │ ├── FullPivHouseholderQR.h
│ │ │ │ │ │ ├── HouseholderQR.h
│ │ │ │ │ │ └── HouseholderQR_LAPACKE.h
│ │ │ │ │ ├── SPQRSupport/
│ │ │ │ │ │ └── SuiteSparseQRSupport.h
│ │ │ │ │ ├── SVD/
│ │ │ │ │ │ ├── BDCSVD.h
│ │ │ │ │ │ ├── JacobiSVD.h
│ │ │ │ │ │ ├── JacobiSVD_LAPACKE.h
│ │ │ │ │ │ ├── SVDBase.h
│ │ │ │ │ │ └── UpperBidiagonalization.h
│ │ │ │ │ ├── SparseCholesky/
│ │ │ │ │ │ ├── SimplicialCholesky.h
│ │ │ │ │ │ └── SimplicialCholesky_impl.h
│ │ │ │ │ ├── SparseCore/
│ │ │ │ │ │ ├── AmbiVector.h
│ │ │ │ │ │ ├── CompressedStorage.h
│ │ │ │ │ │ ├── ConservativeSparseSparseProduct.h
│ │ │ │ │ │ ├── MappedSparseMatrix.h
│ │ │ │ │ │ ├── SparseAssign.h
│ │ │ │ │ │ ├── SparseBlock.h
│ │ │ │ │ │ ├── SparseColEtree.h
│ │ │ │ │ │ ├── SparseCompressedBase.h
│ │ │ │ │ │ ├── SparseCwiseBinaryOp.h
│ │ │ │ │ │ ├── SparseCwiseUnaryOp.h
│ │ │ │ │ │ ├── SparseDenseProduct.h
│ │ │ │ │ │ ├── SparseDiagonalProduct.h
│ │ │ │ │ │ ├── SparseDot.h
│ │ │ │ │ │ ├── SparseFuzzy.h
│ │ │ │ │ │ ├── SparseMap.h
│ │ │ │ │ │ ├── SparseMatrix.h
│ │ │ │ │ │ ├── SparseMatrixBase.h
│ │ │ │ │ │ ├── SparsePermutation.h
│ │ │ │ │ │ ├── SparseProduct.h
│ │ │ │ │ │ ├── SparseRedux.h
│ │ │ │ │ │ ├── SparseRef.h
│ │ │ │ │ │ ├── SparseSelfAdjointView.h
│ │ │ │ │ │ ├── SparseSolverBase.h
│ │ │ │ │ │ ├── SparseSparseProductWithPruning.h
│ │ │ │ │ │ ├── SparseTranspose.h
│ │ │ │ │ │ ├── SparseTriangularView.h
│ │ │ │ │ │ ├── SparseUtil.h
│ │ │ │ │ │ ├── SparseVector.h
│ │ │ │ │ │ ├── SparseView.h
│ │ │ │ │ │ └── TriangularSolver.h
│ │ │ │ │ ├── SparseLU/
│ │ │ │ │ │ ├── SparseLU.h
│ │ │ │ │ │ ├── SparseLUImpl.h
│ │ │ │ │ │ ├── SparseLU_Memory.h
│ │ │ │ │ │ ├── SparseLU_Structs.h
│ │ │ │ │ │ ├── SparseLU_SupernodalMatrix.h
│ │ │ │ │ │ ├── SparseLU_Utils.h
│ │ │ │ │ │ ├── SparseLU_column_bmod.h
│ │ │ │ │ │ ├── SparseLU_column_dfs.h
│ │ │ │ │ │ ├── SparseLU_copy_to_ucol.h
│ │ │ │ │ │ ├── SparseLU_gemm_kernel.h
│ │ │ │ │ │ ├── SparseLU_heap_relax_snode.h
│ │ │ │ │ │ ├── SparseLU_kernel_bmod.h
│ │ │ │ │ │ ├── SparseLU_panel_bmod.h
│ │ │ │ │ │ ├── SparseLU_panel_dfs.h
│ │ │ │ │ │ ├── SparseLU_pivotL.h
│ │ │ │ │ │ ├── SparseLU_pruneL.h
│ │ │ │ │ │ └── SparseLU_relax_snode.h
│ │ │ │ │ ├── SparseQR/
│ │ │ │ │ │ └── SparseQR.h
│ │ │ │ │ ├── StlSupport/
│ │ │ │ │ │ ├── StdDeque.h
│ │ │ │ │ │ ├── StdList.h
│ │ │ │ │ │ ├── StdVector.h
│ │ │ │ │ │ └── details.h
│ │ │ │ │ ├── SuperLUSupport/
│ │ │ │ │ │ └── SuperLUSupport.h
│ │ │ │ │ ├── UmfPackSupport/
│ │ │ │ │ │ └── UmfPackSupport.h
│ │ │ │ │ ├── misc/
│ │ │ │ │ │ ├── Image.h
│ │ │ │ │ │ ├── Kernel.h
│ │ │ │ │ │ ├── RealSvd2x2.h
│ │ │ │ │ │ ├── blas.h
│ │ │ │ │ │ ├── lapack.h
│ │ │ │ │ │ ├── lapacke.h
│ │ │ │ │ │ └── lapacke_mangling.h
│ │ │ │ │ └── plugins/
│ │ │ │ │ ├── ArrayCwiseBinaryOps.h
│ │ │ │ │ ├── ArrayCwiseUnaryOps.h
│ │ │ │ │ ├── BlockMethods.h
│ │ │ │ │ ├── CommonCwiseBinaryOps.h
│ │ │ │ │ ├── CommonCwiseUnaryOps.h
│ │ │ │ │ ├── IndexedViewMethods.h
│ │ │ │ │ ├── MatrixCwiseBinaryOps.h
│ │ │ │ │ ├── MatrixCwiseUnaryOps.h
│ │ │ │ │ └── ReshapedMethods.h
│ │ │ │ ├── INSTALL
│ │ │ │ ├── README.md
│ │ │ │ ├── bench/
│ │ │ │ │ ├── BenchSparseUtil.h
│ │ │ │ │ ├── BenchTimer.h
│ │ │ │ │ ├── BenchUtil.h
│ │ │ │ │ ├── README.txt
│ │ │ │ │ ├── analyze-blocking-sizes.cpp
│ │ │ │ │ ├── basicbench.cxxlist
│ │ │ │ │ ├── basicbenchmark.cpp
│ │ │ │ │ ├── basicbenchmark.h
│ │ │ │ │ ├── benchBlasGemm.cpp
│ │ │ │ │ ├── benchCholesky.cpp
│ │ │ │ │ ├── benchEigenSolver.cpp
│ │ │ │ │ ├── benchFFT.cpp
│ │ │ │ │ ├── benchGeometry.cpp
│ │ │ │ │ ├── benchVecAdd.cpp
│ │ │ │ │ ├── bench_gemm.cpp
│ │ │ │ │ ├── bench_move_semantics.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/
│ │ │ │ │ │ ├── changesets.txt
│ │ │ │ │ │ ├── gemm.cpp
│ │ │ │ │ │ ├── gemm_common.h
│ │ │ │ │ │ ├── gemm_settings.txt
│ │ │ │ │ │ ├── gemm_square_settings.txt
│ │ │ │ │ │ ├── gemv.cpp
│ │ │ │ │ │ ├── gemv_common.h
│ │ │ │ │ │ ├── gemv_settings.txt
│ │ │ │ │ │ ├── gemv_square_settings.txt
│ │ │ │ │ │ ├── gemvt.cpp
│ │ │ │ │ │ ├── lazy_gemm.cpp
│ │ │ │ │ │ ├── lazy_gemm_settings.txt
│ │ │ │ │ │ ├── llt.cpp
│ │ │ │ │ │ ├── make_plot.sh
│ │ │ │ │ │ ├── resources/
│ │ │ │ │ │ │ ├── chart_footer.html
│ │ │ │ │ │ │ ├── chart_header.html
│ │ │ │ │ │ │ ├── footer.html
│ │ │ │ │ │ │ ├── header.html
│ │ │ │ │ │ │ ├── s1.js
│ │ │ │ │ │ │ └── s2.js
│ │ │ │ │ │ ├── run.sh
│ │ │ │ │ │ ├── runall.sh
│ │ │ │ │ │ ├── trmv_lo.cpp
│ │ │ │ │ │ ├── trmv_lot.cpp
│ │ │ │ │ │ ├── trmv_up.cpp
│ │ │ │ │ │ └── trmv_upt.cpp
│ │ │ │ │ ├── product_threshold.cpp
│ │ │ │ │ ├── quat_slerp.cpp
│ │ │ │ │ ├── quatmul.cpp
│ │ │ │ │ ├── sparse_cholesky.cpp
│ │ │ │ │ ├── sparse_dense_product.cpp
│ │ │ │ │ ├── sparse_lu.cpp
│ │ │ │ │ ├── sparse_product.cpp
│ │ │ │ │ ├── sparse_randomsetter.cpp
│ │ │ │ │ ├── sparse_setter.cpp
│ │ │ │ │ ├── sparse_transpose.cpp
│ │ │ │ │ ├── sparse_trisolver.cpp
│ │ │ │ │ ├── spbench/
│ │ │ │ │ │ ├── CMakeLists.txt
│ │ │ │ │ │ ├── sp_solver.cpp
│ │ │ │ │ │ ├── spbench.dtd
│ │ │ │ │ │ ├── spbenchsolver.cpp
│ │ │ │ │ │ ├── spbenchsolver.h
│ │ │ │ │ │ ├── spbenchstyle.h
│ │ │ │ │ │ └── test_sparseLU.cpp
│ │ │ │ │ ├── spmv.cpp
│ │ │ │ │ ├── tensors/
│ │ │ │ │ │ ├── README
│ │ │ │ │ │ ├── benchmark.h
│ │ │ │ │ │ ├── benchmark_main.cc
│ │ │ │ │ │ ├── contraction_benchmarks_cpu.cc
│ │ │ │ │ │ ├── eigen_sycl_bench.sh
│ │ │ │ │ │ ├── eigen_sycl_bench_contract.sh
│ │ │ │ │ │ ├── tensor_benchmarks.h
│ │ │ │ │ │ ├── tensor_benchmarks_cpu.cc
│ │ │ │ │ │ ├── tensor_benchmarks_fp16_gpu.cu
│ │ │ │ │ │ ├── tensor_benchmarks_gpu.cu
│ │ │ │ │ │ ├── tensor_benchmarks_sycl.cc
│ │ │ │ │ │ └── tensor_contract_sycl_bench.cc
│ │ │ │ │ └── vdw_new.cpp
│ │ │ │ ├── blas/
│ │ │ │ │ ├── BandTriangularSolver.h
│ │ │ │ │ ├── CMakeLists.txt
│ │ │ │ │ ├── GeneralRank1Update.h
│ │ │ │ │ ├── PackedSelfadjointProduct.h
│ │ │ │ │ ├── PackedTriangularMatrixVector.h
│ │ │ │ │ ├── PackedTriangularSolverVector.h
│ │ │ │ │ ├── README.txt
│ │ │ │ │ ├── Rank2Update.h
│ │ │ │ │ ├── common.h
│ │ │ │ │ ├── complex_double.cpp
│ │ │ │ │ ├── complex_single.cpp
│ │ │ │ │ ├── double.cpp
│ │ │ │ │ ├── f2c/
│ │ │ │ │ │ ├── chbmv.c
│ │ │ │ │ │ ├── chpmv.c
│ │ │ │ │ │ ├── complexdots.c
│ │ │ │ │ │ ├── ctbmv.c
│ │ │ │ │ │ ├── d_cnjg.c
│ │ │ │ │ │ ├── datatypes.h
│ │ │ │ │ │ ├── drotm.c
│ │ │ │ │ │ ├── drotmg.c
│ │ │ │ │ │ ├── dsbmv.c
│ │ │ │ │ │ ├── dspmv.c
│ │ │ │ │ │ ├── dtbmv.c
│ │ │ │ │ │ ├── lsame.c
│ │ │ │ │ │ ├── r_cnjg.c
│ │ │ │ │ │ ├── srotm.c
│ │ │ │ │ │ ├── srotmg.c
│ │ │ │ │ │ ├── ssbmv.c
│ │ │ │ │ │ ├── sspmv.c
│ │ │ │ │ │ ├── stbmv.c
│ │ │ │ │ │ ├── zhbmv.c
│ │ │ │ │ │ ├── zhpmv.c
│ │ │ │ │ │ └── ztbmv.c
│ │ │ │ │ ├── fortran/
│ │ │ │ │ │ └── complexdots.f
│ │ │ │ │ ├── level1_cplx_impl.h
│ │ │ │ │ ├── level1_impl.h
│ │ │ │ │ ├── level1_real_impl.h
│ │ │ │ │ ├── level2_cplx_impl.h
│ │ │ │ │ ├── level2_impl.h
│ │ │ │ │ ├── level2_real_impl.h
│ │ │ │ │ ├── level3_impl.h
│ │ │ │ │ ├── single.cpp
│ │ │ │ │ ├── testing/
│ │ │ │ │ │ ├── CMakeLists.txt
│ │ │ │ │ │ ├── cblat1.f
│ │ │ │ │ │ ├── cblat2.f
│ │ │ │ │ │ ├── cblat3.f
│ │ │ │ │ │ ├── dblat1.f
│ │ │ │ │ │ ├── dblat2.f
│ │ │ │ │ │ ├── dblat3.f
│ │ │ │ │ │ ├── runblastest.sh
│ │ │ │ │ │ ├── sblat1.f
│ │ │ │ │ │ ├── sblat2.f
│ │ │ │ │ │ ├── sblat3.f
│ │ │ │ │ │ ├── zblat1.f
│ │ │ │ │ │ ├── zblat2.f
│ │ │ │ │ │ └── zblat3.f
│ │ │ │ │ └── xerbla.cpp
│ │ │ │ ├── ci/
│ │ │ │ │ ├── CTest2JUnit.xsl
│ │ │ │ │ ├── README.md
│ │ │ │ │ └── test.gitlab-ci.yml
│ │ │ │ ├── cmake/
│ │ │ │ │ ├── ComputeCppCompilerChecks.cmake
│ │ │ │ │ ├── ComputeCppIRMap.cmake
│ │ │ │ │ ├── Eigen3Config.cmake.in
│ │ │ │ │ ├── Eigen3ConfigLegacy.cmake.in
│ │ │ │ │ ├── EigenConfigureTesting.cmake
│ │ │ │ │ ├── EigenDetermineOSVersion.cmake
│ │ │ │ │ ├── EigenDetermineVSServicePack.cmake
│ │ │ │ │ ├── EigenTesting.cmake
│ │ │ │ │ ├── EigenUninstall.cmake
│ │ │ │ │ ├── FindAdolc.cmake
│ │ │ │ │ ├── FindBLAS.cmake
│ │ │ │ │ ├── FindBLASEXT.cmake
│ │ │ │ │ ├── FindCHOLMOD.cmake
│ │ │ │ │ ├── FindComputeCpp.cmake
│ │ │ │ │ ├── FindEigen2.cmake
│ │ │ │ │ ├── FindEigen3.cmake
│ │ │ │ │ ├── FindFFTW.cmake
│ │ │ │ │ ├── FindGLEW.cmake
│ │ │ │ │ ├── FindGMP.cmake
│ │ │ │ │ ├── FindGSL.cmake
│ │ │ │ │ ├── FindGoogleHash.cmake
│ │ │ │ │ ├── FindHWLOC.cmake
│ │ │ │ │ ├── FindKLU.cmake
│ │ │ │ │ ├── FindLAPACK.cmake
│ │ │ │ │ ├── FindMPFR.cmake
│ │ │ │ │ ├── FindMetis.cmake
│ │ │ │ │ ├── FindPTSCOTCH.cmake
│ │ │ │ │ ├── FindPastix.cmake
│ │ │ │ │ ├── FindSPQR.cmake
│ │ │ │ │ ├── FindScotch.cmake
│ │ │ │ │ ├── FindStandardMathLibrary.cmake
│ │ │ │ │ ├── FindSuperLU.cmake
│ │ │ │ │ ├── FindTriSYCL.cmake
│ │ │ │ │ ├── FindUMFPACK.cmake
│ │ │ │ │ ├── RegexUtils.cmake
│ │ │ │ │ └── UseEigen3.cmake
│ │ │ │ ├── debug/
│ │ │ │ │ ├── gdb/
│ │ │ │ │ │ ├── __init__.py
│ │ │ │ │ │ └── printers.py
│ │ │ │ │ └── msvc/
│ │ │ │ │ └── eigen.natvis
│ │ │ │ ├── demos/
│ │ │ │ │ ├── CMakeLists.txt
│ │ │ │ │ ├── mandelbrot/
│ │ │ │ │ │ ├── CMakeLists.txt
│ │ │ │ │ │ ├── README
│ │ │ │ │ │ ├── mandelbrot.cpp
│ │ │ │ │ │ └── mandelbrot.h
│ │ │ │ │ ├── mix_eigen_and_c/
│ │ │ │ │ │ ├── README
│ │ │ │ │ │ ├── binary_library.cpp
│ │ │ │ │ │ ├── binary_library.h
│ │ │ │ │ │ └── example.c
│ │ │ │ │ └── opengl/
│ │ │ │ │ ├── CMakeLists.txt
│ │ │ │ │ ├── README
│ │ │ │ │ ├── camera.cpp
│ │ │ │ │ ├── camera.h
│ │ │ │ │ ├── gpuhelper.cpp
│ │ │ │ │ ├── gpuhelper.h
│ │ │ │ │ ├── icosphere.cpp
│ │ │ │ │ ├── icosphere.h
│ │ │ │ │ ├── quaternion_demo.cpp
│ │ │ │ │ ├── quaternion_demo.h
│ │ │ │ │ ├── trackball.cpp
│ │ │ │ │ └── trackball.h
│ │ │ │ ├── doc/
│ │ │ │ │ ├── AsciiQuickReference.txt
│ │ │ │ │ ├── B01_Experimental.dox
│ │ │ │ │ ├── CMakeLists.txt
│ │ │ │ │ ├── ClassHierarchy.dox
│ │ │ │ │ ├── CoeffwiseMathFunctionsTable.dox
│ │ │ │ │ ├── CustomizingEigen_CustomScalar.dox
│ │ │ │ │ ├── CustomizingEigen_InheritingMatrix.dox
│ │ │ │ │ ├── CustomizingEigen_NullaryExpr.dox
│ │ │ │ │ ├── CustomizingEigen_Plugins.dox
│ │ │ │ │ ├── DenseDecompositionBenchmark.dox
│ │ │ │ │ ├── Doxyfile.in
│ │ │ │ │ ├── FixedSizeVectorizable.dox
│ │ │ │ │ ├── FunctionsTakingEigenTypes.dox
│ │ │ │ │ ├── HiPerformance.dox
│ │ │ │ │ ├── InplaceDecomposition.dox
│ │ │ │ │ ├── InsideEigenExample.dox
│ │ │ │ │ ├── LeastSquares.dox
│ │ │ │ │ ├── Manual.dox
│ │ │ │ │ ├── MatrixfreeSolverExample.dox
│ │ │ │ │ ├── NewExpressionType.dox
│ │ │ │ │ ├── Overview.dox
│ │ │ │ │ ├── PassingByValue.dox
│ │ │ │ │ ├── Pitfalls.dox
│ │ │ │ │ ├── PreprocessorDirectives.dox
│ │ │ │ │ ├── QuickReference.dox
│ │ │ │ │ ├── QuickStartGuide.dox
│ │ │ │ │ ├── SparseLinearSystems.dox
│ │ │ │ │ ├── SparseQuickReference.dox
│ │ │ │ │ ├── StlContainers.dox
│ │ │ │ │ ├── StorageOrders.dox
│ │ │ │ │ ├── StructHavingEigenMembers.dox
│ │ │ │ │ ├── TemplateKeyword.dox
│ │ │ │ │ ├── TopicAliasing.dox
│ │ │ │ │ ├── TopicAssertions.dox
│ │ │ │ │ ├── TopicCMakeGuide.dox
│ │ │ │ │ ├── TopicEigenExpressionTemplates.dox
│ │ │ │ │ ├── TopicLazyEvaluation.dox
│ │ │ │ │ ├── TopicLinearAlgebraDecompositions.dox
│ │ │ │ │ ├── TopicMultithreading.dox
│ │ │ │ │ ├── TopicResizing.dox
│ │ │ │ │ ├── TopicScalarTypes.dox
│ │ │ │ │ ├── TopicVectorization.dox
│ │ │ │ │ ├── TutorialAdvancedInitialization.dox
│ │ │ │ │ ├── TutorialArrayClass.dox
│ │ │ │ │ ├── TutorialBlockOperations.dox
│ │ │ │ │ ├── TutorialGeometry.dox
│ │ │ │ │ ├── TutorialLinearAlgebra.dox
│ │ │ │ │ ├── TutorialMapClass.dox
│ │ │ │ │ ├── TutorialMatrixArithmetic.dox
│ │ │ │ │ ├── TutorialMatrixClass.dox
│ │ │ │ │ ├── TutorialReductionsVisitorsBroadcasting.dox
│ │ │ │ │ ├── TutorialReshape.dox
│ │ │ │ │ ├── TutorialSTL.dox
│ │ │ │ │ ├── TutorialSlicingIndexing.dox
│ │ │ │ │ ├── TutorialSparse.dox
│ │ │ │ │ ├── TutorialSparse_example_details.dox
│ │ │ │ │ ├── UnalignedArrayAssert.dox
│ │ │ │ │ ├── UsingBlasLapackBackends.dox
│ │ │ │ │ ├── UsingIntelMKL.dox
│ │ │ │ │ ├── UsingNVCC.dox
│ │ │ │ │ ├── WrongStackAlignment.dox
│ │ │ │ │ ├── eigen_navtree_hacks.js
│ │ │ │ │ ├── eigendoxy.css
│ │ │ │ │ ├── eigendoxy_footer.html.in
│ │ │ │ │ ├── eigendoxy_header.html.in
│ │ │ │ │ ├── eigendoxy_layout.xml.in
│ │ │ │ │ ├── eigendoxy_tabs.css
│ │ │ │ │ ├── examples/
│ │ │ │ │ │ ├── .krazy
│ │ │ │ │ │ ├── CMakeLists.txt
│ │ │ │ │ │ ├── CustomizingEigen_Inheritance.cpp
│ │ │ │ │ │ ├── Cwise_erf.cpp
│ │ │ │ │ │ ├── Cwise_erfc.cpp
│ │ │ │ │ │ ├── Cwise_lgamma.cpp
│ │ │ │ │ │ ├── DenseBase_middleCols_int.cpp
│ │ │ │ │ │ ├── DenseBase_middleRows_int.cpp
│ │ │ │ │ │ ├── DenseBase_template_int_middleCols.cpp
│ │ │ │ │ │ ├── DenseBase_template_int_middleRows.cpp
│ │ │ │ │ │ ├── QuickStart_example.cpp
│ │ │ │ │ │ ├── QuickStart_example2_dynamic.cpp
│ │ │ │ │ │ ├── QuickStart_example2_fixed.cpp
│ │ │ │ │ │ ├── TemplateKeyword_flexible.cpp
│ │ │ │ │ │ ├── TemplateKeyword_simple.cpp
│ │ │ │ │ │ ├── TutorialInplaceLU.cpp
│ │ │ │ │ │ ├── TutorialLinAlgComputeTwice.cpp
│ │ │ │ │ │ ├── TutorialLinAlgExComputeSolveError.cpp
│ │ │ │ │ │ ├── TutorialLinAlgExSolveColPivHouseholderQR.cpp
│ │ │ │ │ │ ├── TutorialLinAlgExSolveLDLT.cpp
│ │ │ │ │ │ ├── TutorialLinAlgInverseDeterminant.cpp
│ │ │ │ │ │ ├── TutorialLinAlgRankRevealing.cpp
│ │ │ │ │ │ ├── TutorialLinAlgSVDSolve.cpp
│ │ │ │ │ │ ├── TutorialLinAlgSelfAdjointEigenSolver.cpp
│ │ │ │ │ │ ├── TutorialLinAlgSetThreshold.cpp
│ │ │ │ │ │ ├── Tutorial_ArrayClass_accessors.cpp
│ │ │ │ │ │ ├── Tutorial_ArrayClass_addition.cpp
│ │ │ │ │ │ ├── Tutorial_ArrayClass_cwise_other.cpp
│ │ │ │ │ │ ├── Tutorial_ArrayClass_interop.cpp
│ │ │ │ │ │ ├── Tutorial_ArrayClass_interop_matrix.cpp
│ │ │ │ │ │ ├── Tutorial_ArrayClass_mult.cpp
│ │ │ │ │ │ ├── Tutorial_BlockOperations_block_assignment.cpp
│ │ │ │ │ │ ├── Tutorial_BlockOperations_colrow.cpp
│ │ │ │ │ │ ├── Tutorial_BlockOperations_corner.cpp
│ │ │ │ │ │ ├── Tutorial_BlockOperations_print_block.cpp
│ │ │ │ │ │ ├── Tutorial_BlockOperations_vector.cpp
│ │ │ │ │ │ ├── Tutorial_PartialLU_solve.cpp
│ │ │ │ │ │ ├── Tutorial_ReductionsVisitorsBroadcasting_broadcast_1nn.cpp
│ │ │ │ │ │ ├── Tutorial_ReductionsVisitorsBroadcasting_broadcast_simple.cpp
│ │ │ │ │ │ ├── Tutorial_ReductionsVisitorsBroadcasting_broadcast_simple_rowwise.cpp
│ │ │ │ │ │ ├── Tutorial_ReductionsVisitorsBroadcasting_colwise.cpp
│ │ │ │ │ │ ├── Tutorial_ReductionsVisitorsBroadcasting_maxnorm.cpp
│ │ │ │ │ │ ├── Tutorial_ReductionsVisitorsBroadcasting_reductions_bool.cpp
│ │ │ │ │ │ ├── Tutorial_ReductionsVisitorsBroadcasting_reductions_norm.cpp
│ │ │ │ │ │ ├── Tutorial_ReductionsVisitorsBroadcasting_reductions_operatornorm.cpp
│ │ │ │ │ │ ├── Tutorial_ReductionsVisitorsBroadcasting_rowwise.cpp
│ │ │ │ │ │ ├── Tutorial_ReductionsVisitorsBroadcasting_visitors.cpp
│ │ │ │ │ │ ├── Tutorial_simple_example_dynamic_size.cpp
│ │ │ │ │ │ ├── Tutorial_simple_example_fixed_size.cpp
│ │ │ │ │ │ ├── class_Block.cpp
│ │ │ │ │ │ ├── class_CwiseBinaryOp.cpp
│ │ │ │ │ │ ├── class_CwiseUnaryOp.cpp
│ │ │ │ │ │ ├── class_CwiseUnaryOp_ptrfun.cpp
│ │ │ │ │ │ ├── class_FixedBlock.cpp
│ │ │ │ │ │ ├── class_FixedReshaped.cpp
│ │ │ │ │ │ ├── class_FixedVectorBlock.cpp
│ │ │ │ │ │ ├── class_Reshaped.cpp
│ │ │ │ │ │ ├── class_VectorBlock.cpp
│ │ │ │ │ │ ├── function_taking_eigenbase.cpp
│ │ │ │ │ │ ├── function_taking_ref.cpp
│ │ │ │ │ │ ├── make_circulant.cpp
│ │ │ │ │ │ ├── make_circulant.cpp.entry
│ │ │ │ │ │ ├── make_circulant.cpp.evaluator
│ │ │ │ │ │ ├── make_circulant.cpp.expression
│ │ │ │ │ │ ├── make_circulant.cpp.main
│ │ │ │ │ │ ├── make_circulant.cpp.preamble
│ │ │ │ │ │ ├── make_circulant.cpp.traits
│ │ │ │ │ │ ├── make_circulant2.cpp
│ │ │ │ │ │ ├── matrixfree_cg.cpp
│ │ │ │ │ │ ├── nullary_indexing.cpp
│ │ │ │ │ │ ├── tut_arithmetic_add_sub.cpp
│ │ │ │ │ │ ├── tut_arithmetic_dot_cross.cpp
│ │ │ │ │ │ ├── tut_arithmetic_matrix_mul.cpp
│ │ │ │ │ │ ├── tut_arithmetic_redux_basic.cpp
│ │ │ │ │ │ ├── tut_arithmetic_scalar_mul_div.cpp
│ │ │ │ │ │ ├── tut_matrix_coefficient_accessors.cpp
│ │ │ │ │ │ ├── tut_matrix_resize.cpp
│ │ │ │ │ │ └── tut_matrix_resize_fixed_size.cpp
│ │ │ │ │ ├── snippets/
│ │ │ │ │ │ ├── .krazy
│ │ │ │ │ │ ├── AngleAxis_mimic_euler.cpp
│ │ │ │ │ │ ├── Array_initializer_list_23_cxx11.cpp
│ │ │ │ │ │ ├── Array_initializer_list_vector_cxx11.cpp
│ │ │ │ │ │ ├── Array_variadic_ctor_cxx11.cpp
│ │ │ │ │ │ ├── BiCGSTAB_simple.cpp
│ │ │ │ │ │ ├── BiCGSTAB_step_by_step.cpp
│ │ │ │ │ │ ├── CMakeLists.txt
│ │ │ │ │ │ ├── ColPivHouseholderQR_solve.cpp
│ │ │ │ │ │ ├── ComplexEigenSolver_compute.cpp
│ │ │ │ │ │ ├── ComplexEigenSolver_eigenvalues.cpp
│ │ │ │ │ │ ├── ComplexEigenSolver_eigenvectors.cpp
│ │ │ │ │ │ ├── ComplexSchur_compute.cpp
│ │ │ │ │ │ ├── ComplexSchur_matrixT.cpp
│ │ │ │ │ │ ├── ComplexSchur_matrixU.cpp
│ │ │ │ │ │ ├── Cwise_abs.cpp
│ │ │ │ │ │ ├── Cwise_abs2.cpp
│ │ │ │ │ │ ├── Cwise_acos.cpp
│ │ │ │ │ │ ├── Cwise_arg.cpp
│ │ │ │ │ │ ├── Cwise_array_power_array.cpp
│ │ │ │ │ │ ├── Cwise_asin.cpp
│ │ │ │ │ │ ├── Cwise_atan.cpp
│ │ │ │ │ │ ├── Cwise_boolean_and.cpp
│ │ │ │ │ │ ├── Cwise_boolean_not.cpp
│ │ │ │ │ │ ├── Cwise_boolean_or.cpp
│ │ │ │ │ │ ├── Cwise_boolean_xor.cpp
│ │ │ │ │ │ ├── Cwise_ceil.cpp
│ │ │ │ │ │ ├── Cwise_cos.cpp
│ │ │ │ │ │ ├── Cwise_cosh.cpp
│ │ │ │ │ │ ├── Cwise_cube.cpp
│ │ │ │ │ │ ├── Cwise_equal_equal.cpp
│ │ │ │ │ │ ├── Cwise_exp.cpp
│ │ │ │ │ │ ├── Cwise_floor.cpp
│ │ │ │ │ │ ├── Cwise_greater.cpp
│ │ │ │ │ │ ├── Cwise_greater_equal.cpp
│ │ │ │ │ │ ├── Cwise_inverse.cpp
│ │ │ │ │ │ ├── Cwise_isFinite.cpp
│ │ │ │ │ │ ├── Cwise_isInf.cpp
│ │ │ │ │ │ ├── Cwise_isNaN.cpp
│ │ │ │ │ │ ├── Cwise_less.cpp
│ │ │ │ │ │ ├── Cwise_less_equal.cpp
│ │ │ │ │ │ ├── Cwise_log.cpp
│ │ │ │ │ │ ├── Cwise_log10.cpp
│ │ │ │ │ │ ├── Cwise_max.cpp
│ │ │ │ │ │ ├── Cwise_min.cpp
│ │ │ │ │ │ ├── Cwise_minus.cpp
│ │ │ │ │ │ ├── Cwise_minus_equal.cpp
│ │ │ │ │ │ ├── Cwise_not_equal.cpp
│ │ │ │ │ │ ├── Cwise_plus.cpp
│ │ │ │ │ │ ├── Cwise_plus_equal.cpp
│ │ │ │ │ │ ├── Cwise_pow.cpp
│ │ │ │ │ │ ├── Cwise_product.cpp
│ │ │ │ │ │ ├── Cwise_quotient.cpp
│ │ │ │ │ │ ├── Cwise_rint.cpp
│ │ │ │ │ │ ├── Cwise_round.cpp
│ │ │ │ │ │ ├── Cwise_scalar_power_array.cpp
│ │ │ │ │ │ ├── Cwise_sign.cpp
│ │ │ │ │ │ ├── Cwise_sin.cpp
│ │ │ │ │ │ ├── Cwise_sinh.cpp
│ │ │ │ │ │ ├── Cwise_slash_equal.cpp
│ │ │ │ │ │ ├── Cwise_sqrt.cpp
│ │ │ │ │ │ ├── Cwise_square.cpp
│ │ │ │ │ │ ├── Cwise_tan.cpp
│ │ │ │ │ │ ├── Cwise_tanh.cpp
│ │ │ │ │ │ ├── Cwise_times_equal.cpp
│ │ │ │ │ │ ├── DenseBase_LinSpaced.cpp
│ │ │ │ │ │ ├── DenseBase_LinSpacedInt.cpp
│ │ │ │ │ │ ├── DenseBase_LinSpaced_seq_deprecated.cpp
│ │ │ │ │ │ ├── DenseBase_setLinSpaced.cpp
│ │ │ │ │ │ ├── DirectionWise_hnormalized.cpp
│ │ │ │ │ │ ├── DirectionWise_replicate.cpp
│ │ │ │ │ │ ├── DirectionWise_replicate_int.cpp
│ │ │ │ │ │ ├── EigenSolver_EigenSolver_MatrixType.cpp
│ │ │ │ │ │ ├── EigenSolver_compute.cpp
│ │ │ │ │ │ ├── EigenSolver_eigenvalues.cpp
│ │ │ │ │ │ ├── EigenSolver_eigenvectors.cpp
│ │ │ │ │ │ ├── EigenSolver_pseudoEigenvectors.cpp
│ │ │ │ │ │ ├── FullPivHouseholderQR_solve.cpp
│ │ │ │ │ │ ├── FullPivLU_image.cpp
│ │ │ │ │ │ ├── FullPivLU_kernel.cpp
│ │ │ │ │ │ ├── FullPivLU_solve.cpp
│ │ │ │ │ │ ├── GeneralizedEigenSolver.cpp
│ │ │ │ │ │ ├── HessenbergDecomposition_compute.cpp
│ │ │ │ │ │ ├── HessenbergDecomposition_matrixH.cpp
│ │ │ │ │ │ ├── HessenbergDecomposition_packedMatrix.cpp
│ │ │ │ │ │ ├── HouseholderQR_householderQ.cpp
│ │ │ │ │ │ ├── HouseholderQR_solve.cpp
│ │ │ │ │ │ ├── HouseholderSequence_HouseholderSequence.cpp
│ │ │ │ │ │ ├── IOFormat.cpp
│ │ │ │ │ │ ├── JacobiSVD_basic.cpp
│ │ │ │ │ │ ├── Jacobi_makeGivens.cpp
│ │ │ │ │ │ ├── Jacobi_makeJacobi.cpp
│ │ │ │ │ │ ├── LLT_example.cpp
│ │ │ │ │ │ ├── LLT_solve.cpp
│ │ │ │ │ │ ├── LeastSquaresNormalEquations.cpp
│ │ │ │ │ │ ├── LeastSquaresQR.cpp
│ │ │ │ │ │ ├── Map_general_stride.cpp
│ │ │ │ │ │ ├── Map_inner_stride.cpp
│ │ │ │ │ │ ├── Map_outer_stride.cpp
│ │ │ │ │ │ ├── Map_placement_new.cpp
│ │ │ │ │ │ ├── Map_simple.cpp
│ │ │ │ │ │ ├── MatrixBase_adjoint.cpp
│ │ │ │ │ │ ├── MatrixBase_all.cpp
│ │ │ │ │ │ ├── MatrixBase_applyOnTheLeft.cpp
│ │ │ │ │ │ ├── MatrixBase_applyOnTheRight.cpp
│ │ │ │ │ │ ├── MatrixBase_array.cpp
│ │ │ │ │ │ ├── MatrixBase_array_const.cpp
│ │ │ │ │ │ ├── MatrixBase_asDiagonal.cpp
│ │ │ │ │ │ ├── MatrixBase_block_int_int.cpp
│ │ │ │ │ │ ├── MatrixBase_block_int_int_int_int.cpp
│ │ │ │ │ │ ├── MatrixBase_bottomLeftCorner_int_int.cpp
│ │ │ │ │ │ ├── MatrixBase_bottomRightCorner_int_int.cpp
│ │ │ │ │ │ ├── MatrixBase_bottomRows_int.cpp
│ │ │ │ │ │ ├── MatrixBase_cast.cpp
│ │ │ │ │ │ ├── MatrixBase_col.cpp
│ │ │ │ │ │ ├── MatrixBase_colwise.cpp
│ │ │ │ │ │ ├── MatrixBase_colwise_iterator_cxx11.cpp
│ │ │ │ │ │ ├── MatrixBase_computeInverseAndDetWithCheck.cpp
│ │ │ │ │ │ ├── MatrixBase_computeInverseWithCheck.cpp
│ │ │ │ │ │ ├── MatrixBase_cwiseAbs.cpp
│ │ │ │ │ │ ├── MatrixBase_cwiseAbs2.cpp
│ │ │ │ │ │ ├── MatrixBase_cwiseArg.cpp
│ │ │ │ │ │ ├── MatrixBase_cwiseEqual.cpp
│ │ │ │ │ │ ├── MatrixBase_cwiseInverse.cpp
│ │ │ │ │ │ ├── MatrixBase_cwiseMax.cpp
│ │ │ │ │ │ ├── MatrixBase_cwiseMin.cpp
│ │ │ │ │ │ ├── MatrixBase_cwiseNotEqual.cpp
│ │ │ │ │ │ ├── MatrixBase_cwiseProduct.cpp
│ │ │ │ │ │ ├── MatrixBase_cwiseQuotient.cpp
│ │ │ │ │ │ ├── MatrixBase_cwiseSign.cpp
│ │ │ │ │ │ ├── MatrixBase_cwiseSqrt.cpp
│ │ │ │ │ │ ├── MatrixBase_diagonal.cpp
│ │ │ │ │ │ ├── MatrixBase_diagonal_int.cpp
│ │ │ │ │ │ ├── MatrixBase_diagonal_template_int.cpp
│ │ │ │ │ │ ├── MatrixBase_eigenvalues.cpp
│ │ │ │ │ │ ├── MatrixBase_end_int.cpp
│ │ │ │ │ │ ├── MatrixBase_eval.cpp
│ │ │ │ │ │ ├── MatrixBase_fixedBlock_int_int.cpp
│ │ │ │ │ │ ├── MatrixBase_hnormalized.cpp
│ │ │ │ │ │ ├── MatrixBase_homogeneous.cpp
│ │ │ │ │ │ ├── MatrixBase_identity.cpp
│ │ │ │ │ │ ├── MatrixBase_identity_int_int.cpp
│ │ │ │ │ │ ├── MatrixBase_inverse.cpp
│ │ │ │ │ │ ├── MatrixBase_isDiagonal.cpp
│ │ │ │ │ │ ├── MatrixBase_isIdentity.cpp
│ │ │ │ │ │ ├── MatrixBase_isOnes.cpp
│ │ │ │ │ │ ├── MatrixBase_isOrthogonal.cpp
│ │ │ │ │ │ ├── MatrixBase_isUnitary.cpp
│ │ │ │ │ │ ├── MatrixBase_isZero.cpp
│ │ │ │ │ │ ├── MatrixBase_leftCols_int.cpp
│ │ │ │ │ │ ├── MatrixBase_noalias.cpp
│ │ │ │ │ │ ├── MatrixBase_ones.cpp
│ │ │ │ │ │ ├── MatrixBase_ones_int.cpp
│ │ │ │ │ │ ├── MatrixBase_ones_int_int.cpp
│ │ │ │ │ │ ├── MatrixBase_operatorNorm.cpp
│ │ │ │ │ │ ├── MatrixBase_prod.cpp
│ │ │ │ │ │ ├── MatrixBase_random.cpp
│ │ │ │ │ │ ├── MatrixBase_random_int.cpp
│ │ │ │ │ │ ├── MatrixBase_random_int_int.cpp
│ │ │ │ │ │ ├── MatrixBase_replicate.cpp
│ │ │ │ │ │ ├── MatrixBase_replicate_int_int.cpp
│ │ │ │ │ │ ├── MatrixBase_reshaped_auto.cpp
│ │ │ │ │ │ ├── MatrixBase_reshaped_fixed.cpp
│ │ │ │ │ │ ├── MatrixBase_reshaped_int_int.cpp
│ │ │ │ │ │ ├── MatrixBase_reshaped_to_vector.cpp
│ │ │ │ │ │ ├── MatrixBase_reverse.cpp
│ │ │ │ │ │ ├── MatrixBase_rightCols_int.cpp
│ │ │ │ │ │ ├── MatrixBase_row.cpp
│ │ │ │ │ │ ├── MatrixBase_rowwise.cpp
│ │ │ │ │ │ ├── MatrixBase_segment_int_int.cpp
│ │ │ │ │ │ ├── MatrixBase_select.cpp
│ │ │ │ │ │ ├── MatrixBase_selfadjointView.cpp
│ │ │ │ │ │ ├── MatrixBase_set.cpp
│ │ │ │ │ │ ├── MatrixBase_setIdentity.cpp
│ │ │ │ │ │ ├── MatrixBase_setOnes.cpp
│ │ │ │ │ │ ├── MatrixBase_setRandom.cpp
│ │ │ │ │ │ ├── MatrixBase_setZero.cpp
│ │ │ │ │ │ ├── MatrixBase_start_int.cpp
│ │ │ │ │ │ ├── MatrixBase_template_int_bottomRows.cpp
│ │ │ │ │ │ ├── MatrixBase_template_int_end.cpp
│ │ │ │ │ │ ├── MatrixBase_template_int_int_block_int_int_int_int.cpp
│ │ │ │ │ │ ├── MatrixBase_template_int_int_bottomLeftCorner.cpp
│ │ │ │ │ │ ├── MatrixBase_template_int_int_bottomLeftCorner_int_int.cpp
│ │ │ │ │ │ ├── MatrixBase_template_int_int_bottomRightCorner.cpp
│ │ │ │ │ │ ├── MatrixBase_template_int_int_bottomRightCorner_int_int.cpp
│ │ │ │ │ │ ├── MatrixBase_template_int_int_topLeftCorner.cpp
│ │ │ │ │ │ ├── MatrixBase_template_int_int_topLeftCorner_int_int.cpp
│ │ │ │ │ │ ├── MatrixBase_template_int_int_topRightCorner.cpp
│ │ │ │ │ │ ├── MatrixBase_template_int_int_topRightCorner_int_int.cpp
│ │ │ │ │ │ ├── MatrixBase_template_int_leftCols.cpp
│ │ │ │ │ │ ├── MatrixBase_template_int_rightCols.cpp
│ │ │ │ │ │ ├── MatrixBase_template_int_segment.cpp
│ │ │ │ │ │ ├── MatrixBase_template_int_start.cpp
│ │ │ │ │ │ ├── MatrixBase_template_int_topRows.cpp
│ │ │ │ │ │ ├── MatrixBase_topLeftCorner_int_int.cpp
│ │ │ │ │ │ ├── MatrixBase_topRightCorner_int_int.cpp
│ │ │ │ │ │ ├── MatrixBase_topRows_int.cpp
│ │ │ │ │ │ ├── MatrixBase_transpose.cpp
│ │ │ │ │ │ ├── MatrixBase_triangularView.cpp
│ │ │ │ │ │ ├── MatrixBase_zero.cpp
│ │ │ │ │ │ ├── MatrixBase_zero_int.cpp
│ │ │ │ │ │ ├── MatrixBase_zero_int_int.cpp
│ │ │ │ │ │ ├── Matrix_Map_stride.cpp
│ │ │ │ │ │ ├── Matrix_initializer_list_23_cxx11.cpp
│ │ │ │ │ │ ├── Matrix_initializer_list_vector_cxx11.cpp
│ │ │ │ │ │ ├── Matrix_resize_NoChange_int.cpp
│ │ │ │ │ │ ├── Matrix_resize_int.cpp
│ │ │ │ │ │ ├── Matrix_resize_int_NoChange.cpp
│ │ │ │ │ │ ├── Matrix_resize_int_int.cpp
│ │ │ │ │ │ ├── Matrix_setConstant_int.cpp
│ │ │ │ │ │ ├── Matrix_setConstant_int_int.cpp
│ │ │ │ │ │ ├── Matrix_setIdentity_int_int.cpp
│ │ │ │ │ │ ├── Matrix_setOnes_int.cpp
│ │ │ │ │ │ ├── Matrix_setOnes_int_int.cpp
│ │ │ │ │ │ ├── Matrix_setRandom_int.cpp
│ │ │ │ │ │ ├── Matrix_setRandom_int_int.cpp
│ │ │ │ │ │ ├── Matrix_setZero_int.cpp
│ │ │ │ │ │ ├── Matrix_setZero_int_int.cpp
│ │ │ │ │ │ ├── Matrix_variadic_ctor_cxx11.cpp
│ │ │ │ │ │ ├── PartialPivLU_solve.cpp
│ │ │ │ │ │ ├── PartialRedux_count.cpp
│ │ │ │ │ │ ├── PartialRedux_maxCoeff.cpp
│ │ │ │ │ │ ├── PartialRedux_minCoeff.cpp
│ │ │ │ │ │ ├── PartialRedux_norm.cpp
│ │ │ │ │ │ ├── PartialRedux_prod.cpp
│ │ │ │ │ │ ├── PartialRedux_squaredNorm.cpp
│ │ │ │ │ │ ├── PartialRedux_sum.cpp
│ │ │ │ │ │ ├── RealQZ_compute.cpp
│ │ │ │ │ │ ├── RealSchur_RealSchur_MatrixType.cpp
│ │ │ │ │ │ ├── RealSchur_compute.cpp
│ │ │ │ │ │ ├── SelfAdjointEigenSolver_SelfAdjointEigenSolver.cpp
│ │ │ │ │ │ ├── SelfAdjointEigenSolver_SelfAdjointEigenSolver_MatrixType.cpp
│ │ │ │ │ │ ├── SelfAdjointEigenSolver_SelfAdjointEigenSolver_MatrixType2.cpp
│ │ │ │ │ │ ├── SelfAdjointEigenSolver_compute_MatrixType.cpp
│ │ │ │ │ │ ├── SelfAdjointEigenSolver_compute_MatrixType2.cpp
│ │ │ │ │ │ ├── SelfAdjointEigenSolver_eigenvalues.cpp
│ │ │ │ │ │ ├── SelfAdjointEigenSolver_eigenvectors.cpp
│ │ │ │ │ │ ├── SelfAdjointEigenSolver_operatorInverseSqrt.cpp
│ │ │ │ │ │ ├── SelfAdjointEigenSolver_operatorSqrt.cpp
│ │ │ │ │ │ ├── SelfAdjointView_eigenvalues.cpp
│ │ │ │ │ │ ├── SelfAdjointView_operatorNorm.cpp
│ │ │ │ │ │ ├── Slicing_arrayexpr.cpp
│ │ │ │ │ │ ├── Slicing_custom_padding_cxx11.cpp
│ │ │ │ │ │ ├── Slicing_rawarray_cxx11.cpp
│ │ │ │ │ │ ├── Slicing_stdvector_cxx11.cpp
│ │ │ │ │ │ ├── SparseMatrix_coeffs.cpp
│ │ │ │ │ │ ├── TopicAliasing_block.cpp
│ │ │ │ │ │ ├── TopicAliasing_block_correct.cpp
│ │ │ │ │ │ ├── TopicAliasing_cwise.cpp
│ │ │ │ │ │ ├── TopicAliasing_mult1.cpp
│ │ │ │ │ │ ├── TopicAliasing_mult2.cpp
│ │ │ │ │ │ ├── TopicAliasing_mult3.cpp
│ │ │ │ │ │ ├── TopicAliasing_mult4.cpp
│ │ │ │ │ │ ├── TopicAliasing_mult5.cpp
│ │ │ │ │ │ ├── TopicStorageOrders_example.cpp
│ │ │ │ │ │ ├── Triangular_solve.cpp
│ │ │ │ │ │ ├── Tridiagonalization_Tridiagonalization_MatrixType.cpp
│ │ │ │ │ │ ├── Tridiagonalization_compute.cpp
│ │ │ │ │ │ ├── Tridiagonalization_decomposeInPlace.cpp
│ │ │ │ │ │ ├── Tridiagonalization_diagonal.cpp
│ │ │ │ │ │ ├── Tridiagonalization_householderCoefficients.cpp
│ │ │ │ │ │ ├── Tridiagonalization_packedMatrix.cpp
│ │ │ │ │ │ ├── Tutorial_AdvancedInitialization_Block.cpp
│ │ │ │ │ │ ├── Tutorial_AdvancedInitialization_CommaTemporary.cpp
│ │ │ │ │ │ ├── Tutorial_AdvancedInitialization_Join.cpp
│ │ │ │ │ │ ├── Tutorial_AdvancedInitialization_LinSpaced.cpp
│ │ │ │ │ │ ├── Tutorial_AdvancedInitialization_ThreeWays.cpp
│ │ │ │ │ │ ├── Tutorial_AdvancedInitialization_Zero.cpp
│ │ │ │ │ │ ├── Tutorial_Map_rowmajor.cpp
│ │ │ │ │ │ ├── Tutorial_Map_using.cpp
│ │ │ │ │ │ ├── Tutorial_ReshapeMat2Mat.cpp
│ │ │ │ │ │ ├── Tutorial_ReshapeMat2Vec.cpp
│ │ │ │ │ │ ├── Tutorial_SlicingCol.cpp
│ │ │ │ │ │ ├── Tutorial_SlicingVec.cpp
│ │ │ │ │ │ ├── Tutorial_commainit_01.cpp
│ │ │ │ │ │ ├── Tutorial_commainit_01b.cpp
│ │ │ │ │ │ ├── Tutorial_commainit_02.cpp
│ │ │ │ │ │ ├── Tutorial_range_for_loop_1d_cxx11.cpp
│ │ │ │ │ │ ├── Tutorial_range_for_loop_2d_cxx11.cpp
│ │ │ │ │ │ ├── Tutorial_reshaped_vs_resize_1.cpp
│ │ │ │ │ │ ├── Tutorial_reshaped_vs_resize_2.cpp
│ │ │ │ │ │ ├── Tutorial_solve_matrix_inverse.cpp
│ │ │ │ │ │ ├── Tutorial_solve_multiple_rhs.cpp
│ │ │ │ │ │ ├── Tutorial_solve_reuse_decomposition.cpp
│ │ │ │ │ │ ├── Tutorial_solve_singular.cpp
│ │ │ │ │ │ ├── Tutorial_solve_triangular.cpp
│ │ │ │ │ │ ├── Tutorial_solve_triangular_inplace.cpp
│ │ │ │ │ │ ├── Tutorial_std_sort.cpp
│ │ │ │ │ │ ├── Tutorial_std_sort_rows_cxx11.cpp
│ │ │ │ │ │ ├── VectorwiseOp_homogeneous.cpp
│ │ │ │ │ │ ├── Vectorwise_reverse.cpp
│ │ │ │ │ │ ├── class_FullPivLU.cpp
│ │ │ │ │ │ ├── compile_snippet.cpp.in
│ │ │ │ │ │ ├── tut_arithmetic_redux_minmax.cpp
│ │ │ │ │ │ ├── tut_arithmetic_transpose_aliasing.cpp
│ │ │ │ │ │ ├── tut_arithmetic_transpose_conjugate.cpp
│ │ │ │ │ │ ├── tut_arithmetic_transpose_inplace.cpp
│ │ │ │ │ │ └── tut_matrix_assignment_resizing.cpp
│ │ │ │ │ ├── special_examples/
│ │ │ │ │ │ ├── CMakeLists.txt
│ │ │ │ │ │ ├── Tutorial_sparse_example.cpp
│ │ │ │ │ │ ├── Tutorial_sparse_example_details.cpp
│ │ │ │ │ │ └── random_cpp11.cpp
│ │ │ │ │ └── tutorial.cpp
│ │ │ │ ├── eigen3.pc.in
│ │ │ │ ├── failtest/
│ │ │ │ │ ├── CMakeLists.txt
│ │ │ │ │ ├── bdcsvd_int.cpp
│ │ │ │ │ ├── block_nonconst_ctor_on_const_xpr_0.cpp
│ │ │ │ │ ├── block_nonconst_ctor_on_const_xpr_1.cpp
│ │ │ │ │ ├── block_nonconst_ctor_on_const_xpr_2.cpp
│ │ │ │ │ ├── block_on_const_type_actually_const_0.cpp
│ │ │ │ │ ├── block_on_const_type_actually_const_1.cpp
│ │ │ │ │ ├── colpivqr_int.cpp
│ │ │ │ │ ├── const_qualified_block_method_retval_0.cpp
│ │ │ │ │ ├── const_qualified_block_method_retval_1.cpp
│ │ │ │ │ ├── const_qualified_diagonal_method_retval.cpp
│ │ │ │ │ ├── const_qualified_transpose_method_retval.cpp
│ │ │ │ │ ├── cwiseunaryview_nonconst_ctor_on_const_xpr.cpp
│ │ │ │ │ ├── cwiseunaryview_on_const_type_actually_const.cpp
│ │ │ │ │ ├── diagonal_nonconst_ctor_on_const_xpr.cpp
│ │ │ │ │ ├── diagonal_on_const_type_actually_const.cpp
│ │ │ │ │ ├── eigensolver_cplx.cpp
│ │ │ │ │ ├── eigensolver_int.cpp
│ │ │ │ │ ├── failtest_sanity_check.cpp
│ │ │ │ │ ├── fullpivlu_int.cpp
│ │ │ │ │ ├── fullpivqr_int.cpp
│ │ │ │ │ ├── initializer_list_1.cpp
│ │ │ │ │ ├── initializer_list_2.cpp
│ │ │ │ │ ├── jacobisvd_int.cpp
│ │ │ │ │ ├── ldlt_int.cpp
│ │ │ │ │ ├── llt_int.cpp
│ │ │ │ │ ├── map_nonconst_ctor_on_const_ptr_0.cpp
│ │ │ │ │ ├── map_nonconst_ctor_on_const_ptr_1.cpp
│ │ │ │ │ ├── map_nonconst_ctor_on_const_ptr_2.cpp
│ │ │ │ │ ├── map_nonconst_ctor_on_const_ptr_3.cpp
│ │ │ │ │ ├── map_nonconst_ctor_on_const_ptr_4.cpp
│ │ │ │ │ ├── map_on_const_type_actually_const_0.cpp
│ │ │ │ │ ├── map_on_const_type_actually_const_1.cpp
│ │ │ │ │ ├── partialpivlu_int.cpp
│ │ │ │ │ ├── qr_int.cpp
│ │ │ │ │ ├── ref_1.cpp
│ │ │ │ │ ├── ref_2.cpp
│ │ │ │ │ ├── ref_3.cpp
│ │ │ │ │ ├── ref_4.cpp
│ │ │ │ │ ├── ref_5.cpp
│ │ │ │ │ ├── selfadjointview_nonconst_ctor_on_const_xpr.cpp
│ │ │ │ │ ├── selfadjointview_on_const_type_actually_const.cpp
│ │ │ │ │ ├── sparse_ref_1.cpp
│ │ │ │ │ ├── sparse_ref_2.cpp
│ │ │ │ │ ├── sparse_ref_3.cpp
│ │ │ │ │ ├── sparse_ref_4.cpp
│ │ │ │ │ ├── sparse_ref_5.cpp
│ │ │ │ │ ├── sparse_storage_mismatch.cpp
│ │ │ │ │ ├── swap_1.cpp
│ │ │ │ │ ├── swap_2.cpp
│ │ │ │ │ ├── ternary_1.cpp
│ │ │ │ │ ├── ternary_2.cpp
│ │ │ │ │ ├── transpose_nonconst_ctor_on_const_xpr.cpp
│ │ │ │ │ ├── transpose_on_const_type_actually_const.cpp
│ │ │ │ │ ├── triangularview_nonconst_ctor_on_const_xpr.cpp
│ │ │ │ │ └── triangularview_on_const_type_actually_const.cpp
│ │ │ │ ├── lapack/
│ │ │ │ │ ├── CMakeLists.txt
│ │ │ │ │ ├── cholesky.cpp
│ │ │ │ │ ├── clacgv.f
│ │ │ │ │ ├── cladiv.f
│ │ │ │ │ ├── clarf.f
│ │ │ │ │ ├── clarfb.f
│ │ │ │ │ ├── clarfg.f
│ │ │ │ │ ├── clarft.f
│ │ │ │ │ ├── complex_double.cpp
│ │ │ │ │ ├── complex_single.cpp
│ │ │ │ │ ├── dladiv.f
│ │ │ │ │ ├── dlamch.f
│ │ │ │ │ ├── dlapy2.f
│ │ │ │ │ ├── dlapy3.f
│ │ │ │ │ ├── dlarf.f
│ │ │ │ │ ├── dlarfb.f
│ │ │ │ │ ├── dlarfg.f
│ │ │ │ │ ├── dlarft.f
│ │ │ │ │ ├── double.cpp
│ │ │ │ │ ├── dsecnd_NONE.f
│ │ │ │ │ ├── eigenvalues.cpp
│ │ │ │ │ ├── ilaclc.f
│ │ │ │ │ ├── ilaclr.f
│ │ │ │ │ ├── iladlc.f
│ │ │ │ │ ├── iladlr.f
│ │ │ │ │ ├── ilaslc.f
│ │ │ │ │ ├── ilaslr.f
│ │ │ │ │ ├── ilazlc.f
│ │ │ │ │ ├── ilazlr.f
│ │ │ │ │ ├── lapack_common.h
│ │ │ │ │ ├── lu.cpp
│ │ │ │ │ ├── second_NONE.f
│ │ │ │ │ ├── single.cpp
│ │ │ │ │ ├── sladiv.f
│ │ │ │ │ ├── slamch.f
│ │ │ │ │ ├── slapy2.f
│ │ │ │ │ ├── slapy3.f
│ │ │ │ │ ├── slarf.f
│ │ │ │ │ ├── slarfb.f
│ │ │ │ │ ├── slarfg.f
│ │ │ │ │ ├── slarft.f
│ │ │ │ │ ├── svd.cpp
│ │ │ │ │ ├── zlacgv.f
│ │ │ │ │ ├── zladiv.f
│ │ │ │ │ ├── zlarf.f
│ │ │ │ │ ├── zlarfb.f
│ │ │ │ │ ├── zlarfg.f
│ │ │ │ │ └── zlarft.f
│ │ │ │ ├── scripts/
│ │ │ │ │ ├── CMakeLists.txt
│ │ │ │ │ ├── cdashtesting.cmake.in
│ │ │ │ │ ├── check.in
│ │ │ │ │ ├── debug.in
│ │ │ │ │ ├── eigen_gen_credits.cpp
│ │ │ │ │ ├── eigen_gen_docs
│ │ │ │ │ ├── eigen_gen_split_test_help.cmake
│ │ │ │ │ ├── eigen_monitor_perf.sh
│ │ │ │ │ ├── release.in
│ │ │ │ │ └── relicense.py
│ │ │ │ ├── signature_of_eigen3_matrix_library
│ │ │ │ ├── test/
│ │ │ │ │ ├── AnnoyingScalar.h
│ │ │ │ │ ├── CMakeLists.txt
│ │ │ │ │ ├── MovableScalar.h
│ │ │ │ │ ├── adjoint.cpp
│ │ │ │ │ ├── array_cwise.cpp
│ │ │ │ │ ├── array_for_matrix.cpp
│ │ │ │ │ ├── array_of_string.cpp
│ │ │ │ │ ├── array_replicate.cpp
│ │ │ │ │ ├── array_reverse.cpp
│ │ │ │ │ ├── bandmatrix.cpp
│ │ │ │ │ ├── basicstuff.cpp
│ │ │ │ │ ├── bdcsvd.cpp
│ │ │ │ │ ├── bfloat16_float.cpp
│ │ │ │ │ ├── bicgstab.cpp
│ │ │ │ │ ├── blasutil.cpp
│ │ │ │ │ ├── block.cpp
│ │ │ │ │ ├── boostmultiprec.cpp
│ │ │ │ │ ├── bug1213.cpp
│ │ │ │ │ ├── bug1213.h
│ │ │ │ │ ├── bug1213_main.cpp
│ │ │ │ │ ├── cholesky.cpp
│ │ │ │ │ ├── cholmod_support.cpp
│ │ │ │ │ ├── commainitializer.cpp
│ │ │ │ │ ├── conjugate_gradient.cpp
│ │ │ │ │ ├── conservative_resize.cpp
│ │ │ │ │ ├── constructor.cpp
│ │ │ │ │ ├── corners.cpp
│ │ │ │ │ ├── ctorleak.cpp
│ │ │ │ │ ├── denseLM.cpp
│ │ │ │ │ ├── dense_storage.cpp
│ │ │ │ │ ├── determinant.cpp
│ │ │ │ │ ├── diagonal.cpp
│ │ │ │ │ ├── diagonal_matrix_variadic_ctor.cpp
│ │ │ │ │ ├── diagonalmatrices.cpp
│ │ │ │ │ ├── dontalign.cpp
│ │ │ │ │ ├── dynalloc.cpp
│ │ │ │ │ ├── eigen2support.cpp
│ │ │ │ │ ├── eigensolver_complex.cpp
│ │ │ │ │ ├── eigensolver_generalized_real.cpp
│ │ │ │ │ ├── eigensolver_generic.cpp
│ │ │ │ │ ├── eigensolver_selfadjoint.cpp
│ │ │ │ │ ├── evaluator_common.h
│ │ │ │ │ ├── evaluators.cpp
│ │ │ │ │ ├── exceptions.cpp
│ │ │ │ │ ├── fastmath.cpp
│ │ │ │ │ ├── first_aligned.cpp
│ │ │ │ │ ├── geo_alignedbox.cpp
│ │ │ │ │ ├── geo_eulerangles.cpp
│ │ │ │ │ ├── geo_homogeneous.cpp
│ │ │ │ │ ├── geo_hyperplane.cpp
│ │ │ │ │ ├── geo_orthomethods.cpp
│ │ │ │ │ ├── geo_parametrizedline.cpp
│ │ │ │ │ ├── geo_quaternion.cpp
│ │ │ │ │ ├── geo_transformations.cpp
│ │ │ │ │ ├── gpu_basic.cu
│ │ │ │ │ ├── gpu_common.h
│ │ │ │ │ ├── half_float.cpp
│ │ │ │ │ ├── hessenberg.cpp
│ │ │ │ │ ├── householder.cpp
│ │ │ │ │ ├── incomplete_cholesky.cpp
│ │ │ │ │ ├── indexed_view.cpp
│ │ │ │ │ ├── initializer_list_construction.cpp
│ │ │ │ │ ├── inplace_decomposition.cpp
│ │ │ │ │ ├── integer_types.cpp
│ │ │ │ │ ├── inverse.cpp
│ │ │ │ │ ├── io.cpp
│ │ │ │ │ ├── is_same_dense.cpp
│ │ │ │ │ ├── jacobi.cpp
│ │ │ │ │ ├── jacobisvd.cpp
│ │ │ │ │ ├── klu_support.cpp
│ │ │ │ │ ├── linearstructure.cpp
│ │ │ │ │ ├── lscg.cpp
│ │ │ │ │ ├── lu.cpp
│ │ │ │ │ ├── main.h
│ │ │ │ │ ├── mapped_matrix.cpp
│ │ │ │ │ ├── mapstaticmethods.cpp
│ │ │ │ │ ├── mapstride.cpp
│ │ │ │ │ ├── meta.cpp
│ │ │ │ │ ├── metis_support.cpp
│ │ │ │ │ ├── miscmatrices.cpp
│ │ │ │ │ ├── mixingtypes.cpp
│ │ │ │ │ ├── mpl2only.cpp
│ │ │ │ │ ├── nestbyvalue.cpp
│ │ │ │ │ ├── nesting_ops.cpp
│ │ │ │ │ ├── nomalloc.cpp
│ │ │ │ │ ├── nullary.cpp
│ │ │ │ │ ├── num_dimensions.cpp
│ │ │ │ │ ├── numext.cpp
│ │ │ │ │ ├── packetmath.cpp
│ │ │ │ │ ├── packetmath_test_shared.h
│ │ │ │ │ ├── pardiso_support.cpp
│ │ │ │ │ ├── pastix_support.cpp
│ │ │ │ │ ├── permutationmatrices.cpp
│ │ │ │ │ ├── prec_inverse_4x4.cpp
│ │ │ │ │ ├── product.h
│ │ │ │ │ ├── product_extra.cpp
│ │ │ │ │ ├── product_large.cpp
│ │ │ │ │ ├── product_mmtr.cpp
│ │ │ │ │ ├── product_notemporary.cpp
│ │ │ │ │ ├── product_selfadjoint.cpp
│ │ │ │ │ ├── product_small.cpp
│ │ │ │ │ ├── product_symm.cpp
│ │ │ │ │ ├── product_syrk.cpp
│ │ │ │ │ ├── product_trmm.cpp
│ │ │ │ │ ├── product_trmv.cpp
│ │ │ │ │ ├── product_trsolve.cpp
│ │ │ │ │ ├── qr.cpp
│ │ │ │ │ ├── qr_colpivoting.cpp
│ │ │ │ │ ├── qr_fullpivoting.cpp
│ │ │ │ │ ├── qtvector.cpp
│ │ │ │ │ ├── rand.cpp
│ │ │ │ │ ├── random_without_cast_overflow.h
│ │ │ │ │ ├── real_qz.cpp
│ │ │ │ │ ├── redux.cpp
│ │ │ │ │ ├── ref.cpp
│ │ │ │ │ ├── reshape.cpp
│ │ │ │ │ ├── resize.cpp
│ │ │ │ │ ├── rvalue_types.cpp
│ │ │ │ │ ├── schur_complex.cpp
│ │ │ │ │ ├── schur_real.cpp
│ │ │ │ │ ├── selfadjoint.cpp
│ │ │ │ │ ├── simplicial_cholesky.cpp
│ │ │ │ │ ├── sizeof.cpp
│ │ │ │ │ ├── sizeoverflow.cpp
│ │ │ │ │ ├── smallvectors.cpp
│ │ │ │ │ ├── solverbase.h
│ │ │ │ │ ├── sparse.h
│ │ │ │ │ ├── sparseLM.cpp
│ │ │ │ │ ├── sparse_basic.cpp
│ │ │ │ │ ├── sparse_block.cpp
│ │ │ │ │ ├── sparse_permutations.cpp
│ │ │ │ │ ├── sparse_product.cpp
│ │ │ │ │ ├── sparse_ref.cpp
│ │ │ │ │ ├── sparse_solver.h
│ │ │ │ │ ├── sparse_solvers.cpp
│ │ │ │ │ ├── sparse_vector.cpp
│ │ │ │ │ ├── sparselu.cpp
│ │ │ │ │ ├── sparseqr.cpp
│ │ │ │ │ ├── special_numbers.cpp
│ │ │ │ │ ├── split_test_helper.h
│ │ │ │ │ ├── spqr_support.cpp
│ │ │ │ │ ├── stable_norm.cpp
│ │ │ │ │ ├── stddeque.cpp
│ │ │ │ │ ├── stddeque_overload.cpp
│ │ │ │ │ ├── stdlist.cpp
│ │ │ │ │ ├── stdlist_overload.cpp
│ │ │ │ │ ├── stdvector.cpp
│ │ │ │ │ ├── stdvector_overload.cpp
│ │ │ │ │ ├── stl_iterators.cpp
│ │ │ │ │ ├── superlu_support.cpp
│ │ │ │ │ ├── svd_common.h
│ │ │ │ │ ├── svd_fill.h
│ │ │ │ │ ├── swap.cpp
│ │ │ │ │ ├── symbolic_index.cpp
│ │ │ │ │ ├── triangular.cpp
│ │ │ │ │ ├── type_alias.cpp
│ │ │ │ │ ├── umeyama.cpp
│ │ │ │ │ ├── umfpack_support.cpp
│ │ │ │ │ ├── unalignedassert.cpp
│ │ │ │ │ ├── unalignedcount.cpp
│ │ │ │ │ ├── upperbidiagonalization.cpp
│ │ │ │ │ ├── vectorization_logic.cpp
│ │ │ │ │ ├── vectorwiseop.cpp
│ │ │ │ │ ├── visitor.cpp
│ │ │ │ │ └── zerosized.cpp
│ │ │ │ └── unsupported/
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── Eigen/
│ │ │ │ │ ├── AdolcForward
│ │ │ │ │ ├── AlignedVector3
│ │ │ │ │ ├── ArpackSupport
│ │ │ │ │ ├── AutoDiff
│ │ │ │ │ ├── BVH
│ │ │ │ │ ├── CMakeLists.txt
│ │ │ │ │ ├── CXX11/
│ │ │ │ │ │ ├── CMakeLists.txt
│ │ │ │ │ │ ├── Tensor
│ │ │ │ │ │ ├── TensorSymmetry
│ │ │ │ │ │ ├── ThreadPool
│ │ │ │ │ │ └── src/
│ │ │ │ │ │ ├── Tensor/
│ │ │ │ │ │ │ ├── README.md
│ │ │ │ │ │ │ ├── Tensor.h
│ │ │ │ │ │ │ ├── TensorArgMax.h
│ │ │ │ │ │ │ ├── TensorAssign.h
│ │ │ │ │ │ │ ├── TensorBase.h
│ │ │ │ │ │ │ ├── TensorBlock.h
│ │ │ │ │ │ │ ├── TensorBroadcasting.h
│ │ │ │ │ │ │ ├── TensorChipping.h
│ │ │ │ │ │ │ ├── TensorConcatenation.h
│ │ │ │ │ │ │ ├── TensorContraction.h
│ │ │ │ │ │ │ ├── TensorContractionBlocking.h
│ │ │ │ │ │ │ ├── TensorContractionCuda.h
│ │ │ │ │ │ │ ├── TensorContractionGpu.h
│ │ │ │ │ │ │ ├── TensorContractionMapper.h
│ │ │ │ │ │ │ ├── TensorContractionSycl.h
│ │ │ │ │ │ │ ├── TensorContractionThreadPool.h
│ │ │ │ │ │ │ ├── TensorConversion.h
│ │ │ │ │ │ │ ├── TensorConvolution.h
│ │ │ │ │ │ │ ├── TensorConvolutionSycl.h
│ │ │ │ │ │ │ ├── TensorCostModel.h
│ │ │ │ │ │ │ ├── TensorCustomOp.h
│ │ │ │ │ │ │ ├── TensorDevice.h
│ │ │ │ │ │ │ ├── TensorDeviceCuda.h
│ │ │ │ │ │ │ ├── TensorDeviceDefault.h
│ │ │ │ │ │ │ ├── TensorDeviceGpu.h
│ │ │ │ │ │ │ ├── TensorDeviceSycl.h
│ │ │ │ │ │ │ ├── TensorDeviceThreadPool.h
│ │ │ │ │ │ │ ├── TensorDimensionList.h
│ │ │ │ │ │ │ ├── TensorDimensions.h
│ │ │ │ │ │ │ ├── TensorEvalTo.h
│ │ │ │ │ │ │ ├── TensorEvaluator.h
│ │ │ │ │ │ │ ├── TensorExecutor.h
│ │ │ │ │ │ │ ├── TensorExpr.h
│ │ │ │ │ │ │ ├── TensorFFT.h
│ │ │ │ │ │ │ ├── TensorFixedSize.h
│ │ │ │ │ │ │ ├── TensorForcedEval.h
│ │ │ │ │ │ │ ├── TensorForwardDeclarations.h
│ │ │ │ │ │ │ ├── TensorFunctors.h
│ │ │ │ │ │ │ ├── TensorGenerator.h
│ │ │ │ │ │ │ ├── TensorGlobalFunctions.h
│ │ │ │ │ │ │ ├── TensorGpuHipCudaDefines.h
│ │ │ │ │ │ │ ├── TensorGpuHipCudaUndefines.h
│ │ │ │ │ │ │ ├── TensorIO.h
│ │ │ │ │ │ │ ├── TensorImagePatch.h
│ │ │ │ │ │ │ ├── TensorIndexList.h
│ │ │ │ │ │ │ ├── TensorInflation.h
│ │ │ │ │ │ │ ├── TensorInitializer.h
│ │ │ │ │ │ │ ├── TensorIntDiv.h
│ │ │ │ │ │ │ ├── TensorLayoutSwap.h
│ │ │ │ │ │ │ ├── TensorMacros.h
│ │ │ │ │ │ │ ├── TensorMap.h
│ │ │ │ │ │ │ ├── TensorMeta.h
│ │ │ │ │ │ │ ├── TensorMorphing.h
│ │ │ │ │ │ │ ├── TensorPadding.h
│ │ │ │ │ │ │ ├── TensorPatch.h
│ │ │ │ │ │ │ ├── TensorRandom.h
│ │ │ │ │ │ │ ├── TensorReduction.h
│ │ │ │ │ │ │ ├── TensorReductionCuda.h
│ │ │ │ │ │ │ ├── TensorReductionGpu.h
│ │ │ │ │ │ │ ├── TensorReductionSycl.h
│ │ │ │ │ │ │ ├── TensorRef.h
│ │ │ │ │ │ │ ├── TensorReverse.h
│ │ │ │ │ │ │ ├── TensorScan.h
│ │ │ │ │ │ │ ├── TensorScanSycl.h
│ │ │ │ │ │ │ ├── TensorShuffling.h
│ │ │ │ │ │ │ ├── TensorStorage.h
│ │ │ │ │ │ │ ├── TensorStriding.h
│ │ │ │ │ │ │ ├── TensorTrace.h
│ │ │ │ │ │ │ ├── TensorTraits.h
│ │ │ │ │ │ │ ├── TensorUInt128.h
│ │ │ │ │ │ │ └── TensorVolumePatch.h
│ │ │ │ │ │ ├── TensorSymmetry/
│ │ │ │ │ │ │ ├── DynamicSymmetry.h
│ │ │ │ │ │ │ ├── StaticSymmetry.h
│ │ │ │ │ │ │ ├── Symmetry.h
│ │ │ │ │ │ │ └── util/
│ │ │ │ │ │ │ └── TemplateGroupTheory.h
│ │ │ │ │ │ ├── ThreadPool/
│ │ │ │ │ │ │ ├── Barrier.h
│ │ │ │ │ │ │ ├── EventCount.h
│ │ │ │ │ │ │ ├── NonBlockingThreadPool.h
│ │ │ │ │ │ │ ├── RunQueue.h
│ │ │ │ │ │ │ ├── ThreadCancel.h
│ │ │ │ │ │ │ ├── ThreadEnvironment.h
│ │ │ │ │ │ │ ├── ThreadLocal.h
│ │ │ │ │ │ │ ├── ThreadPoolInterface.h
│ │ │ │ │ │ │ └── ThreadYield.h
│ │ │ │ │ │ └── util/
│ │ │ │ │ │ ├── CXX11Meta.h
│ │ │ │ │ │ ├── CXX11Workarounds.h
│ │ │ │ │ │ ├── EmulateArray.h
│ │ │ │ │ │ └── MaxSizeVector.h
│ │ │ │ │ ├── EulerAngles
│ │ │ │ │ ├── FFT
│ │ │ │ │ ├── IterativeSolvers
│ │ │ │ │ ├── KroneckerProduct
│ │ │ │ │ ├── LevenbergMarquardt
│ │ │ │ │ ├── MPRealSupport
│ │ │ │ │ ├── MatrixFunctions
│ │ │ │ │ ├── MoreVectorization
│ │ │ │ │ ├── NonLinearOptimization
│ │ │ │ │ ├── NumericalDiff
│ │ │ │ │ ├── OpenGLSupport
│ │ │ │ │ ├── Polynomials
│ │ │ │ │ ├── Skyline
│ │ │ │ │ ├── SparseExtra
│ │ │ │ │ ├── SpecialFunctions
│ │ │ │ │ ├── Splines
│ │ │ │ │ └── src/
│ │ │ │ │ ├── AutoDiff/
│ │ │ │ │ │ ├── AutoDiffJacobian.h
│ │ │ │ │ │ ├── AutoDiffScalar.h
│ │ │ │ │ │ └── AutoDiffVector.h
│ │ │ │ │ ├── BVH/
│ │ │ │ │ │ ├── BVAlgorithms.h
│ │ │ │ │ │ └── KdBVH.h
│ │ │ │ │ ├── Eigenvalues/
│ │ │ │ │ │ └── ArpackSelfAdjointEigenSolver.h
│ │ │ │ │ ├── EulerAngles/
│ │ │ │ │ │ ├── CMakeLists.txt
│ │ │ │ │ │ ├── EulerAngles.h
│ │ │ │ │ │ └── EulerSystem.h
│ │ │ │ │ ├── FFT/
│ │ │ │ │ │ ├── ei_fftw_impl.h
│ │ │ │ │ │ └── ei_kissfft_impl.h
│ │ │ │ │ ├── IterativeSolvers/
│ │ │ │ │ │ ├── ConstrainedConjGrad.h
│ │ │ │ │ │ ├── DGMRES.h
│ │ │ │ │ │ ├── GMRES.h
│ │ │ │ │ │ ├── IDRS.h
│ │ │ │ │ │ ├── IncompleteLU.h
│ │ │ │ │ │ ├── IterationController.h
│ │ │ │ │ │ ├── MINRES.h
│ │ │ │ │ │ └── Scaling.h
│ │ │ │ │ ├── KroneckerProduct/
│ │ │ │ │ │ └── KroneckerTensorProduct.h
│ │ │ │ │ ├── LevenbergMarquardt/
│ │ │ │ │ │ ├── CopyrightMINPACK.txt
│ │ │ │ │ │ ├── LMcovar.h
│ │ │ │ │ │ ├── LMonestep.h
│ │ │ │ │ │ ├── LMpar.h
│ │ │ │ │ │ ├── LMqrsolv.h
│ │ │ │ │ │ └── LevenbergMarquardt.h
│ │ │ │ │ ├── MatrixFunctions/
│ │ │ │ │ │ ├── MatrixExponential.h
│ │ │ │ │ │ ├── MatrixFunction.h
│ │ │ │ │ │ ├── MatrixLogarithm.h
│ │ │ │ │ │ ├── MatrixPower.h
│ │ │ │ │ │ ├── MatrixSquareRoot.h
│ │ │ │ │ │ └── StemFunction.h
│ │ │ │ │ ├── MoreVectorization/
│ │ │ │ │ │ └── MathFunctions.h
│ │ │ │ │ ├── NonLinearOptimization/
│ │ │ │ │ │ ├── HybridNonLinearSolver.h
│ │ │ │ │ │ ├── LevenbergMarquardt.h
│ │ │ │ │ │ ├── chkder.h
│ │ │ │ │ │ ├── covar.h
│ │ │ │ │ │ ├── dogleg.h
│ │ │ │ │ │ ├── fdjac1.h
│ │ │ │ │ │ ├── lmpar.h
│ │ │ │ │ │ ├── qrsolv.h
│ │ │ │ │ │ ├── r1mpyq.h
│ │ │ │ │ │ ├── r1updt.h
│ │ │ │ │ │ └── rwupdt.h
│ │ │ │ │ ├── NumericalDiff/
│ │ │ │ │ │ └── NumericalDiff.h
│ │ │ │ │ ├── Polynomials/
│ │ │ │ │ │ ├── Companion.h
│ │ │ │ │ │ ├── PolynomialSolver.h
│ │ │ │ │ │ └── PolynomialUtils.h
│ │ │ │ │ ├── Skyline/
│ │ │ │ │ │ ├── SkylineInplaceLU.h
│ │ │ │ │ │ ├── SkylineMatrix.h
│ │ │ │ │ │ ├── SkylineMatrixBase.h
│ │ │ │ │ │ ├── SkylineProduct.h
│ │ │ │ │ │ ├── SkylineStorage.h
│ │ │ │ │ │ └── SkylineUtil.h
│ │ │ │ │ ├── SparseExtra/
│ │ │ │ │ │ ├── BlockOfDynamicSparseMatrix.h
│ │ │ │ │ │ ├── BlockSparseMatrix.h
│ │ │ │ │ │ ├── DynamicSparseMatrix.h
│ │ │ │ │ │ ├── MarketIO.h
│ │ │ │ │ │ ├── MatrixMarketIterator.h
│ │ │ │ │ │ └── RandomSetter.h
│ │ │ │ │ ├── SpecialFunctions/
│ │ │ │ │ │ ├── BesselFunctionsArrayAPI.h
│ │ │ │ │ │ ├── BesselFunctionsBFloat16.h
│ │ │ │ │ │ ├── BesselFunctionsFunctors.h
│ │ │ │ │ │ ├── BesselFunctionsHalf.h
│ │ │ │ │ │ ├── BesselFunctionsImpl.h
│ │ │ │ │ │ ├── BesselFunctionsPacketMath.h
│ │ │ │ │ │ ├── HipVectorCompatibility.h
│ │ │ │ │ │ ├── SpecialFunctionsArrayAPI.h
│ │ │ │ │ │ ├── SpecialFunctionsBFloat16.h
│ │ │ │ │ │ ├── SpecialFunctionsFunctors.h
│ │ │ │ │ │ ├── SpecialFunctionsHalf.h
│ │ │ │ │ │ ├── SpecialFunctionsImpl.h
│ │ │ │ │ │ ├── SpecialFunctionsPacketMath.h
│ │ │ │ │ │ └── arch/
│ │ │ │ │ │ ├── AVX/
│ │ │ │ │ │ │ ├── BesselFunctions.h
│ │ │ │ │ │ │ └── SpecialFunctions.h
│ │ │ │ │ │ ├── AVX512/
│ │ │ │ │ │ │ ├── BesselFunctions.h
│ │ │ │ │ │ │ └── SpecialFunctions.h
│ │ │ │ │ │ ├── GPU/
│ │ │ │ │ │ │ └── SpecialFunctions.h
│ │ │ │ │ │ └── NEON/
│ │ │ │ │ │ ├── BesselFunctions.h
│ │ │ │ │ │ └── SpecialFunctions.h
│ │ │ │ │ └── Splines/
│ │ │ │ │ ├── Spline.h
│ │ │ │ │ ├── SplineFitting.h
│ │ │ │ │ └── SplineFwd.h
│ │ │ │ ├── README.txt
│ │ │ │ ├── bench/
│ │ │ │ │ └── bench_svd.cpp
│ │ │ │ ├── doc/
│ │ │ │ │ ├── CMakeLists.txt
│ │ │ │ │ ├── Overview.dox
│ │ │ │ │ ├── SYCL.dox
│ │ │ │ │ ├── eigendoxy_layout.xml.in
│ │ │ │ │ ├── examples/
│ │ │ │ │ │ ├── BVH_Example.cpp
│ │ │ │ │ │ ├── CMakeLists.txt
│ │ │ │ │ │ ├── EulerAngles.cpp
│ │ │ │ │ │ ├── FFT.cpp
│ │ │ │ │ │ ├── MatrixExponential.cpp
│ │ │ │ │ │ ├── MatrixFunction.cpp
│ │ │ │ │ │ ├── MatrixLogarithm.cpp
│ │ │ │ │ │ ├── MatrixPower.cpp
│ │ │ │ │ │ ├── MatrixPower_optimal.cpp
│ │ │ │ │ │ ├── MatrixSine.cpp
│ │ │ │ │ │ ├── MatrixSinh.cpp
│ │ │ │ │ │ ├── MatrixSquareRoot.cpp
│ │ │ │ │ │ ├── PolynomialSolver1.cpp
│ │ │ │ │ │ ├── PolynomialUtils1.cpp
│ │ │ │ │ │ └── SYCL/
│ │ │ │ │ │ ├── CMakeLists.txt
│ │ │ │ │ │ └── CwiseMul.cpp
│ │ │ │ │ └── snippets/
│ │ │ │ │ └── CMakeLists.txt
│ │ │ │ └── test/
│ │ │ │ ├── BVH.cpp
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── EulerAngles.cpp
│ │ │ │ ├── FFT.cpp
│ │ │ │ ├── FFTW.cpp
│ │ │ │ ├── NonLinearOptimization.cpp
│ │ │ │ ├── NumericalDiff.cpp
│ │ │ │ ├── alignedvector3.cpp
│ │ │ │ ├── autodiff.cpp
│ │ │ │ ├── autodiff_scalar.cpp
│ │ │ │ ├── bessel_functions.cpp
│ │ │ │ ├── cxx11_eventcount.cpp
│ │ │ │ ├── cxx11_maxsizevector.cpp
│ │ │ │ ├── cxx11_meta.cpp
│ │ │ │ ├── cxx11_non_blocking_thread_pool.cpp
│ │ │ │ ├── cxx11_runqueue.cpp
│ │ │ │ ├── cxx11_tensor_argmax.cpp
│ │ │ │ ├── cxx11_tensor_argmax_gpu.cu
│ │ │ │ ├── cxx11_tensor_argmax_sycl.cpp
│ │ │ │ ├── cxx11_tensor_assign.cpp
│ │ │ │ ├── cxx11_tensor_block_access.cpp
│ │ │ │ ├── cxx11_tensor_block_eval.cpp
│ │ │ │ ├── cxx11_tensor_block_io.cpp
│ │ │ │ ├── cxx11_tensor_broadcast_sycl.cpp
│ │ │ │ ├── cxx11_tensor_broadcasting.cpp
│ │ │ │ ├── cxx11_tensor_builtins_sycl.cpp
│ │ │ │ ├── cxx11_tensor_cast_float16_gpu.cu
│ │ │ │ ├── cxx11_tensor_casts.cpp
│ │ │ │ ├── cxx11_tensor_chipping.cpp
│ │ │ │ ├── cxx11_tensor_chipping_sycl.cpp
│ │ │ │ ├── cxx11_tensor_comparisons.cpp
│ │ │ │ ├── cxx11_tensor_complex_cwise_ops_gpu.cu
│ │ │ │ ├── cxx11_tensor_complex_gpu.cu
│ │ │ │ ├── cxx11_tensor_concatenation.cpp
│ │ │ │ ├── cxx11_tensor_concatenation_sycl.cpp
│ │ │ │ ├── cxx11_tensor_const.cpp
│ │ │ │ ├── cxx11_tensor_contract_gpu.cu
│ │ │ │ ├── cxx11_tensor_contract_sycl.cpp
│ │ │ │ ├── cxx11_tensor_contraction.cpp
│ │ │ │ ├── cxx11_tensor_convolution.cpp
│ │ │ │ ├── cxx11_tensor_convolution_sycl.cpp
│ │ │ │ ├── cxx11_tensor_custom_index.cpp
│ │ │ │ ├── cxx11_tensor_custom_op.cpp
│ │ │ │ ├── cxx11_tensor_custom_op_sycl.cpp
│ │ │ │ ├── cxx11_tensor_device.cu
│ │ │ │ ├── cxx11_tensor_device_sycl.cpp
│ │ │ │ ├── cxx11_tensor_dimension.cpp
│ │ │ │ ├── cxx11_tensor_empty.cpp
│ │ │ │ ├── cxx11_tensor_executor.cpp
│ │ │ │ ├── cxx11_tensor_expr.cpp
│ │ │ │ ├── cxx11_tensor_fft.cpp
│ │ │ │ ├── cxx11_tensor_fixed_size.cpp
│ │ │ │ ├── cxx11_tensor_forced_eval.cpp
│ │ │ │ ├── cxx11_tensor_forced_eval_sycl.cpp
│ │ │ │ ├── cxx11_tensor_generator.cpp
│ │ │ │ ├── cxx11_tensor_generator_sycl.cpp
│ │ │ │ ├── cxx11_tensor_gpu.cu
│ │ │ │ ├── cxx11_tensor_ifft.cpp
│ │ │ │ ├── cxx11_tensor_image_op_sycl.cpp
│ │ │ │ ├── cxx11_tensor_image_patch.cpp
│ │ │ │ ├── cxx11_tensor_image_patch_sycl.cpp
│ │ │ │ ├── cxx11_tensor_index_list.cpp
│ │ │ │ ├── cxx11_tensor_inflation.cpp
│ │ │ │ ├── cxx11_tensor_inflation_sycl.cpp
│ │ │ │ ├── cxx11_tensor_intdiv.cpp
│ │ │ │ ├── cxx11_tensor_io.cpp
│ │ │ │ ├── cxx11_tensor_layout_swap.cpp
│ │ │ │ ├── cxx11_tensor_layout_swap_sycl.cpp
│ │ │ │ ├── cxx11_tensor_lvalue.cpp
│ │ │ │ ├── cxx11_tensor_map.cpp
│ │ │ │ ├── cxx11_tensor_math.cpp
│ │ │ │ ├── cxx11_tensor_math_sycl.cpp
│ │ │ │ ├── cxx11_tensor_mixed_indices.cpp
│ │ │ │ ├── cxx11_tensor_morphing.cpp
│ │ │ │ ├── cxx11_tensor_morphing_sycl.cpp
│ │ │ │ ├── cxx11_tensor_move.cpp
│ │ │ │ ├── cxx11_tensor_notification.cpp
│ │ │ │ ├── cxx11_tensor_of_complex.cpp
│ │ │ │ ├── cxx11_tensor_of_const_values.cpp
│ │ │ │ ├── cxx11_tensor_of_float16_gpu.cu
│ │ │ │ ├── cxx11_tensor_of_strings.cpp
│ │ │ │ ├── cxx11_tensor_padding.cpp
│ │ │ │ ├── cxx11_tensor_padding_sycl.cpp
│ │ │ │ ├── cxx11_tensor_patch.cpp
│ │ │ │ ├── cxx11_tensor_patch_sycl.cpp
│ │ │ │ ├── cxx11_tensor_random.cpp
│ │ │ │ ├── cxx11_tensor_random_gpu.cu
│ │ │ │ ├── cxx11_tensor_random_sycl.cpp
│ │ │ │ ├── cxx11_tensor_reduction.cpp
│ │ │ │ ├── cxx11_tensor_reduction_gpu.cu
│ │ │ │ ├── cxx11_tensor_reduction_sycl.cpp
│ │ │ │ ├── cxx11_tensor_ref.cpp
│ │ │ │ ├── cxx11_tensor_reverse.cpp
│ │ │ │ ├── cxx11_tensor_reverse_sycl.cpp
│ │ │ │ ├── cxx11_tensor_roundings.cpp
│ │ │ │ ├── cxx11_tensor_scan.cpp
│ │ │ │ ├── cxx11_tensor_scan_gpu.cu
│ │ │ │ ├── cxx11_tensor_scan_sycl.cpp
│ │ │ │ ├── cxx11_tensor_shuffling.cpp
│ │ │ │ ├── cxx11_tensor_shuffling_sycl.cpp
│ │ │ │ ├── cxx11_tensor_simple.cpp
│ │ │ │ ├── cxx11_tensor_striding.cpp
│ │ │ │ ├── cxx11_tensor_striding_sycl.cpp
│ │ │ │ ├── cxx11_tensor_sugar.cpp
│ │ │ │ ├── cxx11_tensor_sycl.cpp
│ │ │ │ ├── cxx11_tensor_symmetry.cpp
│ │ │ │ ├── cxx11_tensor_thread_local.cpp
│ │ │ │ ├── cxx11_tensor_thread_pool.cpp
│ │ │ │ ├── cxx11_tensor_trace.cpp
│ │ │ │ ├── cxx11_tensor_uint128.cpp
│ │ │ │ ├── cxx11_tensor_volume_patch.cpp
│ │ │ │ ├── cxx11_tensor_volume_patch_sycl.cpp
│ │ │ │ ├── dgmres.cpp
│ │ │ │ ├── forward_adolc.cpp
│ │ │ │ ├── gmres.cpp
│ │ │ │ ├── idrs.cpp
│ │ │ │ ├── kronecker_product.cpp
│ │ │ │ ├── levenberg_marquardt.cpp
│ │ │ │ ├── matrix_exponential.cpp
│ │ │ │ ├── matrix_function.cpp
│ │ │ │ ├── matrix_functions.h
│ │ │ │ ├── matrix_power.cpp
│ │ │ │ ├── matrix_square_root.cpp
│ │ │ │ ├── minres.cpp
│ │ │ │ ├── mpreal/
│ │ │ │ │ └── mpreal.h
│ │ │ │ ├── mpreal_support.cpp
│ │ │ │ ├── openglsupport.cpp
│ │ │ │ ├── polynomialsolver.cpp
│ │ │ │ ├── polynomialutils.cpp
│ │ │ │ ├── sparse_extra.cpp
│ │ │ │ ├── special_functions.cpp
│ │ │ │ ├── special_packetmath.cpp
│ │ │ │ └── splines.cpp
│ │ │ ├── examples/
│ │ │ │ ├── __init__.py
│ │ │ │ ├── core/
│ │ │ │ │ ├── data_readers/
│ │ │ │ │ │ ├── __init__.py
│ │ │ │ │ │ ├── augmentation.py
│ │ │ │ │ │ ├── base.py
│ │ │ │ │ │ ├── eth3d.py
│ │ │ │ │ │ ├── factory.py
│ │ │ │ │ │ ├── nyu2.py
│ │ │ │ │ │ ├── rgbd_utils.py
│ │ │ │ │ │ ├── scannet.py
│ │ │ │ │ │ ├── stream.py
│ │ │ │ │ │ ├── tartan.py
│ │ │ │ │ │ └── tum.py
│ │ │ │ │ ├── geom/
│ │ │ │ │ │ ├── __init__.py
│ │ │ │ │ │ ├── ba.py
│ │ │ │ │ │ ├── chol.py
│ │ │ │ │ │ ├── graph_utils.py
│ │ │ │ │ │ ├── losses.py
│ │ │ │ │ │ ├── projective_ops.py
│ │ │ │ │ │ └── sampler_utils.py
│ │ │ │ │ ├── logger.py
│ │ │ │ │ └── networks/
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ ├── modules/
│ │ │ │ │ │ ├── __init__.py
│ │ │ │ │ │ ├── clipping.py
│ │ │ │ │ │ ├── corr.py
│ │ │ │ │ │ ├── extractor.py
│ │ │ │ │ │ ├── gru.py
│ │ │ │ │ │ └── unet.py
│ │ │ │ │ ├── rslam.py
│ │ │ │ │ ├── sim3_net.py
│ │ │ │ │ └── slam_system.py
│ │ │ │ ├── pgo/
│ │ │ │ │ ├── main.py
│ │ │ │ │ └── readme.md
│ │ │ │ ├── readme.md
│ │ │ │ ├── registration/
│ │ │ │ │ ├── assets/
│ │ │ │ │ │ ├── depth1.npy
│ │ │ │ │ │ ├── depth2.npy
│ │ │ │ │ │ ├── depth3.npy
│ │ │ │ │ │ ├── depth4.npy
│ │ │ │ │ │ ├── renderoption.json
│ │ │ │ │ │ └── tartan_test.txt
│ │ │ │ │ ├── demo.py
│ │ │ │ │ ├── main.py
│ │ │ │ │ ├── readme.md
│ │ │ │ │ └── viz.py
│ │ │ │ └── rgbdslam/
│ │ │ │ ├── assets/
│ │ │ │ │ └── renderoption.json
│ │ │ │ ├── demo.py
│ │ │ │ ├── evaluate.py
│ │ │ │ ├── readme.md
│ │ │ │ ├── reprojection_test.py
│ │ │ │ ├── rgbd_benchmark/
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ ├── associate.py
│ │ │ │ │ ├── evaluate_ate.py
│ │ │ │ │ └── evaluate_rpe.py
│ │ │ │ ├── train.py
│ │ │ │ └── viz.py
│ │ │ ├── lietorch/
│ │ │ │ ├── __init__.py
│ │ │ │ ├── broadcasting.py
│ │ │ │ ├── extras/
│ │ │ │ │ ├── altcorr_kernel.cu
│ │ │ │ │ ├── corr_index_kernel.cu
│ │ │ │ │ ├── extras.cpp
│ │ │ │ │ ├── se3_builder.cu
│ │ │ │ │ ├── se3_inplace_builder.cu
│ │ │ │ │ └── se3_solver.cu
│ │ │ │ ├── gradcheck.py
│ │ │ │ ├── group_ops.py
│ │ │ │ ├── groups.py
│ │ │ │ ├── include/
│ │ │ │ │ ├── common.h
│ │ │ │ │ ├── dispatch.h
│ │ │ │ │ ├── lietorch_cpu.h
│ │ │ │ │ ├── lietorch_gpu.h
│ │ │ │ │ ├── rxso3.h
│ │ │ │ │ ├── se3.h
│ │ │ │ │ ├── sim3.h
│ │ │ │ │ └── so3.h
│ │ │ │ ├── run_tests.py
│ │ │ │ └── src/
│ │ │ │ ├── lietorch.cpp
│ │ │ │ ├── lietorch_cpu.cpp
│ │ │ │ └── lietorch_gpu.cu
│ │ │ ├── run_tests.sh
│ │ │ └── setup.py
│ │ └── tartanair_tools/
│ │ ├── LICENSE
│ │ ├── README.md
│ │ ├── TartanAir_Sample.ipynb
│ │ ├── data_type.md
│ │ ├── download_cvpr_slam_test.txt
│ │ ├── download_training.py
│ │ ├── download_training_zipfiles.txt
│ │ ├── evaluation/
│ │ │ ├── __init__.py
│ │ │ ├── evaluate_ate_scale.py
│ │ │ ├── evaluate_kitti.py
│ │ │ ├── evaluate_rpe.py
│ │ │ ├── evaluator_base.py
│ │ │ ├── pose_est.txt
│ │ │ ├── pose_gt.txt
│ │ │ ├── tartanair_evaluator.py
│ │ │ ├── trajectory_transform.py
│ │ │ └── transformation.py
│ │ └── seg_rgbs.txt
│ ├── tools/
│ │ ├── generate_demo.py
│ │ ├── vis.py
│ │ ├── vis_2.py
│ │ └── vis_ori.py
│ └── train.py
├── VPS_Module/
│ ├── .circleci/
│ │ └── config.yml
│ ├── .clang-format
│ ├── .flake8
│ ├── README.md
│ ├── configs/
│ │ ├── Base-RCNN-C4.yaml
│ │ ├── Base-RCNN-DilatedC5.yaml
│ │ ├── Base-RCNN-FPN.yaml
│ │ ├── Base-RetinaNet.yaml
│ │ ├── COCO-Detection/
│ │ │ ├── fast_rcnn_R_50_FPN_1x.yaml
│ │ │ ├── faster_rcnn_R_101_C4_3x.yaml
│ │ │ ├── faster_rcnn_R_101_DC5_3x.yaml
│ │ │ ├── faster_rcnn_R_101_FPN_3x.yaml
│ │ │ ├── faster_rcnn_R_50_C4_1x.yaml
│ │ │ ├── faster_rcnn_R_50_C4_3x.yaml
│ │ │ ├── faster_rcnn_R_50_DC5_1x.yaml
│ │ │ ├── faster_rcnn_R_50_DC5_3x.yaml
│ │ │ ├── faster_rcnn_R_50_FPN_1x.yaml
│ │ │ ├── faster_rcnn_R_50_FPN_3x.yaml
│ │ │ ├── faster_rcnn_X_101_32x8d_FPN_3x.yaml
│ │ │ ├── fcos_R_50_FPN_1x.py
│ │ │ ├── retinanet_R_101_FPN_3x.yaml
│ │ │ ├── retinanet_R_50_FPN_1x.py
│ │ │ ├── retinanet_R_50_FPN_1x.yaml
│ │ │ ├── retinanet_R_50_FPN_3x.yaml
│ │ │ ├── rpn_R_50_C4_1x.yaml
│ │ │ └── rpn_R_50_FPN_1x.yaml
│ │ ├── COCO-InstanceSegmentation/
│ │ │ ├── mask_rcnn_R_101_C4_3x.yaml
│ │ │ ├── mask_rcnn_R_101_DC5_3x.yaml
│ │ │ ├── mask_rcnn_R_101_FPN_3x.yaml
│ │ │ ├── mask_rcnn_R_50_C4_1x.py
│ │ │ ├── mask_rcnn_R_50_C4_1x.yaml
│ │ │ ├── mask_rcnn_R_50_C4_3x.yaml
│ │ │ ├── mask_rcnn_R_50_DC5_1x.yaml
│ │ │ ├── mask_rcnn_R_50_DC5_3x.yaml
│ │ │ ├── mask_rcnn_R_50_FPN_1x.py
│ │ │ ├── mask_rcnn_R_50_FPN_1x.yaml
│ │ │ ├── mask_rcnn_R_50_FPN_1x_giou.yaml
│ │ │ ├── mask_rcnn_R_50_FPN_3x.yaml
│ │ │ ├── mask_rcnn_X_101_32x8d_FPN_3x.yaml
│ │ │ ├── mask_rcnn_regnetx_4gf_dds_fpn_1x.py
│ │ │ └── mask_rcnn_regnety_4gf_dds_fpn_1x.py
│ │ ├── COCO-Keypoints/
│ │ │ ├── Base-Keypoint-RCNN-FPN.yaml
│ │ │ ├── keypoint_rcnn_R_101_FPN_3x.yaml
│ │ │ ├── keypoint_rcnn_R_50_FPN_1x.py
│ │ │ ├── keypoint_rcnn_R_50_FPN_1x.yaml
│ │ │ ├── keypoint_rcnn_R_50_FPN_3x.yaml
│ │ │ └── keypoint_rcnn_X_101_32x8d_FPN_3x.yaml
│ │ ├── COCO-PanopticSegmentation/
│ │ │ ├── Base-Panoptic-FPN.yaml
│ │ │ ├── panoptic_fpn_R_101_3x.yaml
│ │ │ ├── panoptic_fpn_R_50_1x.py
│ │ │ ├── panoptic_fpn_R_50_1x.yaml
│ │ │ ├── panoptic_fpn_R_50_3x.yaml
│ │ │ ├── panoptic_fpn_R_50_3x_vkitti_511.yaml
│ │ │ ├── panoptic_fpn_R_50_3x_vkitti_init_clone.yaml
│ │ │ └── panoptic_fpn_R_50_3x_vkitti_init_test.yaml
│ │ ├── Cityscapes/
│ │ │ └── mask_rcnn_R_50_FPN.yaml
│ │ ├── Detectron1-Comparisons/
│ │ │ ├── README.md
│ │ │ ├── faster_rcnn_R_50_FPN_noaug_1x.yaml
│ │ │ ├── keypoint_rcnn_R_50_FPN_1x.yaml
│ │ │ └── mask_rcnn_R_50_FPN_noaug_1x.yaml
│ │ ├── LVISv0.5-InstanceSegmentation/
│ │ │ ├── mask_rcnn_R_101_FPN_1x.yaml
│ │ │ ├── mask_rcnn_R_50_FPN_1x.yaml
│ │ │ └── mask_rcnn_X_101_32x8d_FPN_1x.yaml
│ │ ├── LVISv1-InstanceSegmentation/
│ │ │ ├── mask_rcnn_R_101_FPN_1x.yaml
│ │ │ ├── mask_rcnn_R_50_FPN_1x.yaml
│ │ │ └── mask_rcnn_X_101_32x8d_FPN_1x.yaml
│ │ ├── Misc/
│ │ │ ├── cascade_mask_rcnn_R_50_FPN_1x.yaml
│ │ │ ├── cascade_mask_rcnn_R_50_FPN_3x.yaml
│ │ │ ├── cascade_mask_rcnn_X_152_32x8d_FPN_IN5k_gn_dconv.yaml
│ │ │ ├── mask_rcnn_R_50_FPN_1x_cls_agnostic.yaml
│ │ │ ├── mask_rcnn_R_50_FPN_1x_dconv_c3-c5.yaml
│ │ │ ├── mask_rcnn_R_50_FPN_3x_dconv_c3-c5.yaml
│ │ │ ├── mask_rcnn_R_50_FPN_3x_gn.yaml
│ │ │ ├── mask_rcnn_R_50_FPN_3x_syncbn.yaml
│ │ │ ├── mmdet_mask_rcnn_R_50_FPN_1x.py
│ │ │ ├── panoptic_fpn_R_101_dconv_cascade_gn_3x.yaml
│ │ │ ├── scratch_mask_rcnn_R_50_FPN_3x_gn.yaml
│ │ │ ├── scratch_mask_rcnn_R_50_FPN_9x_gn.yaml
│ │ │ ├── scratch_mask_rcnn_R_50_FPN_9x_syncbn.yaml
│ │ │ ├── semantic_R_50_FPN_1x.yaml
│ │ │ └── torchvision_imagenet_R_50.py
│ │ ├── PascalVOC-Detection/
│ │ │ ├── faster_rcnn_R_50_C4.yaml
│ │ │ └── faster_rcnn_R_50_FPN.yaml
│ │ ├── common/
│ │ │ ├── README.md
│ │ │ ├── coco_schedule.py
│ │ │ ├── models/
│ │ │ │ ├── cascade_rcnn.py
│ │ │ │ ├── fcos.py
│ │ │ │ ├── keypoint_rcnn_fpn.py
│ │ │ │ ├── mask_rcnn_c4.py
│ │ │ │ ├── mask_rcnn_fpn.py
│ │ │ │ ├── panoptic_fpn.py
│ │ │ │ └── retinanet.py
│ │ │ ├── optim.py
│ │ │ └── train.py
│ │ ├── new_baselines/
│ │ │ ├── mask_rcnn_R_101_FPN_100ep_LSJ.py
│ │ │ ├── mask_rcnn_R_101_FPN_200ep_LSJ.py
│ │ │ ├── mask_rcnn_R_101_FPN_400ep_LSJ.py
│ │ │ ├── mask_rcnn_R_50_FPN_100ep_LSJ.py
│ │ │ ├── mask_rcnn_R_50_FPN_200ep_LSJ.py
│ │ │ ├── mask_rcnn_R_50_FPN_400ep_LSJ.py
│ │ │ ├── mask_rcnn_R_50_FPN_50ep_LSJ.py
│ │ │ ├── mask_rcnn_regnetx_4gf_dds_FPN_100ep_LSJ.py
│ │ │ ├── mask_rcnn_regnetx_4gf_dds_FPN_200ep_LSJ.py
│ │ │ ├── mask_rcnn_regnetx_4gf_dds_FPN_400ep_LSJ.py
│ │ │ ├── mask_rcnn_regnety_4gf_dds_FPN_100ep_LSJ.py
│ │ │ ├── mask_rcnn_regnety_4gf_dds_FPN_200ep_LSJ.py
│ │ │ └── mask_rcnn_regnety_4gf_dds_FPN_400ep_LSJ.py
│ │ └── quick_schedules/
│ │ ├── README.md
│ │ ├── cascade_mask_rcnn_R_50_FPN_inference_acc_test.yaml
│ │ ├── cascade_mask_rcnn_R_50_FPN_instant_test.yaml
│ │ ├── fast_rcnn_R_50_FPN_inference_acc_test.yaml
│ │ ├── fast_rcnn_R_50_FPN_instant_test.yaml
│ │ ├── keypoint_rcnn_R_50_FPN_inference_acc_test.yaml
│ │ ├── keypoint_rcnn_R_50_FPN_instant_test.yaml
│ │ ├── keypoint_rcnn_R_50_FPN_normalized_training_acc_test.yaml
│ │ ├── keypoint_rcnn_R_50_FPN_training_acc_test.yaml
│ │ ├── mask_rcnn_R_50_C4_GCV_instant_test.yaml
│ │ ├── mask_rcnn_R_50_C4_inference_acc_test.yaml
│ │ ├── mask_rcnn_R_50_C4_instant_test.yaml
│ │ ├── mask_rcnn_R_50_C4_training_acc_test.yaml
│ │ ├── mask_rcnn_R_50_DC5_inference_acc_test.yaml
│ │ ├── mask_rcnn_R_50_FPN_inference_acc_test.yaml
│ │ ├── mask_rcnn_R_50_FPN_instant_test.yaml
│ │ ├── mask_rcnn_R_50_FPN_pred_boxes_training_acc_test.yaml
│ │ ├── mask_rcnn_R_50_FPN_training_acc_test.yaml
│ │ ├── panoptic_fpn_R_50_inference_acc_test.yaml
│ │ ├── panoptic_fpn_R_50_instant_test.yaml
│ │ ├── panoptic_fpn_R_50_training_acc_test.yaml
│ │ ├── retinanet_R_50_FPN_inference_acc_test.yaml
│ │ ├── retinanet_R_50_FPN_instant_test.yaml
│ │ ├── rpn_R_50_FPN_inference_acc_test.yaml
│ │ ├── rpn_R_50_FPN_instant_test.yaml
│ │ ├── semantic_R_50_FPN_inference_acc_test.yaml
│ │ ├── semantic_R_50_FPN_instant_test.yaml
│ │ └── semantic_R_50_FPN_training_acc_test.yaml
│ ├── demo/
│ │ ├── README.md
│ │ ├── demo.py
│ │ └── predictor.py
│ ├── detectron2/
│ │ ├── __init__.py
│ │ ├── aot_modules/
│ │ │ ├── __init__.py
│ │ │ ├── aot_config.py
│ │ │ ├── decoders/
│ │ │ │ ├── __init__.py
│ │ │ │ └── fpn.py
│ │ │ ├── encoders/
│ │ │ │ ├── __init__.py
│ │ │ │ ├── mobilenetv2.py
│ │ │ │ ├── mobilenetv3.py
│ │ │ │ ├── resnest/
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ ├── resnest.py
│ │ │ │ │ ├── resnet.py
│ │ │ │ │ └── splat.py
│ │ │ │ ├── resnet.py
│ │ │ │ └── swin/
│ │ │ │ ├── __init__.py
│ │ │ │ ├── build.py
│ │ │ │ └── swin_transformer.py
│ │ │ ├── engines/
│ │ │ │ ├── __init__.py
│ │ │ │ └── aot_engine.py
│ │ │ ├── layers/
│ │ │ │ ├── __init__.py
│ │ │ │ ├── attention.py
│ │ │ │ ├── basic.py
│ │ │ │ ├── loss.py
│ │ │ │ ├── normalization.py
│ │ │ │ ├── position.py
│ │ │ │ └── transformer.py
│ │ │ ├── models/
│ │ │ │ ├── __init__.py
│ │ │ │ └── aot.py
│ │ │ └── utils/
│ │ │ ├── __init__.py
│ │ │ ├── checkpoint.py
│ │ │ ├── ema.py
│ │ │ ├── eval.py
│ │ │ ├── image.py
│ │ │ ├── learning.py
│ │ │ ├── math.py
│ │ │ ├── meters.py
│ │ │ └── metric.py
│ │ ├── checkpoint/
│ │ │ ├── __init__.py
│ │ │ ├── c2_model_loading.py
│ │ │ ├── catalog.py
│ │ │ └── detection_checkpoint.py
│ │ ├── config/
│ │ │ ├── __init__.py
│ │ │ ├── compat.py
│ │ │ ├── config.py
│ │ │ ├── defaults.py
│ │ │ ├── instantiate.py
│ │ │ └── lazy.py
│ │ ├── engine/
│ │ │ ├── __init__.py
│ │ │ ├── defaults.py
│ │ │ ├── hooks.py
│ │ │ ├── launch.py
│ │ │ └── train_loop.py
│ │ ├── evaluation/
│ │ │ ├── __init__.py
│ │ │ ├── cityscapes_evaluation.py
│ │ │ ├── coco_evaluation.py
│ │ │ ├── evaluator.py
│ │ │ ├── fast_eval_api.py
│ │ │ ├── lvis_evaluation.py
│ │ │ ├── panoptic_evaluation.py
│ │ │ ├── pascal_voc_evaluation.py
│ │ │ ├── pq_compute.py
│ │ │ ├── rotated_coco_evaluation.py
│ │ │ ├── sem_seg_evaluation.py
│ │ │ └── testing.py
│ │ ├── export/
│ │ │ ├── README.md
│ │ │ ├── __init__.py
│ │ │ ├── api.py
│ │ │ ├── c10.py
│ │ │ ├── caffe2_export.py
│ │ │ ├── caffe2_inference.py
│ │ │ ├── caffe2_modeling.py
│ │ │ ├── caffe2_patch.py
│ │ │ ├── flatten.py
│ │ │ ├── shared.py
│ │ │ ├── torchscript.py
│ │ │ └── torchscript_patch.py
│ │ ├── layers/
│ │ │ ├── __init__.py
│ │ │ ├── aspp.py
│ │ │ ├── batch_norm.py
│ │ │ ├── blocks.py
│ │ │ ├── csrc/
│ │ │ │ ├── README.md
│ │ │ │ ├── ROIAlignRotated/
│ │ │ │ │ ├── ROIAlignRotated.h
│ │ │ │ │ ├── ROIAlignRotated_cpu.cpp
│ │ │ │ │ └── ROIAlignRotated_cuda.cu
│ │ │ │ ├── box_iou_rotated/
│ │ │ │ │ ├── box_iou_rotated.h
│ │ │ │ │ ├── box_iou_rotated_cpu.cpp
│ │ │ │ │ ├── box_iou_rotated_cuda.cu
│ │ │ │ │ └── box_iou_rotated_utils.h
│ │ │ │ ├── cocoeval/
│ │ │ │ │ ├── cocoeval.cpp
│ │ │ │ │ └── cocoeval.h
│ │ │ │ ├── cuda_version.cu
│ │ │ │ ├── deformable/
│ │ │ │ │ ├── deform_conv.h
│ │ │ │ │ ├── deform_conv_cuda.cu
│ │ │ │ │ └── deform_conv_cuda_kernel.cu
│ │ │ │ ├── nms_rotated/
│ │ │ │ │ ├── nms_rotated.h
│ │ │ │ │ ├── nms_rotated_cpu.cpp
│ │ │ │ │ └── nms_rotated_cuda.cu
│ │ │ │ └── vision.cpp
│ │ │ ├── deform_conv.py
│ │ │ ├── losses.py
│ │ │ ├── mask_ops.py
│ │ │ ├── nms.py
│ │ │ ├── roi_align.py
│ │ │ ├── roi_align_rotated.py
│ │ │ ├── rotated_boxes.py
│ │ │ ├── shape_spec.py
│ │ │ └── wrappers.py
│ │ ├── model_zoo/
│ │ │ ├── __init__.py
│ │ │ ├── configs
│ │ │ └── model_zoo.py
│ │ ├── modeling/
│ │ │ ├── __init__.py
│ │ │ ├── anchor_generator.py
│ │ │ ├── backbone/
│ │ │ │ ├── __init__.py
│ │ │ │ ├── backbone.py
│ │ │ │ ├── build.py
│ │ │ │ ├── fpn.py
│ │ │ │ ├── regnet.py
│ │ │ │ └── resnet.py
│ │ │ ├── box_regression.py
│ │ │ ├── matcher.py
│ │ │ ├── meta_arch/
│ │ │ │ ├── __init__.py
│ │ │ │ ├── build.py
│ │ │ │ ├── dense_detector.py
│ │ │ │ ├── fcos.py
│ │ │ │ ├── panoptic_fpn.py
│ │ │ │ ├── panoptic_fpn_train.py
│ │ │ │ ├── rcnn.py
│ │ │ │ ├── retinanet.py
│ │ │ │ └── semantic_seg.py
│ │ │ ├── mmdet_wrapper.py
│ │ │ ├── poolers.py
│ │ │ ├── postprocessing.py
│ │ │ ├── proposal_generator/
│ │ │ │ ├── __init__.py
│ │ │ │ ├── build.py
│ │ │ │ ├── proposal_utils.py
│ │ │ │ ├── rpn.py
│ │ │ │ └── rrpn.py
│ │ │ ├── roi_heads/
│ │ │ │ ├── __init__.py
│ │ │ │ ├── box_head.py
│ │ │ │ ├── cascade_rcnn.py
│ │ │ │ ├── fast_rcnn.py
│ │ │ │ ├── keypoint_head.py
│ │ │ │ ├── mask_head.py
│ │ │ │ ├── roi_heads.py
│ │ │ │ └── rotated_fast_rcnn.py
│ │ │ ├── sampling.py
│ │ │ └── test_time_augmentation.py
│ │ ├── projects/
│ │ │ ├── README.md
│ │ │ └── __init__.py
│ │ ├── solver/
│ │ │ ├── __init__.py
│ │ │ ├── build.py
│ │ │ └── lr_scheduler.py
│ │ ├── structures/
│ │ │ ├── __init__.py
│ │ │ ├── boxes.py
│ │ │ ├── image_list.py
│ │ │ ├── instances.py
│ │ │ ├── keypoints.py
│ │ │ ├── masks.py
│ │ │ └── rotated_boxes.py
│ │ └── utils/
│ │ ├── README.md
│ │ ├── __init__.py
│ │ ├── analysis.py
│ │ ├── collect_env.py
│ │ ├── colormap.py
│ │ ├── comm.py
│ │ ├── env.py
│ │ ├── events.py
│ │ ├── file_io.py
│ │ ├── logger.py
│ │ ├── memory.py
│ │ ├── registry.py
│ │ ├── serialize.py
│ │ ├── testing.py
│ │ ├── video_visualizer.py
│ │ └── visualizer.py
│ ├── dev/
│ │ ├── README.md
│ │ ├── linter.sh
│ │ ├── packaging/
│ │ │ ├── README.md
│ │ │ ├── build_all_wheels.sh
│ │ │ ├── build_wheel.sh
│ │ │ ├── gen_install_table.py
│ │ │ ├── gen_wheel_index.sh
│ │ │ └── pkg_helpers.bash
│ │ ├── parse_results.sh
│ │ ├── run_inference_tests.sh
│ │ └── run_instant_tests.sh
│ ├── docker/
│ │ ├── Dockerfile
│ │ ├── README.md
│ │ ├── deploy.Dockerfile
│ │ └── docker-compose.yml
│ ├── docs/
│ │ ├── .gitignore
│ │ ├── Makefile
│ │ ├── README.md
│ │ ├── _static/
│ │ │ └── css/
│ │ │ └── custom.css
│ │ ├── conf.py
│ │ ├── index.rst
│ │ ├── modules/
│ │ │ ├── checkpoint.rst
│ │ │ ├── config.rst
│ │ │ ├── data.rst
│ │ │ ├── data_transforms.rst
│ │ │ ├── engine.rst
│ │ │ ├── evaluation.rst
│ │ │ ├── export.rst
│ │ │ ├── fvcore.rst
│ │ │ ├── index.rst
│ │ │ ├── layers.rst
│ │ │ ├── model_zoo.rst
│ │ │ ├── modeling.rst
│ │ │ ├── solver.rst
│ │ │ ├── structures.rst
│ │ │ └── utils.rst
│ │ ├── notes/
│ │ │ ├── benchmarks.md
│ │ │ ├── changelog.md
│ │ │ ├── compatibility.md
│ │ │ ├── contributing.md
│ │ │ └── index.rst
│ │ ├── requirements.txt
│ │ └── tutorials/
│ │ ├── README.md
│ │ ├── augmentation.md
│ │ ├── builtin_datasets.md
│ │ ├── configs.md
│ │ ├── data_loading.md
│ │ ├── datasets.md
│ │ ├── deployment.md
│ │ ├── evaluation.md
│ │ ├── extend.md
│ │ ├── getting_started.md
│ │ ├── index.rst
│ │ ├── install.md
│ │ ├── lazyconfigs.md
│ │ ├── models.md
│ │ ├── training.md
│ │ └── write-models.md
│ ├── projects/
│ │ ├── DeepLab/
│ │ │ ├── README.md
│ │ │ ├── configs/
│ │ │ │ └── Cityscapes-SemanticSegmentation/
│ │ │ │ ├── Base-DeepLabV3-OS16-Semantic.yaml
│ │ │ │ ├── deeplab_v3_R_103_os16_mg124_poly_90k_bs16.yaml
│ │ │ │ └── deeplab_v3_plus_R_103_os16_mg124_poly_90k_bs16.yaml
│ │ │ ├── deeplab/
│ │ │ │ ├── __init__.py
│ │ │ │ ├── build_solver.py
│ │ │ │ ├── config.py
│ │ │ │ ├── loss.py
│ │ │ │ ├── lr_scheduler.py
│ │ │ │ ├── resnet.py
│ │ │ │ └── semantic_seg.py
│ │ │ └── train_net.py
│ │ ├── DensePose/
│ │ │ ├── README.md
│ │ │ ├── apply_net.py
│ │ │ ├── configs/
│ │ │ │ ├── Base-DensePose-RCNN-FPN.yaml
│ │ │ │ ├── HRNet/
│ │ │ │ │ ├── densepose_rcnn_HRFPN_HRNet_w32_s1x.yaml
│ │ │ │ │ ├── densepose_rcnn_HRFPN_HRNet_w40_s1x.yaml
│ │ │ │ │ └── densepose_rcnn_HRFPN_HRNet_w48_s1x.yaml
│ │ │ │ ├── cse/
│ │ │ │ │ ├── Base-DensePose-RCNN-FPN-Human.yaml
│ │ │ │ │ ├── Base-DensePose-RCNN-FPN.yaml
│ │ │ │ │ ├── densepose_rcnn_R_101_FPN_DL_s1x.yaml
│ │ │ │ │ ├── densepose_rcnn_R_101_FPN_DL_soft_s1x.yaml
│ │ │ │ │ ├── densepose_rcnn_R_101_FPN_s1x.yaml
│ │ │ │ │ ├── densepose_rcnn_R_101_FPN_soft_s1x.yaml
│ │ │ │ │ ├── densepose_rcnn_R_50_FPN_DL_s1x.yaml
│ │ │ │ │ ├── densepose_rcnn_R_50_FPN_DL_soft_s1x.yaml
│ │ │ │ │ ├── densepose_rcnn_R_50_FPN_s1x.yaml
│ │ │ │ │ ├── densepose_rcnn_R_50_FPN_soft_animals_CA_finetune_16k.yaml
│ │ │ │ │ ├── densepose_rcnn_R_50_FPN_soft_animals_CA_finetune_4k.yaml
│ │ │ │ │ ├── densepose_rcnn_R_50_FPN_soft_animals_I0_finetune_16k.yaml
│ │ │ │ │ ├── densepose_rcnn_R_50_FPN_soft_animals_I0_finetune_i2m_16k.yaml
│ │ │ │ │ ├── densepose_rcnn_R_50_FPN_soft_animals_I0_finetune_m2m_16k.yaml
│ │ │ │ │ ├── densepose_rcnn_R_50_FPN_soft_animals_finetune_16k.yaml
│ │ │ │ │ ├── densepose_rcnn_R_50_FPN_soft_animals_finetune_4k.yaml
│ │ │ │ │ ├── densepose_rcnn_R_50_FPN_soft_animals_finetune_maskonly_24k.yaml
│ │ │ │ │ ├── densepose_rcnn_R_50_FPN_soft_chimps_finetune_4k.yaml
│ │ │ │ │ └── densepose_rcnn_R_50_FPN_soft_s1x.yaml
│ │ │ │ ├── densepose_rcnn_R_101_FPN_DL_WC1M_s1x.yaml
│ │ │ │ ├── densepose_rcnn_R_101_FPN_DL_WC1_s1x.yaml
│ │ │ │ ├── densepose_rcnn_R_101_FPN_DL_WC2M_s1x.yaml
│ │ │ │ ├── densepose_rcnn_R_101_FPN_DL_WC2_s1x.yaml
│ │ │ │ ├── densepose_rcnn_R_101_FPN_DL_s1x.yaml
│ │ │ │ ├── densepose_rcnn_R_101_FPN_WC1M_s1x.yaml
│ │ │ │ ├── densepose_rcnn_R_101_FPN_WC1_s1x.yaml
│ │ │ │ ├── densepose_rcnn_R_101_FPN_WC2M_s1x.yaml
│ │ │ │ ├── densepose_rcnn_R_101_FPN_WC2_s1x.yaml
│ │ │ │ ├── densepose_rcnn_R_101_FPN_s1x.yaml
│ │ │ │ ├── densepose_rcnn_R_101_FPN_s1x_legacy.yaml
│ │ │ │ ├── densepose_rcnn_R_50_FPN_DL_WC1M_s1x.yaml
│ │ │ │ ├── densepose_rcnn_R_50_FPN_DL_WC1_s1x.yaml
│ │ │ │ ├── densepose_rcnn_R_50_FPN_DL_WC2M_s1x.yaml
│ │ │ │ ├── densepose_rcnn_R_50_FPN_DL_WC2_s1x.yaml
│ │ │ │ ├── densepose_rcnn_R_50_FPN_DL_s1x.yaml
│ │ │ │ ├── densepose_rcnn_R_50_FPN_WC1M_s1x.yaml
│ │ │ │ ├── densepose_rcnn_R_50_FPN_WC1_s1x.yaml
│ │ │ │ ├── densepose_rcnn_R_50_FPN_WC2M_s1x.yaml
│ │ │ │ ├── densepose_rcnn_R_50_FPN_WC2_s1x.yaml
│ │ │ │ ├── densepose_rcnn_R_50_FPN_s1x.yaml
│ │ │ │ ├── densepose_rcnn_R_50_FPN_s1x_legacy.yaml
│ │ │ │ ├── evolution/
│ │ │ │ │ ├── Base-RCNN-FPN-Atop10P_CA.yaml
│ │ │ │ │ ├── densepose_R_50_FPN_DL_WC1M_3x_Atop10P_CA.yaml
│ │ │ │ │ ├── densepose_R_50_FPN_DL_WC1M_3x_Atop10P_CA_B_coarsesegm.yaml
│ │ │ │ │ ├── densepose_R_50_FPN_DL_WC1M_3x_Atop10P_CA_B_finesegm.yaml
│ │ │ │ │ ├── densepose_R_50_FPN_DL_WC1M_3x_Atop10P_CA_B_uniform.yaml
│ │ │ │ │ └── densepose_R_50_FPN_DL_WC1M_3x_Atop10P_CA_B_uv.yaml
│ │ │ │ └── quick_schedules/
│ │ │ │ ├── cse/
│ │ │ │ │ ├── densepose_rcnn_R_50_FPN_DL_instant_test.yaml
│ │ │ │ │ └── densepose_rcnn_R_50_FPN_soft_animals_finetune_instant_test.yaml
│ │ │ │ ├── densepose_rcnn_HRFPN_HRNet_w32_instant_test.yaml
│ │ │ │ ├── densepose_rcnn_R_50_FPN_DL_instant_test.yaml
│ │ │ │ ├── densepose_rcnn_R_50_FPN_TTA_inference_acc_test.yaml
│ │ │ │ ├── densepose_rcnn_R_50_FPN_WC1_instant_test.yaml
│ │ │ │ ├── densepose_rcnn_R_50_FPN_WC2_instant_test.yaml
│ │ │ │ ├── densepose_rcnn_R_50_FPN_inference_acc_test.yaml
│ │ │ │ ├── densepose_rcnn_R_50_FPN_instant_test.yaml
│ │ │ │ └── densepose_rcnn_R_50_FPN_training_acc_test.yaml
│ │ │ ├── densepose/
│ │ │ │ ├── __init__.py
│ │ │ │ ├── config.py
│ │ │ │ ├── converters/
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ ├── base.py
│ │ │ │ │ ├── builtin.py
│ │ │ │ │ ├── chart_output_hflip.py
│ │ │ │ │ ├── chart_output_to_chart_result.py
│ │ │ │ │ ├── hflip.py
│ │ │ │ │ ├── segm_to_mask.py
│ │ │ │ │ ├── to_chart_result.py
│ │ │ │ │ └── to_mask.py
│ │ │ │ ├── engine/
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ └── trainer.py
│ │ │ │ ├── evaluation/
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ ├── d2_evaluator_adapter.py
│ │ │ │ │ ├── densepose_coco_evaluation.py
│ │ │ │ │ ├── evaluator.py
│ │ │ │ │ ├── mesh_alignment_evaluator.py
│ │ │ │ │ └── tensor_storage.py
│ │ │ │ ├── modeling/
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ ├── build.py
│ │ │ │ │ ├── confidence.py
│ │ │ │ │ ├── cse/
│ │ │ │ │ │ ├── __init__.py
│ │ │ │ │ │ ├── embedder.py
│ │ │ │ │ │ ├── utils.py
│ │ │ │ │ │ ├── vertex_direct_embedder.py
│ │ │ │ │ │ └── vertex_feature_embedder.py
│ │ │ │ │ ├── densepose_checkpoint.py
│ │ │ │ │ ├── filter.py
│ │ │ │ │ ├── hrfpn.py
│ │ │ │ │ ├── hrnet.py
│ │ │ │ │ ├── inference.py
│ │ │ │ │ ├── losses/
│ │ │ │ │ │ ├── __init__.py
│ │ │ │ │ │ ├── chart.py
│ │ │ │ │ │ ├── chart_with_confidences.py
│ │ │ │ │ │ ├── cse.py
│ │ │ │ │ │ ├── cycle_pix2shape.py
│ │ │ │ │ │ ├── cycle_shape2shape.py
│ │ │ │ │ │ ├── embed.py
│ │ │ │ │ │ ├── embed_utils.py
│ │ │ │ │ │ ├── mask.py
│ │ │ │ │ │ ├── mask_or_segm.py
│ │ │ │ │ │ ├── registry.py
│ │ │ │ │ │ ├── segm.py
│ │ │ │ │ │ ├── soft_embed.py
│ │ │ │ │ │ └── utils.py
│ │ │ │ │ ├── predictors/
│ │ │ │ │ │ ├── __init__.py
│ │ │ │ │ │ ├── chart.py
│ │ │ │ │ │ ├── chart_confidence.py
│ │ │ │ │ │ ├── chart_with_confidence.py
│ │ │ │ │ │ ├── cse.py
│ │ │ │ │ │ ├── cse_confidence.py
│ │ │ │ │ │ ├── cse_with_confidence.py
│ │ │ │ │ │ └── registry.py
│ │ │ │ │ ├── roi_heads/
│ │ │ │ │ │ ├── __init__.py
│ │ │ │ │ │ ├── deeplab.py
│ │ │ │ │ │ ├── registry.py
│ │ │ │ │ │ ├── roi_head.py
│ │ │ │ │ │ └── v1convx.py
│ │ │ │ │ ├── test_time_augmentation.py
│ │ │ │ │ └── utils.py
│ │ │ │ ├── structures/
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ ├── chart.py
│ │ │ │ │ ├── chart_confidence.py
│ │ │ │ │ ├── chart_result.py
│ │ │ │ │ ├── cse.py
│ │ │ │ │ ├── cse_confidence.py
│ │ │ │ │ ├── data_relative.py
│ │ │ │ │ ├── list.py
│ │ │ │ │ ├── mesh.py
│ │ │ │ │ └── transform_data.py
│ │ │ │ ├── utils/
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ ├── dbhelper.py
│ │ │ │ │ ├── logger.py
│ │ │ │ │ └── transform.py
│ │ │ │ └── vis/
│ │ │ │ ├── __init__.py
│ │ │ │ ├── base.py
│ │ │ │ ├── bounding_box.py
│ │ │ │ ├── densepose_data_points.py
│ │ │ │ ├── densepose_outputs_iuv.py
│ │ │ │ ├── densepose_outputs_vertex.py
│ │ │ │ ├── densepose_results.py
│ │ │ │ ├── densepose_results_textures.py
│ │ │ │ └── extractor.py
│ │ │ ├── dev/
│ │ │ │ ├── README.md
│ │ │ │ ├── run_inference_tests.sh
│ │ │ │ └── run_instant_tests.sh
│ │ │ ├── doc/
│ │ │ │ ├── BOOTSTRAPPING_PIPELINE.md
│ │ │ │ ├── DENSEPOSE_CSE.md
│ │ │ │ ├── DENSEPOSE_DATASETS.md
│ │ │ │ ├── DENSEPOSE_IUV.md
│ │ │ │ ├── GETTING_STARTED.md
│ │ │ │ ├── RELEASE_2020_04.md
│ │ │ │ ├── RELEASE_2021_03.md
│ │ │ │ ├── RELEASE_2021_06.md
│ │ │ │ ├── TOOL_APPLY_NET.md
│ │ │ │ └── TOOL_QUERY_DB.md
│ │ │ ├── query_db.py
│ │ │ ├── setup.py
│ │ │ └── train_net.py
│ │ ├── Panoptic-DeepLab/
│ │ │ ├── README.md
│ │ │ ├── configs/
│ │ │ │ ├── COCO-PanopticSegmentation/
│ │ │ │ │ └── panoptic_deeplab_R_52_os16_mg124_poly_200k_bs64_crop_640_640_coco_dsconv.yaml
│ │ │ │ └── Cityscapes-PanopticSegmentation/
│ │ │ │ ├── Base-PanopticDeepLab-OS16.yaml
│ │ │ │ ├── panoptic_deeplab_R_52_os16_mg124_poly_90k_bs32_crop_512_1024.yaml
│ │ │ │ └── panoptic_deeplab_R_52_os16_mg124_poly_90k_bs32_crop_512_1024_dsconv.yaml
│ │ │ ├── panoptic_deeplab/
│ │ │ │ ├── __init__.py
│ │ │ │ ├── config.py
│ │ │ │ ├── dataset_mapper.py
│ │ │ │ ├── panoptic_seg.py
│ │ │ │ ├── post_processing.py
│ │ │ │ └── target_generator.py
│ │ │ └── train_net.py
│ │ ├── PointRend/
│ │ │ ├── README.md
│ │ │ ├── configs/
│ │ │ │ ├── InstanceSegmentation/
│ │ │ │ │ ├── Base-Implicit-PointRend.yaml
│ │ │ │ │ ├── Base-PointRend-RCNN-FPN.yaml
│ │ │ │ │ ├── implicit_pointrend_R_50_FPN_1x_coco.yaml
│ │ │ │ │ ├── implicit_pointrend_R_50_FPN_3x_coco.yaml
│ │ │ │ │ ├── pointrend_rcnn_R_101_FPN_3x_coco.yaml
│ │ │ │ │ ├── pointrend_rcnn_R_50_FPN_1x_cityscapes.yaml
│ │ │ │ │ ├── pointrend_rcnn_R_50_FPN_1x_coco.yaml
│ │ │ │ │ ├── pointrend_rcnn_R_50_FPN_3x_coco.yaml
│ │ │ │ │ └── pointrend_rcnn_X_101_32x8d_FPN_3x_coco.yaml
│ │ │ │ └── SemanticSegmentation/
│ │ │ │ ├── Base-PointRend-Semantic-FPN.yaml
│ │ │ │ └── pointrend_semantic_R_101_FPN_1x_cityscapes.yaml
│ │ │ ├── point_rend/
│ │ │ │ ├── __init__.py
│ │ │ │ ├── color_augmentation.py
│ │ │ │ ├── config.py
│ │ │ │ ├── mask_head.py
│ │ │ │ ├── point_features.py
│ │ │ │ ├── point_head.py
│ │ │ │ ├── roi_heads.py
│ │ │ │ └── semantic_seg.py
│ │ │ └── train_net.py
│ │ ├── PointSup/
│ │ │ ├── README.md
│ │ │ ├── configs/
│ │ │ │ ├── implicit_pointrend_R_50_FPN_3x_point_sup_point_aug_coco.yaml
│ │ │ │ ├── mask_rcnn_R_50_FPN_3x_point_sup_coco.yaml
│ │ │ │ └── mask_rcnn_R_50_FPN_3x_point_sup_point_aug_coco.yaml
│ │ │ ├── point_sup/
│ │ │ │ ├── __init__.py
│ │ │ │ ├── config.py
│ │ │ │ ├── dataset_mapper.py
│ │ │ │ ├── detection_utils.py
│ │ │ │ ├── mask_head.py
│ │ │ │ ├── point_utils.py
│ │ │ │ └── register_point_annotations.py
│ │ │ ├── tools/
│ │ │ │ └── prepare_coco_point_annotations_without_masks.py
│ │ │ └── train_net.py
│ │ ├── README.md
│ │ ├── Rethinking-BatchNorm/
│ │ │ ├── README.md
│ │ │ ├── configs/
│ │ │ │ ├── mask_rcnn_BNhead.py
│ │ │ │ ├── mask_rcnn_BNhead_batch_stats.py
│ │ │ │ ├── mask_rcnn_BNhead_shuffle.py
│ │ │ │ ├── mask_rcnn_SyncBNhead.py
│ │ │ │ ├── retinanet_SyncBNhead.py
│ │ │ │ └── retinanet_SyncBNhead_SharedTraining.py
│ │ │ └── retinanet-eval-domain-specific.py
│ │ ├── TensorMask/
│ │ │ ├── README.md
│ │ │ ├── configs/
│ │ │ │ ├── Base-TensorMask.yaml
│ │ │ │ ├── tensormask_R_50_FPN_1x.yaml
│ │ │ │ └── tensormask_R_50_FPN_6x.yaml
│ │ │ ├── setup.py
│ │ │ ├── tensormask/
│ │ │ │ ├── __init__.py
│ │ │ │ ├── arch.py
│ │ │ │ ├── config.py
│ │ │ │ └── layers/
│ │ │ │ ├── __init__.py
│ │ │ │ ├── csrc/
│ │ │ │ │ ├── SwapAlign2Nat/
│ │ │ │ │ │ ├── SwapAlign2Nat.h
│ │ │ │ │ │ └── SwapAlign2Nat_cuda.cu
│ │ │ │ │ └── vision.cpp
│ │ │ │ └── swap_align2nat.py
│ │ │ └── train_net.py
│ │ └── TridentNet/
│ │ ├── README.md
│ │ ├── configs/
│ │ │ ├── Base-TridentNet-Fast-C4.yaml
│ │ │ ├── tridentnet_fast_R_101_C4_3x.yaml
│ │ │ ├── tridentnet_fast_R_50_C4_1x.yaml
│ │ │ └── tridentnet_fast_R_50_C4_3x.yaml
│ │ ├── train_net.py
│ │ └── tridentnet/
│ │ ├── __init__.py
│ │ ├── config.py
│ │ ├── trident_backbone.py
│ │ ├── trident_conv.py
│ │ ├── trident_rcnn.py
│ │ └── trident_rpn.py
│ ├── setup.cfg
│ ├── setup.py
│ └── tools/
│ ├── 1_tracking.py
│ ├── 2_matching.py
│ ├── 3_preparing.py
│ ├── 4_eval_vpq.py
│ ├── README.md
│ ├── __init__.py
│ ├── analyze_model.py
│ ├── benchmark.py
│ ├── convert-torchvision-to-d2.py
│ ├── default.py
│ ├── deploy/
│ │ ├── CMakeLists.txt
│ │ ├── README.md
│ │ ├── export_model.py
│ │ └── torchscript_mask_rcnn.cpp
│ ├── lazyconfig_train_net.py
│ ├── lightning_train_net.py
│ ├── plain_train_net.py
│ ├── train_net.py
│ ├── visualize_data.py
│ └── visualize_json_results.py
├── prepare.md
└── tools/
├── initial_segmentation.sh
├── split_init_segm.py
├── test_vo_scene.sh
└── test_vps.sh
Showing preview only (1,631K chars total). Download the full file or copy to clipboard to get everything.
SYMBOL INDEX (17995 symbols across 2174 files)
FILE: VO_Module/demo.py
function show_image (line 20) | def show_image(image):
function image_stream (line 25) | def image_stream(imagedir, calib, stride):
FILE: VO_Module/droid_slam/data_readers/augmentation.py
class RGBDAugmentor (line 7) | class RGBDAugmentor:
method __init__ (line 10) | def __init__(self, crop_size):
method resize_sparse_flow_map (line 21) | def resize_sparse_flow_map(self, flow, valid, fx=1.0, fy=1.0):
method spatial_transform (line 57) | def spatial_transform(self, images, depths, poses, intrinsics,
method spatial_transform_only_pose (line 141) | def spatial_transform_only_pose(self, images, poses, intrinsics):
method color_transform (line 165) | def color_transform(self, images):
method __call__ (line 172) | def __call__(self, images, poses, depths, intrinsics,
FILE: VO_Module/droid_slam/data_readers/base.py
class RGBDDataset (line 26) | class RGBDDataset(data.Dataset):
method __init__ (line 27) | def __init__(self, name, datapath, n_frames=4, crop_size=[384, 512],
method _build_dataset_index (line 67) | def _build_dataset_index(self):
method image_read (line 84) | def image_read(image_file):
method depth_read (line 88) | def depth_read(depth_file):
method build_frame_graph (line 91) | def build_frame_graph(self, poses, depths, intrinsics, f=16, max_flow=...
method __getitem__ (line 114) | def __getitem__(self, index):
method __len__ (line 272) | def __len__(self):
method __imul__ (line 275) | def __imul__(self, x):
method build_motion_masks (line 279) | def build_motion_masks(self, poses, disps, intrinsics, fo_flows, ba_fl...
FILE: VO_Module/droid_slam/data_readers/factory.py
function dataset_factory (line 19) | def dataset_factory(dataset_list, **kwargs):
function create_datastream (line 38) | def create_datastream(dataset_path, **kwargs):
function create_imagestream (line 66) | def create_imagestream(dataset_path, **kwargs):
function create_stereostream (line 74) | def create_stereostream(dataset_path, **kwargs):
function create_rgbdstream (line 82) | def create_rgbdstream(dataset_path, **kwargs):
FILE: VO_Module/droid_slam/data_readers/replica.py
class Replica (line 18) | class Replica(RGBDDataset):
method __init__ (line 24) | def __init__(self, mode='training', **kwargs):
method is_test_scene (line 30) | def is_test_scene(scene):
method _build_dataset (line 34) | def _build_dataset(self):
method calib_read (line 60) | def calib_read():
method image_read (line 64) | def image_read(image_file):
method depth_read (line 68) | def depth_read(depth_file):
class ReplicaStream (line 75) | class ReplicaStream(RGBDStream):
method __init__ (line 76) | def __init__(self, datapath, **kwargs):
method _build_dataset_index (line 79) | def _build_dataset_index(self):
method calib_read (line 102) | def calib_read(datapath):
method image_read (line 106) | def image_read(image_file):
class ReplicaTestStream (line 110) | class ReplicaTestStream(RGBDStream):
method __init__ (line 111) | def __init__(self, datapath, **kwargs):
method _build_dataset_index (line 114) | def _build_dataset_index(self):
method calib_read (line 135) | def calib_read(datapath):
method image_read (line 139) | def image_read(image_file):
FILE: VO_Module/droid_slam/data_readers/replica_utils.py
function get_replica_cam_list (line 8) | def get_replica_cam_list(cam_list_dir, base_dir):
function quat_to_rmat (line 23) | def quat_to_rmat(quat):
function rmat_to_quad (line 38) | def rmat_to_quad(mat):
function get_trajectories_quad (line 44) | def get_trajectories_quad(cam_list, norm_val=1):
function get_trajectories_mat (line 56) | def get_trajectories_mat(cam_list, norm_val=1):
function build_track_pred_file (line 70) | def build_track_pred_file(gt_time_dir, pred_dir, trajectories, keyframe_...
function build_track_pred_file_notime (line 89) | def build_track_pred_file_notime(pred_dir, trajectories, keyframe_freq=1):
function build_timestamps (line 102) | def build_timestamps(file_dir, time_num, interval=0.05):
function build_depth_npy (line 111) | def build_depth_npy(root_dir, scene_dir, dep_scale):
FILE: VO_Module/droid_slam/data_readers/rgbd_utils.py
function parse_list (line 11) | def parse_list(filepath, skiprows=0):
function associate_frames (line 18) | def associate_frames(tstamp_image, tstamp_depth, tstamp_pose, max_dt=1.0):
function loadtum (line 38) | def loadtum(datapath, frame_rate=-1):
function all_pairs_distance_matrix (line 94) | def all_pairs_distance_matrix(poses, beta=2.5):
function pose_matrix_to_quaternion (line 104) | def pose_matrix_to_quaternion(pose):
function compute_distance_matrix_flow (line 110) | def compute_distance_matrix_flow(poses, disps, intrinsics, need_inv=True):
function compute_distance_matrix_flow2 (line 155) | def compute_distance_matrix_flow2(poses, disps, intrinsics, beta=0.4):
FILE: VO_Module/droid_slam/data_readers/stream.py
class RGBDStream (line 18) | class RGBDStream(data.Dataset):
method __init__ (line 19) | def __init__(self, datapath, frame_rate=-1, image_size=[384,512], crop...
method image_read (line 27) | def image_read(image_file):
method depth_read (line 31) | def depth_read(depth_file):
method __len__ (line 34) | def __len__(self):
method __getitem__ (line 37) | def __getitem__(self, index):
class ImageStream (line 75) | class ImageStream(data.Dataset):
method __init__ (line 76) | def __init__(self, datapath, intrinsics, rate=1, image_size=[384,512]):
method __len__ (line 93) | def __len__(self):
method image_read (line 97) | def image_read(imfile):
method __getitem__ (line 100) | def __getitem__(self, index):
class StereoStream (line 127) | class StereoStream(data.Dataset):
method __init__ (line 128) | def __init__(self, datapath, intrinsics, rate=1, image_size=[384,512],
method __len__ (line 150) | def __len__(self):
method image_read (line 154) | def image_read(imfile, imap=None):
method __getitem__ (line 160) | def __getitem__(self, index):
FILE: VO_Module/droid_slam/data_readers/tartan.py
class TartanAir (line 18) | class TartanAir(RGBDDataset):
method __init__ (line 23) | def __init__(self, mode='training', **kwargs):
method is_test_scene (line 29) | def is_test_scene(scene):
method _build_dataset (line 33) | def _build_dataset(self):
method calib_read (line 64) | def calib_read():
method image_read (line 68) | def image_read(image_file):
method depth_read (line 72) | def depth_read(depth_file):
method dymask_read (line 79) | def dymask_read(mask_file):
class TartanAirStream (line 85) | class TartanAirStream(RGBDStream):
method __init__ (line 86) | def __init__(self, datapath, **kwargs):
method _build_dataset_index (line 89) | def _build_dataset_index(self):
method calib_read (line 112) | def calib_read(datapath):
method image_read (line 116) | def image_read(image_file):
class TartanAirTestStream (line 120) | class TartanAirTestStream(RGBDStream):
method __init__ (line 121) | def __init__(self, datapath, **kwargs):
method _build_dataset_index (line 124) | def _build_dataset_index(self):
method calib_read (line 146) | def calib_read(datapath):
method image_read (line 150) | def image_read(image_file):
FILE: VO_Module/droid_slam/data_readers/vkitti2.py
function rmat_to_quad (line 18) | def rmat_to_quad(mat):
class VKitti2 (line 23) | class VKitti2(RGBDDataset):
method __init__ (line 34) | def __init__(self, split_mode='train', foo=False, scene_id='Scene01', ...
method is_test_scene (line 42) | def is_test_scene(self, scene):
method _build_dataset (line 45) | def _build_dataset(self):
method calib_read (line 107) | def calib_read():
method image_read (line 111) | def image_read(image_file):
method depth_read (line 115) | def depth_read(depth_file):
method flow_read (line 124) | def flow_read(flow_file):
method dymask_read (line 134) | def dymask_read(mask_file):
method segment_read (line 139) | def segment_read(segment_file):
class VKitti2Stream (line 144) | class VKitti2Stream(RGBDStream):
method __init__ (line 145) | def __init__(self, datapath, **kwargs):
method _build_dataset_index (line 148) | def _build_dataset_index(self):
method calib_read (line 171) | def calib_read(datapath):
method image_read (line 175) | def image_read(image_file):
class VKitti2TestStream (line 179) | class VKitti2TestStream(RGBDStream):
method __init__ (line 180) | def __init__(self, datapath, **kwargs):
method _build_dataset_index (line 183) | def _build_dataset_index(self):
method calib_read (line 205) | def calib_read(datapath):
method image_read (line 209) | def image_read(image_file):
FILE: VO_Module/droid_slam/depth_video.py
class DepthVideo (line 13) | class DepthVideo:
method __init__ (line 14) | def __init__(self, image_size=[480, 640], buffer=1024, device="cuda:0"...
method get_lock (line 61) | def get_lock(self):
method __item_setter (line 64) | def __item_setter(self, index, item):
method __setitem__ (line 96) | def __setitem__(self, index, item):
method __getitem__ (line 100) | def __getitem__(self, index):
method append (line 118) | def append(self, *item):
method format_indicies (line 125) | def format_indicies(ii, jj, device):
method upsample (line 139) | def upsample(self, ix, mask):
method normalize (line 145) | def normalize(self):
method reproject (line 154) | def reproject(self, ii, jj):
method distance (line 165) | def distance(self, ii=None, jj=None, beta=0.3, bidirectional=True):
method ba (line 197) | def ba(self, target, weight, eta, ii, jj, t0=1, t1=None, itrs=2, lm=1e...
FILE: VO_Module/droid_slam/droid.py
class Droid (line 20) | class Droid:
method __init__ (line 21) | def __init__(self, args):
method load_weights (line 52) | def load_weights(self, weights, use_aff_bri=False):
method track (line 61) | def track(self, tstamp, image, depth=None, intrinsics=None, segments=N...
method terminate (line 74) | def terminate(self, stream=None, need_inv=True):
method get_traj (line 94) | def get_traj(self):
method get_depth (line 98) | def get_depth(self):
method get_flow (line 102) | def get_flow(self):
function upsample_inter (line 106) | def upsample_inter(mask):
FILE: VO_Module/droid_slam/droid_backend.py
class DroidBackend (line 9) | class DroidBackend:
method __init__ (line 10) | def __init__(self, net, video, args):
method __call__ (line 25) | def __call__(self, steps=12):
FILE: VO_Module/droid_slam/droid_frontend.py
class DroidFrontend (line 9) | class DroidFrontend:
method __init__ (line 10) | def __init__(self, net, video, args):
method __update (line 36) | def __update(self):
method __initialize (line 72) | def __initialize(self):
method __call__ (line 103) | def __call__(self):
FILE: VO_Module/droid_slam/droid_net.py
function cvx_upsample (line 23) | def cvx_upsample(data, mask):
function upsample_dim_1 (line 40) | def upsample_dim_1(disp, mask):
function upsample_dim_x (line 47) | def upsample_dim_x(flow, mask):
function upsample_inter (line 54) | def upsample_inter(mask):
class GraphAgg (line 64) | class GraphAgg(nn.Module):
method __init__ (line 65) | def __init__(self):
method forward (line 79) | def forward(self, net, ii):
class UpdateModule (line 98) | class UpdateModule(nn.Module):
method __init__ (line 99) | def __init__(self):
method forward (line 131) | def forward(self, net, inp, corr, flow=None, ii=None, jj=None):
class DynamicUpdateModule (line 166) | class DynamicUpdateModule(nn.Module):
method __init__ (line 167) | def __init__(self, use_aff_bri=False):
method do_filter (line 227) | def do_filter(self, lay, weight, delta_dy, delta_m, segments):
method forward (line 256) | def forward(self, net, inp, corr, flow=None,
class DroidNet (line 317) | class DroidNet(nn.Module):
method __init__ (line 318) | def __init__(self, use_aff_bri=False):
method extract_features (line 325) | def extract_features(self, images):
method forward (line 342) | def forward(self, Gs, images, disps, intrinsics, graph=None, num_steps...
FILE: VO_Module/droid_slam/factor_graph.py
class FactorGraph (line 12) | class FactorGraph:
method __init__ (line 13) | def __init__(self, video, update_op, device="cuda:0", corr_impl="volum...
method __filter_repeated_edges (line 65) | def __filter_repeated_edges(self, ii, jj):
method print_edges (line 78) | def print_edges(self):
method filter_edges (line 92) | def filter_edges(self):
method clear_edges (line 101) | def clear_edges(self):
method add_factors (line 107) | def add_factors(self, ii, jj, remove=False):
method rm_factors (line 164) | def rm_factors(self, mask, store=False):
method rm_keyframe (line 202) | def rm_keyframe(self, ix):
method update (line 228) | def update(self, t0=None, t1=None, itrs=2, use_inactive=False, EP=1e-7...
method update_lowmem (line 310) | def update_lowmem(self, t0=None, t1=None, itrs=2, use_inactive=False, ...
method add_neighborhood_factors (line 362) | def add_neighborhood_factors(self, t0, t1, r=3):
method add_proximity_factors (line 372) | def add_proximity_factors(self, t0=0, t1=0, rad=2, nms=2, beta=0.25, t...
function upsample_inter (line 431) | def upsample_inter(mask):
FILE: VO_Module/droid_slam/geom/ba.py
function safe_scatter_add_mat (line 12) | def safe_scatter_add_mat(A, ii, jj, n, m):
function safe_scatter_add_vec (line 16) | def safe_scatter_add_vec(b, ii, n):
function disp_retr (line 21) | def disp_retr(disps, dz, ii):
function pose_retr (line 26) | def pose_retr(poses, dx, ii):
function BA (line 31) | def BA(target, weight, eta, poses, disps, intrinsics, ii, jj, fixedp=1, ...
function MoBA (line 109) | def MoBA(target, weight, eta, poses, disps, intrinsics, ii, jj, fixedp=1...
FILE: VO_Module/droid_slam/geom/chol.py
class CholeskySolver (line 5) | class CholeskySolver(torch.autograd.Function):
method forward (line 7) | def forward(ctx, H, b):
method backward (line 22) | def backward(ctx, grad_x):
function block_solve (line 32) | def block_solve(H, b, ep=0.1, lm=0.0001):
function schur_solve (line 46) | def schur_solve(H, E, C, v, w, ep=0.1, lm=0.0001, sless=False):
FILE: VO_Module/droid_slam/geom/graph_utils.py
function graph_to_edge_list (line 10) | def graph_to_edge_list(graph):
function keyframe_indicies (line 23) | def keyframe_indicies(graph):
function meshgrid (line 26) | def meshgrid(m, n, device='cuda'):
function neighbourhood_graph (line 30) | def neighbourhood_graph(n, r):
function build_frame_graph (line 37) | def build_frame_graph(poses, disps, intrinsics, num=16, thresh=24.0, r=2...
function build_frame_graph_v2 (line 72) | def build_frame_graph_v2(poses, disps, intrinsics, num=16, thresh=24.0, ...
FILE: VO_Module/droid_slam/geom/losses.py
function pose_metrics (line 11) | def pose_metrics(dE):
function fit_scale (line 23) | def fit_scale(Ps, Gs):
function geodesic_loss (line 32) | def geodesic_loss(Ps, Gs, graph, gamma=0.9, do_scale=True):
function residual_loss (line 79) | def residual_loss(residuals, gamma=0.9):
function cam_flow_loss (line 91) | def cam_flow_loss(Ps, disps, poses_est, disps_est, intrinsics, graph, ga...
function flow_loss (line 124) | def flow_loss(fo_flows, ba_flows, full_flows, graph, gamma=0.9):
function photo_loss (line 151) | def photo_loss(images, full_flows, vals, graph, mode, gamma=0.9, ssim=None,
function photo_loss_cam (line 214) | def photo_loss_cam(images, poses_est, disps_est, intrinsics,
function unsup_occ_vals (line 268) | def unsup_occ_vals(poses_est, disps_est, intrinsics,
function unsup_dy_vals (line 323) | def unsup_dy_vals(vals, dy_masks, graph):
function compute_reprojection_loss (line 348) | def compute_reprojection_loss(pred, target, ssim):
class SSIM (line 365) | class SSIM(nn.Module):
method __init__ (line 369) | def __init__(self):
method forward (line 382) | def forward(self, x, y):
function mean_on_mask (line 400) | def mean_on_mask(diff, val_pix):
function ce_reg_loss (line 410) | def ce_reg_loss(preds, gamma=0.9):
function unsup_art_label (line 429) | def unsup_art_label(poses_est, disps_est, intrinsics, full_flows, graph,...
function upsample_inter (line 463) | def upsample_inter(mask):
function art_label_loss (line 473) | def art_label_loss(art_masks, masks, gamma=0.9, downsample=True):
function gt_label_loss (line 505) | def gt_label_loss(gt_masks, gt_vals, masks, graph, gamma=0.9, mean_mask=...
function ce_func (line 535) | def ce_func(labels, inputs):
function consistency_loss (line 541) | def consistency_loss(masks, n_frames, graph, gamma=0.9):
FILE: VO_Module/droid_slam/geom/projective_ops.py
function extract_intrinsics (line 9) | def extract_intrinsics(intrinsics):
function coords_grid (line 13) | def coords_grid(ht, wd, **kwargs):
function iproj (line 21) | def iproj(disps, intrinsics, jacobian=False):
function proj (line 43) | def proj(Xs, intrinsics, jacobian=False, return_depth=False):
function actp (line 72) | def actp(Gij, X0, jacobian=False):
function projective_transform (line 102) | def projective_transform(poses, depths, intrinsics, ii, jj, jacobian=Fal...
function projective_transform_unsup (line 133) | def projective_transform_unsup(poses, depths, intrinsics, ii, jj, jacobi...
function induced_flow (line 166) | def induced_flow(poses, disps, intrinsics, ii, jj):
function coords_clamp (line 181) | def coords_clamp(coords, h_max, w_max, h_min=0, w_min=0):
function coords_valid (line 187) | def coords_valid(coords, h_max, w_max, h_min=0, w_min=0, neg_fac=0.1):
FILE: VO_Module/droid_slam/logger.py
class Logger (line 8) | class Logger:
method __init__ (line 9) | def __init__(self, name, scheduler):
method _print_training_status (line 16) | def _print_training_status(self):
method push (line 34) | def push(self, metrics):
method write_dict (line 48) | def write_dict(self, results):
method close (line 52) | def close(self):
FILE: VO_Module/droid_slam/modules/clipping.py
class GradClip (line 7) | class GradClip(torch.autograd.Function):
method forward (line 9) | def forward(ctx, x):
method backward (line 13) | def backward(ctx, grad_x):
class GradientClip (line 19) | class GradientClip(nn.Module):
method __init__ (line 20) | def __init__(self):
method forward (line 23) | def forward(self, x):
FILE: VO_Module/droid_slam/modules/corr.py
class CorrSampler (line 6) | class CorrSampler(torch.autograd.Function):
method forward (line 9) | def forward(ctx, volume, coords, radius):
method backward (line 16) | def backward(ctx, grad_output):
class CorrBlock (line 23) | class CorrBlock:
method __init__ (line 24) | def __init__(self, fmap1, fmap2, num_levels=4, radius=3):
method __call__ (line 40) | def __call__(self, coords):
method cat (line 52) | def cat(self, other):
method __getitem__ (line 57) | def __getitem__(self, index):
method corr (line 64) | def corr(fmap1, fmap2):
class CorrLayer (line 74) | class CorrLayer(torch.autograd.Function):
method forward (line 76) | def forward(ctx, fmap1, fmap2, coords, r):
method backward (line 83) | def backward(ctx, grad_corr):
class AltCorrBlock (line 91) | class AltCorrBlock:
method __init__ (line 92) | def __init__(self, fmaps, num_levels=4, radius=3):
method corr_fn (line 106) | def corr_fn(self, coords, ii, jj):
method __call__ (line 128) | def __call__(self, coords, ii, jj):
FILE: VO_Module/droid_slam/modules/extractor.py
class ResidualBlock (line 6) | class ResidualBlock(nn.Module):
method __init__ (line 7) | def __init__(self, in_planes, planes, norm_fn='group', stride=1):
method forward (line 47) | def forward(self, x):
class BottleneckBlock (line 58) | class BottleneckBlock(nn.Module):
method __init__ (line 59) | def __init__(self, in_planes, planes, norm_fn='group', stride=1):
method forward (line 104) | def forward(self, x):
class BasicEncoder (line 118) | class BasicEncoder(nn.Module):
method __init__ (line 119) | def __init__(self, output_dim=128, norm_fn='batch', dropout=0.0, multi...
method _make_layer (line 175) | def _make_layer(self, dim, stride=1):
method forward (line 183) | def forward(self, x):
FILE: VO_Module/droid_slam/modules/gru.py
class ConvGRU (line 5) | class ConvGRU(nn.Module):
method __init__ (line 6) | def __init__(self, h_planes=128, i_planes=128):
method forward (line 19) | def forward(self, net, *inputs):
FILE: VO_Module/droid_slam/motion_filter.py
class MotionFilter (line 12) | class MotionFilter:
method __init__ (line 15) | def __init__(self, net, video, thresh=2.5, device="cuda:0"):
method __context_encoder (line 35) | def __context_encoder(self, image):
method __feature_encoder (line 42) | def __feature_encoder(self, image):
method track (line 48) | def track(self, tstamp, image, depth=None, intrinsics=None, segments=N...
method track_vo (line 91) | def track_vo(self, tstamp, image, depth=None, intrinsics=None, segment...
FILE: VO_Module/droid_slam/trajectory_filler.py
class PoseTrajectoryFiller (line 12) | class PoseTrajectoryFiller:
method __init__ (line 15) | def __init__(self, net, video, device="cuda:0"):
method __feature_encoder (line 31) | def __feature_encoder(self, image):
method __fill (line 35) | def __fill(self, tstamps, images, intrinsics):
method __call__ (line 80) | def __call__(self, image_stream):
FILE: VO_Module/droid_slam/visualization.py
function white_balance (line 26) | def white_balance(img):
function create_camera_actor (line 36) | def create_camera_actor(g, scale=0.05):
function create_point_actor (line 46) | def create_point_actor(points, colors):
function droid_visualization (line 53) | def droid_visualization(video, device="cuda:0"):
FILE: VO_Module/evaluation_scripts/flow_vis_utils.py
function make_colorwheel (line 20) | def make_colorwheel():
function flow_uv_to_colors (line 68) | def flow_uv_to_colors(u, v, convert_to_bgr=False):
function flow_to_image (line 104) | def flow_to_image(flow_uv, clip_flow=None, convert_to_bgr=False):
function writeFlow (line 128) | def writeFlow(filename,uv,v=None):
FILE: VO_Module/evaluation_scripts/test_vo.py
function image_stream (line 19) | def image_stream(datapath, image_size=[240, 808], mode='train', args=Non...
function init (line 58) | def init():
function read_vkitti2_poses_file (line 121) | def read_vkitti2_poses_file(file_path, args) -> PosePath3D:
FILE: VO_Module/evaluation_scripts/test_vo2.py
function resize (line 23) | def resize(mask, size, need_permute):
function init (line 41) | def init():
FILE: VO_Module/src/droid.cpp
function ba (line 87) | std::vector<torch::Tensor> ba(
function frame_distance (line 117) | torch::Tensor frame_distance(
function projmap (line 136) | std::vector<torch::Tensor> projmap(
function iproj (line 154) | torch::Tensor iproj(
function corr_index_forward (line 167) | std::vector<torch::Tensor> corr_index_forward(
function corr_index_backward (line 177) | std::vector<torch::Tensor> corr_index_backward(
function altcorr_forward (line 190) | std::vector<torch::Tensor> altcorr_forward(
function altcorr_backward (line 202) | std::vector<torch::Tensor> altcorr_backward(
function depth_filter (line 217) | torch::Tensor depth_filter(
function PYBIND11_MODULE (line 234) | PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) {
FILE: VO_Module/thirdparty/eigen/Eigen/src/Cholesky/LDLT.h
function namespace (line 16) | namespace Eigen {
type SolverBase (line 64) | typedef SolverBase<LDLT> Base;
function enum (line 67) | EIGEN_GENERIC_PUBLIC_INTERFACE(LDLT)
type Matrix (line 73) | typedef Matrix<Scalar, RowsAtCompileTime, 1, 0, MaxRowsAtCompileTime, 1>...
type Transpositions (line 75) | typedef Transpositions<RowsAtCompileTime, MaxRowsAtCompileTime> Transpos...
type PermutationMatrix (line 76) | typedef PermutationMatrix<RowsAtCompileTime, MaxRowsAtCompileTime> Permu...
type internal (line 78) | typedef internal::LDLT_Traits<MatrixType,UpLo> Traits;
function setZero (line 143) | void setZero()
function typename (line 149) | inline typename Traits::MatrixU matrixU() const
function isNegative (line 185) | inline bool isNegative(void) const
function MatrixType (line 234) | inline const MatrixType& matrixLDLT() const
function namespace (line 293) | namespace internal {
function Upper (line 460) | struct ldlt_inplace<Upper>
type TriangularView (line 480) | typedef const TriangularView<const typename
function MatrixL (line 481) | static inline MatrixL getL(const MatrixType& m) { return MatrixL(m); }
function MatrixU (line 482) | static inline MatrixU getU(const MatrixType& m) { return MatrixU(m.adjoi...
type TriangularView (line 488) | typedef const TriangularView<const MatrixType, UnitUpper> MatrixU;
function MatrixL (line 489) | static inline MatrixL getL(const MatrixType& m) { return MatrixL(m.adjoi...
function MatrixU (line 490) | static inline MatrixU getU(const MatrixType& m) { return MatrixU(m); }
type typename (line 541) | typedef typename TranspositionType::StorageIndex IndexType;
FILE: VO_Module/thirdparty/eigen/Eigen/src/Cholesky/LLT.h
function namespace (line 13) | namespace Eigen {
type SolverBase (line 71) | typedef SolverBase<LLT> Base;
function enum (line 74) | EIGEN_GENERIC_PUBLIC_INTERFACE(LLT)
type internal (line 85) | typedef internal::LLT_Traits<MatrixType,UpLo> Traits;
function explicit (line 101) | explicit LLT(Index size) : m_matrix(size, size),
function typename (line 128) | inline typename Traits::MatrixU matrixU() const
function MatrixType (line 177) | inline const MatrixType& matrixLLT() const
function namespace (line 235) | namespace internal {
type typename (line 379) | typedef typename NumTraits<Scalar>::Real RealScalar;
type TriangularView (line 404) | typedef const TriangularView<const typename
function MatrixL (line 405) | static inline MatrixL getL(const MatrixType& m) { return MatrixL(m); }
function MatrixU (line 406) | static inline MatrixU getU(const MatrixType& m) { return MatrixU(m.adjoi...
function inplace_decomposition (line 407) | static bool inplace_decomposition(MatrixType& m)
type TriangularView (line 414) | typedef const TriangularView<const MatrixType, Upper> MatrixU;
function MatrixL (line 415) | static inline MatrixL getL(const MatrixType& m) { return MatrixL(m.adjoi...
function MatrixU (line 416) | static inline MatrixU getU(const MatrixType& m) { return MatrixU(m); }
function inplace_decomposition (line 417) | static bool inplace_decomposition(MatrixType& m)
FILE: VO_Module/thirdparty/eigen/Eigen/src/Cholesky/LLT_LAPACKE.h
function namespace (line 36) | namespace Eigen {
FILE: VO_Module/thirdparty/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 140) | typedef typename Derived::Scalar Scalar;
function namespace (line 165) | namespace internal {
type CholmodMode (line 203) | enum CholmodMode {
type typename (line 223) | typedef typename MatrixType::Scalar Scalar;
type typename (line 224) | typedef typename MatrixType::RealScalar RealScalar;
type MatrixType (line 225) | typedef MatrixType CholMatrixType;
type typename (line 226) | typedef typename MatrixType::StorageIndex StorageIndex;
function StorageIndex (line 258) | inline StorageIndex cols() const { return internal::convert_index<Storag...
function analyzePattern (line 286) | void analyzePattern(const MatrixType& matrix)
function factorize (line 308) | void factorize(const MatrixType& matrix)
function Scalar (line 391) | Scalar determinant() const
function Base (line 488) | CholmodSimplicialLLT(const MatrixType& matrix) : Base()
function Base (line 539) | CholmodSimplicialLDLT(const MatrixType& matrix) : Base()
function Base (line 588) | CholmodSupernodalLLT(const MatrixType& matrix) : Base()
function Base (line 639) | CholmodDecomposition(const MatrixType& matrix) : Base()
function setMode (line 647) | void setMode(CholmodMode mode)
FILE: VO_Module/thirdparty/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: VO_Module/thirdparty/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 352) | namespace internal {
FILE: VO_Module/thirdparty/eigen/Eigen/src/Eigenvalues/ComplexSchur_LAPACKE.h
function namespace (line 36) | namespace Eigen {
FILE: VO_Module/thirdparty/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: VO_Module/thirdparty/eigen/Eigen/src/Eigenvalues/GeneralizedEigenSolver.h
function namespace (line 17) | namespace Eigen {
FILE: VO_Module/thirdparty/eigen/Eigen/src/Eigenvalues/GeneralizedSelfAdjointEigenSolver.h
function namespace (line 16) | namespace Eigen {
FILE: VO_Module/thirdparty/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: VO_Module/thirdparty/eigen/Eigen/src/Eigenvalues/MatrixBaseEigenvalues.h
function namespace (line 14) | namespace Eigen {
FILE: VO_Module/thirdparty/eigen/Eigen/src/Eigenvalues/RealQZ.h
function namespace (line 13) | namespace Eigen {
function MatrixType (line 142) | const MatrixType& matrixS() const {
type Matrix (line 203) | typedef Matrix<Scalar,3,1> Vector3s;
type Matrix (line 204) | typedef Matrix<Scalar,2,1> Vector2s;
type Matrix (line 205) | typedef Matrix<Scalar,2,2> Matrix2s;
type JacobiRotation (line 206) | typedef JacobiRotation<Scalar> JRs;
FILE: VO_Module/thirdparty/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 362) | typename MatrixType::Scalar RealSchur<MatrixType>::computeNormOfT()
FILE: VO_Module/thirdparty/eigen/Eigen/src/Eigenvalues/RealSchur_LAPACKE.h
function namespace (line 36) | namespace Eigen {
FILE: VO_Module/thirdparty/eigen/Eigen/src/Eigenvalues/SelfAdjointEigenSolver.h
function namespace (line 16) | namespace Eigen {
function namespace (line 390) | namespace internal {
function namespace (line 490) | namespace internal {
type typename (line 744) | typedef typename SolverType::RealVectorType VectorType;
type typename (line 745) | typedef typename SolverType::Scalar Scalar;
type typename (line 746) | typedef typename SolverType::EigenvectorsType EigenvectorsType;
function EIGEN_DEVICE_FUNC (line 748) | EIGEN_DEVICE_FUNC
function namespace (line 834) | namespace internal {
FILE: VO_Module/thirdparty/eigen/Eigen/src/Eigenvalues/SelfAdjointEigenSolver_LAPACKE.h
function namespace (line 36) | namespace Eigen {
FILE: VO_Module/thirdparty/eigen/Eigen/src/Eigenvalues/Tridiagonalization.h
function namespace (line 14) | namespace Eigen {
function namespace (line 322) | namespace internal {
type typename (line 443) | typedef typename Tridiagonalization<MatrixType>::CoeffVectorType CoeffVe...
type typename (line 444) | typedef typename Tridiagonalization<MatrixType>::HouseholderSequenceType...
type typename (line 467) | typedef typename MatrixType::RealScalar RealScalar;
FILE: VO_Module/thirdparty/eigen/Eigen/src/Geometry/AlignedBox.h
function namespace (line 49) | namespace Eigen {
function EIGEN_DEVICE_FUNC (line 182) | EIGEN_DEVICE_FUNC inline VectorType corner(CornerType corner) const
function EIGEN_DEVICE_FUNC (line 200) | EIGEN_DEVICE_FUNC inline VectorType sample() const
function contains (line 218) | inline bool contains(const MatrixBase<Derived>& p) const
function EIGEN_DEVICE_FUNC (line 225) | EIGEN_DEVICE_FUNC inline bool contains(const AlignedBox& b) const
function EIGEN_DEVICE_FUNC (line 230) | EIGEN_DEVICE_FUNC inline bool intersects(const AlignedBox& b) const
function EIGEN_DEVICE_FUNC (line 246) | EIGEN_DEVICE_FUNC inline AlignedBox& extend(const AlignedBox& b)
function EIGEN_DEVICE_FUNC (line 256) | EIGEN_DEVICE_FUNC inline AlignedBox& clamp(const AlignedBox& b)
function EIGEN_DEVICE_FUNC (line 266) | EIGEN_DEVICE_FUNC inline AlignedBox intersection(const AlignedBox& b) const
function EIGEN_DEVICE_FUNC (line 272) | EIGEN_DEVICE_FUNC inline AlignedBox merged(const AlignedBox& b) const
function AlignedBox (line 287) | inline AlignedBox translated(const MatrixBase<Derived>& a_t) const
function NonInteger (line 312) | inline NonInteger exteriorDistance(const MatrixBase<Derived>& p) const
function EIGEN_DEVICE_FUNC (line 319) | EIGEN_DEVICE_FUNC inline NonInteger exteriorDistance(const AlignedBox& b...
function transform (line 326) | inline void transform(
function transform (line 339) | inline void transform(const Transform<Scalar, AmbientDimAtCompileTime, M...
function AlignedBox (line 364) | AlignedBox transformed(const Transform<Scalar, AmbientDimAtCompileTime, ...
function explicit (line 386) | inline explicit AlignedBox(const AlignedBox<OtherScalarType,AmbientDimAt...
FILE: VO_Module/thirdparty/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: VO_Module/thirdparty/eigen/Eigen/src/Geometry/EulerAngles.h
function namespace (line 13) | namespace Eigen {
FILE: VO_Module/thirdparty/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 303) | EIGEN_DEVICE_FUNC homogeneous_right_product_impl(const MatrixType& lhs, ...
type HomogeneousShape (line 329) | typedef HomogeneousShape Shape;
type AssignmentKind (line 332) | struct AssignmentKind
type Dense2Dense (line 332) | typedef Dense2Dense Kind;
type typename (line 340) | typedef typename XprType::PlainObject PlainObject;
type evaluator (line 341) | typedef evaluator<PlainObject> Base;
function EIGEN_DEVICE_FUNC (line 343) | EIGEN_DEVICE_FUNC explicit unary_evaluator(const XprType& op)
type Homogeneous (line 374) | typedef Homogeneous<ArgType,Horizontal> SrcXprType;
type typename (line 404) | typedef typename Rhs::template
type typename (line 405) | typedef typename remove_const<LinearBlockConst>::type Li...
type typename (line 406) | typedef typename Rhs::ConstRowXpr Co...
type Replicate (line 407) | typedef Replicate<const ConstantColumn,Rows,1> Co...
type Product (line 408) | typedef Product<Lhs,LinearBlock,LazyProduct> Li...
type CwiseBinaryOp (line 409) | typedef CwiseBinaryOp<internal::scalar_sum_op<typename
type homogeneous_right_product_refactoring_helper (line 417) | typedef homogeneous_right_product_refactoring_helper<typename
type typename (line 418) | typedef typename helper::ConstantBlock ConstantBlock;
type typename (line 419) | typedef typename helper::Xpr RefactoredXpr;
type evaluator (line 420) | typedef evaluator<RefactoredXpr> Base;
function EIGEN_DEVICE_FUNC (line 422) | EIGEN_DEVICE_FUNC explicit product_evaluator(const XprType& xpr)
type typename (line 457) | typedef typename Lhs::template
type typename (line 458) | typedef typename remove_const<LinearBlockConst>::type Li...
type typename (line 459) | typedef typename Lhs::ConstColXpr Co...
type Replicate (line 460) | typedef Replicate<const ConstantColumn,1,Cols> Co...
type Product (line 461) | typedef Product<LinearBlock,Rhs,LazyProduct> Li...
type CwiseBinaryOp (line 462) | typedef CwiseBinaryOp<internal::scalar_sum_op<typename
type homogeneous_left_product_refactoring_helper (line 470) | typedef homogeneous_left_product_refactoring_helper<Lhs,typename
type typename (line 471) | typedef typename helper::ConstantBlock ConstantBlock;
type typename (line 472) | typedef typename helper::Xpr RefactoredXpr;
type evaluator (line 473) | typedef evaluator<RefactoredXpr> Base;
function EIGEN_DEVICE_FUNC (line 475) | EIGEN_DEVICE_FUNC explicit product_evaluator(const XprType& xpr)
function evalTo (line 486) | static void evalTo(Dest& dst, const TransformType& lhs, const Homogeneou...
FILE: VO_Module/thirdparty/eigen/Eigen/src/Geometry/Hyperplane.h
function namespace (line 14) | namespace Eigen {
FILE: VO_Module/thirdparty/eigen/Eigen/src/Geometry/OrthoMethods.h
function namespace (line 14) | namespace Eigen {
function namespace (line 51) | namespace internal {
type typename (line 88) | typedef typename internal::nested_eval<Derived,2>::type DerivedNested;
type typename (line 89) | typedef typename internal::nested_eval<OtherDerived,2>::type OtherDerive...
function namespace (line 138) | namespace internal {
FILE: VO_Module/thirdparty/eigen/Eigen/src/Geometry/ParametrizedLine.h
function namespace (line 14) | namespace Eigen {
FILE: VO_Module/thirdparty/eigen/Eigen/src/Geometry/Quaternion.h
function namespace (line 13) | namespace Eigen {
type Scalar_ (line 279) | typedef Scalar_ Scalar;
type typename (line 284) | typedef typename internal::traits<Quaternion>::Coefficients Coefficients;
type typename (line 285) | typedef typename Base::AngleAxisType AngleAxisType;
function EIGEN_DEVICE_FUNC (line 288) | EIGEN_DEVICE_FUNC inline Quaternion() {}
function EIGEN_DEVICE_FUNC (line 297) | EIGEN_DEVICE_FUNC inline Quaternion(const Scalar& w, const Scalar& x, co...
function EIGEN_DEVICE_FUNC (line 300) | EIGEN_DEVICE_FUNC explicit inline Quaternion(const Scalar* data) : m_coe...
function EIGEN_STRONG_INLINE (line 303) | EIGEN_STRONG_INLINE Quaternion(const QuaternionBase<Derived>& other) { t...
function explicit (line 313) | explicit inline Quaternion(const MatrixBase<Derived>& other) { *this = o...
function explicit (line 317) | explicit inline Quaternion(const Quaternion<OtherScalar, OtherOptions>& ...
function EIGEN_DEVICE_FUNC (line 323) | EIGEN_DEVICE_FUNC inline Quaternion(Quaternion&& other) EIGEN_NOEXCEPT_I...
function EIGEN_DEVICE_FUNC (line 340) | EIGEN_DEVICE_FUNC inline Coefficients& coeffs() { return m_coeffs;}
function EIGEN_STRONG_INLINE (line 353) | static EIGEN_STRONG_INLINE void _check_template_params()
type Quaternion (line 363) | typedef Quaternion<float> Quaternionf;
type Quaternion (line 366) | typedef Quaternion<double> Quaterniond;
function namespace (line 372) | namespace internal {
function namespace (line 380) | namespace internal {
type Scalar_ (line 410) | typedef Scalar_ Scalar;
type typename (line 411) | typedef typename internal::traits<Map>::Coefficients Coefficients;
function EIGEN_STRONG_INLINE (line 421) | EIGEN_STRONG_INLINE Map(const Scalar* coeffs) : m_coeffs(coeffs) {}
type Scalar_ (line 447) | typedef Scalar_ Scalar;
type typename (line 448) | typedef typename internal::traits<Map>::Coefficients Coefficients;
function EIGEN_STRONG_INLINE (line 458) | EIGEN_STRONG_INLINE Map(Scalar* coeffs) : m_coeffs(coeffs) {}
function EIGEN_DEVICE_FUNC (line 460) | EIGEN_DEVICE_FUNC inline Coefficients& coeffs() { return m_coeffs; }
type Map (line 469) | typedef Map<Quaternion<float>, 0> QuaternionMapf;
type Map (line 472) | typedef Map<Quaternion<double>, 0> QuaternionMapd;
type Map (line 475) | typedef Map<Quaternion<float>, Aligned> QuaternionMapAlignedf;
type Map (line 478) | typedef Map<Quaternion<double>, Aligned> QuaternionMapAlignedd;
function namespace (line 486) | namespace internal {
function typename (line 591) | inline typename QuaternionBase<Derived>::Matrix3
function namespace (line 734) | namespace internal {
function typename (line 763) | inline typename internal::traits<Derived>::Scalar
function namespace (line 812) | namespace internal {
function run (line 860) | static inline void run(QuaternionBase<Derived>& q, const Other& vec)
FILE: VO_Module/thirdparty/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: VO_Module/thirdparty/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: VO_Module/thirdparty/eigen/Eigen/src/Geometry/Scaling.h
function namespace (line 13) | namespace Eigen {
FILE: VO_Module/thirdparty/eigen/Eigen/src/Geometry/Transform.h
function namespace (line 15) | namespace Eigen {
type Scalar_ (line 216) | typedef Scalar_ Scalar;
type Eigen (line 217) | typedef Eigen::Index StorageIndex;
type Eigen (line 218) | typedef Eigen::Index Index;
type typename (line 220) | typedef typename internal::make_proper_matrix_type<Scalar,Rows,HDim,Opti...
type MatrixType (line 222) | typedef const MatrixType ConstMatrixType;
type Matrix (line 224) | typedef Matrix<Scalar,Dim,Dim,Options> LinearMatrixType;
type Block (line 226) | typedef Block<MatrixType,Dim,Dim,int(Mode)==(AffineCompact) && (int(Opti...
type Block (line 228) | typedef const Block<ConstMatrixType,Dim,Dim,int(Mode)==(AffineCompact) &...
type typename (line 230) | typedef typename internal::conditional<int(Mode)==int(AffineCompact),
type typename (line 234) | typedef typename internal::conditional<int(Mode)==int(AffineCompact),
type Matrix (line 238) | typedef Matrix<Scalar,Dim,1> VectorType;
type Block (line 240) | typedef Block<MatrixType,Dim,1,!(internal::traits<MatrixType>::Flags & R...
type Block (line 242) | typedef const Block<ConstMatrixType,Dim,1,!(internal::traits<MatrixType>...
type Translation (line 244) | typedef Translation<Scalar,Dim> TranslationType;
type Transform (line 249) | typedef Transform<Scalar,Dim,TransformTimeDiagonalMode> TransformTimeDia...
function EIGEN_DEVICE_FUNC (line 265) | EIGEN_DEVICE_FUNC inline explicit Transform(const TranslationType& t)
function EIGEN_DEVICE_FUNC (line 270) | EIGEN_DEVICE_FUNC inline explicit Transform(const UniformScaling<Scalar>...
function explicit (line 276) | inline explicit Transform(const RotationBase<Derived, Dim>& r)
type internal (line 282) | typedef internal::transform_take_affine_part<Transform> take_affine_part;
function explicit (line 286) | inline explicit Transform(const EigenBase<OtherDerived>& other)
type typename (line 342) | typedef typename Transform<Scalar,Dim,OtherMode,OtherOptions>::MatrixTyp...
function EIGEN_DEVICE_FUNC (line 383) | EIGEN_DEVICE_FUNC inline Scalar operator() (Index row, Index col) const ...
function EIGEN_DEVICE_FUNC (line 386) | EIGEN_DEVICE_FUNC inline Scalar& operator() (Index row, Index col) { ret...
function EIGEN_DEVICE_FUNC (line 391) | EIGEN_DEVICE_FUNC inline MatrixType& matrix() { return m_matrix; }
function EIGEN_DEVICE_FUNC (line 396) | EIGEN_DEVICE_FUNC inline LinearPart linear() { return LinearPart(m_matri...
function EIGEN_DEVICE_FUNC (line 399) | EIGEN_DEVICE_FUNC inline ConstAffinePart affine() const { return take_af...
type internal (line 503) | typedef internal::transform_transform_product_impl<Transform,Transform<S...
type typename (line 504) | typedef typename ProductType::ResultType ResultType;
type typename (line 513) | typedef typename icc_11_workaround<OtherMode,OtherOptions>::ProductType ...
function EIGEN_DEVICE_FUNC (line 527) | EIGEN_DEVICE_FUNC void setIdentity() { m_matrix.setIdentity(); }
function EIGEN_DEVICE_FUNC (line 533) | EIGEN_DEVICE_FUNC static const Transform Identity()
type typename (line 599) | typedef typename internal::conditional<int(Mode)==Isometry,ConstLinearPa...
function Scalar (line 618) | const Scalar* data() const { return m_matrix.data(); }
function EIGEN_DEVICE_FUNC (line 620) | EIGEN_DEVICE_FUNC Scalar* data() { return m_matrix.data(); }
function explicit (line 633) | inline explicit Transform(const Transform<OtherScalarType,Dim,Mode,Optio...
function EIGEN_DEVICE_FUNC (line 643) | EIGEN_DEVICE_FUNC bool isApprox(const Transform& other, const typename N...
function EIGEN_DEVICE_FUNC (line 648) | EIGEN_DEVICE_FUNC void makeAffine()
function check_template_params (line 686) | void check_template_params()
function else (line 913) | else
function namespace (line 1045) | namespace internal {
function namespace (line 1161) | namespace internal {
function namespace (line 1252) | namespace internal {
function MatrixType (line 1272) | static inline const MatrixType& run(const MatrixType& m) { return m; }
function ResultType (line 1336) | ResultType run(const TransformType& T, const MatrixType& other)
type typename (line 1352) | typedef typename MatrixType::PlainObject ResultType;
function ResultType (line 1354) | ResultType run(const TransformType& T, const MatrixType& other)
type typename (line 1378) | typedef typename MatrixType::PlainObject ResultType;
function ResultType (line 1380) | ResultType run(const TransformType& T, const MatrixType& other)
type typename (line 1403) | typedef typename MatrixType::PlainObject ResultType;
function ResultType (line 1405) | ResultType run(const TransformType& T, const MatrixType& other)
type typename (line 1425) | typedef typename TransformType::MatrixType MatrixType;
type Transform (line 1426) | typedef Transform<typename
function ResultType (line 1427) | static ResultType run(const Other& other,const TransformType& tr)
type typename (line 1436) | typedef typename TransformType::MatrixType MatrixType;
type Transform (line 1437) | typedef Transform<typename
function ResultType (line 1438) | static ResultType run(const Other& other,const TransformType& tr)
type typename (line 1452) | typedef typename TransformType::MatrixType MatrixType;
type TransformType (line 1453) | typedef TransformType ResultType;
function ResultType (line 1454) | static ResultType run(const Other& other,const TransformType& tr)
type typename (line 1468) | typedef typename TransformType::MatrixType MatrixType;
type TransformType (line 1469) | typedef TransformType ResultType;
function ResultType (line 1470) | static ResultType run(const Other& other,const TransformType& tr)
type typename (line 1484) | typedef typename TransformType::MatrixType MatrixType;
type TransformType (line 1485) | typedef TransformType ResultType;
function ResultType (line 1486) | static ResultType run(const Other& other, const TransformType& tr)
type Transform (line 1505) | typedef Transform<Scalar,Dim,LhsMode,LhsOptions> Lhs;
type Transform (line 1506) | typedef Transform<Scalar,Dim,RhsMode,RhsOptions> Rhs;
type Transform (line 1507) | typedef Transform<Scalar,Dim,ResultMode,LhsOptions> ResultType;
function ResultType (line 1508) | static ResultType run(const Lhs& lhs, const Rhs& rhs)
type Transform (line 1522) | typedef Transform<Scalar,Dim,RhsMode,RhsOptions> Rhs;
type Transform (line 1523) | typedef Transform<Scalar,Dim,Projective> ResultType;
function ResultType (line 1524) | static ResultType run(const Lhs& lhs, const Rhs& rhs)
type Transform (line 1534) | typedef Transform<Scalar,Dim,Projective,RhsOptions> Rhs;
type Transform (line 1535) | typedef Transform<Scalar,Dim,Projective> ResultType;
function ResultType (line 1536) | static ResultType run(const Lhs& lhs, const Rhs& rhs)
type Transform (line 1549) | typedef Transform<Scalar,Dim,AffineCompact,RhsOptions> Rhs;
type Transform (line 1550) | typedef Transform<Scalar,Dim,Projective> ResultType;
function ResultType (line 1551) | static ResultType run(const Lhs& lhs, const Rhs& rhs)
FILE: VO_Module/thirdparty/eigen/Eigen/src/Geometry/Translation.h
function namespace (line 13) | namespace Eigen {
function explicit (line 154) | inline explicit Translation(const Translation<OtherScalarType,Dim>& other)
function EIGEN_DEVICE_FUNC (line 161) | EIGEN_DEVICE_FUNC bool isApprox(const Translation& other, const typename...
type Translation (line 168) | typedef Translation<float, 2> Translation2f;
type Translation (line 169) | typedef Translation<double,2> Translation2d;
type Translation (line 170) | typedef Translation<float, 3> Translation3f;
type Translation (line 171) | typedef Translation<double,3> Translation3d;
FILE: VO_Module/thirdparty/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: VO_Module/thirdparty/eigen/Eigen/src/Geometry/arch/Geometry_SIMD.h
function namespace (line 14) | namespace Eigen {
function Quaternion (line 101) | static inline Quaternion<double> run(const QuaternionBase<Derived>& _a, ...
function Quaternion (line 147) | static inline Quaternion<double> run(const QuaternionBase<Derived>& q)
FILE: VO_Module/thirdparty/eigen/Eigen/src/Householder/BlockHouseholder.h
function namespace (line 16) | namespace Eigen {
FILE: VO_Module/thirdparty/eigen/Eigen/src/Householder/Householder.h
function namespace (line 14) | namespace Eigen {
FILE: VO_Module/thirdparty/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...
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<
type HouseholderSequence (line 143) | typedef HouseholderSequence<
type HouseholderSequence (line 151) | typedef HouseholderSequence<
type HouseholderSequence (line 159) | typedef HouseholderSequence<
function EIGEN_DEVICE_FUNC (line 228) | EIGEN_DEVICE_FUNC
function evalTo (line 280) | void evalTo(DestType& dst) const
type Block (line 385) | typedef Block<typename
type internal (line 431) | struct internal
function EIGEN_DEVICE_FUNC (line 442) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 460) | EIGEN_DEVICE_FUNC
FILE: VO_Module/thirdparty/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: VO_Module/thirdparty/eigen/Eigen/src/IterativeLinearSolvers/BiCGSTAB.h
function namespace (line 14) | namespace Eigen {
type typename (line 168) | typedef typename MatrixType::Scalar Scalar;
type typename (line 169) | typedef typename MatrixType::RealScalar RealScalar;
type Preconditioner_ (line 170) | typedef Preconditioner_ Preconditioner;
FILE: VO_Module/thirdparty/eigen/Eigen/src/IterativeLinearSolvers/ConjugateGradient.h
function namespace (line 13) | namespace Eigen {
type typename (line 168) | typedef typename MatrixType::Scalar Scalar;
type typename (line 169) | typedef typename MatrixType::RealScalar RealScalar;
type Preconditioner_ (line 170) | typedef Preconditioner_ Preconditioner;
type typename (line 200) | typedef typename Base::MatrixWrapper MatrixWrapper;
type typename (line 201) | typedef typename Base::ActualMatrixType ActualMatrixType;
type typename (line 208) | typedef typename internal::conditional<TransposeInput,Transpose<const Ac...
type typename (line 210) | typedef typename internal::conditional<UpLo==(Lower|Upper),
FILE: VO_Module/thirdparty/eigen/Eigen/src/IterativeLinearSolvers/IncompleteCholesky.h
function namespace (line 17) | namespace Eigen {
FILE: VO_Module/thirdparty/eigen/Eigen/src/IterativeLinearSolvers/IncompleteLUT.h
function namespace (line 15) | namespace Eigen {
FILE: VO_Module/thirdparty/eigen/Eigen/src/IterativeLinearSolvers/IterativeSolverBase.h
function namespace (line 13) | namespace Eigen {
type typename (line 151) | typedef typename internal::traits<Derived>::Preconditioner Preconditioner;
type typename (line 152) | typedef typename MatrixType::Scalar Scalar;
type typename (line 153) | typedef typename MatrixType::StorageIndex StorageIndex;
type typename (line 154) | typedef typename MatrixType::RealScalar RealScalar;
type typename (line 341) | typedef typename DestDerived::Scalar DestScalar;
type internal (line 416) | typedef internal::generic_matrix_wrapper<MatrixType> MatrixWrapper;
type typename (line 417) | typedef typename MatrixWrapper::ActualMatrixType ActualMatrixType;
FILE: VO_Module/thirdparty/eigen/Eigen/src/IterativeLinearSolvers/LeastSquareConjugateGradient.h
function namespace (line 13) | namespace Eigen {
type typename (line 159) | typedef typename MatrixType::Scalar Scalar;
type typename (line 160) | typedef typename MatrixType::RealScalar RealScalar;
type Preconditioner_ (line 161) | typedef Preconditioner_ Preconditioner;
FILE: VO_Module/thirdparty/eigen/Eigen/src/IterativeLinearSolvers/SolveWithGuess.h
function namespace (line 13) | namespace Eigen {
function namespace (line 72) | namespace internal {
type SolveWithGuess (line 100) | typedef SolveWithGuess<DecType,RhsType,GuessType> SrcXprType;
function run (line 101) | static void run(DstXprType &dst, const SrcXprType &src, const internal::...
FILE: VO_Module/thirdparty/eigen/Eigen/src/Jacobi/Jacobi.h
function namespace (line 14) | namespace Eigen {
function namespace (line 274) | namespace internal {
function applyOnTheLeft (line 295) | inline void MatrixBase<Derived>::applyOnTheLeft(Index p, Index q, const ...
function applyOnTheRight (line 311) | inline void MatrixBase<Derived>::applyOnTheRight(Index p, Index q, const...
function namespace (line 318) | namespace internal {
function apply_rotation_in_the_plane (line 453) | void /*EIGEN_DONT_INLINE*/ apply_rotation_in_the_plane(DenseBase<VectorX...
FILE: VO_Module/thirdparty/eigen/Eigen/src/KLUSupport/KLUSupport.h
function namespace (line 13) | namespace Eigen {
FILE: VO_Module/thirdparty/eigen/Eigen/src/LU/Determinant.h
function namespace (line 15) | namespace internal {
FILE: VO_Module/thirdparty/eigen/Eigen/src/LU/FullPivLU.h
function namespace (line 13) | namespace Eigen {
function MatrixType (line 405) | MatrixType reconstructedMatrix() const;
type internal (line 516) | typedef internal::scalar_score_coeff_op<Scalar> Scoring;
type typename (line 517) | typedef typename Scoring::result_type Score;
function namespace (line 615) | namespace internal {
function namespace (line 844) | namespace internal {
FILE: VO_Module/thirdparty/eigen/Eigen/src/LU/InverseImpl.h
function namespace (line 14) | namespace Eigen {
function compute_inverse_size2_helper (line 76) | inline void compute_inverse_size2_helper(
function run (line 91) | static inline void run(const MatrixType& matrix, ResultType& result)
function run (line 103) | static inline void run(
function typename (line 127) | inline typename MatrixType::Scalar cofactor_3x3(const MatrixType& m)
function compute_inverse_size3_helper (line 141) | inline void compute_inverse_size3_helper(
function run (line 165) | static inline void run(const MatrixType& matrix, ResultType& result)
function run (line 182) | static inline void run(
function typename (line 209) | inline const typename Derived::Scalar general_det3_helper
function typename (line 218) | inline typename MatrixType::Scalar cofactor_4x4(const MatrixType& matrix)
function EIGEN_DEVICE_FUNC (line 236) | EIGEN_DEVICE_FUNC
function run (line 270) | static inline void run(
function namespace (line 297) | namespace internal {
FILE: VO_Module/thirdparty/eigen/Eigen/src/LU/PartialPivLU.h
function namespace (line 14) | namespace Eigen {
function namespace (line 577) | namespace internal {
FILE: VO_Module/thirdparty/eigen/Eigen/src/LU/PartialPivLU_LAPACKE.h
function namespace (line 36) | namespace Eigen {
FILE: VO_Module/thirdparty/eigen/Eigen/src/LU/arch/InverseSize4.h
function namespace (line 38) | namespace Eigen
FILE: VO_Module/thirdparty/eigen/Eigen/src/MetisSupport/MetisSupport.h
function namespace (line 12) | namespace Eigen {
FILE: VO_Module/thirdparty/eigen/Eigen/src/OrderingMethods/Amd.h
function namespace (line 24) | namespace Eigen {
FILE: VO_Module/thirdparty/eigen/Eigen/src/OrderingMethods/Eigen_Colamd.h
function namespace (line 50) | namespace internal {
FILE: VO_Module/thirdparty/eigen/Eigen/src/OrderingMethods/Ordering.h
function namespace (line 14) | namespace Eigen {
type Matrix (line 118) | typedef Matrix<StorageIndex, Dynamic, 1> IndexVector;
FILE: VO_Module/thirdparty/eigen/Eigen/src/PaStiXSupport/PaStiXSupport.h
function namespace (line 13) | namespace Eigen {
function eigen_pastix (line 67) | inline void eigen_pastix(pastix_data_t **pastix_data, int pastix_comm, i...
function eigen_pastix (line 74) | inline void eigen_pastix(pastix_data_t **pastix_data, int pastix_comm, i...
function eigen_pastix (line 81) | inline void eigen_pastix(pastix_data_t **pastix_data, int pastix_comm, i...
function eigen_pastix (line 88) | inline void eigen_pastix(pastix_data_t **pastix_data, int pastix_comm, i...
type typename (line 137) | typedef typename internal::pastix_traits<Derived>::MatrixType MatrixType_;
type MatrixType_ (line 138) | typedef MatrixType_ MatrixType;
type typename (line 139) | typedef typename MatrixType::Scalar Scalar;
type typename (line 140) | typedef typename MatrixType::RealScalar RealScalar;
type typename (line 141) | typedef typename MatrixType::StorageIndex StorageIndex;
type Matrix (line 142) | typedef Matrix<Scalar,Dynamic,1> Vector;
type SparseMatrix (line 143) | typedef SparseMatrix<Scalar, ColMajor> ColSpMatrix;
function iparm (line 178) | int& iparm(int idxparam)
function dparm (line 196) | double& dparm(int idxparam)
function clean (line 230) | void clean()
type PastixBase (line 416) | typedef PastixBase<PastixLU<MatrixType> > Base;
type typename (line 417) | typedef typename Base::ColSpMatrix ColSpMatrix;
type typename (line 418) | typedef typename MatrixType::StorageIndex StorageIndex;
function explicit (line 426) | explicit PastixLU(const MatrixType& matrix):Base()
function compute (line 436) | void compute (const MatrixType& matrix)
function analyzePattern (line 448) | void analyzePattern(const MatrixType& matrix)
function factorize (line 461) | void factorize(const MatrixType& matrix)
function grabMatrix (line 476) | void grabMatrix(const MatrixType& matrix, ColSpMatrix& out)
type PastixBase (line 528) | typedef PastixBase<PastixLLT<MatrixType, UpLo_> > Base;
type typename (line 529) | typedef typename Base::ColSpMatrix ColSpMatrix;
function explicit (line 538) | explicit PastixLLT(const MatrixType& matrix):Base()
function compute (line 547) | void compute (const MatrixType& matrix)
function analyzePattern (line 558) | void analyzePattern(const MatrixType& matrix)
function factorize (line 567) | void factorize(const MatrixType& matrix)
function init (line 576) | void init()
function grabMatrix (line 582) | void grabMatrix(const MatrixType& matrix, ColSpMatrix& out)
type PastixBase (line 612) | typedef PastixBase<PastixLDLT<MatrixType, UpLo_> > Base;
type typename (line 613) | typedef typename Base::ColSpMatrix ColSpMatrix;
function explicit (line 622) | explicit PastixLDLT(const MatrixType& matrix):Base()
function compute (line 631) | void compute (const MatrixType& matrix)
function analyzePattern (line 642) | void analyzePattern(const MatrixType& matrix)
function factorize (line 651) | void factorize(const MatrixType& matrix)
function init (line 661) | void init()
function grabMatrix (line 667) | void grabMatrix(const MatrixType& matrix, ColSpMatrix& out)
FILE: VO_Module/thirdparty/eigen/Eigen/src/PardisoSupport/PardisoSupport.h
function namespace (line 35) | namespace Eigen {
type internal (line 106) | typedef internal::pardiso_traits<Derived> Traits;
type typename (line 110) | typedef typename Traits::MatrixType MatrixType;
type typename (line 111) | typedef typename Traits::Scalar Scalar;
type typename (line 112) | typedef typename Traits::RealScalar RealScalar;
type typename (line 113) | typedef typename Traits::StorageIndex StorageIndex;
type SparseMatrix (line 114) | typedef SparseMatrix<Scalar,RowMajor,StorageIndex> SparseMatrixType;
type Matrix (line 115) | typedef Matrix<Scalar,Dynamic,1> VectorType;
type Matrix (line 116) | typedef Matrix<StorageIndex, 1, MatrixType::ColsAtCompileTime> IntRowVec...
type Matrix (line 117) | typedef Matrix<StorageIndex, MatrixType::RowsAtCompileTime, 1> IntColVec...
function pardisoInit (line 193) | void pardisoInit(int type)
type typename (line 396) | typedef typename Base::RealScalar RealScalar;
function explicit (line 407) | explicit PardisoLU(const MatrixType& matrix)
type typename (line 452) | typedef typename Base::RealScalar RealScalar;
type typename (line 453) | typedef typename Base::StorageIndex StorageIndex;
function explicit (line 463) | explicit PardisoLLT(const MatrixType& matrix)
type typename (line 515) | typedef typename Base::RealScalar RealScalar;
type typename (line 516) | typedef typename Base::StorageIndex StorageIndex;
function explicit (line 526) | explicit PardisoLDLT(const MatrixType& matrix)
function getMatrix (line 533) | void getMatrix(const MatrixType& matrix)
FILE: VO_Module/thirdparty/eigen/Eigen/src/QR/ColPivHouseholderQR.h
function namespace (line 14) | namespace Eigen {
function isSurjective (line 298) | inline bool isSurjective() const
function Inverse (line 321) | inline const Inverse<ColPivHouseholderQR> inverse() const
function Index (line 394) | inline Index nonzeroPivots() const
function check_template_parameters (line 429) | static void check_template_parameters()
function namespace (line 635) | namespace internal {
FILE: VO_Module/thirdparty/eigen/Eigen/src/QR/ColPivHouseholderQR_LAPACKE.h
function namespace (line 37) | namespace Eigen {
FILE: VO_Module/thirdparty/eigen/Eigen/src/QR/CompleteOrthogonalDecomposition.h
function namespace (line 13) | namespace Eigen {
function namespace (line 593) | namespace internal {
FILE: VO_Module/thirdparty/eigen/Eigen/src/QR/FullPivHouseholderQR.h
function namespace (line 14) | namespace Eigen {
function isSurjective (line 289) | inline bool isSurjective() const
function Inverse (line 312) | inline const Inverse<FullPivHouseholderQR> inverse() const
function Index (line 385) | inline Index nonzeroPivots() const
type internal (line 487) | typedef internal::scalar_score_coeff_op<Scalar> Scoring;
type typename (line 488) | typedef typename Scoring::result_type Score;
function namespace (line 613) | namespace internal {
FILE: VO_Module/thirdparty/eigen/Eigen/src/QR/HouseholderQR.h
function namespace (line 15) | namespace Eigen {
function namespace (line 263) | namespace internal {
FILE: VO_Module/thirdparty/eigen/Eigen/src/QR/HouseholderQR_LAPACKE.h
function namespace (line 37) | namespace Eigen {
FILE: VO_Module/thirdparty/eigen/Eigen/src/SPQRSupport/SuiteSparseQRSupport.h
function namespace (line 14) | namespace Eigen {
type typename (line 67) | typedef typename MatrixType_::RealScalar RealScalar;
type SuiteSparse_long (line 68) | typedef SuiteSparse_long StorageIndex ;
type SparseMatrix (line 69) | typedef SparseMatrix<Scalar, ColMajor, StorageIndex> MatrixType;
type Map (line 70) | typedef Map<PermutationMatrix<Dynamic, Dynamic, StorageIndex> > Permutat...
function SPQR_free (line 116) | void SPQR_free()
function compute (line 125) | void compute(const MatrixType_& matrix)
function setSPQROrdering (line 231) | void setSPQROrdering(int ord) { m_ordering = ord;}
function setPivotThreshold (line 233) | void setPivotThreshold(const RealScalar& tol)
function cholmod_common (line 240) | cholmod_common *cholmodCommon() const { return &m_cc; }
type SPQR_QProduct (line 271) | struct SPQR_QProduct
type typename (line 277) | typedef typename SPQRType::Scalar Scalar;
type typename (line 278) | typedef typename SPQRType::StorageIndex StorageIndex;
function m_spqr (line 305) | SPQRMatrixQReturnType(const SPQRType& spqr) : m_spqr(spqr) {}
function m_spqr (line 325) | SPQRMatrixQTransposeReturnType(const SPQRType& spqr) : m_spqr(spqr) {}
FILE: VO_Module/thirdparty/eigen/Eigen/src/SVD/BDCSVD.h
function namespace (line 30) | namespace Eigen {
function setSwitchSize (line 173) | void setSwitchSize(int s)
FILE: VO_Module/thirdparty/eigen/Eigen/src/SVD/JacobiSVD.h
function namespace (line 14) | namespace Eigen {
type typename (line 108) | typedef typename MatrixType::Scalar Scalar;
type typename (line 118) | typedef typename internal::make_proper_matrix_type<
function allocate (line 122) | void allocate(const JacobiSVD<MatrixType, FullPivHouseholderQRPreconditi...
function run (line 133) | bool run(JacobiSVD<MatrixType, FullPivHouseholderQRPreconditioner>& svd,...
function allocate (line 159) | void allocate(const JacobiSVD<MatrixType, ColPivHouseholderQRPreconditio...
function run (line 170) | bool run(JacobiSVD<MatrixType, ColPivHouseholderQRPreconditioner>& svd, ...
type typename (line 198) | typedef typename MatrixType::Scalar Scalar;
type typename (line 208) | typedef typename internal::make_proper_matrix_type<
function allocate (line 212) | void allocate(const JacobiSVD<MatrixType, ColPivHouseholderQRPreconditio...
function run (line 224) | bool run(JacobiSVD<MatrixType, ColPivHouseholderQRPreconditioner>& svd, ...
function allocate (line 257) | void allocate(const JacobiSVD<MatrixType, HouseholderQRPreconditioner>& ...
function run (line 268) | bool run(JacobiSVD<MatrixType, HouseholderQRPreconditioner>& svd, const ...
type typename (line 295) | typedef typename MatrixType::Scalar Scalar;
type typename (line 305) | typedef typename internal::make_proper_matrix_type<
function allocate (line 309) | void allocate(const JacobiSVD<MatrixType, HouseholderQRPreconditioner>& ...
function run (line 321) | bool run(JacobiSVD<MatrixType, HouseholderQRPreconditioner>& svd, const ...
type typename (line 357) | typedef typename MatrixType::RealScalar RealScalar;
function run (line 358) | static bool run(typename SVD::WorkMatrixType&, SVD&, Index, Index, RealS...
type typename (line 365) | typedef typename MatrixType::Scalar Scalar;
type typename (line 366) | typedef typename MatrixType::RealScalar RealScalar;
function run (line 367) | static bool run(typename SVD::WorkMatrixType& work_matrix, SVD& svd, Ind...
type typename (line 495) | typedef typename MatrixType::Scalar Scalar;
type typename (line 496) | typedef typename NumTraits<typename MatrixType::Scalar>::Real RealScalar;
type typename (line 507) | typedef typename Base::MatrixUType MatrixUType;
type typename (line 508) | typedef typename Base::MatrixVType MatrixVType;
type typename (line 509) | typedef typename Base::SingularValuesType SingularValuesType;
type typename (line 511) | typedef typename internal::plain_row_type<MatrixType>::type RowType;
type typename (line 512) | typedef typename internal::plain_col_type<MatrixType>::type ColType;
type Matrix (line 513) | typedef Matrix<Scalar, DiagSizeAtCompileTime, DiagSizeAtCompileTime,
type internal (line 605) | struct internal
type internal (line 607) | struct internal
FILE: VO_Module/thirdparty/eigen/Eigen/src/SVD/JacobiSVD_LAPACKE.h
function namespace (line 36) | namespace Eigen {
FILE: VO_Module/thirdparty/eigen/Eigen/src/SVD/SVDBase.h
function namespace (line 19) | namespace Eigen {
FILE: VO_Module/thirdparty/eigen/Eigen/src/SVD/UpperBidiagonalization.h
function namespace (line 14) | namespace Eigen {
FILE: VO_Module/thirdparty/eigen/Eigen/src/SparseCholesky/SimplicialCholesky.h
function namespace (line 13) | namespace Eigen {
function analyzePattern (line 238) | void analyzePattern(const MatrixType& a, bool doLDLT)
type keep_diag (line 252) | struct keep_diag {
function namespace (line 278) | namespace internal {
type Ordering_ (line 297) | typedef Ordering_ OrderingType;
type typename (line 299) | typedef typename MatrixType::Scalar Scalar;
type typename (line 300) | typedef typename MatrixType::StorageIndex StorageI...
type SparseMatrix (line 301) | typedef SparseMatrix<Scalar, ColMajor, StorageIndex> CholMatr...
type TriangularView (line 302) | typedef TriangularView<const CholMatrixType, Eigen::UnitLower> MatrixL;
type TriangularView (line 303) | typedef TriangularView<const typename
function MatrixL (line 304) | static inline MatrixL getL(const CholMatrixType& m) { return MatrixL(m); }
function MatrixU (line 305) | static inline MatrixU getU(const CholMatrixType& m) { return MatrixU(m.a...
type Ordering_ (line 311) | typedef Ordering_ OrderingType;
type MatrixType_ (line 341) | typedef MatrixType_ MatrixType;
type SimplicialCholeskyBase (line 343) | typedef SimplicialCholeskyBase<SimplicialLLT> Base;
type typename (line 344) | typedef typename MatrixType::Scalar Scalar;
type typename (line 345) | typedef typename MatrixType::RealScalar RealScalar;
type typename (line 346) | typedef typename MatrixType::StorageIndex StorageIndex;
type SparseMatrix (line 347) | typedef SparseMatrix<Scalar,ColMajor,Index> CholMatrixType;
type Matrix (line 348) | typedef Matrix<Scalar,Dynamic,1> VectorType;
type internal (line 349) | typedef internal::traits<SimplicialLLT> Traits;
type typename (line 350) | typedef typename Traits::MatrixL MatrixL;
type typename (line 351) | typedef typename Traits::MatrixU MatrixU;
function explicit (line 356) | explicit SimplicialLLT(const MatrixType& matrix)
function analyzePattern (line 384) | void analyzePattern(const MatrixType& a)
function factorize (line 395) | void factorize(const MatrixType& a)
type MatrixType_ (line 432) | typedef MatrixType_ MatrixType;
type SimplicialCholeskyBase (line 434) | typedef SimplicialCholeskyBase<SimplicialLDLT> Base;
type typename (line 435) | typedef typename MatrixType::Scalar Scalar;
type typename (line 436) | typedef typename MatrixType::RealScalar RealScalar;
type typename (line 437) | typedef typename MatrixType::StorageIndex StorageIndex;
type SparseMatrix (line 438) | typedef SparseMatrix<Scalar,ColMajor,StorageIndex> CholMatrixType;
type Matrix (line 439) | typedef Matrix<Scalar,Dynamic,1> VectorType;
type internal (line 440) | typedef internal::traits<SimplicialLDLT> Traits;
type typename (line 441) | typedef typename Traits::MatrixL MatrixL;
type typename (line 442) | typedef typename Traits::MatrixU MatrixU;
function explicit (line 448) | explicit SimplicialLDLT(const MatrixType& matrix)
function MatrixU (line 463) | inline const MatrixU matrixU() const {
function analyzePattern (line 481) | void analyzePattern(const MatrixType& a)
function factorize (line 492) | void factorize(const MatrixType& a)
function Scalar (line 498) | Scalar determinant() const
function VectorType (line 551) | inline const VectorType vectorD() const {
function analyzePattern (line 576) | void analyzePattern(const MatrixType& a)
function factorize (line 587) | void factorize(const MatrixType& a)
FILE: VO_Module/thirdparty/eigen/Eigen/src/SparseCholesky/SimplicialCholesky_impl.h
function namespace (line 23) | namespace Eigen {
FILE: VO_Module/thirdparty/eigen/Eigen/src/SparseCore/AmbiVector.h
function namespace (line 13) | namespace Eigen {
type typename (line 288) | typedef typename NumTraits<Scalar>::Real RealScalar;
function m_vector (line 297) | m_vector(vec)
FILE: VO_Module/thirdparty/eigen/Eigen/src/SparseCore/CompressedStorage.h
function namespace (line 13) | namespace Eigen {
function append (line 101) | void append(const Scalar& v, Index i)
function clear (line 111) | inline void clear() { m_size = 0; }
function Scalar (line 113) | const Scalar* valuePtr() const { return m_values; }
function Scalar (line 114) | Scalar* valuePtr() { return m_values; }
function StorageIndex (line 115) | const StorageIndex* indexPtr() const { return m_indices; }
function StorageIndex (line 116) | StorageIndex* indexPtr() { return m_indices; }
function Scalar (line 118) | inline Scalar& value(Index i) { eigen_internal_assert(m_values!=0); retu...
function Scalar (line 119) | inline const Scalar& value(Index i) const { eigen_internal_assert(m_valu...
function StorageIndex (line 121) | inline StorageIndex& index(Index i) { eigen_internal_assert(m_indices!=0...
function StorageIndex (line 122) | inline const StorageIndex& index(Index i) const { eigen_internal_assert(...
function Index (line 125) | inline Index searchLowerIndex(Index key) const
function Index (line 131) | inline Index searchLowerIndex(Index start, Index end, Index key) const
function moveChunk (line 210) | void moveChunk(Index from, Index to, Index chunkSize)
FILE: VO_Module/thirdparty/eigen/Eigen/src/SparseCore/ConservativeSparseSparseProduct.h
function namespace (line 13) | namespace Eigen {
function namespace (line 125) | namespace internal {
type SparseMatrix (line 172) | typedef SparseMatrix<typename
type SparseMatrix (line 186) | typedef SparseMatrix<typename
function run (line 212) | static void run(const Lhs& lhs, const Rhs& rhs, ResultType& res)
type SparseMatrix (line 227) | typedef SparseMatrix<typename
type SparseMatrix (line 241) | typedef SparseMatrix<typename
type SparseMatrix (line 255) | typedef SparseMatrix<typename
function namespace (line 267) | namespace internal {
function namespace (line 299) | namespace internal {
FILE: VO_Module/thirdparty/eigen/Eigen/src/SparseCore/MappedSparseMatrix.h
function namespace (line 13) | namespace Eigen {
function namespace (line 50) | namespace internal {
FILE: VO_Module/thirdparty/eigen/Eigen/src/SparseCore/SparseAssign.h
function namespace (line 13) | namespace Eigen {
function run (line 162) | void run(DstXprType &dst, const SrcXprType &src, const InitialFunc& /*fu...
type Solve (line 228) | typedef Solve<DecType,RhsType> SrcXprType;
function run (line 229) | static void run(DstXprType &dst, const SrcXprType &src, const internal::...
type Diagonal2Sparse (line 240) | struct Diagonal2Sparse {}
type AssignmentKind (line 242) | struct AssignmentKind
type Diagonal2Sparse (line 242) | typedef Diagonal2Sparse Kind;
type typename (line 248) | typedef typename DstXprType::Scalar Scalar;
FILE: VO_Module/thirdparty/eigen/Eigen/src/SparseCore/SparseBlock.h
function namespace (line 13) | namespace Eigen {
function Scalar (line 54) | inline const Scalar coeff(Index row, Index col) const
function Scalar (line 59) | inline const Scalar coeff(Index index) const
function XprType (line 65) | inline XprType& nestedExpression() { return m_matrix; }
function namespace (line 93) | namespace internal {
type SparseMatrix (line 292) | typedef SparseMatrix<Scalar_, Options_, StorageIndex_> SparseMatrixType;
type internal (line 293) | typedef internal::sparse_matrix_block_impl<SparseMatrixType,BlockRows,Bl...
function Base (line 294) | inline BlockImpl(SparseMatrixType& xpr, Index i)
function Base (line 298) | inline BlockImpl(SparseMatrixType& xpr, Index startRow, Index startCol, ...
type SparseMatrix (line 311) | typedef const SparseMatrix<Scalar_, Options_, StorageIndex_> SparseMatri...
type internal (line 312) | typedef internal::sparse_matrix_block_impl<SparseMatrixType,BlockRows,Bl...
function Base (line 313) | inline BlockImpl(SparseMatrixType& xpr, Index i)
function Base (line 317) | inline BlockImpl(SparseMatrixType& xpr, Index startRow, Index startCol, ...
type SparseMatrixBase (line 337) | typedef SparseMatrixBase<BlockType> Base;
function Scalar (line 364) | inline Scalar& coeffRef(Index row, Index col)
function Scalar (line 369) | inline const Scalar coeff(Index row, Index col) const
function Scalar (line 374) | inline Scalar& coeffRef(Index index)
function Scalar (line 380) | inline const Scalar coeff(Index index) const
function XprType (line 387) | inline XprType& nestedExpression() { return m_matrix; }
function namespace (line 417) | namespace internal {
function public (line 468) | public EvalIterator
type evaluator (line 553) | typedef evaluator<SparseCompressedBase<XprType> > Base;
function explicit (line 554) | explicit unary_evaluator(const XprType &xpr) : Base(xpr) {}
type evaluator (line 562) | typedef evaluator<SparseCompressedBase<XprType> > Base;
function explicit (line 563) | explicit unary_evaluator(const XprType &xpr) : Base(xpr) {}
FILE: VO_Module/thirdparty/eigen/Eigen/src/SparseCore/SparseColEtree.h
function namespace (line 34) | namespace Eigen {
FILE: VO_Module/thirdparty/eigen/Eigen/src/SparseCore/SparseCompressedBase.h
function namespace (line 13) | namespace Eigen {
function Scalar (line 220) | inline Scalar& valueRef() { return const_cast<Scalar&>(m_values[m_id]); }
type internal (line 232) | typedef internal::variable_if_dynamic<Index,Derived::IsVectorAtCompileTi...
function Scalar (line 288) | inline Scalar& valueRef() { return const_cast<Scalar&>(m_values[m_id-1]); }
type internal (line 300) | typedef internal::variable_if_dynamic<Index,Derived::IsVectorAtCompileTi...
type typename (line 312) | typedef typename Derived::Scalar Scalar;
type typename (line 313) | typedef typename Derived::InnerIterator InnerIterator;
function explicit (line 324) | explicit evaluator(const Derived &mat) : m_matrix(&mat), m_zero(0)
FILE: VO_Module/thirdparty/eigen/Eigen/src/SparseCore/SparseCwiseBinaryOp.h
function namespace (line 13) | namespace Eigen {
function namespace (line 53) | namespace internal {
type CwiseBinaryOp (line 159) | typedef CwiseBinaryOp<BinaryOp, Lhs, Rhs> XprType;
type typename (line 160) | typedef typename traits<XprType>::Scalar Scalar;
type typename (line 161) | typedef typename XprType::StorageIndex StorageIndex;
type CwiseBinaryOp (line 246) | typedef CwiseBinaryOp<BinaryOp, Lhs, Rhs> XprType;
type typename (line 247) | typedef typename traits<XprType>::Scalar Scalar;
type typename (line 248) | typedef typename XprType::StorageIndex StorageIndex;
type sparse_conjunction_evaluator (line 338) | typedef sparse_conjunction_evaluator<XprType> Base;
function explicit (line 339) | explicit binary_evaluator(const XprType& xpr) : Base(xpr) {}
type sparse_conjunction_evaluator (line 347) | typedef sparse_conjunction_evaluator<XprType> Base;
function explicit (line 348) | explicit binary_evaluator(const XprType& xpr) : Base(xpr) {}
type sparse_conjunction_evaluator (line 356) | typedef sparse_conjunction_evaluator<XprType> Base;
function explicit (line 357) | explicit binary_evaluator(const XprType& xpr) : Base(xpr) {}
type sparse_conjunction_evaluator (line 366) | typedef sparse_conjunction_evaluator<XprType> Base;
function explicit (line 367) | explicit binary_evaluator(const XprType& xpr) : Base(xpr) {}
type sparse_conjunction_evaluator (line 376) | typedef sparse_conjunction_evaluator<XprType> Base;
function explicit (line 377) | explicit binary_evaluator(const XprType& xpr) : Base(xpr) {}
type sparse_conjunction_evaluator (line 385) | typedef sparse_conjunction_evaluator<XprType> Base;
function explicit (line 386) | explicit binary_evaluator(const XprType& xpr) : Base(xpr) {}
type sparse_conjunction_evaluator (line 394) | typedef sparse_conjunction_evaluator<XprType> Base;
function explicit (line 395) | explicit binary_evaluator(const XprType& xpr) : Base(xpr) {}
type typename (line 405) | typedef typename XprType::Lhs LhsArg;
type typename (line 406) | typedef typename XprType::Rhs RhsArg;
type typename (line 407) | typedef typename evaluator<LhsArg>::InnerIterator LhsIterator;
type typename (line 408) | typedef typename evaluator<RhsArg>::InnerIterator RhsIterator;
type typename (line 409) | typedef typename XprType::StorageIndex StorageIndex;
type typename (line 410) | typedef typename traits<XprType>::Scalar Scalar;
type typename (line 490) | typedef typename XprType::Lhs LhsArg;
type typename (line 491) | typedef typename XprType::Rhs RhsArg;
type evaluator (line 492) | typedef evaluator<LhsArg> LhsEvaluator;
type typename (line 493) | typedef typename evaluator<RhsArg>::InnerIterator RhsIterator;
type typename (line 494) | typedef typename XprType::StorageIndex StorageIndex;
type typename (line 495) | typedef typename traits<XprType>::Scalar Scalar;
type typename (line 563) | typedef typename XprType::Lhs LhsArg;
type typename (line 564) | typedef typename XprType::Rhs RhsArg;
type typename (line 565) | typedef typename evaluator<LhsArg>::InnerIterator LhsIterator;
type evaluator (line 566) | typedef evaluator<RhsArg> RhsEvaluator;
type typename (line 567) | typedef typename XprType::StorageIndex StorageIndex;
type typename (line 568) | typedef typename traits<XprType>::Scalar Scalar;
FILE: VO_Module/thirdparty/eigen/Eigen/src/SparseCore/SparseCwiseUnaryOp.h
function namespace (line 13) | namespace Eigen {
type typename (line 128) | typedef typename internal::evaluator<Derived>::InnerIterator EvalIterator;
type typename (line 140) | typedef typename internal::evaluator<Derived>::InnerIterator EvalIterator;
FILE: VO_Module/thirdparty/eigen/Eigen/src/SparseCore/SparseDenseProduct.h
function namespace (line 13) | namespace Eigen {
function namespace (line 176) | namespace internal {
type typename (line 209) | typedef typename nested_eval<Lhs,((Rhs::Flags&RowMajorBit)==0) ? Dynamic...
type typename (line 210) | typedef typename nested_eval<Rhs,((Lhs::Flags&RowMajorBit)==RowMajorBit)...
type typename (line 230) | typedef typename conditional<NeedToTranspose,LhsT,RhsT>::type ActualRhs;
type Product (line 231) | typedef Product<LhsT,RhsT,DefaultProduct> ProdXprType;
type typename (line 235) | typedef typename conditional<is_same<typename internal::traits<Lhs1>::St...
type typename (line 237) | typedef typename conditional<is_same<typename internal::traits<Lhs1>::St...
type evaluator (line 240) | typedef evaluator<ActualLhs> LhsEval;
type evaluator (line 241) | typedef evaluator<ActualRhs> RhsEval;
type typename (line 242) | typedef typename evaluator<ActualLhs>::InnerIterator LhsIterator;
type typename (line 243) | typedef typename ProdXprType::Scalar Scalar;
function class (line 251) | class InnerIterator : public LhsIterator
type sparse_dense_outer_product_evaluator (line 312) | typedef sparse_dense_outer_product_evaluator<Lhs,Rhs, Lhs::IsRowMajor> B...
type Product (line 314) | typedef Product<Lhs, Rhs> XprType;
type typename (line 315) | typedef typename XprType::PlainObject PlainObject;
function explicit (line 317) | explicit product_evaluator(const XprType& xpr)
type sparse_dense_outer_product_evaluator (line 327) | typedef sparse_dense_outer_product_evaluator<Lhs,Rhs, Rhs::IsRowMajor> B...
type Product (line 329) | typedef Product<Lhs, Rhs> XprType;
type typename (line 330) | typedef typename XprType::PlainObject PlainObject;
function explicit (line 332) | explicit product_evaluator(const XprType& xpr)
FILE: VO_Module/thirdparty/eigen/Eigen/src/SparseCore/SparseDiagonalProduct.h
function namespace (line 13) | namespace Eigen {
type typename (line 96) | typedef typename SparseXprType::StorageIndex StorageIndex;
type typename (line 98) | typedef typename nested_eval<DiagCoeffType,SparseXprType::IsRowMajor ? S...
function class (line 101) | class InnerIterator
FILE: VO_Module/thirdparty/eigen/Eigen/src/SparseCore/SparseDot.h
function namespace (line 13) | namespace Eigen {
FILE: VO_Module/thirdparty/eigen/Eigen/src/SparseCore/SparseFuzzy.h
function namespace (line 13) | namespace Eigen {
FILE: VO_Module/thirdparty/eigen/Eigen/src/SparseCore/SparseMap.h
function namespace (line 13) | namespace Eigen {
type typename (line 55) | typedef typename Base::Scalar Scalar;
type typename (line 56) | typedef typename Base::StorageIndex StorageIndex;
type typename (line 64) | typedef typename internal::conditional<
function Scalar (line 95) | inline const Scalar* valuePtr() const { return m_values; }
function StorageIndex (line 97) | inline const StorageIndex* innerIndexPtr() const { return m_innerIndices; }
function StorageIndex (line 99) | inline const StorageIndex* outerIndexPtr() const { return m_outerIndex; }
function StorageIndex (line 101) | inline const StorageIndex* innerNonZeroPtr() const { return m_innerNonZe...
function Scalar (line 105) | inline Scalar coeff(Index row, Index col) const
type typename (line 155) | typedef typename Base::Scalar Scalar;
type typename (line 156) | typedef typename Base::StorageIndex StorageIndex;
function Scalar (line 170) | inline Scalar* valuePtr() { return Base::m_values; }
function StorageIndex (line 172) | inline StorageIndex* innerIndexPtr() { return Base::m_innerIndices; }
function StorageIndex (line 174) | inline StorageIndex* outerIndexPtr() { return Base::m_outerIndex; }
function StorageIndex (line 176) | inline StorageIndex* innerNonZeroPtr() { return Base::m_innerNonZeros; }
function Scalar (line 180) | inline Scalar& coeffRef(Index row, Index col)
function enum (line 260) | EIGEN_SPARSE_PUBLIC_INTERFACE(Map)
function namespace (line 279) | namespace internal {
type Map (line 296) | typedef Map<const SparseMatrix<MatScalar,MatOptions,MatIndex>, Options, ...
function explicit (line 298) | explicit evaluator(const XprType &mat) : Base(mat) {}
FILE: VO_Module/thirdparty/eigen/Eigen/src/SparseCore/SparseMatrix.h
function namespace (line 13) | namespace Eigen {
type internal (line 103) | struct internal
type MappedSparseMatrix (line 111) | typedef MappedSparseMatrix<Scalar,Flags> Map;
type Diagonal (line 112) | typedef Diagonal<SparseMatrix> DiagonalReturnType;
type Diagonal (line 113) | typedef Diagonal<const SparseMatrix> ConstDiagonalReturnType;
type typename (line 114) | typedef typename Base::InnerIterator InnerIterator;
type typename (line 115) | typedef typename Base::ReverseInnerIterator ReverseInnerIterator;
type internal (line 119) | typedef internal::CompressedStorage<Scalar,StorageIndex> Storage;
type typename (line 124) | typedef typename Base::IndexVector IndexVector;
type typename (line 125) | typedef typename Base::ScalarVector ScalarVector;
function Scalar (line 150) | inline const Scalar* valuePtr() const { return m_data.valuePtr(); }
function Scalar (line 154) | inline Scalar* valuePtr() { return m_data.valuePtr(); }
function StorageIndex (line 159) | inline const StorageIndex* innerIndexPtr() const { return m_data.indexPt...
function StorageIndex (line 163) | inline StorageIndex* innerIndexPtr() { return m_data.indexPtr(); }
function StorageIndex (line 168) | inline const StorageIndex* outerIndexPtr() const { return m_outerIndex; }
function StorageIndex (line 172) | inline StorageIndex* outerIndexPtr() { return m_outerIndex; }
function StorageIndex (line 177) | inline const StorageIndex* innerNonZeroPtr() const { return m_innerNonZe...
function StorageIndex (line 181) | inline StorageIndex* innerNonZeroPtr() { return m_innerNonZeros; }
function Storage (line 184) | inline Storage& data() { return m_data; }
function Scalar (line 190) | inline Scalar coeff(Index row, Index col) const
function Scalar (line 208) | inline Scalar& coeffRef(Index row, Index col)
function reserve (line 265) | inline void reserve(Index reserveSize)
function reserveInnerVectors (line 300) | void reserveInnerVectors(const SizesType& reserveSizes)
function Scalar (line 394) | inline Scalar& insertBackByOuterInner(Index outer, Index inner)
function Scalar (line 406) | inline Scalar& insertBackByOuterInnerUnordered(Index outer, Index inner)
function startVec (line 416) | inline void startVec(Index outer)
function finalize (line 426) | inline void finalize()
function sumupDuplicates (line 452) | void sumupDuplicates() { collapseDuplicates(internal::scalar_sum_op<Scal...
function makeCompressed (line 468) | void makeCompressed()
function uncompress (line 499) | void uncompress()
function conservativeResize (line 557) | void conservativeResize(Index rows, Index cols)
function resize (line 627) | void resize(Index rows, Index cols)
function resizeNonZeros (line 650) | void resizeNonZeros(Index size)
function ConstDiagonalReturnType (line 656) | const ConstDiagonalReturnType diagonal() const { return ConstDiagonalRet...
function rows (line 665) | inline SparseMatrix()
function class (line 875) | class SingletonVector
type IndexPosPair (line 908) | struct IndexPosPair {
type Array (line 941) | typedef Array<StorageIndex,Dynamic,1> ArrayXI;
type default_prunning_func (line 1022) | struct default_prunning_func {
function namespace (line 1033) | namespace internal {
type typename (line 1192) | typedef typename internal::nested_eval<OtherDerived,2,typename
type typename (line 1193) | typedef typename internal::remove_all<OtherCopy>::type _OtherCopy;
type internal (line 1194) | typedef internal::evaluator<_OtherCopy> OtherCopyEval;
function namespace (line 1503) | namespace internal {
FILE: VO_Module/thirdparty/eigen/Eigen/src/SparseCore/SparseMatrixBase.h
function namespace (line 13) | namespace Eigen {
FILE: VO_Module/thirdparty/eigen/Eigen/src/SparseCore/SparsePermutation.h
function namespace (line 15) | namespace Eigen {
function namespace (line 86) | namespace internal {
type typename (line 100) | typedef typename permutation_matrix_product<Rhs,OnTheLeft,false,SparseSh...
type evaluator (line 101) | typedef evaluator<PlainObject> Base;
function explicit (line 107) | explicit product_evaluator(const XprType& xpr)
type typename (line 123) | typedef typename permutation_matrix_product<Lhs,OnTheRight,false,SparseS...
type evaluator (line 124) | typedef evaluator<PlainObject> Base;
function explicit (line 130) | explicit product_evaluator(const XprType& xpr)
FILE: VO_Module/thirdparty/eigen/Eigen/src/SparseCore/SparseProduct.h
function namespace (line 13) | namespace Eigen {
type typename (line 71) | typedef typename nested_eval<Lhs,Dynamic>::type LhsNested;
type typename (line 72) | typedef typename nested_eval<Rhs,Dynamic>::type RhsNested;
function run (line 105) | static void run(DstXprType &dst, const SrcXprType &src, const internal::...
function run (line 121) | static void run(DstXprType &dst, const SrcXprType &src, const internal::...
function run (line 132) | static void run(DstXprType &dst, const SrcXprType &src, const internal::...
type typename (line 143) | typedef typename XprType::PlainObject PlainObject;
type evaluator (line 144) | typedef evaluator<PlainObject> Base;
function explicit (line 146) | explicit unary_evaluator(const XprType& xpr)
FILE: VO_Module/thirdparty/eigen/Eigen/src/SparseCore/SparseRedux.h
function namespace (line 13) | namespace Eigen {
FILE: VO_Module/thirdparty/eigen/Eigen/src/SparseCore/SparseRef.h
function namespace (line 13) | namespace Eigen {
type typename (line 66) | typedef typename internal::conditional<MatchAtCompileTime,internal::true...
type internal (line 132) | typedef internal::traits<Ref> Traits;
type internal (line 181) | typedef internal::traits<Ref> Traits;
function Ref (line 185) | EIGEN_SPARSE_PUBLIC_INTERFACE(Ref)
function m_hasCopy (line 198) | m_hasCopy(false) {
type internal (line 263) | typedef internal::traits<Ref> Traits;
type internal (line 299) | typedef internal::traits<Ref> Traits;
function Ref (line 303) | EIGEN_SPARSE_PUBLIC_INTERFACE(Ref)
function m_hasCopy (line 316) | m_hasCopy(false) {
function namespace (line 349) | namespace internal {
type Ref (line 368) | typedef Ref<const SparseMatrix<MatScalar,MatOptions,MatIndex>, Options, ...
function explicit (line 370) | explicit evaluator(const XprType &mat) : Base(mat) {}
type Ref (line 378) | typedef Ref<SparseVector<MatScalar,MatOptions,MatIndex>, Options, Stride...
function explicit (line 380) | explicit evaluator(const XprType &mat) : Base(mat) {}
type Ref (line 388) | typedef Ref<const SparseVector<MatScalar,MatOptions,MatIndex>, Options, ...
function explicit (line 390) | explicit evaluator(const XprType &mat) : Base(mat) {}
FILE: VO_Module/thirdparty/eigen/Eigen/src/SparseCore/SparseSelfAdjointView.h
function namespace (line 13) | namespace Eigen {
function namespace (line 208) | namespace internal {
type SparseSelfAdjoint2Sparse (line 220) | struct SparseSelfAdjoint2Sparse {}
type AssignmentKind (line 222) | struct AssignmentKind
type SparseSelfAdjoint2Sparse (line 222) | typedef SparseSelfAdjoint2Sparse Kind;
type AssignmentKind (line 223) | struct AssignmentKind
type Sparse2Sparse (line 223) | typedef Sparse2Sparse Kind;
type internal (line 229) | typedef internal::assign_op<typename
type typename (line 287) | typedef typename internal::nested_eval<SparseLhsType,DenseRhsType::MaxCo...
type typename (line 288) | typedef typename internal::remove_all<SparseLhsTypeNested>::type SparseL...
type evaluator (line 289) | typedef evaluator<SparseLhsTypeNestedCleaned> LhsEval;
type typename (line 290) | typedef typename LhsEval::InnerIterator LhsIterator;
type typename (line 291) | typedef typename SparseLhsType::Scalar LhsScalar;
type typename (line 350) | typedef typename LhsView::_MatrixTypeNested Lhs;
type typename (line 351) | typedef typename nested_eval<Lhs,Dynamic>::type LhsNested;
type typename (line 352) | typedef typename nested_eval<Rhs,Dynamic>::type RhsNested;
type typename (line 367) | typedef typename RhsView::_MatrixTypeNested Rhs;
type typename (line 368) | typedef typename nested_eval<Lhs,Dynamic>::type LhsNested;
type typename (line 369) | typedef typename nested_eval<Rhs,Dynamic>::type RhsNested;
type Product (line 386) | typedef Product<LhsView, Rhs, DefaultProduct> XprType;
type typename (line 387) | typedef typename XprType::PlainObject PlainObject;
type evaluator (line 388) | typedef evaluator<PlainObject> Base;
type Product (line 406) | typedef Product<Lhs, RhsView, DefaultProduct> XprType;
type typename (line 407) | typedef typename XprType::PlainObject PlainObject;
type evaluator (line 408) | typedef evaluator<PlainObject> Base;
type typename (line 432) | typedef typename MatrixType::StorageIndex StorageIndex;
type typename (line 433) | typedef typename MatrixType::Scalar Scalar;
type SparseMatrix (line 434) | typedef SparseMatrix<Scalar,DestOrder,StorageIndex> Dest;
type Matrix (line 435) | typedef Matrix<StorageIndex,Dynamic,1> VectorI;
type evaluator (line 436) | typedef evaluator<MatrixType> MatEval;
type typename (line 437) | typedef typename evaluator<MatrixType>::InnerIterator MatIterator;
type typename (line 522) | typedef typename MatrixType::StorageIndex StorageIndex;
type typename (line 523) | typedef typename MatrixType::Scalar Scalar;
type Matrix (line 525) | typedef Matrix<StorageIndex,Dynamic,1> VectorI;
type evaluator (line 526) | typedef evaluator<MatrixType> MatEval;
type typename (line 527) | typedef typename evaluator<MatrixType>::InnerIterator MatIterator;
type typename (line 604) | typedef typename MatrixType::StorageIndex StorageIndex;
type typename (line 613) | typedef typename MatrixType::Nested MatrixTypeNested;
type typename (line 614) | typedef typename internal::remove_all<MatrixTypeNested>::type NestedExpr...
type SparseSymmetricPermutationProduct (line 637) | typedef SparseSymmetricPermutationProduct<MatrixType,Mode> SrcXprType;
type typename (line 638) | typedef typename DstXprType::StorageIndex DstIndex;
FILE: VO_Module/thirdparty/eigen/Eigen/src/SparseCore/SparseSolverBase.h
function namespace (line 13) | namespace Eigen {
FILE: VO_Module/thirdparty/eigen/Eigen/src/SparseCore/SparseSparseProductWithPruning.h
function namespace (line 13) | namespace Eigen {
function run (line 117) | static void run(const Lhs& lhs, const Rhs& rhs, ResultType& res, const R...
function run (line 130) | static void run(const Lhs& lhs, const Rhs& rhs, ResultType& res, const R...
function run (line 150) | static void run(const Lhs& lhs, const Rhs& rhs, ResultType& res, const R...
function run (line 162) | static void run(const Lhs& lhs, const Rhs& rhs, ResultType& res, const R...
function run (line 174) | static void run(const Lhs& lhs, const Rhs& rhs, ResultType& res, const R...
function run (line 186) | static void run(const Lhs& lhs, const Rhs& rhs, ResultType& res, const R...
FILE: VO_Module/thirdparty/eigen/Eigen/src/SparseCore/SparseTranspose.h
function namespace (line 13) | namespace Eigen {
function namespace (line 52) | namespace internal {
FILE: VO_Module/thirdparty/eigen/Eigen/src/SparseCore/SparseTriangularView.h
function namespace (line 14) | namespace Eigen {
function namespace (line 66) | namespace internal {
FILE: VO_Module/thirdparty/eigen/Eigen/src/SparseCore/SparseUtil.h
function namespace (line 13) | namespace Eigen {
type typename (line 98) | typedef typename traits<T>::Scalar Scalar_;
type typename (line 99) | typedef typename traits<T>::StorageIndex StorageIndex_;
type typename (line 113) | typedef typename traits<T>::Scalar Scalar_;
type typename (line 114) | typedef typename traits<T>::StorageIndex StorageIndex_;
type SparseTriangularShape (line 137) | struct SparseTriangularShape { static std::string debugName() { return ...
type LowerBoundIndex (line 144) | struct LowerBoundIndex {
FILE: VO_Module/thirdparty/eigen/Eigen/src/SparseCore/SparseVector.h
function namespace (line 13) | namespace Eigen {
function EIGEN_STRONG_INLINE (line 86) | EIGEN_STRONG_INLINE const Scalar* valuePtr() const { return m_data.value...
function EIGEN_STRONG_INLINE (line 87) | EIGEN_STRONG_INLINE Scalar* valuePtr() { return m_data.valuePtr(); }
function EIGEN_STRONG_INLINE (line 89) | EIGEN_STRONG_INLINE const StorageIndex* innerIndexPtr() const { return m...
function EIGEN_STRONG_INLINE (line 90) | EIGEN_STRONG_INLINE StorageIndex* innerIndexPtr() { return m_data.indexP...
function StorageIndex (line 92) | inline const StorageIndex* outerIndexPtr() const { return 0; }
function StorageIndex (line 93) | inline StorageIndex* outerIndexPtr() { return 0; }
function StorageIndex (line 94) | inline const StorageIndex* innerNonZeroPtr() const { return 0; }
function StorageIndex (line 95) | inline StorageIndex* innerNonZeroPtr() { return 0; }
function Storage (line 98) | inline Storage& data() { return m_data; }
function Scalar (line 102) | inline Scalar coeff(Index row, Index col) const
function Scalar (line 107) | inline Scalar coeff(Index i) const
function Scalar (line 113) | inline Scalar& coeffRef(Index row, Index col)
function Scalar (line 125) | inline Scalar& coeffRef(Index i)
type typename (line 135) | typedef typename Base::ReverseInnerIterator ReverseInnerIterator;
function setZero (line 137) | inline void setZero() { m_data.clear(); }
function startVec (line 142) | inline void startVec(Index outer)
function Scalar (line 148) | inline Scalar& insertBackByOuterInner(Index outer, Index inner)
function Scalar (line 154) | inline Scalar& insertBack(Index i)
function Scalar (line 166) | inline Scalar& insertBackUnordered(Index i)
function Scalar (line 172) | inline Scalar& insert(Index row, Index col)
function reserve (line 204) | inline void reserve(Index reserveSize) { m_data.reserve(reserveSize); }
function finalize (line 207) | inline void finalize() {}
function resize (line 223) | void resize(Index rows, Index cols)
function resize (line 233) | void resize(Index newSize)
function conservativeResize (line 246) | void conservativeResize(Index newSize)
function resizeNonZeros (line 257) | void resizeNonZeros(Index size) { m_data.resize(size); }
function EIGEN_DEPRECATED (line 356) | EIGEN_DEPRECATED Scalar& fill(Index r, Index c)
function EIGEN_DEPRECATED (line 363) | EIGEN_DEPRECATED Scalar& fill(Index i)
function EIGEN_DEPRECATED (line 370) | EIGEN_DEPRECATED Scalar& fillrand(Index r, Index c)
function EIGEN_DEPRECATED (line 377) | EIGEN_DEPRECATED Scalar& fillrand(Index i)
function EIGEN_DEPRECATED (line 383) | EIGEN_DEPRECATED void endFill() {}
function EIGEN_DEPRECATED (line 387) | EIGEN_DEPRECATED Storage& _data() { return m_data; }
function namespace (line 407) | namespace internal {
type internal (line 455) | typedef internal::evaluator<Src> SrcEvaluatorType;
FILE: VO_Module/thirdparty/eigen/Eigen/src/SparseCore/SparseView.h
function namespace (line 14) | namespace Eigen {
FILE: VO_Module/thirdparty/eigen/Eigen/src/SparseCore/TriangularSolver.h
function namespace (line 13) | namespace Eigen {
type evaluator (line 107) | typedef evaluator<Lhs> LhsEval;
type typename (line 108) | typedef typename evaluator<Lhs>::InnerIterator LhsIterator;
function run (line 109) | static void run(const Lhs& lhs, Rhs& other)
type evaluator (line 142) | typedef evaluator<Lhs> LhsEval;
type typename (line 143) | typedef typename evaluator<Lhs>::InnerIterator LhsIterator;
function run (line 144) | static void run(const Lhs& lhs, Rhs& other)
type typename (line 185) | typedef typename internal::conditional<copy,
function namespace (line 198) | namespace internal {
FILE: VO_Module/thirdparty/eigen/Eigen/src/SparseLU/SparseLU.h
function namespace (line 15) | namespace Eigen {
type MatrixType_ (line 139) | typedef MatrixType_ MatrixType;
type OrderingType_ (line 140) | typedef OrderingType_ OrderingType;
type typename (line 141) | typedef typename MatrixType::Scalar Scalar;
type typename (line 142) | typedef typename MatrixType::RealScalar RealScalar;
type typename (line 143) | typedef typename MatrixType::StorageIndex StorageIndex;
type SparseMatrix (line 144) | typedef SparseMatrix<Scalar,ColMajor,StorageIndex> NCMatrix;
type internal (line 145) | typedef internal::MappedSuperNodalMatrix<Scalar, StorageIndex> SCMatrix;
type Matrix (line 146) | typedef Matrix<Scalar,Dynamic,1> ScalarVector;
type Matrix (line 147) | typedef Matrix<StorageIndex,Dynamic,1> IndexVector;
type PermutationMatrix (line 148) | typedef PermutationMatrix<Dynamic, Dynamic, StorageIndex> PermutationType;
type internal (line 149) | typedef internal::SparseLUImpl<Scalar, StorageIndex> Base;
function explicit (line 162) | explicit SparseLU(const MatrixType& matrix)
function compute (line 182) | void compute (const MatrixType& matrix)
function isSymmetric (line 232) | void isSymmetric(bool sym)
function setPivotThreshold (line 275) | void setPivotThreshold(const RealScalar& thresh)
function Scalar (line 350) | Scalar absDeterminant()
function Scalar (line 406) | Scalar signDeterminant()
function Scalar (line 434) | Scalar determinant()
type typename (line 801) | typedef typename MappedSupernodalType::Scalar Scalar;
function explicit (line 802) | explicit SparseLUMatrixLReturnType(const MappedSupernodalType& mapL) : m...
type typename (line 823) | typedef typename MatrixLType::Scalar Scalar;
FILE: VO_Module/thirdparty/eigen/Eigen/src/SparseLU/SparseLUImpl.h
function namespace (line 12) | namespace Eigen {
FILE: VO_Module/thirdparty/eigen/Eigen/src/SparseLU/SparseLU_Memory.h
function namespace (line 34) | namespace Eigen {
FILE: VO_Module/thirdparty/eigen/Eigen/src/SparseLU/SparseLU_Structs.h
function namespace (line 71) | namespace Eigen {
FILE: VO_Module/thirdparty/eigen/Eigen/src/SparseLU/SparseLU_SupernodalMatrix.h
function namespace (line 14) | namespace Eigen {
FILE: VO_Module/thirdparty/eigen/Eigen/src/SparseLU/SparseLU_Utils.h
function namespace (line 14) | namespace Eigen {
FILE: VO_Module/thirdparty/eigen/Eigen/src/SparseLU/SparseLU_column_bmod.h
function namespace (line 34) | namespace Eigen {
FILE: VO_Module/thirdparty/eigen/Eigen/src/SparseLU/SparseLU_column_dfs.h
function namespace (line 34) | namespace Eigen {
FILE: VO_Module/thirdparty/eigen/Eigen/src/SparseLU/SparseLU_copy_to_ucol.h
function namespace (line 32) | namespace Eigen {
FILE: VO_Module/thirdparty/eigen/Eigen/src/SparseLU/SparseLU_gemm_kernel.h
function namespace (line 13) | namespace Eigen {
FILE: VO_Module/thirdparty/eigen/Eigen/src/SparseLU/SparseLU_heap_relax_snode.h
function namespace (line 31) | namespace Eigen {
FILE: VO_Module/thirdparty/eigen/Eigen/src/SparseLU/SparseLU_kernel_bmod.h
function namespace (line 14) | namespace Eigen {
FILE: VO_Module/thirdparty/eigen/Eigen/src/SparseLU/SparseLU_panel_bmod.h
function namespace (line 34) | namespace Eigen {
FILE: VO_Module/thirdparty/eigen/Eigen/src/SparseLU/SparseLU_panel_dfs.h
function namespace (line 33) | namespace Eigen {
FILE: VO_Module/thirdparty/eigen/Eigen/src/SparseLU/SparseLU_pivotL.h
function namespace (line 33) | namespace Eigen {
FILE: VO_Module/thirdparty/eigen/Eigen/src/SparseLU/SparseLU_pruneL.h
function namespace (line 33) | namespace Eigen {
FILE: VO_Module/thirdparty/eigen/Eigen/src/SparseLU/SparseLU_relax_snode.h
function namespace (line 31) | namespace Eigen {
FILE: VO_Module/thirdparty/eigen/Eigen/src/SparseQR/SparseQR.h
function namespace (line 14) | namespace Eigen {
type MatrixType_ (line 91) | typedef MatrixType_ MatrixType;
type OrderingType_ (line 92) | typedef OrderingType_ OrderingType;
type typename (line 93) | typedef typename MatrixType::Scalar Scalar;
type typename (line 94) | typedef typename MatrixType::RealScalar RealScalar;
type typename (line 95) | typedef typename MatrixType::StorageIndex StorageIndex;
type SparseMatrix (line 96) | typedef SparseMatrix<Scalar,ColMajor,StorageIndex> QRMatrixType;
type Matrix (line 97) | typedef Matrix<StorageIndex, Dynamic, 1> IndexVector;
type Matrix (line 98) | typedef Matrix<Scalar, Dynamic, 1> ScalarVector;
type PermutationMatrix (line 99) | typedef PermutationMatrix<Dynamic, Dynamic, StorageIndex> PermutationType;
function compute (line 127) | void compute(const MatrixType& mat)
function setPivotThreshold (line 235) | void setPivotThreshold(const RealScalar& threshold)
function _sort_matrix_Q (line 276) | inline void _sort_matrix_Q()
type SparseQR_QProduct (line 306) | struct SparseQR_QProduct
type typename (line 615) | typedef typename SparseQRType::QRMatrixType MatrixType;
type typename (line 616) | typedef typename SparseQRType::Scalar Scalar;
type typename (line 676) | typedef typename SparseQRType::Scalar Scalar;
type Matrix (line 677) | typedef Matrix<Scalar,Dynamic,Dynamic> DenseMatrix;
function explicit (line 682) | explicit SparseQRMatrixQReturnType(const SparseQRType& qr) : m_qr(qr) {}
function explicit (line 707) | explicit SparseQRMatrixQTransposeReturnType(const SparseQRType& qr) : m_...
function namespace (line 716) | namespace internal {
type typename (line 746) | typedef typename DstXprType::Scalar Scalar;
type typename (line 747) | typedef typename DstXprType::StorageIndex StorageIndex;
function run (line 748) | static void run(DstXprType &dst, const SrcXprType &src, const internal::...
FILE: VO_Module/thirdparty/eigen/Eigen/src/StlSupport/StdDeque.h
function namespace (line 50) | namespace std {
FILE: VO_Module/thirdparty/eigen/Eigen/src/StlSupport/StdList.h
function namespace (line 49) | namespace std
FILE: VO_Module/thirdparty/eigen/Eigen/src/StlSupport/StdVector.h
function namespace (line 50) | namespace std {
FILE: VO_Module/thirdparty/eigen/Eigen/src/StlSupport/details.h
function namespace (line 18) | namespace Eigen {
FILE: VO_Module/thirdparty/eigen/Eigen/src/SuperLUSupport/SuperLUSupport.h
function namespace (line 13) | namespace Eigen {
FILE: VO_Module/thirdparty/eigen/Eigen/src/UmfPackSupport/UmfPackSupport.h
function namespace (line 23) | namespace Eigen {
function UmfpackControl (line 432) | inline UmfpackControl& umfpackControl()
function printUmfpackControl (line 459) | void printUmfpackControl()
function printUmfpackInfo (line 468) | void printUmfpackInfo()
function printUmfpackStatus (line 478) | void printUmfpackStatus() {
function Scalar (line 487) | Scalar determinant() const;
function factorize_impl (line 518) | void factorize_impl()
function grab (line 536) | void grab(const UmfpackMatrixRef &A)
FILE: VO_Module/thirdparty/eigen/Eigen/src/misc/Image.h
function namespace (line 13) | namespace Eigen {
FILE: VO_Module/thirdparty/eigen/Eigen/src/misc/Kernel.h
function namespace (line 13) | namespace Eigen {
FILE: VO_Module/thirdparty/eigen/Eigen/src/misc/RealSvd2x2.h
function namespace (line 14) | namespace Eigen {
FILE: VO_Module/thirdparty/eigen/Eigen/src/misc/blas.h
type BLASLONG (line 12) | typedef long long BLASLONG;
type BLASULONG (line 13) | typedef unsigned long long BLASULONG;
type BLASLONG (line 15) | typedef long BLASLONG;
type BLASULONG (line 16) | typedef unsigned long BLASULONG;
FILE: VO_Module/thirdparty/eigen/Eigen/src/misc/lapacke.h
type lapack_logical (line 132) | typedef lapack_logical (*LAPACK_S_SELECT2) ( const float*, const float* );
type lapack_logical (line 133) | typedef lapack_logical (*LAPACK_S_SELECT3)
type lapack_logical (line 135) | typedef lapack_logical (*LAPACK_D_SELECT2) ( const double*, const double...
type lapack_logical (line 136) | typedef lapack_logical (*LAPACK_D_SELECT3)
type lapack_logical (line 139) | typedef lapack_logical (*LAPACK_C_SELECT1) ( const lapack_complex_float* );
type lapack_logical (line 140) | typedef lapack_logical (*LAPACK_C_SELECT2)
type lapack_logical (line 142) | typedef lapack_logical (*LAPACK_Z_SELECT1) ( const lapack_complex_double...
type lapack_logical (line 143) | typedef lapack_logical (*LAPACK_Z_SELECT2)
FILE: VO_Module/thirdparty/eigen/Eigen/src/plugins/ArrayCwiseBinaryOps.h
function Derived (line 330) | const Derived>
FILE: VO_Module/thirdparty/eigen/Eigen/src/plugins/ArrayCwiseUnaryOps.h
type CwiseUnaryOp (line 3) | typedef CwiseUnaryOp<internal::scalar_abs_op<Scalar>, const
type CwiseUnaryOp (line 4) | typedef CwiseUnaryOp<internal::scalar_arg_op<Scalar>, const
type CwiseUnaryOp (line 5) | typedef CwiseUnaryOp<internal::scalar_abs2_op<Scalar>, const
type CwiseUnaryOp (line 6) | typedef CwiseUnaryOp<internal::scalar_sqrt_op<Scalar>, const
type CwiseUnaryOp (line 7) | typedef CwiseUnaryOp<internal::scalar_rsqrt_op<Scalar>, const
type CwiseUnaryOp (line 8) | typedef CwiseUnaryOp<internal::scalar_sign_op<Scalar>, const
type CwiseUnaryOp (line 9) | typedef CwiseUnaryOp<internal::scalar_inverse_op<Scalar>, const
type CwiseUnaryOp (line 10) | typedef CwiseUnaryOp<internal::scalar_boolean_not_op<Scalar>, const
type CwiseUnaryOp (line 12) | typedef CwiseUnaryOp<internal::scalar_exp_op<Scalar>, const
type CwiseUnaryOp (line 13) | typedef CwiseUnaryOp<internal::scalar_expm1_op<Scalar>, const
type CwiseUnaryOp (line 14) | typedef CwiseUnaryOp<internal::scalar_log_op<Scalar>, const
type CwiseUnaryOp (line 15) | typedef CwiseUnaryOp<internal::scalar_log1p_op<Scalar>, const
type CwiseUnaryOp (line 16) | typedef CwiseUnaryOp<internal::scalar_log10_op<Scalar>, const
type CwiseUnaryOp (line 17) | typedef CwiseUnaryOp<internal::scalar_log2_op<Scalar>, const
type CwiseUnaryOp (line 18) | typedef CwiseUnaryOp<internal::scalar_cos_op<Scalar>, const
type CwiseUnaryOp (line 19) | typedef CwiseUnaryOp<internal::scalar_sin_op<Scalar>, const
type CwiseUnaryOp (line 20) | typedef CwiseUnaryOp<internal::scalar_tan_op<Scalar>, const
type CwiseUnaryOp (line 21) | typedef CwiseUnaryOp<internal::scalar_acos_op<Scalar>, const
type CwiseUnaryOp (line 22) | typedef CwiseUnaryOp<internal::scalar_asin_op<Scalar>, const
type CwiseUnaryOp (line 23) | typedef CwiseUnaryOp<internal::scalar_atan_op<Scalar>, const
type CwiseUnaryOp (line 24) | typedef CwiseUnaryOp<internal::scalar_tanh_op<Scalar>, const
type CwiseUnaryOp (line 25) | typedef CwiseUnaryOp<internal::scalar_logistic_op<Scalar>, const
type CwiseUnaryOp (line 26) | typedef CwiseUnaryOp<internal::scalar_sinh_op<Scalar>, const
type CwiseUnaryOp (line 28) | typedef CwiseUnaryOp<internal::scalar_atanh_op<Scalar>, const
type CwiseUnaryOp (line 29) | typedef CwiseUnaryOp<internal::scalar_asinh_op<Scalar>, const
type CwiseUnaryOp (line 30) | typedef CwiseUnaryOp<internal::scalar_acosh_op<Scalar>, const
type CwiseUnaryOp (line 32) | typedef CwiseUnaryOp<internal::scalar_cosh_op<Scalar>, const
type CwiseUnaryOp (line 33) | typedef CwiseUnaryOp<internal::scalar_square_op<Scalar>, const
type CwiseUnaryOp (line 34) | typedef CwiseUnaryOp<internal::scalar_cube_op<Scalar>, const
type CwiseUnaryOp (line 35) | typedef CwiseUnaryOp<internal::scalar_round_op<Scalar>, const
type CwiseUnaryOp (line 36) | typedef CwiseUnaryOp<internal::scalar_rint_op<Scalar>, const
type CwiseUnaryOp (line 37) | typedef CwiseUnaryOp<internal::scalar_floor_op<Scalar>, const
type CwiseUnaryOp (line 38) | typedef CwiseUnaryOp<internal::scalar_ceil_op<Scalar>, const
type CwiseUnaryOp (line 39) | typedef CwiseUnaryOp<internal::scalar_isnan_op<Scalar>, const
type CwiseUnaryOp (line 40) | typedef CwiseUnaryOp<internal::scalar_isinf_op<Scalar>, const
type CwiseUnaryOp (line 41) | typedef CwiseUnaryOp<internal::scalar_isfinite_op<Scalar>, const
function AbsReturnType (line 51) | const AbsReturnType
function Abs2ReturnType (line 79) | const Abs2ReturnType
type ShiftRightXpr (line 500) | struct ShiftRightXpr {
type ShiftLeftXpr (line 520) | struct ShiftLeftXpr {
FILE: VO_Module/thirdparty/eigen/Eigen/src/plugins/BlockMethods.h
type Block (line 14) | typedef Block<Derived, internal::traits<Derived>::RowsAtCompileTime, 1, ...
type Block (line 15) | typedef const Block<const Derived, internal::traits<Derived>::RowsAtComp...
type Block (line 17) | typedef Block<Derived, 1, internal::traits<Derived>::ColsAtCompileTime, ...
type Block (line 18) | typedef const Block<const Derived, 1, internal::traits<Derived>::ColsAtC...
type Block (line 20) | typedef Block<Derived, internal::traits<Derived>::RowsAtCompileTime, Dyn...
type Block (line 21) | typedef const Block<const Derived, internal::traits<Derived>::RowsAtComp...
type Block (line 23) | typedef Block<Derived, Dynamic, internal::traits<Derived>::ColsAtCompile...
type Block (line 24) | typedef const Block<const Derived, Dynamic, internal::traits<Derived>::C...
type Block (line 26) | typedef Block<Derived, internal::traits<Derived>::RowsAtCompileTime, N, ...
type Block (line 27) | typedef const Block<const Derived, internal::traits<Derived>::RowsAtComp...
type Block (line 29) | typedef Block<Derived, N, internal::traits<Derived>::ColsAtCompileTime, ...
type Block (line 30) | typedef const Block<const Derived, N, internal::traits<Derived>::ColsAtC...
type Block (line 32) | typedef Block<Derived> BlockXpr;
type Block (line 33) | typedef const Block<const Derived> ConstBlockXpr;
type Block (line 35) | typedef Block<Derived,Rows,Cols> Type;
type Block (line 36) | typedef Block<const Derived,Rows,Cols> Type;
type VectorBlock (line 38) | typedef VectorBlock<Derived> SegmentReturnType;
type VectorBlock (line 39) | typedef const VectorBlock<const Derived> ConstSegmentReturnType;
type VectorBlock (line 40) | typedef VectorBlock<Derived, Size> Type;
type VectorBlock (line 41) | typedef const VectorBlock<const Derived, Size> Type;
type Block (line 44) | typedef Block<Derived,IsRowMajor?1:Dynamic,IsRowMajor?Dynamic:1,true> ...
type Block (line 45) | typedef Block<const Derived,IsRowMajor?1:Dynamic,IsRowMajor?Dynamic:1,tr...
type Block (line 48) | typedef Block<Derived,Dynamic,Dynamic,true> InnerVectorsReturnType;
type Block (line 49) | typedef Block<const Derived,Dynamic,Dynamic,true> ConstInnerVectorsRetur...
function typename (line 582) | const typename ConstNRowsBlockXpr<...>::Type
function typename (line 657) | const typename ConstNRowsBlockXpr<...>::Type
function typename (line 733) | const typename ConstNRowsBlockXpr<...>::Type
function typename (line 809) | const typename ConstNColsBlockXpr<...>::Type
function typename (line 884) | const typename ConstNColsBlockXpr<...>::Type
function typename (line 960) | const typename ConstNColsBlockXpr<...>::Type
function EIGEN_STRONG_INLINE (line 1096) | EIGEN_STRONG_INLINE
function ConstColXpr (line 1104) | ConstColXpr col(Index i) const
function EIGEN_STRONG_INLINE (line 1117) | EIGEN_STRONG_INLINE
function ConstRowXpr (line 1125) | ConstRowXpr row(Index i) const
function ConstInnerVectorReturnType (line 1387) | const ConstInnerVectorReturnType innerVector(Index outer) const
function InnerVectorsReturnType (line 1394) | InnerVectorsReturnType
function ConstInnerVectorsReturnType (line 1407) | const ConstInnerVectorsReturnType
FILE: VO_Module/thirdparty/eigen/Eigen/src/plugins/CommonCwiseUnaryOps.h
type typename (line 16) | typedef typename internal::conditional<NumTraits<Scalar>::IsComplex,
type typename (line 21) | typedef typename internal::conditional<NumTraits<Scalar>::IsComplex,
type typename (line 26) | typedef typename internal::conditional<NumTraits<Scalar>::IsComplex,
type CwiseUnaryOp (line 31) | typedef CwiseUnaryOp<internal::scalar_imag_op<Scalar>, const
type CwiseUnaryView (line 33) | typedef CwiseUnaryView<internal::scalar_imag_ref_op<Scalar>, Derived> No...
type CwiseUnaryOp (line 35) | typedef CwiseUnaryOp<internal::scalar_opposite_op<Scalar>, const
type typename (line 48) | typedef typename internal::cast_return_type<Derived,const
FILE: VO_Module/thirdparty/eigen/Eigen/src/plugins/IndexedViewMethods.h
type typename (line 36) | typedef typename internal::IndexedViewCompatibleType<Index,1>::type IvcI...
type IndexedView (line 62) | typedef IndexedView<EIGEN_INDEXED_VIEW_METHOD_CONST Derived,
type typename (line 87) | typedef typename internal::traits<typename EIGEN_INDEXED_VIEW_METHOD_TYP...
FILE: VO_Module/thirdparty/eigen/Eigen/src/plugins/MatrixCwiseUnaryOps.h
type CwiseUnaryOp (line 15) | typedef CwiseUnaryOp<internal::scalar_abs_op<Scalar>, const
type CwiseUnaryOp (line 16) | typedef CwiseUnaryOp<internal::scalar_abs2_op<Scalar>, const
type CwiseUnaryOp (line 17) | typedef CwiseUnaryOp<internal::scalar_arg_op<Scalar>, const
type CwiseUnaryOp (line 18) | typedef CwiseUnaryOp<internal::scalar_sqrt_op<Scalar>, const
type CwiseUnaryOp (line 19) | typedef CwiseUnaryOp<internal::scalar_sign_op<Scalar>, const
type CwiseUnaryOp (line 20) | typedef CwiseUnaryOp<internal::scalar_inverse_op<Scalar>, const
FILE: VO_Module/thirdparty/eigen/bench/BenchSparseUtil.h
type SCALAR (line 22) | typedef SCALAR Scalar;
type Matrix (line 23) | typedef Matrix<Scalar,Dynamic,Dynamic> DenseMatrix;
type Matrix (line 24) | typedef Matrix<Scalar,Dynamic,1> DenseVector;
type SparseMatrix (line 25) | typedef SparseMatrix<Scalar> EigenSparseMatrix;
function fillMatrix (line 27) | void fillMatrix(float density, int rows, int cols, EigenSparseMatrix& dst)
function fillMatrix2 (line 42) | void fillMatrix2(int nnzPerCol, int rows, int cols, EigenSparseMatrix& ...
function eiToDense (line 62) | void eiToDense(const EigenSparseMatrix& src, DenseMatrix& dst)
type gmm (line 72) | typedef gmm::csc_matrix<Scalar> GmmSparse;
type gmm (line 73) | typedef gmm::col_matrix< gmm::wsvector<Scalar> > GmmDynSparse;
function eiToGmm (line 74) | void eiToGmm(const EigenSparseMatrix& src, GmmSparse& dst)
type mtl (line 86) | typedef mtl::compressed2D<Scalar, mtl::matrix::parameters<mtl::tag::col_...
type mtl (line 87) | typedef mtl::compressed2D<Scalar, mtl::matrix::parameters<mtl::tag::row_...
function eiToMtl (line 88) | void eiToMtl(const EigenSparseMatrix& src, MtlSparse& dst)
function eiToCSparse (line 101) | void eiToCSparse(const EigenSparseMatrix& src, cs* &dst)
type boost (line 126) | typedef boost::numeric::ublas::compressed_matrix<Scalar,boost::numeric::...
function eiToUblas (line 128) | void eiToUblas(const EigenSparseMatrix& src, UBlasSparse& dst)
FILE: VO_Module/thirdparty/eigen/bench/BenchTimer.h
function escape (line 30) | static void escape(void *p) {
function clobber (line 36) | static void clobber() {
function namespace (line 44) | namespace Eigen
FILE: VO_Module/thirdparty/eigen/bench/analyze-blocking-sizes.cpp
function log2_pot (line 34) | uint8_t log2_pot(size_t x) {
function compact_size_triple (line 40) | uint16_t compact_size_triple(size_t k, size_t m, size_t n)
type size_triple_t (line 46) | struct size_triple_t
method size_triple_t (line 49) | size_triple_t() : k(0), m(0), n(0) {}
method size_triple_t (line 50) | size_triple_t(size_t _k, size_t _m, size_t _n) : k(_k), m(_m), n(_n) {}
method size_triple_t (line 51) | size_triple_t(const size_triple_t& o) : k(o.k), m(o.m), n(o.n) {}
method size_triple_t (line 52) | size_triple_t(uint16_t compact)
method is_cubic (line 58) | bool is_cubic() const { return k == m && m == n; }
function ostream (line 61) | ostream& operator<<(ostream& s, const size_triple_t& t)
type inputfile_entry_t (line 66) | struct inputfile_entry_t
type inputfile_t (line 74) | struct inputfile_t
type type_t (line 76) | enum class type_t {
method inputfile_t (line 86) | inputfile_t(const string& fname)
type preprocessed_inputfile_entry_t (line 195) | struct preprocessed_inputfile_entry_t
function lower_efficiency (line 203) | bool lower_efficiency(const preprocessed_inputfile_entry_t& e1, const pr...
type preprocessed_inputfile_t (line 208) | struct preprocessed_inputfile_t
method preprocessed_inputfile_t (line 213) | preprocessed_inputfile_t(const inputfile_t& inputfile)
method import_input_file_range_one_product_size (line 233) | void import_input_file_range_one_product_size(
function check_all_files_in_same_exact_order (line 257) | void check_all_files_in_same_exact_order(
function efficiency_of_subset (line 297) | float efficiency_of_subset(
function dump_table_for_subset (line 334) | void dump_table_for_subset(
function efficiency_of_partition (line 400) | float efficiency_of_partition(
function make_first_subset (line 411) | void make_first_subset(size_t subset_size, vector<size_t>& out_subset, s...
function is_last_subset (line 420) | bool is_last_subset(const vector<size_t>& subset, size_t set_size)
function next_subset (line 425) | void next_subset(vector<size_t>& inout_subset, size_t set_size)
function is_number_of_subsets_feasible (line 447) | bool is_number_of_subsets_feasible(size_t n, size_t p)
function max_feasible_subset_size (line 461) | size_t max_feasible_subset_size(size_t n)
function find_subset_with_efficiency_higher_than (line 473) | void find_subset_with_efficiency_higher_than(
function find_partition_with_efficiency_higher_than (line 545) | void find_partition_with_efficiency_higher_than(
function print_partition (line 568) | void print_partition(
type action_t (line 589) | struct action_t
method run (line 592) | virtual void run(const vector<string>&) const { abort(); }
type partition_action_t (line 596) | struct partition_action_t : action_t
method run (line 599) | virtual void run(const vector<string>& input_filenames) const override
type evaluate_defaults_action_t (line 668) | struct evaluate_defaults_action_t : action_t
type results_entry_t (line 670) | struct results_entry_t {
method ostream (line 678) | ostream& operator<<(ostream& s, const results_entry_t& entry)
method lower_efficiency (line 689) | static bool lower_efficiency(const results_entry_t& e1, const results_...
method show_usage_and_exit (line 693) | void show_usage_and_exit() const
method run (line 700) | virtual void run(const vector<string>& input_filenames) const override
function show_usage_and_exit (line 798) | void show_usage_and_exit(int argc, char* argv[],
function main (line 810) | int main(int argc, char* argv[])
FILE: VO_Module/thirdparty/eigen/bench/basicbenchmark.cpp
function main (line 6) | int main(int argc, char *argv[])
FILE: VO_Module/thirdparty/eigen/bench/benchBlasGemm.cpp
function main (line 34) | int main(int argc, char *argv[])
function bench_eigengemm (line 165) | void bench_eigengemm(MyMatrix& mc, const MyMatrix& ma, const MyMatrix& m...
function check_product (line 174) | void check_product(int M, int N, int K)
function check_product (line 206) | void check_product(void)
FILE: VO_Module/thirdparty/eigen/bench/benchCholesky.cpp
function benchLLT (line 28) | __attribute__ ((noinline)) void benchLLT(const MatrixType& m)
function main (line 119) | int main(int argc, char* argv[])
FILE: VO_Module/thirdparty/eigen/bench/benchEigenSolver.cpp
function benchEigenSolver (line 34) | __attribute__ ((noinline)) void benchEigenSolver(const MatrixType& m)
function main (line 189) | int main(int argc, char* argv[])
FILE: VO_Module/thirdparty/eigen/bench/benchFFT.cpp
function string (line 26) | string nameof<float>() {return "float";}
function string (line 27) | string nameof<double>() {return "double";}
function string (line 28) | string nameof<long double>() {return "long double";}
function bench (line 44) | void bench(int nfft,bool fwd,bool unscaled=false, bool halfspec=false)
function main (line 97) | int main(int argc,char ** argv)
FILE: VO_Module/thirdparty/eigen/bench/benchGeometry.cpp
type func_opt (line 14) | enum func_opt
type func (line 23) | struct func
type func<res, arg1, arg2, TV> (line 26) | struct func<res, arg1, arg2, TV>
method EIGEN_DONT_INLINE (line 28) | static EIGEN_DONT_INLINE res run( arg1& a1, arg2& a2 )
type func<res, arg1, arg2, TMATV> (line 36) | struct func<res, arg1, arg2, TMATV>
method EIGEN_DONT_INLINE (line 38) | static EIGEN_DONT_INLINE res run( arg1& a1, arg2& a2 )
type func<res, arg1, arg2, TMATVMAT> (line 46) | struct func<res, arg1, arg2, TMATVMAT>
method EIGEN_DONT_INLINE (line 48) | static EIGEN_DONT_INLINE res run( arg1& a1, arg2& a2 )
type test_transform (line 56) | struct test_transform
method run (line 58) | static void run()
FILE: VO_Module/thirdparty/eigen/bench/benchVecAdd.cpp
function main (line 21) | int main(int argc, char* argv[])
function benchVec (line 79) | void benchVec(MatrixXf& a, MatrixXf& b, MatrixXf& c)
function benchVec (line 85) | void benchVec(VectorXf& a, VectorXf& b, VectorXf& c)
function benchVec (line 91) | void benchVec(Scalar* a, Scalar* b, Scalar* c, int size)
FILE: VO_Module/thirdparty/eigen/bench/bench_gemm.cpp
function blas_gemm (line 87) | void blas_gemm(const A& a, const B& b, MatrixXf& c)
function blas_gemm (line 99) | void blas_gemm(const A& a, const B& b, MatrixXd& c)
function blas_gemm (line 111) | void blas_gemm(const A& a, const B& b, MatrixXcf& c)
function blas_gemm (line 123) | void blas_gemm(const A& a, const B& b, MatrixXcd& c)
function matlab_cplx_cplx (line 138) | void matlab_cplx_cplx(const M& ar, const M& ai, const M& br, const M& bi...
function matlab_real_cplx (line 147) | void matlab_real_cplx(const M& a, const M& br, const M& bi, M& cr, M& ci)
function matlab_cplx_real (line 153) | void matlab_cplx_real(const M& ar, const M& ai, const M& b, M& cr, M& ci)
function EIGEN_DONT_INLINE (line 162) | EIGEN_DONT_INLINE void gemm(const A& a, const B& b, C& c)
function main (line 167) | int main(int argc, char ** argv)
FILE: VO_Module/thirdparty/eigen/bench/bench_move_semantics.cpp
function copy_matrix (line 19) | void copy_matrix(MatrixType& m)
function move_matrix (line 26) | void move_matrix(MatrixType&& m)
function bench (line 33) | void bench(const std::string& label)
function main (line 51) | int main()
FILE: VO_Module/thirdparty/eigen/bench/bench_norm.cpp
function EIGEN_DONT_INLINE (line 9) | EIGEN_DONT_INLINE typename T::Scalar sqsumNorm(T& v)
function EIGEN_DONT_INLINE (line 15) | EIGEN_DONT_INLINE typename T::Scalar stableNorm(T& v)
function EIGEN_DONT_INLINE (line 21) | EIGEN_DONT_INLINE typename T::Scalar hypotNorm(T& v)
function EIGEN_DONT_INLINE (line 27) | EIGEN_DONT_INLINE typename T::Scalar blueNorm(T& v)
function EIGEN_DONT_INLINE (line 33) | EIGEN_DONT_INLINE typename T::Scalar lapackNorm(T& v)
function EIGEN_DONT_INLINE (line 56) | EIGEN_DONT_INLINE typename T::Scalar twopassNorm(T& v)
function EIGEN_DONT_INLINE (line 64) | EIGEN_DONT_INLINE typename T::Scalar bl2passNorm(T& v)
function EIGEN_DONT_INLINE (line 70) | EIGEN_DONT_INLINE typename T::Scalar divacNorm(T& v)
type Eigen (line 85) | namespace Eigen {
type internal (line 86) | namespace internal {
function Packet4f (line 88) | Packet4f plt(const Packet4f& a, Packet4f& b) { return _mm_cmplt_ps(a...
function Packet2d (line 89) | Packet2d plt(const Packet2d& a, Packet2d& b) { return _mm_cmplt_pd(a...
function Packet4f (line 91) | Packet4f pandnot(const Packet4f& a, Packet4f& b) { return _mm_andnot...
function Packet2d (line 92) | Packet2d pandnot(const Packet2d& a, Packet2d& b) { return _mm_andnot...
function EIGEN_DONT_INLINE (line 98) | EIGEN_DONT_INLINE typename T::Scalar pblueNorm(const T& v)
function check_accuracy (line 246) | void check_accuracy(double basef, double based, int s)
function check_accuracy_var (line 263) | void check_accuracy_var(int ef0, int ef1, int ed0, int ed1, int s)
function main (line 283) | int main(int argc, char** argv)
FILE: VO_Module/thirdparty/eigen/bench/bench_reverse.cpp
function bench_reverse (line 18) | __attribute__ ((noinline)) void bench_reverse(const MatrixType& m)
function main (line 60) | int main(int argc, char* argv[])
FILE: VO_Module/thirdparty/eigen/bench/bench_sum.cpp
function main (line 6) | int main()
FILE: VO_Module/thirdparty/eigen/bench/benchmark-blocking-sizes.cpp
type size_triple_t (line 62) | struct size_triple_t
method size_triple_t (line 65) | size_triple_t() : k(0), m(0), n(0) {}
method size_triple_t (line 66) | size_triple_t(size_t _k, size_t _m, size_t _n) : k(_k), m(_m), n(_n) {}
method size_triple_t (line 67) | size_triple_t(const size_triple_t& o) : k(o.k), m(o.m), n(o.n) {}
method size_triple_t (line 68) | size_triple_t(uint16_t compact)
function log2_pot (line 76) | uint8_t log2_pot(size_t x) {
function compact_size_triple (line 85) | uint16_t compact_size_triple(size_t k, size_t m, size_t n)
function compact_size_triple (line 90) | uint16_t compact_size_triple(const size_triple_t& t)
type benchmark_t (line 97) | struct benchmark_t
method benchmark_t (line 103) | benchmark_t()
method benchmark_t (line 110) | benchmark_t(size_t pk, size_t pm, size_t pn,
method benchmark_t (line 117) | benchmark_t(size_t pk, size_t pm, size_t pn)
function ostream (line 127) | ostream& operator<<(ostream& s, const benchmark_t& b)
function print_cpuinfo (line 231) | void print_cpuinfo()
function string (line 252) | string type_name()
function string (line 258) | string type_name<float>()
function string (line 264) | string type_name<double>()
type action_t (line 269) | struct action_t
method run (line 272) | virtual void run() const { abort(); }
function show_usage_and_exit (line 276) | void show_usage_and_exit(int /*argc*/, char* argv[],
function measure_clock_speed (line 297) | float measure_clock_speed()
type human_duration_t (line 318) | struct human_duration_t
method human_duration_t (line 321) | human_duration_t(int s) : seconds(s) {}
function ostream (line 324) | ostream& operator<<(ostream& s, const human_duration_t& d)
function serialize_benchmarks (line 345) | void serialize_benchmarks(const char* filename, const vector<benchmark_t...
function deserialize_benchmarks (line 361) | bool deserialize_benchmarks(const char* filename, vector<benchmark_t>& b...
function try_run_some_benchmarks (line 385) | void try_run_some_benchmarks(
function run_benchmarks (line 501) | void run_benchmarks(vector<benchmark_t>& benchmarks)
type measure_all_pot_sizes_action_t (line 565) | struct measure_all_pot_sizes_action_t : action_t
method run (line 568) | virtual void run() const
type measure_default_sizes_action_t (line 596) | struct measure_default_sizes_action_t : action_t
method run (line 599) | virtual void run() const
function main (line 621) | int main(int argc, char* argv[])
FILE: VO_Module/thirdparty/eigen/bench/benchmark.cpp
function main (line 22) | int main(int argc, char *argv[])
FILE: VO_Module/thirdparty/eigen/bench/benchmarkSlice.cpp
function main (line 18) | int main(int argc, char *argv[])
FILE: VO_Module/thirdparty/eigen/bench/benchmarkX.cpp
function main (line 22) | int main(int argc, char *argv[])
FILE: VO_Module/thirdparty/eigen/bench/benchmarkXcwise.cpp
function main (line 21) | int main(int argc, char *argv[])
FILE: VO_Module/thirdparty/eigen/bench/btl/actions/action_aat_product.hh
class Action_aat_product (line 32) | class Action_aat_product {
method Action_aat_product (line 38) | Action_aat_product( int size ):_size(size)
method Action_aat_product (line 60) | Action_aat_product( const Action_aat_product & )
method name (line 84) | static inline std::string name( void )
method nb_op_base (line 89) | double nb_op_base( void ){
method initialize (line 93) | inline void initialize( void ){
method calculate (line 100) | inline void calculate( void ) {
method check_result (line 106) | void check_result( void ){
FILE: VO_Module/thirdparty/eigen/bench/btl/actions/action_ata_product.hh
class Action_ata_product (line 32) | class Action_ata_product {
method Action_ata_product (line 38) | Action_ata_product( int size ):_size(size)
method Action_ata_product (line 60) | Action_ata_product( const Action_ata_product & )
method name (line 84) | static inline std::string name( void )
method nb_op_base (line 89) | double nb_op_base( void ){
method initialize (line 93) | inline void initialize( void ){
method calculate (line 100) | inline void calculate( void ) {
method check_result (line 106) | void check_result( void ){
FILE: VO_Module/thirdparty/eigen/bench/btl/actions/action_atv_product.hh
class Action_atv_product (line 32) | class Action_atv_product {
method Action_atv_product (line 36) | Action_atv_product( int size ) : _size(size)
method Action_atv_product (line 59) | Action_atv_product( const Action_atv_product & )
method name (line 78) | static inline std::string name() { return "atv_" + Interface::name(); }
method nb_op_base (line 80) | double nb_op_base( void ) { return 2.0*_size*_size; }
method initialize (line 82) | inline void initialize( void ){
method BTL_DONT_INLINE (line 88) | BTL_DONT_INLINE void calculate( void ) {
method check_result (line 94) | void check_result( void )
FILE: VO_Module/thirdparty/eigen/bench/btl/actions/action_axpby.hh
class Action_axpby (line 31) | class Action_axpby {
method Action_axpby (line 36) | Action_axpby( int size ):_alpha(0.5),_beta(0.95),_size(size)
method Action_axpby (line 54) | Action_axpby( const Action_axpby & )
method name (line 73) | static inline std::string name( void )
method nb_op_base (line 78) | double nb_op_base( void ){
method initialize (line 82) | inline void initialize( void ){
method calculate (line 87) | inline void calculate( void ) {
method check_result (line 93) | void check_result( void ){
FILE: VO_Module/thirdparty/eigen/bench/btl/actions/action_axpy.hh
class Action_axpy (line 32) | class Action_axpy {
method Action_axpy (line 38) | Action_axpy( int size ):_coef(1.0),_size(size)
method Action_axpy (line 61) | Action_axpy( const Action_axpy & )
method name (line 84) | static inline std::string name( void )
method nb_op_base (line 89) | double nb_op_base( void ){
method initialize (line 93) | inline void initialize( void ){
method calculate (line 98) | inline void calculate( void ) {
method check_result (line 104) | void check_result( void ){
FILE: VO_Module/thirdparty/eigen/bench/btl/actions/action_cholesky.hh
class Action_cholesky (line 31) | class Action_cholesky {
method Action_cholesky (line 37) | Action_cholesky( int size ):_size(size)
method Action_cholesky (line 64) | Action_cholesky( const Action_cholesky & )
method name (line 84) | static inline std::string name( void )
method nb_op_base (line 89) | double nb_op_base( void ){
method initialize (line 93) | inline void initialize( void ){
method calculate (line 97) | inline void calculate( void ) {
method check_result (line 101) | void check_result( void ){
FILE: VO_Module/thirdparty/eigen/bench/btl/actions/action_ger.hh
class Action_ger (line 27) | class Action_ger {
method BTL_DONT_INLINE (line 32) | BTL_DONT_INLINE Action_ger( int size ):_size(size)
method Action_ger (line 53) | Action_ger( const Action_ger & )
method BTL_DONT_INLINE (line 60) | BTL_DONT_INLINE ~Action_ger( void ){
method name (line 72) | static inline std::string name( void )
method nb_op_base (line 77) | double nb_op_base( void ){
method BTL_DONT_INLINE (line 81) | BTL_DONT_INLINE void initialize( void ){
method BTL_DONT_INLINE (line 87) | BTL_DONT_INLINE void calculate( void ) {
method BTL_DONT_INLINE (line 93) | BTL_DONT_INLINE void check_result( void ){
FILE: VO_Module/thirdparty/eigen/bench/btl/actions/action_hessenberg.hh
class Action_hessenberg (line 31) | class Action_hessenberg {
method Action_hessenberg (line 37) | Action_hessenberg( int size ):_size(size)
method Action_hessenberg (line 63) | Action_hessenberg( const Action_hessenberg & )
method name (line 83) | static inline std::string name( void )
method nb_op_base (line 88) | double nb_op_base( void ){
method initialize (line 92) | inline void initialize( void ){
method calculate (line 96) | inline void calculate( void ) {
method check_result (line 100) | void check_result( void ){
class Action_tridiagonalization (line 131) | class Action_tridiagonalization {
method Action_tridiagonalization (line 137) | Action_tridiagonalization( int size ):_size(size)
method Action_tridiagonalization (line 169) | Action_tridiagonalization( const Action_tridiagonalization & )
method name (line 189) | static inline std::string name( void ) { return "tridiagonalization_"+...
method nb_op_base (line 191) | double nb_op_base( void ){
method initialize (line 195) | inline void initialize( void ){
method calculate (line 199) | inline void calculate( void ) {
method check_result (line 203) | void check_result( void ){
FILE: VO_Module/thirdparty/eigen/bench/btl/actions/action_lu_decomp.hh
class Action_lu_decomp (line 31) | class Action_lu_decomp {
method Action_lu_decomp (line 37) | Action_lu_decomp( int size ):_size(size)
method Action_lu_decomp (line 57) | Action_lu_decomp( const Action_lu_decomp & )
method name (line 77) | static inline std::string name( void )
method nb_op_base (line 82) | double nb_op_base( void ){
method initialize (line 86) | inline void initialize( void ){
method calculate (line 90) | inline void calculate( void ) {
method check_result (line 94) | void check_result( void ){
FILE: VO_Module/thirdparty/eigen/bench/btl/actions/action_lu_solve.hh
class Action_lu_solve (line 32) | class Action_lu_solve
method name (line 37) | static inline std::string name( void )
method nb_op_base (line 42) | static double nb_op_base(int size){
method calculate (line 47) | static double calculate( int nb_calc, int size ) {
FILE: VO_Module/thirdparty/eigen/bench/btl/actions/action_matrix_matrix_product.hh
class Action_matrix_matrix_product (line 32) | class Action_matrix_matrix_product {
method Action_matrix_matrix_product (line 38) | Action_matrix_matrix_product( int size ):_size(size)
method Action_matrix_matrix_product (line 63) | Action_matrix_matrix_product( const Action_matrix_matrix_product & )
method name (line 89) | static inline std::string name( void )
method nb_op_base (line 94) | double nb_op_base( void ){
method initialize (line 98) | inline void initialize( void ){
method calculate (line 106) | inline void calculate( void ) {
method check_result (line 110) | void check_result( void ){
FILE: VO_Module/thirdparty/eigen/bench/btl/actions/action_matrix_matrix_product_bis.hh
class Action_matrix_matrix_product_bis (line 33) | class Action_matrix_matrix_product_bis {
method name (line 37) | static inline std::string name( void )
method nb_op_base (line 42) | static double nb_op_base(int size){
method calculate (line 46) | static double calculate( int nb_calc, int size ) {
FILE: VO_Module/thirdparty/eigen/bench/btl/actions/action_matrix_vector_product.hh
class Action_matrix_vector_product (line 32) | class Action_matrix_vector_product {
method BTL_DONT_INLINE (line 38) | BTL_DONT_INLINE Action_matrix_vector_product( int size ):_size(size)
method Action_matrix_vector_product (line 62) | Action_matrix_vector_product( const Action_matrix_vector_product & )
method BTL_DONT_INLINE (line 70) | BTL_DONT_INLINE ~Action_matrix_vector_product( void ){
method name (line 88) | static inline std::string name( void )
method nb_op_base (line 93) | double nb_op_base( void ){
method BTL_DONT_INLINE (line 97) | BTL_DONT_INLINE void initialize( void ){
method BTL_DONT_INLINE (line 105) | BTL_DONT_INLINE void calculate( void ) {
method BTL_DONT_INLINE (line 111) | BTL_DONT_INLINE void check_result( void ){
FILE: VO_Module/thirdparty/eigen/bench/btl/actions/action_partial_lu.hh
class Action_partial_lu (line 31) | class Action_partial_lu {
method Action_partial_lu (line 37) | Action_partial_lu( int size ):_size(size)
method Action_partial_lu (line 59) | Action_partial_lu( const Action_partial_lu & )
method name (line 79) | static inline std::string name( void )
method nb_op_base (line 84) | double nb_op_base( void ){
method initialize (line 88) | inline void initialize( void ){
method calculate (line 92) | inline void calculate( void ) {
method check_result (line 96) | void check_result( void ){
FILE: VO_Module/thirdparty/eigen/bench/btl/actions/action_rot.hh
class Action_rot (line 27) | class Action_rot {
method BTL_DONT_INLINE (line 32) | BTL_DONT_INLINE Action_rot( int size ):_size(size)
method Action_rot (line 49) | Action_rot( const Action_rot & )
method BTL_DONT_INLINE (line 56) | BTL_DONT_INLINE ~Action_rot( void ){
method name (line 65) | static inline std::string name( void )
method nb_op_base (line 70) | double nb_op_base( void ){
method BTL_DONT_INLINE (line 74) | BTL_DONT_INLINE void initialize( void ){
method BTL_DONT_INLINE (line 79) | BTL_DONT_INLINE void calculate( void ) {
method BTL_DONT_INLINE (line 85) | BTL_DONT_INLINE void check_result( void ){
FILE: VO_Module/thirdparty/eigen/bench/btl/actions/action_symv.hh
class Action_symv (line 32) | class Action_symv {
method BTL_DONT_INLINE (line 38) | BTL_DONT_INLINE Action_symv( int size ):_size(size)
method Action_symv (line 60) | Action_symv( const Action_symv & )
method BTL_DONT_INLINE (line 67) | BTL_DONT_INLINE ~Action_symv( void ){
method name (line 78) | static inline std::string name( void )
method nb_op_base (line 83) | double nb_op_base( void ){
method BTL_DONT_INLINE (line 87) | BTL_DONT_INLINE void initialize( void ){
method BTL_DONT_INLINE (line 95) | BTL_DONT_INLINE void calculate( void ) {
method BTL_DONT_INLINE (line 101) | BTL_DONT_INLINE void check_result( void ){
FILE: VO_Module/thirdparty/eigen/bench/btl/actions/action_syr2.hh
class Action_syr2 (line 32) | class Action_syr2 {
method BTL_DONT_INLINE (line 38) | BTL_DONT_INLINE Action_syr2( int size ):_size(size)
method Action_syr2 (line 57) | Action_syr2( const Action_syr2 & )
method BTL_DONT_INLINE (line 64) | BTL_DONT_INLINE ~Action_syr2( void ){
method name (line 75) | static inline std::string name( void )
method nb_op_base (line 80) | double nb_op_base( void ){
method BTL_DONT_INLINE (line 84) | BTL_DONT_INLINE void initialize( void ){
method BTL_DONT_INLINE (line 90) | BTL_DONT_INLINE void calculate( void ) {
method BTL_DONT_INLINE (line 96) | BTL_DONT_INLINE void check_result( void ){
FILE: VO_Module/thirdparty/eigen/bench/btl/actions/action_trisolve.hh
class Action_trisolve (line 31) | class Action_trisolve {
method Action_trisolve (line 37) | Action_trisolve( int size ):_size(size)
method Action_trisolve (line 68) | Action_trisolve( const Action_trisolve & )
method name (line 88) | static inline std::string name( void )
method nb_op_base (line 93) | double nb_op_base( void ){
method initialize (line 97) | inline void initialize( void ){
method calculate (line 101) | inline void calculate( void ) {
method check_result (line 105) | void check_result(){
FILE: VO_Module/thirdparty/eigen/bench/btl/actions/action_trisolve_matrix.hh
class Action_trisolve_matrix (line 32) | class Action_trisolve_matrix {
method Action_trisolve_matrix (line 38) | Action_trisolve_matrix( int size ):_size(size)
method Action_trisolve_matrix (line 76) | Action_trisolve_matrix( const Action_trisolve_matrix & )
method name (line 102) | static inline std::string name( void )
method nb_op_base (line 107) | double nb_op_base( void ){
method initialize (line 111) | inline void initialize( void ){
method calculate (line 119) | inline void calculate( void ) {
method check_result (line 123) | void check_result( void ){
FILE: VO_Module/thirdparty/eigen/bench/btl/actions/action_trmm.hh
class Action_trmm (line 32) | class Action_trmm {
method Action_trmm (line 38) | Action_trmm( int size ):_size(size)
method Action_trmm (line 76) | Action_trmm( const Action_trmm & )
method name (line 102) | static inline std::string name( void )
method nb_op_base (line 107) | double nb_op_base( void ){
method initialize (line 111) | inline void initialize( void ){
method calculate (line 119) | inline void calculate( void ) {
method check_result (line 123) | void check_result( void ){
FILE: VO_Module/thirdparty/eigen/bench/btl/generic_bench/bench.hh
function BTL_DONT_INLINE (line 41) | BTL_DONT_INLINE void bench( int size_min, int size_max, int nb_point )
function BTL_DONT_INLINE (line 154) | BTL_DONT_INLINE void bench( int size_min, int size_max, int nb_point ){
FILE: VO_Module/thirdparty/eigen/bench/btl/generic_bench/btl.hh
class BtlString (line 57) | class BtlString : public std::string
method BtlString (line 60) | BtlString() : std::string() {}
method BtlString (line 61) | BtlString(const BtlString& str) : std::string(static_cast<const std::s...
method BtlString (line 62) | BtlString(const std::string& str) : std::string(str) {}
method BtlString (line 63) | BtlString(const char* str) : std::string(str) {}
method trim (line 67) | void trim( bool left = true, bool right = true )
method split (line 81) | std::vector<BtlString> split( const BtlString& delims = "\t\n ") const
method endsWith (line 108) | bool endsWith(const BtlString& str) const
method contains (line 114) | bool contains(const BtlString& str) const
method beginsWith (line 118) | bool beginsWith(const BtlString& str) const
method BtlString (line 125) | BtlString toLowerCase( void )
method BtlString (line 130) | BtlString toUpperCase( void )
method isEquiv (line 138) | bool isEquiv(const BtlString& str) const
method decomposePathAndFile (line 150) | void decomposePathAndFile(BtlString& path, BtlString& filename) const
class BtlConfig (line 163) | class BtlConfig
method BtlConfig (line 166) | BtlConfig()
method BTL_DONT_INLINE (line 216) | BTL_DONT_INLINE static bool skipAction(const std::string& _name)
FILE: VO_Module/thirdparty/eigen/bench/btl/generic_bench/init/init_function.hh
function simple_function (line 23) | double simple_function(int index)
function simple_function (line 28) | double simple_function(int index_i, int index_j)
function pseudo_random (line 33) | double pseudo_random(int /*index*/)
function pseudo_random (line 38) | double pseudo_random(int /*index_i*/, int /*index_j*/)
function null_function (line 44) | double null_function(int /*index*/)
function null_function (line 49) | double null_function(int /*index_i*/, int /*index_j*/)
FILE: VO_Module/thirdparty/eigen/bench/btl/generic_bench/init/init_matrix.hh
function BTL_DONT_INLINE (line 28) | BTL_DONT_INLINE void init_row(Vector & X, int size, int row){
function BTL_DONT_INLINE (line 43) | BTL_DONT_INLINE void init_matrix(Vector & A, int size){
function BTL_DONT_INLINE (line 51) | BTL_DONT_INLINE void init_matrix_symm(Matrix& A, int size){
FILE: VO_Module/thirdparty/eigen/bench/btl/generic_bench/init/init_vector.hh
function init_vector (line 28) | void init_vector(Vector & X, int size){
FILE: VO_Module/thirdparty/eigen/bench/btl/generic_bench/static/bench_static.hh
function BTL_DONT_INLINE (line 37) | BTL_DONT_INLINE void bench_static(void)
function BTL_DONT_INLINE (line 58) | BTL_DONT_INLINE void bench_static(void)
FILE: VO_Module/thirdparty/eigen/bench/btl/generic_bench/static/intel_bench_fixed_size.hh
function bench_fixed_size (line 27) | double bench_fixed_size(int size, unsigned long long & nb_calc,unsigned...
FILE: VO_Module/thirdparty/eigen/bench/btl/generic_bench/static/static_size_generator.hh
type static_size_generator (line 29) | struct static_size_generator{
method go (line 30) | static void go(vector<double> & tab_sizes, vector<double> & tab_mflops)
type static_size_generator<1,Perf_Analyzer,Action,Interface> (line 44) | struct static_size_generator<1,Perf_Analyzer,Action,Interface>{
method go (line 45) | static void go(vector<double> & tab_sizes, vector<double> & tab_mflops)
FILE: VO_Module/thirdparty/eigen/bench/btl/generic_bench/timers/STL_perf_analyzer.hh
class STL_Perf_Analyzer (line 27) | class STL_Perf_Analyzer{
method STL_Perf_Analyzer (line 29) | STL_Perf_Analyzer(unsigned long long nb_sample=DEFAULT_NB_SAMPLE):_nb_...
method STL_Perf_Analyzer (line 33) | STL_Perf_Analyzer( const STL_Perf_Analyzer & ){
method eval_mflops (line 42) | inline double eval_mflops(int size)
FILE: VO_Module/thirdparty/eigen/bench/btl/generic_bench/timers/STL_timer.hh
class STL_Timer (line 30) | class STL_Timer {
method STL_Timer (line 32) | STL_Timer(){ baseline = false; }
method start (line 34) | void start(unsigned int r){
method start_baseline (line 42) | void start_baseline(unsigned int r)
method check (line 48) | bool check()
method get_time (line 60) | double get_time( void )
FILE: VO_Module/thirdparty/eigen/bench/btl/generic_bench/timers/mixed_perf_analyzer.hh
class Mixed_Perf_Analyzer (line 30) | class Mixed_Perf_Analyzer{
method Mixed_Perf_Analyzer (line 33) | Mixed_Perf_Analyzer( void ):_x86pa(),_ppa(),_use_ppa(true)
method Mixed_Perf_Analyzer (line 37) | Mixed_Perf_Analyzer( const Mixed_Perf_Analyzer & ){
method eval_mflops (line 46) | inline double eval_mflops(int size)
FILE: VO_Module/thirdparty/eigen/bench/btl/generic_bench/timers/portable_perf_analyzer.hh
class Portable_Perf_Analyzer (line 28) | class Portable_Perf_Analyzer{
method Portable_Perf_Analyzer (line 30) | Portable_Perf_Analyzer( ):_nb_calc(0), m_time_action(0), _chronos(){
method Portable_Perf_Analyzer (line 33) | Portable_Perf_Analyzer( const Portable_Perf_Analyzer & ){
method BTL_DONT_INLINE (line 41) | BTL_DONT_INLINE double eval_mflops(int size)
method BTL_DONT_INLINE (line 76) | BTL_DONT_INLINE double time_calculate(Action & action)
method get_nb_calc (line 89) | unsigned long long get_nb_calc()
FILE: VO_Module/thirdparty/eigen/bench/btl/generic_bench/timers/portable_perf_analyzer_old.hh
class Portable_Perf_Analyzer (line 27) | class Portable_Perf_Analyzer{
method Portable_Perf_Analyzer (line 29) | Portable_Perf_Analyzer( void ):_nb_calc(1),_nb_init(1),_chronos(){
method Portable_Perf_Analyzer (line 32) | Portable_Perf_Analyzer( const Portable_Perf_Analyzer & ){
method eval_mflops (line 42) | inline double eval_mflops(int size)
method time_init (line 97) | inline double time_init(Action & action)
method time_calculate (line 108) | inline double time_calculate(Action & action)
method get_nb_calc (line 121) | unsigned long long get_nb_calc( void )
FILE: VO_Module/thirdparty/eigen/bench/btl/generic_bench/timers/portable_timer.hh
class Portable_Timer (line 47) | class Portable_Timer
method Portable_Timer (line 57) | Portable_Timer()
method start (line 64) | void start() { QueryPerformanceCounter(&startVal); }
method stop (line 66) | void stop() { QueryPerformanceCounter(&stopVal); }
method elapsed (line 68) | double elapsed() {
method user_time (line 74) | double user_time() { return elapsed(); }
method LIToSecs (line 79) | double LIToSecs(LARGE_INTEGER& L) {
method Portable_Timer (line 99) | Portable_Timer()
method start (line 103) | void start()
method stop (line 109) | void stop()
method elapsed (line 115) | double elapsed()
method user_time (line 120) | double user_time()
method Portable_Timer (line 143) | Portable_Timer()
method Portable_Timer (line 148) | Portable_Timer(int clkid) : m_clkid(clkid)
method start (line 151) | void start()
method stop (line 159) | void stop()
method elapsed (line 167) | double elapsed()
method user_time (line 172) | double user_time()
class Portable_Timer (line 95) | class Portable_Timer
method Portable_Timer (line 57) | Portable_Timer()
method start (line 64) | void start() { QueryPerformanceCounter(&startVal); }
method stop (line 66) | void stop() { QueryPerformanceCounter(&stopVal); }
method elapsed (line 68) | double elapsed() {
method user_time (line 74) | double user_time() { return elapsed(); }
method LIToSecs (line 79) | double LIToSecs(LARGE_INTEGER& L) {
method Portable_Timer (line 99) | Portable_Timer()
method start (line 103) | void start()
method stop (line 109) | void stop()
method elapsed (line 115) | double elapsed()
method user_time (line 120) | double user_time()
method Portable_Timer (line 143) | Portable_Timer()
method Portable_Timer (line 148) | Portable_Timer(int clkid) : m_clkid(clkid)
method start (line 151) | void start()
method stop (line 159) | void stop()
method elapsed (line 167) | double elapsed()
method user_time (line 172) | double user_time()
class Portable_Timer (line 139) | class Portable_Timer
method Portable_Timer (line 57) | Portable_Timer()
method start (line 64) | void start() { QueryPerformanceCounter(&startVal); }
method stop (line 66) | void stop() { QueryPerformanceCounter(&stopVal); }
method elapsed (line 68) | double elapsed() {
method user_time (line 74) | double user_time() { return elapsed(); }
method LIToSecs (line 79) | double LIToSecs(LARGE_INTEGER& L) {
method Portable_Timer (line 99) | Portable_Timer()
method start (line 103) | void start()
method stop (line 109) | void stop()
method elapsed (line 115) | double elapsed()
method user_time (line 120) | double user_time()
method Portable_Timer (line 143) | Portable_Timer()
method Portable_Timer (line 148) | Portable_Timer(int clkid) : m_clkid(clkid)
method start (line 151) | void start()
method stop (line 159) | void stop()
method elapsed (line 167) | double elapsed()
method user_time (line 172) | double user_time()
FILE: VO_Module/thirdparty/eigen/bench/btl/generic_bench/timers/x86_perf_analyzer.hh
class X86_Perf_Analyzer (line 27) | class X86_Perf_Analyzer{
method X86_Perf_Analyzer (line 29) | X86_Perf_Analyzer( unsigned long long nb_sample=DEFAULT_NB_SAMPLE):_nb...
method X86_Perf_Analyzer (line 34) | X86_Perf_Analyzer( const X86_Perf_Analyzer & ){
method eval_mflops (line 43) | inline double eval_mflops(int size)
FILE: VO_Module/thirdparty/eigen/bench/btl/generic_bench/timers/x86_timer.hh
class X86_Timer (line 44) | class X86_Timer {
method X86_Timer (line 48) | X86_Timer( void ):_frequency(FREQUENCY),_nb_sample(0)
method start (line 53) | inline void start( void ){
method stop (line 60) | inline void stop( void ){
method frequency (line 67) | inline double frequency( void ){
method get_elapsed_time_in_second (line 71) | double get_elapsed_time_in_second( void ){
method get_click (line 78) | unsigned long long get_click( void ){
method find_frequency (line 84) | inline void find_frequency( void ){
method add_get_click (line 111) | void add_get_click( void ){
method dump_statistics (line 119) | void dump_statistics(string filemane){
method dump_history (line 133) | void dump_history(string filemane){
method get_mean_clicks (line 153) | double get_mean_clicks( void ){
method get_shortest_clicks (line 169) | double get_shortest_clicks( void ){
method fill_history_clicks (line 175) | void fill_history_clicks( void ){
method get_most_occured_clicks (line 184) | double get_most_occured_clicks( void ){
method clear (line 204) | void clear( void )
FILE: VO_Module/thirdparty/eigen/bench/btl/generic_bench/utils/size_lin_log.hh
function size_lin_log (line 26) | void size_lin_log(const int nb_point, const int /*size_min*/, const int ...
FILE: VO_Module/thirdparty/eigen/bench/btl/generic_bench/utils/size_log.hh
function size_log (line 29) | void size_log(const int nb_point, const int size_min, const int size_max...
FILE: VO_Module/thirdparty/eigen/bench/btl/generic_bench/utils/xy_file.hh
function read_xy_file (line 28) | bool read_xy_file(const std::string & filename, std::vector<int> & tab_s...
function dump_xy_file (line 64) | void dump_xy_file(const Vector_A & X, const Vector_B & Y, const std::str...
FILE: VO_Module/thirdparty/eigen/bench/btl/libs/BLAS/blas.h
type BLASLONG (line 7) | typedef long long BLASLONG;
type BLASULONG (line 8) | typedef unsigned long long BLASULONG;
type BLASLONG (line 10) | typedef long BLASLONG;
type BLASULONG (line 11) | typedef unsigned long BLASULONG;
FILE: VO_Module/thirdparty/eigen/bench/btl/libs/BLAS/blas_interface.hh
class blas_interface (line 54) | class blas_interface
FILE: VO_Module/thirdparty/eigen/bench/btl/libs/BLAS/blas_interface_impl.hh
class blas_interface<SCALAR> (line 4) | class blas_interface<SCALAR> : public c_interface_base<SCALAR>
method name (line 12) | static inline std::string name()
method matrix_vector_product (line 17) | static inline void matrix_vector_product(gene_matrix & A, gene_vector ...
method symv (line 21) | static inline void symv(gene_matrix & A, gene_vector & B, gene_vector ...
method syr2 (line 25) | static inline void syr2(gene_matrix & A, gene_vector & B, gene_vector ...
method ger (line 29) | static inline void ger(gene_matrix & A, gene_vector & X, gene_vector &...
method rot (line 33) | static inline void rot(gene_vector & A, gene_vector & B, SCALAR c, SC...
method atv_product (line 37) | static inline void atv_product(gene_matrix & A, gene_vector & B, gene_...
method matrix_matrix_product (line 41) | static inline void matrix_matrix_product(gene_matrix & A, gene_matrix ...
method transposed_matrix_matrix_product (line 45) | static inline void transposed_matrix_matrix_product(gene_matrix & A, g...
method ata_product (line 49) | static inline void ata_product(gene_matrix & A, gene_matrix & X, int N){
method aat_product (line 53) | static inline void aat_product(gene_matrix & A, gene_matrix & X, int N){
method axpy (line 57) | static inline void axpy(SCALAR coef, const gene_vector & X, gene_vecto...
method axpby (line 61) | static inline void axpby(SCALAR a, const gene_vector & X, SCALAR b, ge...
method cholesky (line 66) | static inline void cholesky(const gene_matrix & X, gene_matrix & C, in...
method partial_lu_decomp (line 75) | static inline void partial_lu_decomp(const gene_matrix & X, gene_matri...
method trisolve_lower (line 84) | static inline void trisolve_lower(const gene_matrix & L, const gene_ve...
method trisolve_lower_matrix (line 89) | static inline void trisolve_lower_matrix(const gene_matrix & L, const ...
method trmm (line 94) | static inline void trmm(gene_matrix & A, gene_matrix & B, gene_matrix ...
method lu_decomp (line 100) | static inline void lu_decomp(const gene_matrix & X, gene_matrix & C, i...
method hessenberg (line 111) | static inline void hessenberg(const gene_matrix & X, gene_matrix & C, ...
method tridiagonalization (line 127) | static inline void tridiagonalization(const gene_matrix & X, gene_matr...
FILE: VO_Module/thirdparty/eigen/bench/btl/libs/BLAS/c_interface_base.h
type std (line 14) | typedef std::vector<real> stl_vector;
type std (line 15) | typedef std::vector<stl_vector > stl_matrix;
type real (line 17) | typedef real* gene_matrix;
type real (line 18) | typedef real* gene_vector;
function free_matrix (line 20) | static void free_matrix(gene_matrix & A, int /*N*/){
function free_vector (line 24) | static void free_vector(gene_vector & B){
function matrix_from_stl (line 28) | static inline void matrix_from_stl(gene_matrix & A, stl_matrix & A_stl){
function vector_from_stl (line 36) | static inline void vector_from_stl(gene_vector & B, stl_vector & B_stl){
function vector_to_stl (line 43) | static inline void vector_to_stl(gene_vector & B, stl_vector & B_stl){
function matrix_to_stl (line 49) | static inline void matrix_to_stl(gene_matrix & A, stl_matrix & A_stl){
function copy_vector (line 58) | static inline void copy_vector(const gene_vector & source, gene_vector &...
function copy_matrix (line 63) | static inline void copy_matrix(const gene_matrix & source, gene_matrix &...
FILE: VO_Module/thirdparty/eigen/bench/btl/libs/BLAS/main.cpp
function main (line 36) | int main()
FILE: VO_Module/thirdparty/eigen/bench/btl/libs/STL/STL_interface.hh
class STL_interface (line 29) | class STL_interface{
method name (line 42) | static inline std::string name( void )
method free_matrix (line 47) | static void free_matrix(gene_matrix & /*A*/, int /*N*/){}
method free_vector (line 49) | static void free_vector(gene_vector & /*B*/){}
method matrix_from_stl (line 51) | static inline void matrix_from_stl(gene_matrix & A, stl_matrix & A_stl){
method vector_from_stl (line 55) | static inline void vector_from_stl(gene_vector & B, stl_vector & B_stl){
method vector_to_stl (line 59) | static inline void vector_to_stl(gene_vector & B, stl_vector & B_stl){
method matrix_to_stl (line 64) | static inline void matrix_to_stl(gene_matrix & A, stl_matrix & A_stl){
method copy_vector (line 68) | static inline void copy_vector(const gene_vector & source, gene_vector...
method copy_matrix (line 75) | static inline void copy_matrix(const gene_matrix & source, gene_matrix...
method ata_product (line 81) | static inline void ata_product(const gene_matrix & A, gene_matrix & X,...
method aat_product (line 94) | static inline void aat_product(const gene_matrix & A, gene_matrix & X,...
method matrix_matrix_product (line 112) | static inline void matrix_matrix_product(const gene_matrix & A, const ...
method matrix_vector_product (line 125) | static inline void matrix_vector_product(gene_matrix & A, gene_vector ...
method symv (line 136) | static inline void symv(gene_matrix & A, gene_vector & B, gene_vector ...
method syr2 (line 153) | static inline void syr2(gene_matrix & A, gene_vector & B, gene_vector ...
method ger (line 162) | static inline void ger(gene_matrix & A, gene_vector & X, gene_vector &...
method atv_product (line 171) | static inline void atv_product(gene_matrix & A, gene_vector & B, gene_...
method axpy (line 182) | static inline void axpy(real coef, const gene_vector & X, gene_vector ...
method axpby (line 187) | static inline void axpby(real a, const gene_vector & X, real b, gene_v...
method trisolve_lower (line 192) | static inline void trisolve_lower(const gene_matrix & L, const gene_ve...
method real (line 203) | static inline real norm_diff(const stl_vector & A, const stl_vector & B)
method real (line 217) | static inline real norm_diff(const stl_matrix & A, const stl_matrix & B)
method display_vector (line 234) | static inline void display_vector(const stl_vector & A)
FILE: VO_Module/thirdparty/eigen/bench/btl/libs/STL/main.cpp
function main (line 27) | int main()
FILE: VO_Module/thirdparty/eigen/bench/btl/libs/blaze/blaze_interface.hh
class blaze_interface (line 29) | class blaze_interface {
method name (line 41) | static inline std::string name() { return "blaze"; }
method free_matrix (line 43) | static void free_matrix(gene_matrix & A, int N){
method free_vector (line 47) | static void free_vector(gene_vector & B){
method matrix_from_stl (line 51) | static inline void matrix_from_stl(gene_matrix & A, stl_matrix & A_stl){
method vector_from_stl (line 61) | static inline void vector_from_stl(gene_vector & B, stl_vector & B_stl){
method vector_to_stl (line 68) | static inline void vector_to_stl(gene_vector & B, stl_vector & B_stl){
method matrix_to_stl (line 74) | static inline void matrix_to_stl(gene_matrix & A, stl_matrix & A_stl){
method EIGEN_DONT_INLINE (line 84) | static EIGEN_DONT_INLINE void matrix_matrix_product(const gene_matrix ...
method EIGEN_DONT_INLINE (line 88) | static EIGEN_DONT_INLINE void transposed_matrix_matrix_product(const g...
method EIGEN_DONT_INLINE (line 92) | static EIGEN_DONT_INLINE void ata_product(const gene_matrix & A, gene_...
method EIGEN_DONT_INLINE (line 96) | static EIGEN_DONT_INLINE void aat_product(const gene_matrix & A, gene_...
method EIGEN_DONT_INLINE (line 100) | static EIGEN_DONT_INLINE void matrix_vector_product(gene_matrix & A, g...
method EIGEN_DONT_INLINE (line 104) | static EIGEN_DONT_INLINE void atv_product(gene_matrix & A, gene_vector...
method EIGEN_DONT_INLINE (line 108) | static EIGEN_DONT_INLINE void axpy(const real coef, const gene_vector ...
method EIGEN_DONT_INLINE (line 112) | static EIGEN_DONT_INLINE void axpby(real a, const gene_vector & X, rea...
method copy_matrix (line 131) | static inline void copy_matrix(const gene_matrix & source, gene_matrix...
method copy_vector (line 135) | static inline void copy_vector(const gene_vector & source, gene_vector...
FILE: VO_Module/thirdparty/eigen/bench/btl/libs/blaze/main.cpp
function main (line 25) | int main()
FILE: VO_Module/thirdparty/eigen/bench/btl/libs/blitz/blitz_LU_solve_interface.hh
class blitz_LU_solve_interface (line 29) | class blitz_LU_solve_interface : public blitz_interface<real>
method new_Pivot_Vector (line 39) | inline static void new_Pivot_Vector(Pivot_Vector & pivot,int N)
method free_Pivot_Vector (line 46) | inline static void free_Pivot_Vector(Pivot_Vector & pivot)
method real (line 54) | static inline real matrix_vector_product_sliced(const gene_matrix & A,...
method real (line 72) | static inline real matrix_matrix_product_sliced(gene_matrix & A, int r...
method LU_factor (line 87) | inline static void LU_factor(gene_matrix & LU, Pivot_Vector & pivot, i...
method LU_solve (line 150) | inline static void LU_solve(const gene_matrix & LU, const Pivot_Vector...
FILE: VO_Module/thirdparty/eigen/bench/btl/libs/blitz/blitz_interface.hh
class blitz_interface (line 34) | class blitz_interface{
method name (line 48) | static inline std::string name() { return "blitz"; }
method free_matrix (line 50) | static void free_matrix(gene_matrix & A, int N){}
method free_vector (line 52) | static void free_vector(gene_vector & B){}
method matrix_from_stl (line 54) | static inline void matrix_from_stl(gene_matrix & A, stl_matrix & A_stl){
method vector_from_stl (line 63) | static inline void vector_from_stl(gene_vector & B, stl_vector & B_stl){
method vector_to_stl (line 70) | static inline void vector_to_stl(gene_vector & B, stl_vector & B_stl){
method matrix_to_stl (line 76) | static inline void matrix_to_stl(gene_matrix & A, stl_matrix & A_stl){
method matrix_matrix_product (line 85) | static inline void matrix_matrix_product(const gene_matrix & A, const ...
method ata_product (line 93) | static inline void ata_product(const gene_matrix & A, gene_matrix & X,...
method aat_product (line 101) | static inline void aat_product(const gene_matrix & A, gene_matrix & X,...
method matrix_vector_product (line 109) | static inline void matrix_vector_product(gene_matrix & A, gene_vector ...
method atv_product (line 116) | static inline void atv_product(gene_matrix & A, gene_vector & B, gene_...
method axpy (line 123) | static inline void axpy(const real coef, const gene_vector & X, gene_v...
method copy_matrix (line 130) | static inline void copy_matrix(const gene_matrix & source, gene_matrix...
method copy_vector (line 140) | static inline void copy_vector(const gene_vector & source, gene_vector...
FILE: VO_Module/thirdparty/eigen/bench/btl/libs/blitz/btl_blitz.cpp
function main (line 34) | int main()
FILE: VO_Module/thirdparty/eigen/bench/btl/libs/blitz/btl_tiny_blitz.cpp
function main (line 29) | int main()
FILE: VO_Module/thirdparty/eigen/bench/btl/libs/blitz/tiny_blitz_interface.hh
class tiny_blitz_interface (line 34) | class tiny_blitz_interface
method name (line 47) | static inline std::string name() { return "tiny_blitz"; }
method free_matrix (line 49) | static void free_matrix(gene_matrix & A, int N){}
method free_vector (line 51) | static void free_vector(gene_vector & B){}
method matrix_from_stl (line 53) | static inline void matrix_from_stl(gene_matrix & A, stl_matrix & A_stl){
method vector_from_stl (line 59) | static inline void vector_from_stl(gene_vector & B, stl_vector & B_stl){
method vector_to_stl (line 64) | static inline void vector_to_stl(gene_vector & B, stl_vector & B_stl){
method matrix_to_stl (line 69) | static inline void matrix_to_stl(gene_matrix & A, stl_matrix & A_stl){
method copy_matrix (line 79) | static inline void copy_matrix(const gene_matrix & source, gene_matrix...
method copy_vector (line 85) | static inline void copy_vector(const gene_vector & source, gene_vector...
method matrix_matrix_product (line 91) | static inline void matrix_matrix_product(const gene_matrix & A, const ...
method matrix_vector_product (line 95) | static inline void matrix_vector_product(gene_matrix & A, gene_vector ...
method axpy (line 99) | static inline void axpy(const real coef, const gene_vector & X, gene_v...
FILE: VO_Module/thirdparty/eigen/bench/btl/libs/eigen2/btl_tiny_eigen2.cpp
function main (line 33) | int main()
FILE: VO_Module/thirdparty/eigen/bench/btl/libs/eigen2/eigen2_interface.hh
class eigen2_interface (line 31) | class eigen2_interface
method name (line 46) | static inline std::string name( void )
method free_matrix (line 57) | static void free_matrix(gene_matrix & A, int N) {}
method free_vector (line 59) | static void free_vector(gene_vector & B) {}
method BTL_DONT_INLINE (line 61) | static BTL_DONT_INLINE void matrix_from_stl(gene_matrix & A, stl_matri...
method BTL_DONT_INLINE (line 71) | static BTL_DONT_INLINE void vector_from_stl(gene_vector & B, stl_vect...
method BTL_DONT_INLINE (line 79) | static BTL_DONT_INLINE void vector_to_stl(gene_vector & B, stl_vector...
method BTL_DONT_INLINE (line 85) | static BTL_DONT_INLINE void matrix_to_stl(gene_matrix & A, stl_matrix...
method matrix_matrix_product (line 96) | static inline void matrix_matrix_product(const gene_matrix & A, const ...
method transposed_matrix_matrix_product (line 100) | static inline void transposed_matrix_matrix_product(const gene_matrix ...
method ata_product (line 104) | static inline void ata_product(const gene_matrix & A, gene_matrix & X,...
method aat_product (line 108) | static inline void aat_product(const gene_matrix & A, gene_matrix & X,...
method matrix_vector_product (line 112) | static inline void matrix_vector_product(const gene_matrix & A, const ...
method atv_product (line 116) | static inline void atv_product(gene_matrix & A, gene_vector & B, gene_...
method axpy (line 120) | static inline void axpy(real coef, const gene_vector & X, gene_vector ...
method axpby (line 124) | static inline void axpby(real a, const gene_vector & X, real b, gene_v...
method copy_matrix (line 128) | static inline void copy_matrix(const gene_matrix & source, gene_matrix...
method copy_vector (line 132) | static inline void copy_vector(const gene_vector & source, gene_vector...
method trisolve_lower (line 136) | static inline void trisolve_lower(const gene_matrix & L, const gene_ve...
method trisolve_lower_matrix (line 140) | static inline void trisolve_lower_matrix(const gene_matrix & L, const ...
method cholesky (line 144) | static inline void cholesky(const gene_matrix & X, gene_matrix & C, in...
method lu_decomp (line 151) | static inline void lu_decomp(const gene_matrix & X, gene_matrix & C, i...
method tridiagonalization (line 156) | static inline void tridiagonalization(const gene_matrix & X, gene_matr...
method hessenberg (line 160) | static inline void hessenberg(const gene_matrix & X, gene_matrix & C, ...
FILE: VO_Module/thirdparty/eigen/bench/btl/libs/eigen2/main_adv.cpp
function main (line 30) | int main()
FILE: VO_Module/thirdparty/eigen/bench/btl/libs/eigen2/main_linear.cpp
function main (line 25) | int main()
FILE: VO_Module/thirdparty/eigen/bench/btl/libs/eigen2/main_matmat.cpp
function main (line 25) | int main()
FILE: VO_Module/thirdparty/eigen/bench/btl/libs/eigen2/main_vecmat.cpp
function main (line 25) | int main()
FILE: VO_Module/thirdparty/eigen/bench/btl/libs/eigen3/btl_tiny_eigen3.cpp
function main (line 33) | int main()
FILE: VO_Module/thirdparty/eigen/bench/btl/libs/eigen3/eigen3_interface.hh
class eigen3_interface (line 28) | class eigen3_interface
method name (line 43) | static inline std::string name( void )
method free_matrix (line 48) | static void free_matrix(gene_matrix & /*A*/, int /*N*/) {}
method free_vector (line 50) | static void free_vector(gene_vector & /*B*/) {}
method BTL_DONT_INLINE (line 52) | static BTL_DONT_INLINE void matrix_from_stl(gene_matrix & A, stl_matri...
method BTL_DONT_INLINE (line 62) | static BTL_DONT_INLINE void vector_from_stl(gene_vector & B, stl_vect...
method BTL_DONT_INLINE (line 70) | static BTL_DONT_INLINE void vector_to_stl(gene_vector & B, stl_vector...
method BTL_DONT_INLINE (line 76) | static BTL_DONT_INLINE void matrix_to_stl(gene_matrix & A, stl_matrix...
method matrix_matrix_product (line 87) | static inline void matrix_matrix_product(const gene_matrix & A, const ...
method transposed_matrix_matrix_product (line 91) | static inline void transposed_matrix_matrix_product(const gene_matrix ...
method ata_product (line 95) | static inline void ata_product(const gene_matrix & A, gene_matrix & X,...
method aat_product (line 101) | static inline void aat_product(const gene_matrix & A, gene_matrix & X,...
method matrix_vector_product (line 106) | static inline void matrix_vector_product(const gene_matrix & A, const ...
method symv (line 110) | static inline void symv(const gene_matrix & A, const gene_vector & B, ...
method triassign (line 115) | static void triassign(Dest& dst, const Src& src)
method EIGEN_DONT_INLINE (line 160) | static EIGEN_DONT_INLINE void syr2(gene_matrix & A, gene_vector & X, ...
method EIGEN_DONT_INLINE (line 166) | static EIGEN_DONT_INLINE void ger(gene_matrix & A, gene_vector & X, g...
method EIGEN_DONT_INLINE (line 171) | static EIGEN_DONT_INLINE void rot(gene_vector & A, gene_vector & B, r...
method atv_product (line 175) | static inline void atv_product(gene_matrix & A, gene_vector & B, gene_...
method axpy (line 179) | static inline void axpy(real coef, const gene_vector & X, gene_vector ...
method axpby (line 183) | static inline void axpby(real a, const gene_vector & X, real b, gene_v...
method EIGEN_DONT_INLINE (line 187) | static EIGEN_DONT_INLINE void copy_matrix(const gene_matrix & source, ...
method EIGEN_DONT_INLINE (line 191) | static EIGEN_DONT_INLINE void copy_vector(const gene_vector & source, ...
method trisolve_lower (line 195) | static inline void trisolve_lower(const gene_matrix & L, const gene_ve...
method trisolve_lower_matrix (line 199) | static inline void trisolve_lower_matrix(const gene_matrix & L, const ...
method trmm (line 203) | static inline void trmm(const gene_matrix & L, const gene_matrix& B, g...
method cholesky (line 207) | static inline void cholesky(const gene_matrix & X, gene_matrix & C, in...
method lu_decomp (line 216) | static inline void lu_decomp(const gene_matrix & X, gene_matrix & C, i...
method partial_lu_decomp (line 220) | static inline void partial_lu_decomp(const gene_matrix & X, gene_matri...
method tridiagonalization (line 228) | static inline void tridiagonalization(const gene_matrix & X, gene_matr...
method hessenberg (line 234) | static inline void hessenberg(const gene_matrix & X, gene_matrix & C, ...
FILE: VO_Module/thirdparty/eigen/bench/btl/libs/eigen3/main_adv.cpp
function main (line 30) | int main()
FILE: VO_Module/thirdparty/eigen/bench/btl/libs/eigen3/main_linear.cpp
function main (line 25) | int main()
FILE: VO_Module/thirdparty/eigen/bench/btl/libs/eigen3/main_matmat.cpp
function main (line 25) | int main()
FILE: VO_Module/thirdparty/eigen/bench/btl/libs/eigen3/main_vecmat.cpp
function main (line 25) | int main()
FILE: VO_Module/thirdparty/eigen/bench/btl/libs/gmm/gmm_LU_solve_interface.hh
class blitz_LU_solve_interface (line 29) | class blitz_LU_solve_interface : public blitz_interface<real>
method new_Pivot_Vector (line 39) | inline static void new_Pivot_Vector(Pivot_Vector & pivot,int N)
method free_Pivot_Vector (line 46) | inline static void free_Pivot_Vector(Pivot_Vector & pivot)
method real (line 54) | static inline real matrix_vector_product_sliced(const gene_matrix & A,...
method real (line 72) | static inline real matrix_matrix_product_sliced(gene_matrix & A, int r...
method LU_factor (line 87) | inline static void LU_factor(gene_matrix & LU, Pivot_Vector & pivot, i...
method LU_solve (line 150) | inline static void LU_solve(const gene_matrix & LU, const Pivot_Vector...
FILE: VO_Module/thirdparty/eigen/bench/btl/libs/gmm/gmm_interface.hh
class gmm_interface (line 27) | class gmm_interface {
method name (line 39) | static inline std::string name( void )
method free_matrix (line 44) | static void free_matrix(gene_matrix & A, int N){
method free_vector (line 48) | static void free_vector(gene_vector & B){
method matrix_from_stl (line 52) | static inline void matrix_from_stl(gene_matrix & A, stl_matrix & A_stl){
method vector_from_stl (line 62) | static inline void vector_from_stl(gene_vector & B, stl_vector & B_stl){
method vector_to_stl (line 66) | static inline void vector_to_stl(gene_vector & B, stl_vector & B_stl){
method matrix_to_stl (line 70) | static inline void matrix_to_stl(gene_matrix & A, stl_matrix & A_stl){
method matrix_matrix_product (line 81) | static inline void matrix_matrix_product(const gene_matrix & A, const ...
method transposed_matrix_matrix_product (line 85) | static inline void transposed_matrix_matrix_product(const gene_matrix ...
method ata_product (line 89) | static inline void ata_product(const gene_matrix & A, gene_matrix & X,...
method aat_product (line 93) | static inline void aat_product(const gene_matrix & A, gene_matrix & X,...
method matrix_vector_product (line 97) | static inline void matrix_vector_product(gene_matrix & A, gene_vector ...
method atv_product (line 101) | static inline void atv_product(gene_matrix & A, gene_vector & B, gene_...
method axpy (line 105) | static inline void axpy(const real coef, const gene_vector & X, gene_v...
method axpby (line 109) | static inline void axpby(real a, const gene_vector & X, real b, gene_v...
method copy_matrix (line 113) | static inline void copy_matrix(const gene_matrix & source, gene_matrix...
method copy_vector (line 117) | static inline void copy_vector(const gene_vector & source, gene_vector...
method trisolve_lower (line 121) | static inline void trisolve_lower(const gene_matrix & L, const gene_ve...
method partial_lu_decomp (line 126) | static inline void partial_lu_decomp(const gene_matrix & X, gene_matri...
method hessenberg (line 132) | static inline void hessenberg(const gene_matrix & X, gene_matrix & R, ...
method tridiagonalization (line 137) | static inline void tridiagonalization(const gene_matrix & X, gene_matr...
FILE: VO_Module/thirdparty/eigen/bench/btl/libs/gmm/main.cpp
function main (line 27) | int main()
FILE: VO_Module/thirdparty/eigen/bench/btl/libs/mtl4/main.cpp
function main (line 27) | int main()
FILE: VO_Module/thirdparty/eigen/bench/btl/libs/mtl4/mtl4_LU_solve_interface.hh
class blitz_LU_solve_interface (line 29) | class blitz_LU_solve_interface : public blitz_interface<real>
method new_Pivot_Vector (line 39) | inline static void new_Pivot_Vector(Pivot_Vector & pivot,int N)
method free_Pivot_Vector (line 46) | inline static void free_Pivot_Vector(Pivot_Vector & pivot)
method real (line 54) | static inline real matrix_vector_product_sliced(const gene_matrix & A,...
method real (line 72) | static inline real matrix_matrix_product_sliced(gene_matrix & A, int r...
method LU_factor (line 87) | inline static void LU_factor(gene_matrix & LU, Pivot_Vector & pivot, i...
method LU_solve (line 150) | inline static void LU_solve(const gene_matrix & LU, const Pivot_Vector...
FILE: VO_Module/thirdparty/eigen/bench/btl/libs/mtl4/mtl4_interface.hh
class mtl4_interface (line 29) | class mtl4_interface {
method name (line 41) | static inline std::string name() { return "mtl4"; }
method free_matrix (line 43) | static void free_matrix(gene_matrix & A, int N){
method free_vector (line 47) | static void free_vector(gene_vector & B){
method matrix_from_stl (line 51) | static inline void matrix_from_stl(gene_matrix & A, stl_matrix & A_stl){
method vector_from_stl (line 61) | static inline void vector_from_stl(gene_vector & B, stl_vector & B_stl){
method vector_to_stl (line 68) | static inline void vector_to_stl(gene_vector & B, stl_vector & B_stl){
method matrix_to_stl (line 74) | static inline void matrix_to_stl(gene_matrix & A, stl_matrix & A_stl){
method matrix_matrix_product (line 84) | static inline void matrix_matrix_product(const gene_matrix & A, const ...
method transposed_matrix_matrix_product (line 91) | static inline void transposed_matrix_matrix_product(const gene_matrix ...
method aat_product (line 99) | static inline void aat_product(const gene_matrix & A, gene_matrix & X,...
method matrix_vector_product (line 103) | static inline void matrix_vector_product(gene_matrix & A, gene_vector ...
method atv_product (line 107) | static inline void atv_product(gene_matrix & A, gene_vector & B, gene_...
method axpy (line 111) | static inline void axpy(const real coef, const gene_vector & X, gene_v...
method axpby (line 115) | static inline void axpby(real a, const gene_vector & X, real b, gene_v...
method trisolve_lower (line 130) | static inline void trisolve_lower(const gene_matrix & L, const gene_ve...
method copy_matrix (line 134) | static inline void copy_matrix(const gene_matrix & source, gene_matrix...
method copy_vector (line 138) | static inline void copy_vector(const gene_vector & source, gene_vector...
FILE: VO_Module/thirdparty/eigen/bench/btl/libs/tensors/main_linear.cpp
function main (line 17) | int main()
FILE: VO_Module/thirdparty/eigen/bench/btl/libs/tensors/main_matmat.cpp
function main (line 16) | int main()
FILE: VO_Module/thirdparty/eigen/bench/btl/libs/tensors/main_vecmat.cpp
function main (line 16) | int main()
FILE: VO_Module/thirdparty/eigen/bench/btl/libs/tensors/tensor_interface.hh
class tensor_interface (line 19) | class tensor_interface
method name (line 32) | static inline std::string name( void )
method free_matrix (line 37) | static void free_matrix(gene_matrix & /*A*/, int /*N*/) {}
method free_vector (line 39) | static void free_vector(gene_vector & /*B*/) {}
method BTL_DONT_INLINE (line 41) | static BTL_DONT_INLINE void matrix_from_stl(gene_matrix & A, stl_matri...
method BTL_DONT_INLINE (line 51) | static BTL_DONT_INLINE void vector_from_stl(gene_vector & B, stl_vect...
method BTL_DONT_INLINE (line 59) | static BTL_DONT_INLINE void vector_to_stl(gene_vector & B, stl_vector...
method BTL_DONT_INLINE (line 65) | static BTL_DONT_INLINE void matrix_to_stl(gene_matrix & A, stl_matrix...
method matrix_matrix_product (line 76) | static inline void matrix_matrix_product(const gene_matrix & A, const ...
method matrix_vector_product (line 82) | static inline void matrix_vector_product(const gene_matrix & A, const ...
method axpy (line 88) | static inline void axpy(real coef, const gene_vector & X, gene_vector ...
method axpby (line 92) | static inline void axpby(real a, const gene_vector & X, real b, gene_v...
method EIGEN_DONT_INLINE (line 96) | static EIGEN_DONT_INLINE void copy_matrix(const gene_matrix & source, ...
method EIGEN_DONT_INLINE (line 100) | static EIGEN_DONT_INLINE void copy_vector(const gene_vector & source, ...
FILE: VO_Module/thirdparty/eigen/bench/btl/libs/tvmet/main.cpp
function main (line 30) | int main()
FILE: VO_Module/thirdparty/eigen/bench/btl/libs/tvmet/tvmet_interface.hh
class tvmet_interface (line 32) | class tvmet_interface{
method name (line 44) | static inline std::string name() { return "tiny_tvmet"; }
method free_matrix (line 46) | static void free_matrix(gene_matrix & A, int N){}
method free_vector (line 48) | static void free_vector(gene_vector & B){}
method matrix_from_stl (line 50) | static inline void matrix_from_stl(gene_matrix & A, stl_matrix & A_stl){
method vector_from_stl (line 56) | static inline void vector_from_stl(gene_vector & B, stl_vector & B_stl){
method vector_to_stl (line 61) | static inline void vector_to_stl(gene_vector & B, stl_vector & B_stl){
method matrix_to_stl (line 67) | static inline void matrix_to_stl(gene_matrix & A, stl_matrix & A_stl){
method copy_matrix (line 77) | static inline void copy_matrix(const gene_matrix & source, gene_matrix...
method copy_vector (line 81) | static inline void copy_vector(const gene_vector & source, gene_vector...
method matrix_matrix_product (line 85) | static inline void matrix_matrix_product(const gene_matrix & A, const ...
method matrix_vector_product (line 89) | static inline void matrix_vector_product(gene_matrix & A, gene_vector ...
method atv_product (line 93) | static inline void atv_product(gene_matrix & A, gene_vector & B, gene_...
method axpy (line 97) | static inline void axpy(const real coef, const gene_vector & X, gene_v...
FILE: VO_Module/thirdparty/eigen/bench/btl/libs/ublas/main.cpp
function main (line 27) | int main()
FILE: VO_Module/thirdparty/eigen/bench/btl/libs/ublas/ublas_interface.hh
class ublas_interface (line 31) | class ublas_interface{
method name (line 43) | static inline std::string name( void ) { return "ublas"; }
method free_matrix (line 45) | static void free_matrix(gene_matrix & A, int N) {}
method free_vector (line 47) | static void free_vector(gene_vector & B) {}
method matrix_from_stl (line 49) | static inline void matrix_from_stl(gene_matrix & A, stl_matrix & A_stl){
method vector_from_stl (line 56) | static inline void vector_from_stl(gene_vector & B, stl_vector & B_stl){
method vector_to_stl (line 62) | static inline void vector_to_stl(gene_vector & B, stl_vector & B_stl){
method matrix_to_stl (line 67) | static inline void matrix_to_stl(gene_matrix & A, stl_matrix & A_stl){
method copy_vector (line 77) | static inline void copy_vector(const gene_vector & source, gene_vector...
method copy_matrix (line 83) | static inline void copy_matrix(const gene_matrix & source, gene_matrix...
method matrix_vector_product_slow (line 91) | static inline void matrix_vector_product_slow(gene_matrix & A, gene_ve...
method matrix_matrix_product_slow (line 95) | static inline void matrix_matrix_product_slow(gene_matrix & A, gene_ma...
method axpy_slow (line 99) | static inline void axpy_slow(const real coef, const gene_vector & X, g...
method matrix_vector_product (line 105) | static inline void matrix_vector_product(gene_matrix & A, gene_vector ...
method atv_product (line 109) | static inline void atv_product(gene_matrix & A, gene_vector & B, gene_...
method matrix_matrix_product (line 113) | static inline void matrix_matrix_product(gene_matrix & A, gene_matrix ...
method axpy (line 117) | static inline void axpy(const real coef, const gene_vector & X, gene_v...
method axpby (line 121) | static inline void axpby(real a, const gene_vector & X, real b, gene_v...
method ata_product (line 125) | static inline void ata_product(gene_matrix & A, gene_matrix & X, int N){
method aat_product (line 130) | static inline void aat_product(gene_matrix & A, gene_matrix & X, int N){
method trisolve_lower (line 135) | static inline void trisolve_lower(const gene_matrix & L, const gene_ve...
FILE: VO_Module/thirdparty/eigen/bench/check_cache_queries.cpp
function main (line 18) | int main()
FILE: VO_Module/thirdparty/eigen/bench/dense_solvers.cpp
function EIGEN_DONT_INLINE (line 15) | EIGEN_DONT_INLINE
function EIGEN_DONT_INLINE (line 24) | EIGEN_DONT_INLINE
function bench (line 30) | void bench(int id, int rows, int size = Size)
function main (line 87) | int main()
FILE: VO_Module/thirdparty/eigen/bench/eig33.cpp
function computeRoots (line 49) | inline void computeRoots(const Matrix& m, Roots& roots)
function eigen33 (line 86) | void eigen33(const Matrix& mat, Matrix& evecs, Vector& evals)
function main (line 165) | int main()
FILE: VO_Module/thirdparty/eigen/bench/geometry.cpp
function EIGEN_DONT_INLINE (line 25) | EIGEN_DONT_INLINE void transform(const Transformation& t, Data& data)
function EIGEN_DONT_INLINE (line 33) | EIGEN_DONT_INLINE void transform(const Quaternion<Scalar>& t, Data& data)
type ToRotationMatrixWrapper (line 41) | struct ToRotationMatrixWrapper
method ToRotationMatrixWrapper (line 45) | ToRotationMatrixWrapper(const T& o) : object(o) {}
function EIGEN_DONT_INLINE (line 50) | EIGEN_DONT_INLINE void transform(const ToRotationMatrixWrapper<QType>& t...
function EIGEN_DONT_INLINE (line 58) | EIGEN_DONT_INLINE void transform(const Transform<Scalar,Dim,Projective>&...
type get_dim (line 63) | struct get_dim { enum { Dim = T::Dim }; }
type get_dim<Matrix<S,R,C,O,MR,MC> > (line 65) | struct get_dim<Matrix<S,R,C,O,MR,MC> > { enum { Dim = R }; }
type bench_impl (line 68) | struct bench_impl
method EIGEN_DONT_INLINE (line 70) | static EIGEN_DONT_INLINE void run(const Transformation& t)
type bench_impl<Transformation,0> (line 84) | struct bench_impl<Transformation,0>
method EIGEN_DONT_INLINE (line 86) | static EIGEN_DONT_INLINE void run(const Transformation&) {}
function EIGEN_DONT_INLINE (line 90) | EIGEN_DONT_INLINE void bench(const std::string& msg, const Transformatio...
function main (line 97) | int main(int argc, char ** argv)
FILE: VO_Module/thirdparty/eigen/bench/perf_monitoring/gemm.cpp
function EIGEN_DONT_INLINE (line 3) | EIGEN_DONT_INLINE
function main (line 9) | int main(int argc, char **argv)
FILE: VO_Module/thirdparty/eigen/bench/perf_monitoring/gemm_common.h
type SCALAR (line 13) | typedef SCALAR Scalar;
type Matrix (line 15) | typedef Matrix<Scalar,Dynamic,Dynamic> Mat;
FILE: VO_Module/thirdparty/eigen/bench/perf_monitoring/gemv.cpp
function EIGEN_DONT_INLINE (line 3) | EIGEN_DONT_INLINE
function main (line 9) | int main(int argc, char **argv)
FILE: VO_Module/thirdparty/eigen/bench/perf_monitoring/gemv_common.h
type SCALAR (line 14) | typedef SCALAR Scalar;
type Matrix (line 16) | typedef Matrix<Scalar,Dynamic,Dynamic> Mat;
type Matrix (line 17) | typedef Matrix<Scalar,Dynamic,1> Vec;
FILE: VO_Module/thirdparty/eigen/bench/perf_monitoring/gemvt.cpp
function EIGEN_DONT_INLINE (line 3) | EIGEN_DONT_INLINE
function main (line 9) | int main(int argc, char **argv)
FILE: VO_Module/thirdparty/eigen/bench/perf_monitoring/lazy_gemm.cpp
function EIGEN_DONT_INLINE (line 15) | EIGEN_DONT_INLINE
function EIGEN_DONT_INLINE (line 25) | EIGEN_DONT_INLINE
function bench_t (line 54) | double bench_t(int t)
function EIGEN_DONT_INLINE (line 62) | EIGEN_DONT_INLINE
function main (line 83) | int main(int argc, char **argv)
FILE: VO_Module/thirdparty/eigen/bench/perf_monitoring/llt.cpp
function EIGEN_DONT_INLINE (line 4) | EIGEN_DONT_INLINE
function main (line 12) | int main(int argc, char **argv)
FILE: VO_Module/thirdparty/eigen/bench/perf_monitoring/resources/s1.js
function n (line 1) | function n(n){return n&&(n.ownerDocument||n.document||n).documentElement}
function t (line 1) | function t(n){return n&&(n.ownerDocument&&n.ownerDocument.defaultView||n...
function e (line 1) | function e(n,t){return t>n?-1:n>t?1:n>=t?0:NaN}
function r (line 1) | function r(n){return null===n?NaN:+n}
function i (line 1) | function i(n){return!isNaN(n)}
function u (line 1) | function u(n){return{left:function(t,e,r,i){for(arguments.length<3&&(r=0...
function o (line 1) | function o(n){return n.length}
function a (line 1) | function a(n){for(var t=1;n*t%1;)t*=10;return t}
function l (line 1) | function l(n,t){for(var e in t)Object.defineProperty(n.prototype,e,{valu...
function c (line 1) | function c(){this._=Object.create(null)}
function f (line 1) | function f(n){return(n+="")===bo||n[0]===_o?_o+n:n}
function s (line 1) | function s(n){return(n+="")[0]===_o?n.slice(1):n}
function h (line 1) | function h(n){return f(n)in this._}
function p (line 1) | function p(n){return(n=f(n))in this._&&delete this._[n]}
function g (line 1) | function g(){var n=[];for(var t in this._)n.push(s(t));return n}
function v (line 1) | function v(){var n=0;for(var t in this._)++n;return n}
function d (line 1) | function d(){for(var n in this._)return!1;return!0}
function y (line 1) | function y(){this._=Object.create(null)}
function m (line 1) | function m(n){return n}
function M (line 1) | function M(n,t,e){return function(){var r=e.apply(t,arguments);return r=...
function x (line 1) | function x(n,t){if(t in n)return t;t=t.charAt(0).toUpperCase()+t.slice(1...
function b (line 1) | function b(){}
function _ (line 1) | function _(){}
function w (line 1) | function w(n){function t(){for(var t,r=e,i=-1,u=r.length;++i<u;)(t=r[i]....
function S (line 1) | function S(){ao.event.preventDefault()}
function k (line 1) | function k(){for(var n,t=ao.event;n=t.sourceEvent;)t=n;return t}
function N (line 1) | function N(n){for(var t=new _,e=0,r=arguments.length;++e<r;)t[arguments[...
function E (line 1) | function E(n){return ko(n,Co),n}
function A (line 1) | function A(n){return"function"==typeof n?n:function(){return No(n,this)}}
function C (line 1) | function C(n){return"function"==typeof n?n:function(){return Eo(n,this)}}
function z (line 1
Copy disabled (too large)
Download .json
Condensed preview — 3988 files, each showing path, character count, and a content snippet. Download the .json file for the full structured content (30,283K chars).
[
{
"path": ".gitignore",
"chars": 2265,
"preview": "a# Byte-compiled / optimized / DLL files\n__pycache__/\n*.py[cod]\n*$py.class\n\n# C extensions\n*.so\n\ncheckpoints/\ndatasets/\n"
},
{
"path": "README.md",
"chars": 3362,
"preview": "# PVO: Panoptic Visual Odometry\n### [Project Page](https://zju3dv.github.io/pvo/) | [Paper](https://arxiv.org/abs/2207.0"
},
{
"path": "VO_Module/README.md",
"chars": 1297,
"preview": "\n## Requirements\n\nTo run the code you will need ...\n* **Inference:** Running the demos will require a GPU with at least "
},
{
"path": "VO_Module/calib/barn.txt",
"chars": 67,
"preview": "1161.545689 1161.545689 960.000000 540.000000 -0.025158 0.0 0.0 0.0"
},
{
"path": "VO_Module/calib/eth.txt",
"chars": 62,
"preview": "726.21081542969 726.21081542969 359.2048034668 202.47247314453"
},
{
"path": "VO_Module/calib/euroc.txt",
"chars": 80,
"preview": "458.654 457.296 367.215 248.375 -0.28340811 0.07395907 0.00019359 1.76187114e-05"
},
{
"path": "VO_Module/calib/kitti.txt",
"chars": 75,
"preview": "7.070912000000e+02 7.070912000000e+02 6.018873000000e+02 1.831104000000e+02"
},
{
"path": "VO_Module/calib/replica.txt",
"chars": 23,
"preview": "600.0 600.0 599.5 339.5"
},
{
"path": "VO_Module/calib/tartan.txt",
"chars": 23,
"preview": "320.0 320.0 320.0 240.0"
},
{
"path": "VO_Module/calib/tum3.txt",
"chars": 23,
"preview": "535.4 539.2 320.1 247.6"
},
{
"path": "VO_Module/demo.py",
"chars": 3641,
"preview": "import sys\nsys.path.append('droid_slam')\n\nfrom tqdm import tqdm\nimport numpy as np\nimport torch\nimport lietorch\nimport c"
},
{
"path": "VO_Module/droid_slam/data_readers/__init__.py",
"chars": 1,
"preview": "\n"
},
{
"path": "VO_Module/droid_slam/data_readers/augmentation.py",
"chars": 7877,
"preview": "import torch\nimport torchvision.transforms as transforms\nimport numpy as np\nimport torch.nn.functional as F\n\n\nclass RGBD"
},
{
"path": "VO_Module/droid_slam/data_readers/base.py",
"chars": 11793,
"preview": "\nimport numpy as np\nimport torch\nimport torch.utils.data as data\nimport torch.nn.functional as F\n\nimport sys\nimport csv\n"
},
{
"path": "VO_Module/droid_slam/data_readers/factory.py",
"chars": 2589,
"preview": "\nimport pickle\nimport os\nimport os.path as osp\n\n# RGBD-Dataset\nfrom .tartan import TartanAir\nfrom .replica import Replic"
},
{
"path": "VO_Module/droid_slam/data_readers/replica.py",
"chars": 4532,
"preview": "\nimport numpy as np\nimport torch\nimport glob\nimport cv2\nimport os\nimport os.path as osp\n\nfrom lietorch import SE3\nfrom ."
},
{
"path": "VO_Module/droid_slam/data_readers/replica_test.txt",
"chars": 43,
"preview": "room1\noffice1\nroom2\noffice2\noffice3\noffice4"
},
{
"path": "VO_Module/droid_slam/data_readers/replica_utils.py",
"chars": 4697,
"preview": "from scipy.spatial.transform import Rotation as R\nimport numpy as np\nimport glob\nimport imageio\nimport os.path as osp\n\n\n"
},
{
"path": "VO_Module/droid_slam/data_readers/rgbd_utils.py",
"chars": 6570,
"preview": "import numpy as np\nimport os.path as osp\n\nimport torch\nfrom lietorch import SE3\n\nimport geom.projective_ops as pops\nfrom"
},
{
"path": "VO_Module/droid_slam/data_readers/stream.py",
"chars": 7658,
"preview": "\nimport numpy as np\nimport torch\nimport torch.utils.data as data\nimport torch.nn.functional as F\n\nimport csv\nimport os\ni"
},
{
"path": "VO_Module/droid_slam/data_readers/tartan.py",
"chars": 4879,
"preview": "\nimport numpy as np\nimport torch\nimport glob\nimport cv2\nimport os\nimport os.path as osp\n\nfrom lietorch import SE3\nfrom ."
},
{
"path": "VO_Module/droid_slam/data_readers/tartan_test.txt",
"chars": 1098,
"preview": "abandonedfactory/abandonedfactory/Easy/P011\nabandonedfactory/abandonedfactory/Hard/P011\nabandonedfactory_night/abandoned"
},
{
"path": "VO_Module/droid_slam/data_readers/vkitti2.py",
"chars": 7715,
"preview": "\nimport numpy as np\nimport torch\nimport glob\nimport cv2\nimport os\nimport os.path as osp\n\nfrom scipy.spatial.transform im"
},
{
"path": "VO_Module/droid_slam/depth_video.py",
"chars": 7193,
"preview": "import numpy as np\nimport torch\nimport lietorch\nimport droid_backends\n\nfrom torch.multiprocessing import Process, Queue,"
},
{
"path": "VO_Module/droid_slam/droid.py",
"chars": 3891,
"preview": "import torch\nimport torch.nn.functional as F\nimport lietorch\nimport numpy as np\n\nfrom droid_net import DroidNet\nfrom dep"
},
{
"path": "VO_Module/droid_slam/droid_backend.py",
"chars": 1155,
"preview": "import torch\nimport lietorch\nimport numpy as np\n\nfrom lietorch import SE3\nfrom factor_graph import FactorGraph\n\n\nclass D"
},
{
"path": "VO_Module/droid_slam/droid_frontend.py",
"chars": 3702,
"preview": "import torch\nimport lietorch\nimport numpy as np\n\nfrom lietorch import SE3\nfrom factor_graph import FactorGraph\n\n\nclass D"
},
{
"path": "VO_Module/droid_slam/droid_net.py",
"chars": 15317,
"preview": "import numpy as np\nimport torch\nimport torch.nn as nn\nimport torch.nn.functional as F\nfrom collections import OrderedDic"
},
{
"path": "VO_Module/droid_slam/factor_graph.py",
"chars": 17897,
"preview": "import torch\nimport lietorch\nimport numpy as np\n\nimport matplotlib.pyplot as plt\nimport torch.nn.functional as F\nfrom li"
},
{
"path": "VO_Module/droid_slam/geom/__init__.py",
"chars": 0,
"preview": ""
},
{
"path": "VO_Module/droid_slam/geom/ba.py",
"chars": 4611,
"preview": "import lietorch\nimport torch\nimport torch.nn.functional as F\n\nfrom .chol import block_solve, schur_solve\nimport geom.pro"
},
{
"path": "VO_Module/droid_slam/geom/chol.py",
"chars": 1827,
"preview": "import torch\nimport torch.nn.functional as F\nimport geom.projective_ops as pops\n\nclass CholeskySolver(torch.autograd.Fun"
},
{
"path": "VO_Module/droid_slam/geom/graph_utils.py",
"chars": 2885,
"preview": "\nimport torch\nimport numpy as np\nfrom collections import OrderedDict\n\nimport lietorch\nfrom data_readers.rgbd_utils impor"
},
{
"path": "VO_Module/droid_slam/geom/losses.py",
"chars": 16014,
"preview": "from collections import OrderedDict\nimport numpy as np\nimport torch\nimport torch.nn as nn\nimport torch.nn.functional as "
},
{
"path": "VO_Module/droid_slam/geom/projective_ops.py",
"chars": 5656,
"preview": "import torch\nimport torch.nn.functional as F\n\nfrom lietorch import SE3, Sim3\n\nMIN_DEPTH = 0.2\n\n\ndef extract_intrinsics(i"
},
{
"path": "VO_Module/droid_slam/logger.py",
"chars": 1586,
"preview": "\nimport torch\nfrom torch.utils.tensorboard import SummaryWriter\n\n\nSUM_FREQ = 100\n\nclass Logger:\n def __init__(self, n"
},
{
"path": "VO_Module/droid_slam/modules/__init__.py",
"chars": 0,
"preview": ""
},
{
"path": "VO_Module/droid_slam/modules/clipping.py",
"chars": 580,
"preview": "import torch\nimport torch.nn as nn\nimport torch.nn.functional as F\n\nGRAD_CLIP = .01\n\nclass GradClip(torch.autograd.Funct"
},
{
"path": "VO_Module/droid_slam/modules/corr.py",
"chars": 4632,
"preview": "import torch\nimport torch.nn.functional as F\n\nimport droid_backends\n\nclass CorrSampler(torch.autograd.Function):\n\n @s"
},
{
"path": "VO_Module/droid_slam/modules/extractor.py",
"chars": 6798,
"preview": "import torch\nimport torch.nn as nn\nimport torch.nn.functional as F\n\n\nclass ResidualBlock(nn.Module):\n def __init__(se"
},
{
"path": "VO_Module/droid_slam/modules/gru.py",
"chars": 1229,
"preview": "import torch\nimport torch.nn as nn\n\n\nclass ConvGRU(nn.Module):\n def __init__(self, h_planes=128, i_planes=128):\n "
},
{
"path": "VO_Module/droid_slam/motion_filter.py",
"chars": 4047,
"preview": "import cv2\nimport torch\nimport lietorch\n\nfrom collections import OrderedDict\nfrom droid_net import DroidNet\n\nimport geom"
},
{
"path": "VO_Module/droid_slam/trajectory_filler.py",
"chars": 3220,
"preview": "import cv2\nimport torch\nimport lietorch\n\nfrom lietorch import SE3\nfrom collections import OrderedDict\nfrom factor_graph "
},
{
"path": "VO_Module/droid_slam/visualization.py",
"chars": 5709,
"preview": "import torch\nimport cv2\nimport lietorch\nimport droid_backends\nimport time\nimport argparse\nimport numpy as np\nimport open"
},
{
"path": "VO_Module/environment.yaml",
"chars": 298,
"preview": "name: droidenv\nchannels:\n - rusty1s\n - pytorch\n - open3d-admin\n - nvidia\n - conda-forge\n - defaults\ndependencies:\n"
},
{
"path": "VO_Module/environment_novis.yaml",
"chars": 275,
"preview": "name: droidenv\nchannels:\n - rusty1s\n - pytorch\n - nvidia\n - conda-forge\n - defaults\ndependencies:\n - pytorch-scatt"
},
{
"path": "VO_Module/evaluation_scripts/flow_vis_utils.py",
"chars": 5164,
"preview": "# Flow visualization code used from https://github.com/tomrunia/OpticalFlow_Visualization\n\n\n# MIT License\n#\n# Copyright "
},
{
"path": "VO_Module/evaluation_scripts/test_vo.py",
"chars": 6406,
"preview": "import sys\nsys.path.append('VO_Module/droid_slam')\nfrom droid import Droid\n\nimport glob\nimport torch.nn.functional as F\n"
},
{
"path": "VO_Module/evaluation_scripts/test_vo2.py",
"chars": 5377,
"preview": "import sys\nsys.path.append('VO_Module/droid_slam')\n\nimport torch\nfrom torch.utils.data import DataLoader\nimport glob\nimp"
},
{
"path": "VO_Module/setup.py",
"chars": 2476,
"preview": "from setuptools import setup\nfrom torch.utils.cpp_extension import BuildExtension, CUDAExtension\n\nimport os.path as osp\n"
},
{
"path": "VO_Module/src/altcorr_kernel.cu",
"chars": 11307,
"preview": "#include <torch/extension.h>\n#include <cuda.h>\n#include <cuda_runtime.h>\n#include <vector>\n#include <cuda_fp16.h>\n#inclu"
},
{
"path": "VO_Module/src/correlation_kernels.cu",
"chars": 5216,
"preview": "#include <torch/extension.h>\n#include <cuda.h>\n#include <cuda_runtime.h>\n#include <vector>\n#include <cuda_fp16.h>\n#inclu"
},
{
"path": "VO_Module/src/droid.cpp",
"chars": 5654,
"preview": "#include <torch/extension.h>\n#include <vector>\n\n// CUDA forward declarations\nstd::vector<torch::Tensor> projective_trans"
},
{
"path": "VO_Module/src/droid_kernels.cu",
"chars": 40870,
"preview": "#include <torch/extension.h>\n#include <cuda.h>\n#include <cuda_runtime.h>\n#include <cuda_runtime.h>\n\n#include <vector>\n#i"
},
{
"path": "VO_Module/thirdparty/eigen/.gitignore",
"chars": 292,
"preview": "qrc_*cxx\n*.orig\n*.pyc\n*.diff\ndiff\n*.save\nsave\n*.old\n*.gmo\n*.qm\ncore\ncore.*\n*.bak\n*~\n*build*\n*.moc.*\n*.moc\nui_*\nCMakeCach"
},
{
"path": "VO_Module/thirdparty/eigen/.gitlab/issue_templates/Bug Report.md",
"chars": 2744,
"preview": "<!--\nPlease read this!\n\nBefore opening a new issue, make sure to search for keywords in the issues\nfiltered by \"bug::con"
},
{
"path": "VO_Module/thirdparty/eigen/.gitlab/issue_templates/Feature Request.md",
"chars": 201,
"preview": "### Describe the feature you would like to be implemented.\n\n### Would such a feature be useful for other users? Why?\n\n##"
},
{
"path": "VO_Module/thirdparty/eigen/.gitlab/merge_request_templates/Merge Request Template.md",
"chars": 1394,
"preview": "<!-- \nThanks for contributing a merge request! Please name and fully describe your MR as you would for a commit message."
},
{
"path": "VO_Module/thirdparty/eigen/.gitlab-ci.yml",
"chars": 571,
"preview": "# This file is part of Eigen, a lightweight C++ template library\n# for linear algebra.\n#\n# Copyright (C) 2020 Arm Ltd. a"
},
{
"path": "VO_Module/thirdparty/eigen/.hgeol",
"chars": 180,
"preview": "[patterns]\n*.sh = LF\n*.MINPACK = CRLF\nscripts/*.in = LF\ndebug/msvc/*.dat = CRLF\ndebug/msvc/*.natvis = CRLF\nunsupported/t"
},
{
"path": "VO_Module/thirdparty/eigen/CMakeLists.txt",
"chars": 23876,
"preview": "# cmake_minimum_require must be the first command of the file\ncmake_minimum_required(VERSION 3.5.0)\n\nproject(Eigen3)\n\nse"
},
{
"path": "VO_Module/thirdparty/eigen/COPYING.APACHE",
"chars": 11362,
"preview": "/*\n Apache License\n Version 2.0, January 2004\n "
},
{
"path": "VO_Module/thirdparty/eigen/COPYING.BSD",
"chars": 1517,
"preview": "/*\n Copyright (c) 2011, Intel Corporation. All rights reserved.\n\n Redistribution and use in source and binary forms, wit"
},
{
"path": "VO_Module/thirdparty/eigen/COPYING.GPL",
"chars": 35147,
"preview": " GNU GENERAL PUBLIC LICENSE\n Version 3, 29 June 2007\n\n Copyright (C) 2007 Free "
},
{
"path": "VO_Module/thirdparty/eigen/COPYING.LGPL",
"chars": 26530,
"preview": " GNU LESSER GENERAL PUBLIC LICENSE\n Version 2.1, February 1999\n\n Copyright (C) 19"
},
{
"path": "VO_Module/thirdparty/eigen/COPYING.MINPACK",
"chars": 2193,
"preview": "Minpack Copyright Notice (1999) University of Chicago. All rights reserved\n\nRedistribution and use in source and binary"
},
{
"path": "VO_Module/thirdparty/eigen/COPYING.MPL2",
"chars": 16726,
"preview": "Mozilla Public License Version 2.0\n==================================\n\n1. Definitions\n--------------\n\n1.1. \"Contributor\""
},
{
"path": "VO_Module/thirdparty/eigen/COPYING.README",
"chars": 779,
"preview": "Eigen is primarily MPL2 licensed. See COPYING.MPL2 and these links:\n http://www.mozilla.org/MPL/2.0/\n http://www.mozil"
},
{
"path": "VO_Module/thirdparty/eigen/CTestConfig.cmake",
"chars": 584,
"preview": "## This file should be placed in the root directory of your project.\n## Then modify the CMakeLists.txt file in the root "
},
{
"path": "VO_Module/thirdparty/eigen/CTestCustom.cmake.in",
"chars": 180,
"preview": "\nset(CTEST_CUSTOM_MAXIMUM_NUMBER_OF_WARNINGS \"2000\")\nset(CTEST_CUSTOM_MAXIMUM_NUMBER_OF_ERRORS \"2000\")\nlist(APPEND CTE"
},
{
"path": "VO_Module/thirdparty/eigen/Eigen/Cholesky",
"chars": 1161,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// This Source Code Form is "
},
{
"path": "VO_Module/thirdparty/eigen/Eigen/CholmodSupport",
"chars": 1900,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// This Source Code Form is "
},
{
"path": "VO_Module/thirdparty/eigen/Eigen/Dense",
"chars": 122,
"preview": "#include \"Core\"\n#include \"LU\"\n#include \"Cholesky\"\n#include \"QR\"\n#include \"SVD\"\n#include \"Geometry\"\n#include \"Eigenvalues"
},
{
"path": "VO_Module/thirdparty/eigen/Eigen/Eigen",
"chars": 35,
"preview": "#include \"Dense\"\n#include \"Sparse\"\n"
},
{
"path": "VO_Module/thirdparty/eigen/Eigen/Eigenvalues",
"chars": 1777,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// This Source Code Form is "
},
{
"path": "VO_Module/thirdparty/eigen/Eigen/Geometry",
"chars": 1940,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// This Source Code Form is "
},
{
"path": "VO_Module/thirdparty/eigen/Eigen/Householder",
"chars": 829,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// This Source Code Form is "
},
{
"path": "VO_Module/thirdparty/eigen/Eigen/IterativeLinearSolvers",
"chars": 2083,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// This Source Code Form is "
},
{
"path": "VO_Module/thirdparty/eigen/Eigen/Jacobi",
"chars": 894,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// This Source Code Form is "
},
{
"path": "VO_Module/thirdparty/eigen/Eigen/KLUSupport",
"chars": 1389,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// This Source Code Form is "
},
{
"path": "VO_Module/thirdparty/eigen/Eigen/LU",
"chars": 1268,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// This Source Code Form is "
},
{
"path": "VO_Module/thirdparty/eigen/Eigen/MetisSupport",
"chars": 991,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// This Source Code Form is "
},
{
"path": "VO_Module/thirdparty/eigen/Eigen/OrderingMethods",
"chars": 2451,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// This Source Code Form is "
},
{
"path": "VO_Module/thirdparty/eigen/Eigen/PaStiXSupport",
"chars": 1751,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// This Source Code Form is "
},
{
"path": "VO_Module/thirdparty/eigen/Eigen/PardisoSupport",
"chars": 1116,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// This Source Code Form is "
},
{
"path": "VO_Module/thirdparty/eigen/Eigen/QR",
"chars": 1272,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// This Source Code Form is "
},
{
"path": "VO_Module/thirdparty/eigen/Eigen/QtAlignedMalloc",
"chars": 900,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// This Source Code Form is "
},
{
"path": "VO_Module/thirdparty/eigen/Eigen/SPQRSupport",
"chars": 1162,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// This Source Code Form is "
},
{
"path": "VO_Module/thirdparty/eigen/Eigen/SVD",
"chars": 1584,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// This Source Code Form is "
},
{
"path": "VO_Module/thirdparty/eigen/Eigen/Sparse",
"chars": 888,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// This Source Code Form is "
},
{
"path": "VO_Module/thirdparty/eigen/Eigen/SparseCholesky",
"chars": 1235,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008-2013 G"
},
{
"path": "VO_Module/thirdparty/eigen/Eigen/SparseCore",
"chars": 2240,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// This Source Code Form is "
},
{
"path": "VO_Module/thirdparty/eigen/Eigen/SparseLU",
"chars": 1812,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2012 Désiré"
},
{
"path": "VO_Module/thirdparty/eigen/Eigen/SparseQR",
"chars": 1195,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// This Source Code Form is "
},
{
"path": "VO_Module/thirdparty/eigen/Eigen/StdDeque",
"chars": 797,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2009 Gael G"
},
{
"path": "VO_Module/thirdparty/eigen/Eigen/StdList",
"chars": 726,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2009 Hauke "
},
{
"path": "VO_Module/thirdparty/eigen/Eigen/StdVector",
"chars": 803,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2009 Gael G"
},
{
"path": "VO_Module/thirdparty/eigen/Eigen/SuperLUSupport",
"chars": 2243,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// This Source Code Form is "
},
{
"path": "VO_Module/thirdparty/eigen/Eigen/UmfPackSupport",
"chars": 1382,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// This Source Code Form is "
},
{
"path": "VO_Module/thirdparty/eigen/Eigen/src/Cholesky/LDLT.h",
"chars": 24935,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008-2011 G"
},
{
"path": "VO_Module/thirdparty/eigen/Eigen/src/Cholesky/LLT.h",
"chars": 18761,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008 Gael G"
},
{
"path": "VO_Module/thirdparty/eigen/Eigen/src/Cholesky/LLT_LAPACKE.h",
"chars": 3974,
"preview": "/*\n Copyright (c) 2011, Intel Corporation. All rights reserved.\n\n Redistribution and use in source and binary forms, wit"
},
{
"path": "VO_Module/thirdparty/eigen/Eigen/src/CholmodSupport/CholmodSupport.h",
"chars": 25441,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008-2010 G"
},
{
"path": "VO_Module/thirdparty/eigen/Eigen/src/Eigenvalues/ComplexEigenSolver.h",
"chars": 12559,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2009 Claire"
},
{
"path": "VO_Module/thirdparty/eigen/Eigen/src/Eigenvalues/ComplexSchur.h",
"chars": 17273,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2009 Claire"
},
{
"path": "VO_Module/thirdparty/eigen/Eigen/src/Eigenvalues/ComplexSchur_LAPACKE.h",
"chars": 4178,
"preview": "/*\n Copyright (c) 2011, Intel Corporation. All rights reserved.\n\n Redistribution and use in source and binary forms, wit"
},
{
"path": "VO_Module/thirdparty/eigen/Eigen/src/Eigenvalues/EigenSolver.h",
"chars": 22970,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008 Gael G"
},
{
"path": "VO_Module/thirdparty/eigen/Eigen/src/Eigenvalues/GeneralizedEigenSolver.h",
"chars": 17176,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2012-2016 G"
},
{
"path": "VO_Module/thirdparty/eigen/Eigen/src/Eigenvalues/GeneralizedSelfAdjointEigenSolver.h",
"chars": 9716,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008-2010 G"
},
{
"path": "VO_Module/thirdparty/eigen/Eigen/src/Eigenvalues/HessenbergDecomposition.h",
"chars": 14349,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008-2009 G"
},
{
"path": "VO_Module/thirdparty/eigen/Eigen/src/Eigenvalues/MatrixBaseEigenvalues.h",
"chars": 5575,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008 Gael G"
},
{
"path": "VO_Module/thirdparty/eigen/Eigen/src/Eigenvalues/RealQZ.h",
"chars": 23640,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2012 Alexey"
},
{
"path": "VO_Module/thirdparty/eigen/Eigen/src/Eigenvalues/RealSchur.h",
"chars": 21078,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008 Gael G"
},
{
"path": "VO_Module/thirdparty/eigen/Eigen/src/Eigenvalues/RealSchur_LAPACKE.h",
"chars": 3650,
"preview": "/*\n Copyright (c) 2011, Intel Corporation. All rights reserved.\n\n Redistribution and use in source and binary forms, wit"
},
{
"path": "VO_Module/thirdparty/eigen/Eigen/src/Eigenvalues/SelfAdjointEigenSolver.h",
"chars": 35182,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008-2010 G"
},
{
"path": "VO_Module/thirdparty/eigen/Eigen/src/Eigenvalues/SelfAdjointEigenSolver_LAPACKE.h",
"chars": 4104,
"preview": "/*\n Copyright (c) 2011, Intel Corporation. All rights reserved.\n\n Redistribution and use in source and binary forms, wit"
},
{
"path": "VO_Module/thirdparty/eigen/Eigen/src/Eigenvalues/Tridiagonalization.h",
"chars": 22764,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008 Gael G"
},
{
"path": "VO_Module/thirdparty/eigen/Eigen/src/Geometry/AlignedBox.h",
"chars": 18939,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008 Gael G"
},
{
"path": "VO_Module/thirdparty/eigen/Eigen/src/Geometry/AngleAxis.h",
"chars": 8403,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008 Gael G"
},
{
"path": "VO_Module/thirdparty/eigen/Eigen/src/Geometry/EulerAngles.h",
"chars": 3624,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008 Gael G"
},
{
"path": "VO_Module/thirdparty/eigen/Eigen/src/Geometry/Homogeneous.h",
"chars": 20726,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2009-2010 G"
},
{
"path": "VO_Module/thirdparty/eigen/Eigen/src/Geometry/Hyperplane.h",
"chars": 11962,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008 Gael G"
},
{
"path": "VO_Module/thirdparty/eigen/Eigen/src/Geometry/OrthoMethods.h",
"chars": 8955,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008-2009 G"
},
{
"path": "VO_Module/thirdparty/eigen/Eigen/src/Geometry/ParametrizedLine.h",
"chars": 9812,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008 Gael G"
},
{
"path": "VO_Module/thirdparty/eigen/Eigen/src/Geometry/Quaternion.h",
"chars": 34367,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008-2010 G"
},
{
"path": "VO_Module/thirdparty/eigen/Eigen/src/Geometry/Rotation2D.h",
"chars": 6862,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008 Gael G"
},
{
"path": "VO_Module/thirdparty/eigen/Eigen/src/Geometry/RotationBase.h",
"chars": 8063,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008 Gael G"
},
{
"path": "VO_Module/thirdparty/eigen/Eigen/src/Geometry/Scaling.h",
"chars": 6724,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008 Gael G"
},
{
"path": "VO_Module/thirdparty/eigen/Eigen/src/Geometry/Transform.h",
"chars": 61930,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008 Gael G"
},
{
"path": "VO_Module/thirdparty/eigen/Eigen/src/Geometry/Translation.h",
"chars": 7664,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008 Gael G"
},
{
"path": "VO_Module/thirdparty/eigen/Eigen/src/Geometry/Umeyama.h",
"chars": 6190,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2009 Hauke "
},
{
"path": "VO_Module/thirdparty/eigen/Eigen/src/Geometry/arch/Geometry_SIMD.h",
"chars": 5945,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2009 Rohit "
},
{
"path": "VO_Module/thirdparty/eigen/Eigen/src/Householder/BlockHouseholder.h",
"chars": 4784,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2010 Vincen"
},
{
"path": "VO_Module/thirdparty/eigen/Eigen/src/Householder/Householder.h",
"chars": 5365,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2010 Benoit"
},
{
"path": "VO_Module/thirdparty/eigen/Eigen/src/Householder/HouseholderSequence.h",
"chars": 23611,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2009 Gael G"
},
{
"path": "VO_Module/thirdparty/eigen/Eigen/src/IterativeLinearSolvers/BasicPreconditioners.h",
"chars": 6771,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2011-2014 G"
},
{
"path": "VO_Module/thirdparty/eigen/Eigen/src/IterativeLinearSolvers/BiCGSTAB.h",
"chars": 6848,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2011-2014 G"
},
{
"path": "VO_Module/thirdparty/eigen/Eigen/src/IterativeLinearSolvers/ConjugateGradient.h",
"chars": 8887,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2011-2014 G"
},
{
"path": "VO_Module/thirdparty/eigen/Eigen/src/IterativeLinearSolvers/IncompleteCholesky.h",
"chars": 15032,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2012 Désiré"
},
{
"path": "VO_Module/thirdparty/eigen/Eigen/src/IterativeLinearSolvers/IncompleteLUT.h",
"chars": 14938,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2012 Désiré"
},
{
"path": "VO_Module/thirdparty/eigen/Eigen/src/IterativeLinearSolvers/IterativeSolverBase.h",
"chars": 13379,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2011-2014 G"
},
{
"path": "VO_Module/thirdparty/eigen/Eigen/src/IterativeLinearSolvers/LeastSquareConjugateGradient.h",
"chars": 7349,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2015 Gael G"
},
{
"path": "VO_Module/thirdparty/eigen/Eigen/src/IterativeLinearSolvers/SolveWithGuess.h",
"chars": 4212,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2014 Gael G"
},
{
"path": "VO_Module/thirdparty/eigen/Eigen/src/Jacobi/Jacobi.h",
"chars": 16383,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2009 Benoit"
},
{
"path": "VO_Module/thirdparty/eigen/Eigen/src/KLUSupport/KLUSupport.h",
"chars": 11555,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2017 Kyle M"
},
{
"path": "VO_Module/thirdparty/eigen/Eigen/src/LU/Determinant.h",
"chars": 3439,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008 Benoit"
},
{
"path": "VO_Module/thirdparty/eigen/Eigen/src/LU/FullPivLU.h",
"chars": 32383,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2006-2009 B"
},
{
"path": "VO_Module/thirdparty/eigen/Eigen/src/LU/InverseImpl.h",
"chars": 15727,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008-2010 B"
},
{
"path": "VO_Module/thirdparty/eigen/Eigen/src/LU/PartialPivLU.h",
"chars": 22069,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2006-2009 B"
},
{
"path": "VO_Module/thirdparty/eigen/Eigen/src/LU/PartialPivLU_LAPACKE.h",
"chars": 3555,
"preview": "/*\n Copyright (c) 2011, Intel Corporation. All rights reserved.\n\n Redistribution and use in source and binary forms, wit"
},
{
"path": "VO_Module/thirdparty/eigen/Eigen/src/LU/arch/InverseSize4.h",
"chars": 13693,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2001 Intel "
},
{
"path": "VO_Module/thirdparty/eigen/Eigen/src/MetisSupport/MetisSupport.h",
"chars": 4586,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2012 Désiré"
},
{
"path": "VO_Module/thirdparty/eigen/Eigen/src/OrderingMethods/Amd.h",
"chars": 16105,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2010 Gael G"
},
{
"path": "VO_Module/thirdparty/eigen/Eigen/src/OrderingMethods/Eigen_Colamd.h",
"chars": 61681,
"preview": "// // This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2012 Des"
},
{
"path": "VO_Module/thirdparty/eigen/Eigen/src/OrderingMethods/Ordering.h",
"chars": 5246,
"preview": " \n// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2012 Dés"
},
{
"path": "VO_Module/thirdparty/eigen/Eigen/src/PaStiXSupport/PaStiXSupport.h",
"chars": 22246,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2012 Désiré"
},
{
"path": "VO_Module/thirdparty/eigen/Eigen/src/PardisoSupport/PardisoSupport.h",
"chars": 20088,
"preview": "/*\n Copyright (c) 2011, Intel Corporation. All rights reserved.\n\n Redistribution and use in source and binary forms, wit"
},
{
"path": "VO_Module/thirdparty/eigen/Eigen/src/QR/ColPivHouseholderQR.h",
"chars": 25498,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008-2009 G"
},
{
"path": "VO_Module/thirdparty/eigen/Eigen/src/QR/ColPivHouseholderQR_LAPACKE.h",
"chars": 4662,
"preview": "/*\n Copyright (c) 2011, Intel Corporation. All rights reserved.\n\n Redistribution and use in source and binary forms, wit"
},
{
"path": "VO_Module/thirdparty/eigen/Eigen/src/QR/CompleteOrthogonalDecomposition.h",
"chars": 23429,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2016 Rasmus"
},
{
"path": "VO_Module/thirdparty/eigen/Eigen/src/QR/FullPivHouseholderQR.h",
"chars": 26768,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008-2009 G"
},
{
"path": "VO_Module/thirdparty/eigen/Eigen/src/QR/HouseholderQR.h",
"chars": 14641,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008-2010 G"
},
{
"path": "VO_Module/thirdparty/eigen/Eigen/src/QR/HouseholderQR_LAPACKE.h",
"chars": 2993,
"preview": "/*\n Copyright (c) 2011, Intel Corporation. All rights reserved.\n\n Redistribution and use in source and binary forms, wit"
},
{
"path": "VO_Module/thirdparty/eigen/Eigen/src/SPQRSupport/SuiteSparseQRSupport.h",
"chars": 11826,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2012 Desire"
},
{
"path": "VO_Module/thirdparty/eigen/Eigen/src/SVD/BDCSVD.h",
"chars": 54212,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n// \n// We used the \"A Divide-An"
},
{
"path": "VO_Module/thirdparty/eigen/Eigen/src/SVD/JacobiSVD.h",
"chars": 32987,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2009-2010 B"
},
{
"path": "VO_Module/thirdparty/eigen/Eigen/src/SVD/JacobiSVD_LAPACKE.h",
"chars": 5099,
"preview": "/*\n Copyright (c) 2011, Intel Corporation. All rights reserved.\n\n Redistribution and use in source and binary forms, wit"
},
{
"path": "VO_Module/thirdparty/eigen/Eigen/src/SVD/SVDBase.h",
"chars": 14743,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2009-2010 B"
},
{
"path": "VO_Module/thirdparty/eigen/Eigen/src/SVD/UpperBidiagonalization.h",
"chars": 15957,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2010 Benoit"
},
{
"path": "VO_Module/thirdparty/eigen/Eigen/src/SparseCholesky/SimplicialCholesky.h",
"chars": 24216,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008-2012 G"
},
{
"path": "VO_Module/thirdparty/eigen/Eigen/src/SparseCholesky/SimplicialCholesky_impl.h",
"chars": 5830,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008-2012 G"
},
{
"path": "VO_Module/thirdparty/eigen/Eigen/src/SparseCore/AmbiVector.h",
"chars": 10670,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008 Gael G"
},
{
"path": "VO_Module/thirdparty/eigen/Eigen/src/SparseCore/CompressedStorage.h",
"chars": 8743,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008-2014 G"
},
{
"path": "VO_Module/thirdparty/eigen/Eigen/src/SparseCore/ConservativeSparseSparseProduct.h",
"chars": 13166,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008-2015 G"
},
{
"path": "VO_Module/thirdparty/eigen/Eigen/src/SparseCore/MappedSparseMatrix.h",
"chars": 2191,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008-2014 G"
},
{
"path": "VO_Module/thirdparty/eigen/Eigen/src/SparseCore/SparseAssign.h",
"chars": 11368,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008-2014 G"
},
{
"path": "VO_Module/thirdparty/eigen/Eigen/src/SparseCore/SparseBlock.h",
"chars": 24360,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008-2014 G"
},
{
"path": "VO_Module/thirdparty/eigen/Eigen/src/SparseCore/SparseColEtree.h",
"chars": 6482,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2012 Désiré"
},
{
"path": "VO_Module/thirdparty/eigen/Eigen/src/SparseCore/SparseCompressedBase.h",
"chars": 13606,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2015 Gael G"
},
{
"path": "VO_Module/thirdparty/eigen/Eigen/src/SparseCore/SparseCwiseBinaryOp.h",
"chars": 25524,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008-2014 G"
},
{
"path": "VO_Module/thirdparty/eigen/Eigen/src/SparseCore/SparseCwiseUnaryOp.h",
"chars": 4757,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008-2015 G"
},
{
"path": "VO_Module/thirdparty/eigen/Eigen/src/SparseCore/SparseDenseProduct.h",
"chars": 13256,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008-2015 G"
},
{
"path": "VO_Module/thirdparty/eigen/Eigen/src/SparseCore/SparseDiagonalProduct.h",
"chars": 5808,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2009-2015 G"
},
{
"path": "VO_Module/thirdparty/eigen/Eigen/src/SparseCore/SparseDot.h",
"chars": 3080,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008 Gael G"
},
{
"path": "VO_Module/thirdparty/eigen/Eigen/src/SparseCore/SparseFuzzy.h",
"chars": 1107,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008-2014 G"
},
{
"path": "VO_Module/thirdparty/eigen/Eigen/src/SparseCore/SparseMap.h",
"chars": 12589,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2015 Gael G"
},
{
"path": "VO_Module/thirdparty/eigen/Eigen/src/SparseCore/SparseMatrix.h",
"chars": 57489,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008-2014 G"
},
{
"path": "VO_Module/thirdparty/eigen/Eigen/src/SparseCore/SparseMatrixBase.h",
"chars": 17451,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008-2014 G"
},
{
"path": "VO_Module/thirdparty/eigen/Eigen/src/SparseCore/SparsePermutation.h",
"chars": 7329,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2012 Gael G"
},
{
"path": "VO_Module/thirdparty/eigen/Eigen/src/SparseCore/SparseProduct.h",
"chars": 7593,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008-2015 G"
},
{
"path": "VO_Module/thirdparty/eigen/Eigen/src/SparseCore/SparseRedux.h",
"chars": 1699,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008-2014 G"
},
{
"path": "VO_Module/thirdparty/eigen/Eigen/src/SparseCore/SparseRef.h",
"chars": 15600,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2015 Gael G"
},
{
"path": "VO_Module/thirdparty/eigen/Eigen/src/SparseCore/SparseSelfAdjointView.h",
"chars": 25889,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2009-2014 G"
},
{
"path": "VO_Module/thirdparty/eigen/Eigen/src/SparseCore/SparseSolverBase.h",
"chars": 4424,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2014 Gael G"
},
{
"path": "VO_Module/thirdparty/eigen/Eigen/src/SparseCore/SparseSparseProductWithPruning.h",
"chars": 8704,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008-2014 G"
},
{
"path": "VO_Module/thirdparty/eigen/Eigen/src/SparseCore/SparseTranspose.h",
"chars": 3175,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008-2015 G"
},
{
"path": "VO_Module/thirdparty/eigen/Eigen/src/SparseCore/SparseTriangularView.h",
"chars": 6435,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2009-2015 G"
},
{
"path": "VO_Module/thirdparty/eigen/Eigen/src/SparseCore/SparseUtil.h",
"chars": 6827,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008-2014 G"
},
{
"path": "VO_Module/thirdparty/eigen/Eigen/src/SparseCore/SparseVector.h",
"chars": 14832,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008-2015 G"
},
{
"path": "VO_Module/thirdparty/eigen/Eigen/src/SparseCore/SparseView.h",
"chars": 8127,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2011-2014 G"
}
]
// ... and 3788 more files (download for full content)
About this extraction
This page contains the full source code of the zju3dv/PVO GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 3988 files (27.7 MB), approximately 7.5M tokens, and a symbol index with 17995 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.