-
│ │ │ │ -
│ │ │ │ +
│ │ │ │
- Generated on Tue Jan 9 2024 05:51:35 for gtsam by
1.9.8
│ │ │ │
serialization for Vectors │ │ │ │ +
Efficient incomplete Cholesky on rank-deficient matrices, todo: constrained Cholesky. │ │ │ │ More...
│ │ │ │ - │ │ │ │ -Go to the source code of this file.
│ │ │ ││ │ │ │ +Namespaces | |
| namespace | gtsam |
| Global functions in a separate testing namespace. | |
│ │ │ │ Functions | |
| │ │ │ │ -template<class Archive > | |
| void | boost::serialization::save (Archive &ar, const gtsam::Vector &v, unsigned int) |
| │ │ │ │ -template<class Archive > | |
| void | boost::serialization::load (Archive &ar, gtsam::Vector &v, unsigned int) |
| │ │ │ │ -template<class Archive , int D> | |
| void | boost::serialization::save (Archive &ar, const Eigen::Matrix< double, D, 1 > &v, unsigned int) |
| │ │ │ │ -template<class Archive , int D> | |
| void | boost::serialization::load (Archive &ar, Eigen::Matrix< double, D, 1 > &v, unsigned int) |
| 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]. | |
serialization for Vectors
│ │ │ │ - │ │ │ │ -Efficient incomplete Cholesky on rank-deficient matrices, todo: constrained Cholesky.
│ │ │ │ + │ │ │ │ + 1.9.8 Efficient incomplete Cholesky on rank-deficient matrices, todo: constrained Cholesky. │ │ │ │ +
An easy way to control which allocator is used for Fast* collections. │ │ │ │ More...
│ │ │ │ │ │ │ │Go to the source code of this file.
│ │ │ ││ │ │ │ +Classes | |
| struct | gtsam::internal::FastDefaultAllocator< T > |
| Default allocator for list, map, and set types. More... | |
| struct | gtsam::internal::FastDefaultVectorAllocator< T > |
| Default allocator for vector types (we never use boost pool for vectors) More... | |
│ │ │ │ Namespaces | |
| namespace | gtsam |
| Global functions in a separate testing namespace. | |
│ │ │ │ -Functions | |
| 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]. | |
Efficient incomplete Cholesky on rank-deficient matrices, todo: constrained Cholesky.
│ │ │ │ +An easy way to control which allocator is used for Fast* collections.
│ │ │ │ │ │ │ │ - 1.9.8 1.9.8 Base class and basic functions for Lie types. │ │ │ │ +
typedef and functions to augment Eigen's Vectors │ │ │ │ More...
│ │ │ │ - │ │ │ │ -Go to the source code of this file.
│ │ │ ││ │ │ │ -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... | |
│ │ │ │ Namespaces | |
| namespace | gtsam |
| Global functions in a separate testing namespace. | |
│ │ │ │ -Macros | |
| #define | GTSAM_CONCEPT_LIE_INST(T) template class gtsam::IsLieGroup<T>; |
| Macros for using the LieConcept. | |
| │ │ │ │ -#define | GTSAM_CONCEPT_LIE_TYPE(T) using _gtsam_IsLieGroup_##T = gtsam::IsLieGroup<T>; |
│ │ │ │ Functions | |
| 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. | |
| │ │ │ │ -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. | |
| bool | gtsam::fpEqual (double a, double b, double tol, bool check_relative_also=true) |
| Ensure we are not including a different version of Eigen in user code than while compiling gtsam, since it can lead to hard-to-understand runtime crashes. | |
| │ │ │ │ +void | gtsam::print (const Vector &v, const std::string &s, std::ostream &stream) |
| print without optional string, must specify cout yourself | |
| │ │ │ │ +void | gtsam::print (const Vector &v, const std::string &s="") |
| print with optional string to cout | |
| │ │ │ │ +void | gtsam::save (const Vector &A, const std::string &s, const std::string &filename) |
| save a vector to file, which can be loaded by matlab | |
| │ │ │ │ +bool | gtsam::operator== (const Vector &vec1, const Vector &vec2) |
| operator==() | |
| │ │ │ │ +bool | gtsam::greaterThanOrEqual (const Vector &v1, const Vector &v2) |
| Greater than or equal to operation returns true if all elements in v1 are greater than corresponding elements in v2. | |
| │ │ │ │ +bool | gtsam::equal_with_abs_tol (const Vector &vec1, const Vector &vec2, double tol=1e-9) |
| VecA == VecB up to tolerance. | |
| │ │ │ │ +bool | gtsam::equal_with_abs_tol (const SubVector &vec1, const SubVector &vec2, double tol) |
| bool | gtsam::assert_equal (const Vector &vec1, const Vector &vec2, double tol=1e-9) |
| Same, prints if error. | |
| bool | gtsam::assert_inequal (const Vector &vec1, const Vector &vec2, double tol=1e-9) |
| Not the same, prints if error. | |
| bool | gtsam::assert_equal (const SubVector &vec1, const SubVector &vec2, double tol=1e-9) |
| Same, prints if error. | |
| │ │ │ │ +bool | gtsam::assert_equal (const ConstSubVector &expected, const ConstSubVector &actual, double tol) |
| bool | gtsam::linear_dependent (const Vector &vec1, const Vector &vec2, double tol=1e-9) |
| check whether two vectors are linearly dependent | |
| Vector | gtsam::ediv_ (const Vector &a, const Vector &b) |
| elementwise division, but 0/0 = 0, not inf | |
| │ │ │ │ +double | gtsam::houseInPlace (Vector &x) |
| beta = house(x) computes the HouseHolder vector in place | |
| pair< double, Vector > | gtsam::house (const Vector &x) |
| house(x,j) computes HouseHolder vector v and scaling factor beta from x, such that the corresponding Householder reflection zeroes out all but x. | |
| │ │ │ │ +double | gtsam::weightedPseudoinverse (const Vector &a, const Vector &weights, Vector &pseudo) |
| pair< Vector, double > | gtsam::weightedPseudoinverse (const Vector &v, const Vector &weights) |
| Weighted Householder solution vector, a.k.a., the pseudoinverse of the column NOTE: if any sigmas are zero (indicating a constraint) the pseudoinverse will be a selection vector, and the variance will be zero. | |
| │ │ │ │ +Vector | gtsam::concatVectors (const std::list< Vector > &vs) |
| concatenate Vectors | |
| │ │ │ │ +Vector | gtsam::concatVectors (size_t nrVectors,...) |
| concatenate Vectors | |
Base class and basic functions for Lie types.
│ │ │ │ - 1.9.8 Provides additional testing facilities for common data structures. │ │ │ │ +
typedef and functions to augment Eigen's VectorXd │ │ │ │ More...
│ │ │ │ │ │ │ │Go to the source code of this file.
│ │ │ ││ │ │ │ Namespaces | |
| namespace | gtsam |
| Global functions in a separate testing namespace. | |
│ │ │ │ +Macros | |
| │ │ │ │ +#define | MKL_BLAS MKL_DOMAIN_BLAS |
| #define | GTSAM_MAKE_VECTOR_DEFS(N) |
│ │ │ │ Functions | |
| │ │ │ │ -bool | gtsam::assert_equal (const Key &expected, const Key &actual, double tol=0.0) |
| Equals testing for basic types. | |
| template<class V > | |
| bool | gtsam::assert_equal (const boost::optional< V > &expected, const boost::optional< V > &actual, double tol=1e-9) |
| Comparisons for boost.optional objects that checks whether objects exist before comparing their values. | |
| │ │ │ │ -template<class V > | |
| bool | gtsam::assert_equal (const V &expected, const boost::optional< V > &actual, double tol=1e-9) |
| │ │ │ │ -template<class V > | |
| bool | gtsam::assert_equal (const V &expected, const boost::optional< const V & > &actual, double tol=1e-9) |
| │ │ │ │ + | |
| bool | gtsam::fpEqual (double a, double b, double tol, bool check_relative_also=true) |
| Ensure we are not including a different version of Eigen in user code than while compiling gtsam, since it can lead to hard-to-understand runtime crashes. | |
| │ │ │ │ +void | gtsam::print (const Vector &v, const std::string &s, std::ostream &stream) |
| print without optional string, must specify cout yourself | |
| │ │ │ │ +void | gtsam::print (const Vector &v, const std::string &s="") |
| print with optional string to cout | |
| │ │ │ │ +void | gtsam::save (const Vector &A, const std::string &s, const std::string &filename) |
| save a vector to file, which can be loaded by matlab | |
| │ │ │ │ +bool | gtsam::operator== (const Vector &vec1, const Vector &vec2) |
| operator==() | |
| │ │ │ │ +bool | gtsam::greaterThanOrEqual (const Vector &v1, const Vector &v2) |
| Greater than or equal to operation returns true if all elements in v1 are greater than corresponding elements in v2. | |
| │ │ │ │ +bool | gtsam::equal_with_abs_tol (const Vector &vec1, const Vector &vec2, double tol=1e-9) |
| VecA == VecB up to tolerance. | |
| │ │ │ │ +bool | gtsam::equal_with_abs_tol (const SubVector &vec1, const SubVector &vec2, double tol) |
| │ │ │ │ +bool | gtsam::equal (const Vector &vec1, const Vector &vec2, double tol) |
| Override of equal in Lie.h. | |
| │ │ │ │ +bool | gtsam::equal (const Vector &vec1, const Vector &vec2) |
| Override of equal in Lie.h. | |
| bool | gtsam::assert_equal (const Vector &vec1, const Vector &vec2, double tol=1e-9) |
| Same, prints if error. | |
| bool | gtsam::assert_inequal (const Vector &vec1, const Vector &vec2, double tol=1e-9) |
| Not the same, prints if error. | |
| bool | gtsam::assert_equal (const SubVector &vec1, const SubVector &vec2, double tol=1e-9) |
| Same, prints if error. | |
| │ │ │ │ +bool | gtsam::assert_equal (const ConstSubVector &expected, const ConstSubVector &actual, double tol) |
| bool | gtsam::linear_dependent (const Vector &vec1, const Vector &vec2, double tol=1e-9) |
| check whether two vectors are linearly dependent | |
| Vector | gtsam::ediv_ (const Vector &a, const Vector &b) |
| elementwise division, but 0/0 = 0, not inf | |
| │ │ │ │ template<class V1 , class V2 > | |
| bool | gtsam::assert_container_equal (const std::map< V1, V2 > &expected, const std::map< V1, V2 > &actual, double tol=1e-9) |
| Function for comparing maps of testable->testable TODO: replace with more generalized version. | |
| │ │ │ │ -template<class V2 > | |
| bool | gtsam::assert_container_equal (const std::map< size_t, V2 > &expected, const std::map< size_t, V2 > &actual, double tol=1e-9) |
| Function for comparing maps of size_t->testable. | |
| │ │ │ │ + | |
| double | gtsam::dot (const V1 &a, const V2 &b) |
| Dot product. | |
| │ │ │ │ template<class V1 , class V2 > | |
| bool | gtsam::assert_container_equal (const std::vector< std::pair< V1, V2 > > &expected, const std::vector< std::pair< V1, V2 > > &actual, double tol=1e-9) |
| Function for comparing vector of pairs (testable, testable) | |
| │ │ │ │ -template<class V > | |
| bool | gtsam::assert_container_equal (const V &expected, const V &actual, double tol=1e-9) |
| General function for comparing containers of testable objects. | |
| │ │ │ │ -template<class V2 > | |
| bool | gtsam::assert_container_equality (const std::map< size_t, V2 > &expected, const std::map< size_t, V2 > &actual) |
| Function for comparing maps of size_t->testable Types are assumed to have operator ==. | |
| │ │ │ │ -template<class V > | |
| bool | gtsam::assert_container_equality (const V &expected, const V &actual) |
| General function for comparing containers of objects with operator==. | |
| │ │ │ │ -bool | gtsam::assert_equal (const std::string &expected, const std::string &actual) |
| Compare strings for unit tests. | |
| │ │ │ │ -template<class V > | |
| bool | gtsam::assert_inequal (const V &expected, const V &actual, double tol=1e-9) |
| Allow for testing inequality. | |
| │ │ │ │ -template<class V > | |
| bool | gtsam::assert_stdout_equal (const std::string &expected, const V &actual) |
| Capture std out via cout stream and compare against string. | |
| template<class V > | |
| bool | gtsam::assert_print_equal (const std::string &expected, const V &actual, const std::string &s="") |
| Capture print function output and compare against string. | |
| double | gtsam::inner_prod (const V1 &a, const V2 &b) |
| compatibility version for ublas' inner_prod() | |
| pair< double, Vector > | gtsam::house (const Vector &x) |
| house(x,j) computes HouseHolder vector v and scaling factor beta from x, such that the corresponding Householder reflection zeroes out all but x. | |
| │ │ │ │ +double | gtsam::houseInPlace (Vector &x) |
| beta = house(x) computes the HouseHolder vector in place | |
| pair< Vector, double > | gtsam::weightedPseudoinverse (const Vector &v, const Vector &weights) |
| Weighted Householder solution vector, a.k.a., the pseudoinverse of the column NOTE: if any sigmas are zero (indicating a constraint) the pseudoinverse will be a selection vector, and the variance will be zero. | |
| │ │ │ │ +double | gtsam::weightedPseudoinverse (const Vector &a, const Vector &weights, Vector &pseudo) |
| │ │ │ │ +Vector | gtsam::concatVectors (const std::list< Vector > &vs) |
| concatenate Vectors | |
| │ │ │ │ +Vector | gtsam::concatVectors (size_t nrVectors,...) |
| concatenate Vectors | |
Provides additional testing facilities for common data structures.
│ │ │ │ - │ │ │ │ -typedef and functions to augment Eigen's VectorXd
│ │ │ │ + │ │ │ │ +| #define GTSAM_MAKE_VECTOR_DEFS | │ │ │ │ +( | │ │ │ │ +│ │ │ │ + | N | ) | │ │ │ │ +│ │ │ │ + |
1.9.8 1.9.8