- \n-
- gtsam
- base
- Manifold.h \n+
- gtsam
- base
- VerticalBlockMatrix.h \n
- Generated on Tue Jan 9 2024 05:51:35 for gtsam by
![\"doxygen\"/](\"doxygen.svg\")
1.9.8 \n
Base class and basic functions for Manifold types. \n+
A matrix with column blocks of pre-defined sizes. \n More...
\n \nGo to the source code of this file.
\n\n Classes | |
| struct | gtsam::manifold_tag |
| tag to assert a type is a manifold More... | |
| struct | gtsam::internal::HasManifoldPrereqs< Class > |
| Requirements on type to pass it to Manifold template below. More... | |
| struct | gtsam::internal::GetDimensionImpl< Class, N > |
| Extra manifold traits for fixed-dimension types. More... | |
| struct | gtsam::internal::GetDimensionImpl< Class, Eigen::Dynamic > |
| Extra manifold traits for variable-dimension types. More... | |
| struct | gtsam::internal::ManifoldTraits< Class > |
| A helper that implements the traits interface for GTSAM manifolds. More... | |
| struct | gtsam::internal::Manifold< Class > |
| Both ManifoldTraits and Testable. More... | |
| struct | gtsam::FixedDimension< T > |
| Give fixed size dimension of a type, fails at compile time if dynamic. More... | |
| class | gtsam::VerticalBlockMatrix |
| This class stores a dense matrix and allows it to be accessed as a collection of vertical blocks. More... | |
\n Namespaces | |
| namespace | gtsam |
| Global functions in a separate testing namespace. | |
\n-Functions | |
| \n-template<typename T > | |
| gtsam::BOOST_CONCEPT_REQUIRES (((IsTestable< T >)),(bool)) check_manifold_invariants(const T &a | |
| Check invariants for Manifold type. | |
Base class and basic functions for Manifold types.
\n-A matrix with column blocks of pre-defined sizes.
\n+Used in JacobianFactor and GaussianConditional.
1.9.8 1.9.8 Functions for handling type information. \n+
Base class and basic functions for Lie types. \n More...
\n+\n+Go to the source code of this file.
\n\n+Classes | |
| struct | gtsam::LieGroup< Class, N > |
| A CRTP helper class that implements Lie group methods Prerequisites: methods operator*, inverse, and AdjointMap, as well as a ChartAtOrigin struct that will be used to define the manifold Chart To use, simply derive, but also say \"using LieGroup<Class,N>::inverse\" For derivative math, see doc/math.pdf. More... | |
| struct | gtsam::lie_group_tag |
| tag to assert a type is a Lie group More... | |
| struct | gtsam::internal::LieGroupTraits< Class > |
| A helper class that implements the traits interface for GTSAM lie groups. More... | |
| struct | gtsam::internal::LieGroup< Class > |
| Both LieGroupTraits and Testable. More... | |
| class | gtsam::IsLieGroup< T > |
| Lie Group Concept. More... | |
| class | gtsam::TransformCovariance< T > |
| Functor for transforming covariance of T. More... | |
\n Namespaces | |
| namespace | gtsam |
| Global functions in a separate testing namespace. | |
\n+Macros | |
| #define | GTSAM_CONCEPT_LIE_INST(T) template class gtsam::IsLieGroup<T>; |
| Macros for using the LieConcept. | |
| \n+#define | GTSAM_CONCEPT_LIE_TYPE(T) using _gtsam_IsLieGroup_##T = gtsam::IsLieGroup<T>; |
\n Functions | |
| std::string | gtsam::demangle (const char *name) |
| Pretty print Value type name. | |
| template<class Class > | |
| Class | gtsam::between_default (const Class &l1, const Class &l2) |
| These core global functions can be specialized by new Lie types for better performance. | |
| template<class Class > | |
| Vector | gtsam::logmap_default (const Class &l0, const Class &lp) |
| Log map centered at l0, s.t. | |
| template<class Class > | |
| Class | gtsam::expmap_default (const Class &t, const Vector &d) |
| Exponential map centered at l0, s.t. | |
| template<class T > | |
| T | gtsam::BCH (const T &X, const T &Y) |
| Three term approximation of the Baker-Campbell-Hausdorff formula In non-commutative Lie groups, when composing exp(Z) = exp(X)exp(Y) it is not true that Z = X+Y. | |
| \n+template<class T > | |
| Matrix | gtsam::wedge (const Vector &x) |
| Declaration of wedge (see Murray94book) used to convert from n exponential coordinates to n*n element of the Lie algebra. | |
| template<class T > | |
| T | gtsam::expm (const Vector &x, int K=7) |
| Exponential map given exponential coordinates class T needs a wedge<> function and a constructor from Matrix. | |
| template<typename T > | |
| T | gtsam::interpolate (const T &X, const T &Y, double t, typename MakeOptionalJacobian< T, T >::type Hx=boost::none, typename MakeOptionalJacobian< T, T >::type Hy=boost::none) |
| Linear interpolation between X and Y by coefficient t. | |
Functions for handling type information.
\n-Base class and basic functions for Lie types.
\n+| #define GTSAM_CONCEPT_LIE_INST | \n+( | \n+\n+ | T | ) | \n+template class gtsam::IsLieGroup<T>; | \n+
Macros for using the LieConcept.
\n+NOTE: intentionally not in the gtsam namespace to allow for classes not in the gtsam namespace to be more easily enforced as testable
\n+\n+Global debugging flags. \n+
Efficient incomplete Cholesky on rank-deficient matrices, todo: constrained Cholesky. \n More...
\n \nGo to the source code of this file.
\n\n Namespaces | |
| namespace | gtsam |
| Global functions in a separate testing namespace. | |
\n-Macros | |
| \n-#define | ISDEBUG(S) (gtsam::guardedIsDebug(S)) |
| \n-#define | SETDEBUG(S, V) ((void)(gtsam::guardedSetDebug(S,V))) |
\n Functions | |
| \n-bool | gtsam::guardedIsDebug (const std::string &s) |
| \n-void | gtsam::guardedSetDebug (const std::string &s, const bool v) |
| \n-bool | gtsam::isDebugVersion () |
| pair< size_t, bool > | gtsam::choleskyCareful (Matrix &ATA, int order=-1) |
| \"Careful\" Cholesky computes the positive square-root of a positive symmetric semi-definite matrix (i.e. | |
| bool | gtsam::choleskyPartial (Matrix &ABC, size_t nFrontal, size_t topleft=0) |
| Partial Cholesky computes a factor [R S such that [R' 0 [R S = [A B 0 L] S' I] 0 L] B' C]. | |
Global debugging flags.
\n+Efficient incomplete Cholesky on rank-deficient matrices, todo: constrained Cholesky.
\nBase exception type that uses tbb_allocator if GTSAM is compiled with TBB. \n+
Provides convenient mappings of common member functions for testing. \n More...
\n \nGo to the source code of this file.
\n\n-Classes | |
| class | gtsam::ThreadsafeException< DERIVED > |
| Base exception type that uses tbb_allocator if GTSAM is compiled with TBB. More... | |
| class | gtsam::RuntimeErrorThreadsafe |
| Thread-safe runtime error exception. More... | |
| class | gtsam::OutOfRangeThreadsafe |
| Thread-safe out of range exception. More... | |
| class | gtsam::InvalidArgumentThreadsafe |
| Thread-safe invalid argument exception. More... | |
| class | gtsam::CholeskyFailed |
| Indicate Cholesky factorization failure. More... | |
\n Namespaces | |
| namespace | gtsam |
| Global functions in a separate testing namespace. | |
Base exception type that uses tbb_allocator if GTSAM is compiled with TBB.
\n-Provides convenient mappings of common member functions for testing.
\n+ 1.9.8 1.9.8 A thin wrapper around std::list that uses boost's fast_pool_allocator. \n+
Group product of two Lie Groups. \n More...
\n \nGo to the source code of this file.
\n\n Classes | |
| class | gtsam::FastList< VALUE > |
| FastList is a thin wrapper around std::list that uses the boost fast_pool_allocator instead of the default STL allocator. More... | |
| class | gtsam::ProductLieGroup< G, H > |
| Template to construct the product Lie group of two other Lie groups Assumes Lie group structure for G and H. More... | |
| struct | gtsam::traits< ProductLieGroup< G, H > > |
\n Namespaces | |
| namespace | gtsam |
| Global functions in a separate testing namespace. | |
A thin wrapper around std::list that uses boost's fast_pool_allocator.
\n-Group product of two Lie Groups.
\n+ 1.9.8 1.9.8 1.9.8 typedef and functions to augment Eigen's MatrixXd \n+
Typedefs for easier changing of types. \n More...
\n \nGo to the source code of this file.
\n\n Classes | |
| struct | gtsam::Reshape< OutM, OutN, OutOptions, InM, InN, InOptions > |
| Reshape functor. More... | |
| struct | gtsam::const_selector< TEST_TYPE, BASIC_TYPE, AS_NON_CONST, AS_CONST > |
| Helper class that uses templates to select between two types based on whether TEST_TYPE is const or not. More... | |
| struct | gtsam::Reshape< M, M, InOptions, M, M, InOptions > |
| Reshape specialization that does nothing as shape stays the same (needed to not be ambiguous for square input equals square output) More... | |
| struct | gtsam::const_selector< BASIC_TYPE, BASIC_TYPE, AS_NON_CONST, AS_CONST > |
| Specialization for the non-const version. More... | |
| struct | gtsam::Reshape< M, N, InOptions, M, N, InOptions > |
| Reshape specialization that does nothing as shape stays the same. More... | |
| struct | gtsam::const_selector< const BASIC_TYPE, BASIC_TYPE, AS_NON_CONST, AS_CONST > |
| Specialization for the const version. More... | |
| struct | gtsam::Reshape< N, M, InOptions, M, N, InOptions > |
| Reshape specialization that does transpose. More... | |
| struct | gtsam::ValueWithDefault< T, defaultValue > |
| Helper struct that encapsulates a value with a default, this is just used as a member object so you don't have to specify defaults in the class constructor. More... | |
| struct | gtsam::MultiplyWithInverse< N > |
| Functor that implements multiplication of a vector b with the inverse of a matrix A. More... | |
| class | gtsam::ListOfOneContainer< T > |
| A helper class that behaves as a container with one element, and works with boost::range. More... | |
| struct | gtsam::MultiplyWithInverseFunction< T, N > |
| Functor that implements multiplication with the inverse of a matrix, itself the result of a function f. More... | |
| class | gtsam::TbbOpenMPMixedScope |
| An object whose scope defines a block where TBB and OpenMP parallelism are mixed. More... | |
| struct | gtsam::needs_eigen_aligned_allocator< typename, typename > |
| A SFINAE trait to mark classes that need special alignment. More... | |
| struct | gtsam::needs_eigen_aligned_allocator< T, void_t< typename T::_eigen_aligned_allocator_trait > > |
\n Namespaces | |
| namespace | gtsam |
| Global functions in a separate testing namespace. | |
\n Macros | |
| #define | GTSAM_MAKE_MATRIX_DEFS(N) |
| \n+#define | GTSAM_DEPRECATED |
| \n+#define | DO_PRAGMA(x) _Pragma (#x) |
| \n+#define | CLANG_DIAGNOSTIC_PUSH_IGNORE(diag) |
| \n+#define | GCC_DIAGNOSTIC_PUSH_IGNORE(diag) |
| \n+#define | MSVC_DIAGNOSTIC_PUSH_IGNORE(code) |
| \n+#define | DIAGNOSTIC_POP() |
| #define | assert_throw(CONDITION, EXCEPTION) |
| An assertion that throws an exception if NDEBUG is not defined and evaluates to an empty statement otherwise. | |
| #define | GTSAM_MAKE_ALIGNED_OPERATOR_NEW |
| This marks a GTSAM object to require alignment. | |
| #define | GTSAM_MAKE_ALIGNED_OPERATOR_NEW_IF(NeedsToAlign) |
| This marks a GTSAM object to require alignment. | |
\n Functions | |
| \n-const Eigen::IOFormat & | gtsam::matlabFormat () |
| \n-template<class MATRIX > | |
| bool | gtsam::equal_with_abs_tol (const Eigen::DenseBase< MATRIX > &A, const Eigen::DenseBase< MATRIX > &B, double tol=1e-9) |
| equals with a tolerance | |
| \n-bool | gtsam::operator== (const Matrix &A, const Matrix &B) |
| equality is just equal_with_abs_tol 1e-9 | |
| \n-bool | gtsam::operator!= (const Matrix &A, const Matrix &B) |
| inequality | |
| \n-bool | gtsam::assert_equal (const Matrix &A, const Matrix &B, double tol=1e-9) |
| equals with an tolerance, prints out message if unequal | |
| \n-bool | gtsam::assert_inequal (const Matrix &A, const Matrix &B, double tol=1e-9) |
| inequals with an tolerance, prints out message if within tolerance | |
| \n-bool | gtsam::assert_equal (const std::list< Matrix > &As, const std::list< Matrix > &Bs, double tol=1e-9) |
| equals with an tolerance, prints out message if unequal | |
| \n-bool | gtsam::linear_independent (const Matrix &A, const Matrix &B, double tol=1e-9) |
| check whether the rows of two matrices are linear independent | |
| \n-bool | gtsam::linear_dependent (const Matrix &A, const Matrix &B, double tol=1e-9) |
| check whether the rows of two matrices are linear dependent | |
| \n-Vector | gtsam::operator^ (const Matrix &A, const Vector &v) |
| overload ^ for trans(A)*v We transpose the vectors for speed. | |
| \n-template<class MATRIX > | |
| MATRIX | gtsam::prod (const MATRIX &A, const MATRIX &B) |
| products using old-style format to improve compatibility | |
| \n-void | gtsam::print (const Matrix &A, const std::string &s, std::ostream &stream) |
| print without optional string, must specify cout yourself | |
| \n-void | gtsam::print (const Matrix &A, const std::string &s="") |
| print with optional string to cout | |
| \n-void | gtsam::save (const Matrix &A, const std::string &s, const std::string &filename) |
| save a matrix to file, which can be loaded by matlab | |
| istream & | gtsam::operator>> (std::istream &inputStream, Matrix &destinationMatrix) |
| Read a matrix from an input stream, such as a file. | |
| template<class MATRIX > | |
| Eigen::Block< const MATRIX > | gtsam::sub (const MATRIX &A, size_t i1, size_t i2, size_t j1, size_t j2) |
| extract submatrix, slice semantics, i.e. | |
| template<typename Derived1 , typename Derived2 > | |
| void | gtsam::insertSub (Eigen::MatrixBase< Derived1 > &fullMatrix, const Eigen::MatrixBase< Derived2 > &subMatrix, size_t i, size_t j) |
| insert a submatrix IN PLACE at a specified location in a larger matrix NOTE: there is no size checking | |
| \n-Matrix | gtsam::diag (const std::vector< Matrix > &Hs) |
| Create a matrix with submatrices along its diagonal. | |
| template<class MATRIX > | |
| const MATRIX::ConstColXpr | gtsam::column (const MATRIX &A, size_t j) |
| Extracts a column view from a matrix that avoids a copy. | |
| template<class MATRIX > | |
| const MATRIX::ConstRowXpr | gtsam::row (const MATRIX &A, size_t j) |
| Extracts a row view from a matrix that avoids a copy. | |
| template<class MATRIX > | |
| void | gtsam::zeroBelowDiagonal (MATRIX &A, size_t cols=0) |
| Zeros all of the elements below the diagonal of a matrix, in place. | |
| \n-Matrix | gtsam::trans (const Matrix &A) |
| static transpose function, just calls Eigen transpose member function | |
| \n-template<int OutM, int OutN, int OutOptions, int InM, int InN, int InOptions> | |
| Reshape< OutM, OutN, OutOptions, InM, InN, InOptions >::ReshapedType | gtsam::reshape (const Eigen::Matrix< double, InM, InN, InOptions > &m) |
| pair< Matrix, Matrix > | gtsam::qr (const Matrix &A) |
| Householder QR factorization, Golub & Van Loan p 224, explicit version \n- | |
| void | gtsam::inplace_QR (Matrix &A) |
| QR factorization using Eigen's internal block QR algorithm. | |
| list< boost::tuple< Vector, double, double > > | gtsam::weighted_eliminate (Matrix &A, Vector &b, const Vector &sigmas) |
| Imperative algorithm for in-place full elimination with weights and constraint handling. | |
| void | gtsam::householder_ (Matrix &A, size_t k, bool copy_vectors) |
| Imperative version of Householder QR factorization, Golub & Van Loan p 224 version with Householder vectors below diagonal, as in GVL. | |
| void | gtsam::householder (Matrix &A, size_t k) |
| Householder tranformation, zeros below diagonal. | |
| Vector | gtsam::backSubstituteUpper (const Matrix &U, const Vector &b, bool unit=false) |
| backSubstitute U*x=b | |
| Vector | gtsam::backSubstituteUpper (const Vector &b, const Matrix &U, bool unit=false) |
| backSubstitute x'*U=b' | |
| Vector | gtsam::backSubstituteLower (const Matrix &L, const Vector &b, bool unit=false) |
| backSubstitute L*x=b | |
| Matrix | gtsam::stack (size_t nrMatrices,...) |
| create a matrix by stacking other matrices Given a set of matrices: A1, A2, A3... | |
| \n-Matrix | gtsam::stack (const std::vector< Matrix > &blocks) |
| Matrix | gtsam::collect (const std::vector< const Matrix * > &matrices, size_t m=0, size_t n=0) |
| create a matrix by concatenating Given a set of matrices: A1, A2, A3... If all matrices have the same size, specifying single matrix dimensions will avoid the lookup of dimensions | |
| \n-Matrix | gtsam::collect (size_t nrMatrices,...) |
| void | gtsam::vector_scale_inplace (const Vector &v, Matrix &A, bool inf_mask=false) |
| scales a matrix row or column by the values in a vector Arguments (Matrix, Vector) scales the columns, (Vector, Matrix) scales the rows | |
| \n-Matrix | gtsam::vector_scale (const Vector &v, const Matrix &A, bool inf_mask) |
| \n-Matrix | gtsam::vector_scale (const Matrix &A, const Vector &v, bool inf_mask) |
| Matrix3 | gtsam::skewSymmetric (double wx, double wy, double wz) |
| skew symmetric matrix returns this: 0 -wz wy wz 0 -wx -wy wx 0 | |
| \n-template<class Derived > | |
| Matrix3 | gtsam::skewSymmetric (const Eigen::MatrixBase< Derived > &w) |
| \n-Matrix | gtsam::inverse_square_root (const Matrix &A) |
| Use Cholesky to calculate inverse square root of a matrix. | |
| Matrix | gtsam::cholesky_inverse (const Matrix &A) |
| Return the inverse of a S.P.D. | |
| void | gtsam::svd (const Matrix &A, Matrix &U, Vector &S, Matrix &V) |
| SVD computes economy SVD A=U*S*V'. | |
| boost::tuple< int, double, Vector > | gtsam::DLT (const Matrix &A, double rank_tol=1e-9) |
| Direct linear transform algorithm that calls svd to find a vector v that minimizes the algebraic error A*v. | |
| Matrix | gtsam::expm (const Matrix &A, size_t K=7) |
| Numerical exponential map, naive approach, not industrial strength !!! | |
| \n-std::string | gtsam::formatMatrixIndented (const std::string &label, const Matrix &matrix, bool makeVectorHorizontal) |
| \n-Matrix | gtsam::LLt (const Matrix &A) |
| \n-Matrix | gtsam::RtR (const Matrix &A) |
| \n-Vector | gtsam::columnNormSquare (const Matrix &A) |
| std::string | gtsam::demangle (const char *name) |
| Pretty print Value type name. | |
| \n+ | gtsam::BOOST_CONCEPT_ASSERT ((boost::RandomAccessRangeConcept< ListOfOneContainer< int > >)) |
| \n+template<typename T > | |
| ListOfOneContainer< T > | gtsam::ListOfOne (const T &element) |
| Factory function for ListOfOneContainer to enable ListOfOne(e) syntax. | |
typedef and functions to augment Eigen's MatrixXd
\n-Typedefs for easier changing of types.
\n+| #define assert_throw | \n+( | \n+\n+ | CONDITION, | \n+
| \n+ | \n+ | \n+ | EXCEPTION | \n+
| \n+ | ) | \n+\n+ |
An assertion that throws an exception if NDEBUG is not defined and evaluates to an empty statement otherwise.
\n+\n+| #define GTSAM_MAKE_ALIGNED_OPERATOR_NEW | \n+
This marks a GTSAM object to require alignment.
\n+With this macro an object will automatically be allocated in aligned memory when one uses gtsam::make_shared. It reduces future misalignment problems that is hard to debug. See https://eigen.tuxfamily.org/dox/group__DenseMatrixManipulation__Alignement.html for detailed explanation.
| #define GTSAM_MAKE_MATRIX_DEFS | \n+#define GTSAM_MAKE_ALIGNED_OPERATOR_NEW_IF | \n( | \n\n- | N | ) | \n+NeedsToAlign | ) | \n\n |
This marks a GTSAM object to require alignment.
\n+With this macro an object will automatically be allocated in aligned memory when one uses gtsam::make_shared. It reduces future misalignment problems that is hard to debug. See https://eigen.tuxfamily.org/dox/group__DenseMatrixManipulation__Alignement.html for detailed explanation.