- \n-
- gtsam
- base
- VectorSerialization.h \n+
- gtsam
- base
- ProductLieGroup.h \n
- Generated on Tue Jan 9 2024 05:51:35 for gtsam by
![\"doxygen\"/](\"doxygen.svg\")
1.9.8 \n
serialization for Vectors \n+
Group product of two Lie Groups. \n More...
\n \nGo to the source code of this file.
\n\n-Functions | |
| \n-template<class Archive > | |
| void | boost::serialization::save (Archive &ar, const gtsam::Vector &v, unsigned int) |
| \n-template<class Archive > | |
| void | boost::serialization::load (Archive &ar, gtsam::Vector &v, unsigned int) |
| \n-template<class Archive , int D> | |
| void | boost::serialization::save (Archive &ar, const Eigen::Matrix< double, D, 1 > &v, unsigned int) |
| \n-template<class Archive , int D> | |
| void | boost::serialization::load (Archive &ar, Eigen::Matrix< double, D, 1 > &v, unsigned int) |
\n+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 > > |
\n+Namespaces | |
| namespace | gtsam |
| Global functions in a separate testing namespace. | |
serialization for Vectors
\n+Group product of two Lie Groups.
\n+ 1.9.8 1.9.8 Global debugging flags. \n+
Provides additional testing facilities for common data structures. \n More...
\n+\n+Go to the source code of this file.
\n\n Namespaces | |
| namespace | gtsam |
| Global functions in a separate testing namespace. | |
\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 () |
\n-Variables | |
| \n-GTSAM_EXPORT FastMap< std::string, ValueWithDefault< bool, false > > | gtsam::debugFlags |
| \n+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. | |
| \n+template<class V > | |
| bool | gtsam::assert_equal (const V &expected, const boost::optional< V > &actual, double tol=1e-9) |
| \n+template<class V > | |
| bool | gtsam::assert_equal (const V &expected, const boost::optional< const V & > &actual, double tol=1e-9) |
| \n+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. | |
| \n+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. | |
| \n+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) | |
| \n+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. | |
| \n+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 ==. | |
| \n+template<class V > | |
| bool | gtsam::assert_container_equality (const V &expected, const V &actual) |
| General function for comparing containers of objects with operator==. | |
| \n+bool | gtsam::assert_equal (const std::string &expected, const std::string &actual) |
| Compare strings for unit tests. | |
| \n+template<class V > | |
| bool | gtsam::assert_inequal (const V &expected, const V &actual, double tol=1e-9) |
| Allow for testing inequality. | |
| \n+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.
\n-Provides additional testing facilities for common data structures.
\n+Efficient incomplete Cholesky on rank-deficient matrices, todo: constrained Cholesky. \n+
Convenience functions for serializing data structures via boost.serialization. \n More...
\n \nGo to the source code of this file.
\n\n Namespaces | |
| namespace | gtsam |
| Global functions in a separate testing namespace. | |
\n 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 \n+ | |
| template<class T > | |
| void | gtsam::serializeToStream (const T &input, std::ostream &out_archive_stream) |
| \n+template<class T > | |
| void | gtsam::deserializeFromStream (std::istream &in_archive_stream, T &output) |
| deserializes from a stream | |
| \n+template<class T > | |
| std::string | gtsam::serializeToString (const T &input) |
| serializes to a string | |
| \n+template<class T > | |
| void | gtsam::deserializeFromString (const std::string &serialized, T &output) |
| deserializes from a string | |
| \n+template<class T > | |
| bool | gtsam::serializeToFile (const T &input, const std::string &filename) |
| serializes to a file | |
| \n+template<class T > | |
| bool | gtsam::deserializeFromFile (const std::string &filename, T &output) |
| deserializes from a file | |
| \n+template<class T > | |
| std::string | gtsam::serialize (const T &input) |
| serializes to a string | |
| \n+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 \n+ | |
| template<class T > | |
| void | gtsam::serializeToXMLStream (const T &input, std::ostream &out_archive_stream, const std::string &name="data") |
| \n+template<class T > | |
| void | gtsam::deserializeFromXMLStream (std::istream &in_archive_stream, T &output, const std::string &name="data") |
| deserializes from a stream in XML | |
| \n+template<class T > | |
| std::string | gtsam::serializeToXMLString (const T &input, const std::string &name="data") |
| serializes to a string in XML | |
| \n+template<class T > | |
| void | gtsam::deserializeFromXMLString (const std::string &serialized, T &output, const std::string &name="data") |
| deserializes from a string in XML | |
| \n+template<class T > | |
| bool | gtsam::serializeToXMLFile (const T &input, const std::string &filename, const std::string &name="data") |
| serializes to an XML file | |
| \n+template<class T > | |
| bool | gtsam::deserializeFromXMLFile (const std::string &filename, T &output, const std::string &name="data") |
| deserializes from an XML file | |
| \n+template<class T > | |
| std::string | gtsam::serializeXML (const T &input, const std::string &name="data") |
| serializes to a string in XML | |
| \n+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 \n+ | |
| template<class T > | |
| void | gtsam::serializeToBinaryStream (const T &input, std::ostream &out_archive_stream, const std::string &name="data") |
| \n+template<class T > | |
| void | gtsam::deserializeFromBinaryStream (std::istream &in_archive_stream, T &output, const std::string &name="data") |
| deserializes from a stream in binary | |
| \n+template<class T > | |
| std::string | gtsam::serializeToBinaryString (const T &input, const std::string &name="data") |
| serializes to a string in binary | |
| \n+template<class T > | |
| void | gtsam::deserializeFromBinaryString (const std::string &serialized, T &output, const std::string &name="data") |
| deserializes from a string in binary | |
| \n+template<class T > | |
| bool | gtsam::serializeToBinaryFile (const T &input, const std::string &filename, const std::string &name="data") |
| serializes to a binary file | |
| \n+template<class T > | |
| bool | gtsam::deserializeFromBinaryFile (const std::string &filename, T &output, const std::string &name="data") |
| deserializes from a binary file | |
| \n+template<class T > | |
| std::string | gtsam::serializeBinary (const T &input, const std::string &name="data") |
| serializes to a string in binary | |
| \n+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.
\n-Convenience functions for serializing data structures via boost.serialization.
\n+ 1.9.8 1.9.8 Base class and basic functions for Lie types. \n+
A faster implementation for DSF, which uses vector rather than btree. \n More...
\n \nGo 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... | |
| 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... | |
\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 | |
| 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. | |
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-A faster implementation for DSF, which uses vector rather than btree.
\n+