-
│ │ │ │ -
│ │ │ │ +
│ │ │ │
- Generated on Tue Jan 9 2024 05:51:35 for gtsam by
1.9.8
│ │ │ │
serialization for Vectors │ │ │ │ +
Group product of two Lie Groups. │ │ │ │ More...
│ │ │ │ │ │ │ │Go to the source code of this file.
│ │ │ ││ │ │ │ -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) |
│ │ │ │ +Classes | |
| 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 > > |
│ │ │ │ +Namespaces | |
| namespace | gtsam |
| Global functions in a separate testing namespace. | |
serialization for Vectors
│ │ │ │ +Group product of two Lie Groups.
│ │ │ │ + 1.9.8 1.9.8 Global debugging flags. │ │ │ │ +
Provides additional testing facilities for common data structures. │ │ │ │ More...
│ │ │ │ + │ │ │ │ +Go to the source code of this file.
│ │ │ ││ │ │ │ Namespaces | |
| namespace | gtsam |
| Global functions in a separate testing namespace. | |
│ │ │ │ -Variables | |
| │ │ │ │ -GTSAM_EXPORT FastMap< std::string, ValueWithDefault< bool, false > > | gtsam::debugFlags |
| │ │ │ │ +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) |
| │ │ │ │ +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. | |
| │ │ │ │ +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. | |
Global debugging flags.
│ │ │ │ - │ │ │ │ -Provides additional testing facilities for common data structures.
│ │ │ │ + │ │ │ │ 1.9.8 Efficient incomplete Cholesky on rank-deficient matrices, todo: constrained Cholesky. │ │ │ │ +
Convenience functions for serializing data structures via boost.serialization. │ │ │ │ More...
│ │ │ │ │ │ │ │Go to the source code of this file.
│ │ │ ││ │ │ │ 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]. | |
Standard serialization | |
Serialization in default compressed format │ │ │ │ + | |
| template<class T > | |
| void | gtsam::serializeToStream (const T &input, std::ostream &out_archive_stream) |
| │ │ │ │ +template<class T > | |
| void | gtsam::deserializeFromStream (std::istream &in_archive_stream, T &output) |
| deserializes from a stream | |
| │ │ │ │ +template<class T > | |
| std::string | gtsam::serializeToString (const T &input) |
| serializes to a string | |
| │ │ │ │ +template<class T > | |
| void | gtsam::deserializeFromString (const std::string &serialized, T &output) |
| deserializes from a string | |
| │ │ │ │ +template<class T > | |
| bool | gtsam::serializeToFile (const T &input, const std::string &filename) |
| serializes to a file | |
| │ │ │ │ +template<class T > | |
| bool | gtsam::deserializeFromFile (const std::string &filename, T &output) |
| deserializes from a file | |
| │ │ │ │ +template<class T > | |
| std::string | gtsam::serialize (const T &input) |
| serializes to a string | |
| │ │ │ │ +template<class T > | |
| void | gtsam::deserialize (const std::string &serialized, T &output) |
| deserializes from a string | |
XML Serialization | |
Serialization to XML format with named structures │ │ │ │ + | |
| template<class T > | |
| void | gtsam::serializeToXMLStream (const T &input, std::ostream &out_archive_stream, const std::string &name="data") |
| │ │ │ │ +template<class T > | |
| void | gtsam::deserializeFromXMLStream (std::istream &in_archive_stream, T &output, const std::string &name="data") |
| deserializes from a stream in XML | |
| │ │ │ │ +template<class T > | |
| std::string | gtsam::serializeToXMLString (const T &input, const std::string &name="data") |
| serializes to a string in XML | |
| │ │ │ │ +template<class T > | |
| void | gtsam::deserializeFromXMLString (const std::string &serialized, T &output, const std::string &name="data") |
| deserializes from a string in XML | |
| │ │ │ │ +template<class T > | |
| bool | gtsam::serializeToXMLFile (const T &input, const std::string &filename, const std::string &name="data") |
| serializes to an XML file | |
| │ │ │ │ +template<class T > | |
| bool | gtsam::deserializeFromXMLFile (const std::string &filename, T &output, const std::string &name="data") |
| deserializes from an XML file | |
| │ │ │ │ +template<class T > | |
| std::string | gtsam::serializeXML (const T &input, const std::string &name="data") |
| serializes to a string in XML | |
| │ │ │ │ +template<class T > | |
| void | gtsam::deserializeXML (const std::string &serialized, T &output, const std::string &name="data") |
| deserializes from a string in XML | |
Binary Serialization | |
Serialization to binary format with named structures │ │ │ │ + | |
| template<class T > | |
| void | gtsam::serializeToBinaryStream (const T &input, std::ostream &out_archive_stream, const std::string &name="data") |
| │ │ │ │ +template<class T > | |
| void | gtsam::deserializeFromBinaryStream (std::istream &in_archive_stream, T &output, const std::string &name="data") |
| deserializes from a stream in binary | |
| │ │ │ │ +template<class T > | |
| std::string | gtsam::serializeToBinaryString (const T &input, const std::string &name="data") |
| serializes to a string in binary | |
| │ │ │ │ +template<class T > | |
| void | gtsam::deserializeFromBinaryString (const std::string &serialized, T &output, const std::string &name="data") |
| deserializes from a string in binary | |
| │ │ │ │ +template<class T > | |
| bool | gtsam::serializeToBinaryFile (const T &input, const std::string &filename, const std::string &name="data") |
| serializes to a binary file | |
| │ │ │ │ +template<class T > | |
| bool | gtsam::deserializeFromBinaryFile (const std::string &filename, T &output, const std::string &name="data") |
| deserializes from a binary file | |
| │ │ │ │ +template<class T > | |
| std::string | gtsam::serializeBinary (const T &input, const std::string &name="data") |
| serializes to a string in binary | |
| │ │ │ │ +template<class T > | |
| void | gtsam::deserializeBinary (const std::string &serialized, T &output, const std::string &name="data") |
| deserializes from a string in binary | |
Efficient incomplete Cholesky on rank-deficient matrices, todo: constrained Cholesky.
│ │ │ │ - │ │ │ │ -Convenience functions for serializing data structures via boost.serialization.
│ │ │ │ + │ │ │ │ + 1.9.8 1.9.8 Base class and basic functions for Lie types. │ │ │ │ +
A faster implementation for DSF, which uses vector rather than btree. │ │ │ │ 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... | |
| class | gtsam::DSFBase |
| A fast implementation of disjoint set forests that uses vector as underly data structure. 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... | |
| class | gtsam::DSFVector |
| DSFVector additionally keeps a vector of keys to support more expensive operations. 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. | |
Base class and basic functions for Lie types.
│ │ │ │ - │ │ │ │ -| #define GTSAM_CONCEPT_LIE_INST | │ │ │ │ -( | │ │ │ │ -│ │ │ │ - | T | ) | │ │ │ │ -template class gtsam::IsLieGroup<T>; | │ │ │ │ -
Macros for using the LieConcept.
│ │ │ │ -NOTE: intentionally not in the gtsam namespace to allow for classes not in the gtsam namespace to be more easily enforced as testable
│ │ │ │ - │ │ │ │ -A faster implementation for DSF, which uses vector rather than btree.
│ │ │ │ + 1.9.8 1.9.8