|
TooN 2.1
|
Everything lives inside this namespace. More...
Namespaces | |
| namespace | Internal |
Classes | |
| class | Cholesky |
| Decomposes a positive-semidefinite symmetric matrix A (such as a covariance) into L*D*L^T, where L is lower-triangular and D is diagonal. More... | |
| class | GR_SVD |
| Performs SVD and back substitute to solve equations. More... | |
| struct | RobustI |
| Robust reweighting (type I) for IRLS. More... | |
| struct | RobustII |
| Robust reweighting (type II) for IRLS. More... | |
| struct | ILinear |
| A reweighting class representing no reweighting in IRLS. More... | |
| struct | RobustIII |
| A reweighting class where the objective function tends to a fixed value, rather than infinity. More... | |
| class | IRLS |
| Performs iterative reweighted least squares. More... | |
| class | Lapack_Cholesky |
| Decomposes a positive-semidefinite symmetric matrix A (such as a covariance) into L*L^T, where L is lower-triangular. More... | |
| class | LU |
| Performs LU decomposition and back substitutes to solve equations. More... | |
| class | QR |
| Performs QR decomposition. More... | |
| class | QR_Lapack |
| Performs QR decomposition. More... | |
| class | SE2 |
| Represent a two-dimensional Euclidean transformation (a rotation and a translation). More... | |
| struct | Operator< Internal::SE2VMult< S, P, PV, A > > |
| struct | Operator< Internal::VSE2Mult< S, P, PV, A > > |
| struct | Operator< Internal::SE2MMult< R, Cols, PM, A, P > > |
| struct | Operator< Internal::MSE2Mult< Rows, C, PM, A, P > > |
| class | SE3 |
| Represent a three-dimensional Euclidean transformation (a rotation and a translation). More... | |
| struct | Operator< Internal::SE3VMult< S, PV, A, P > > |
| struct | Operator< Internal::VSE3Mult< S, PV, A, P > > |
| struct | Operator< Internal::SE3MMult< R, Cols, PM, A, P > > |
| struct | Operator< Internal::MSE3Mult< Rows, C, PM, A, P > > |
| class | SIM2 |
| Represent a two-dimensional Similarity transformation (a rotation, a uniform scale and a translation). More... | |
| struct | Operator< Internal::SIM2VMult< S, P, PV, A > > |
| struct | Operator< Internal::VSIM2Mult< S, P, PV, A > > |
| struct | Operator< Internal::SIM2MMult< R, Cols, PM, A, P > > |
| struct | Operator< Internal::MSIM2Mult< Rows, C, PM, A, P > > |
| class | SIM3 |
| Represent a three-dimensional similarity transformation (a rotation, a scale factor and a translation). More... | |
| struct | Operator< Internal::SIM3VMult< S, PV, A, P > > |
| struct | Operator< Internal::VSIM3Mult< S, PV, A, P > > |
| struct | Operator< Internal::SIM3MMult< R, Cols, PM, A, P > > |
| struct | Operator< Internal::MSIM3Mult< Rows, C, PM, A, P > > |
| class | SL |
| represents an element from the group SL(n), the NxN matrices M with det(M) = 1. More... | |
| class | SO2 |
| Class to represent a two-dimensional rotation matrix. More... | |
| class | SO3 |
| Class to represent a three-dimensional rotation matrix. More... | |
| class | SVD |
| Performs SVD and back substitute to solve equations. More... | |
| struct | SQSVD |
| version of SVD forced to be square princiapally here to allow use in WLS More... | |
| class | SymEigen |
| Performs eigen decomposition of a matrix. More... | |
| struct | IsField |
| Is a number a field? i.e., +, -, *, / defined. More... | |
| struct | IsField< std::complex< C > > |
| struct | IsField< const C > |
| Specialized for const types. More... | |
| struct | Operator |
| This is a struct used heavily in TooN internals. More... | |
| class | WLS |
| Performs Gauss-Newton weighted least squares computation. More... | |
| struct | ConjugateGradient |
| This class provides a nonlinear conjugate-gradient optimizer. More... | |
| class | DownhillSimplex |
| This is an implementation of the Downhill Simplex (Nelder & Mead, 1965) algorithm. More... | |
| struct | Operator< Internal::Data< N, P > > |
| Object which fills a matrix some data. There is no size known, since the size of the data is known at compile time. Therefore if the size of the matrix is not known, then something deeply strange is going on. More... | |
| struct | Argument_Needed_For_Dynamic_Parameter |
| struct | Operator< Internal::DiagMatrixOp< Size, Precision, Base > > |
| class | DiagonalMatrix |
| A diagonal matrix. More... | |
| struct | Matrix |
| A matrix. More... | |
| struct | RowMajor |
| struct | ColMajor |
| struct | Field< Internal::One, Rhs > |
| Does One behave as a field with respect to Rhs? Answer: it does is Rhs forms a field. More... | |
| struct | Field< Lhs, Internal::One > |
| Does One behave as a field with respect to Lhs? Answer: it does is Lhs forms a field. More... | |
| struct | Operator< Internal::Zero > |
| Object which behaves like a block of zeros. See TooN::Zeros. More... | |
| struct | Operator< Internal::RCZero > |
| Variant of the Zeros object which holds two sizes for constructing dynamic matrices. More... | |
| struct | Operator< Internal::SizedZero > |
| Variant of the Zeros object which holds a size for constructing dynamic vectors. More... | |
| struct | Operator< Internal::AddIdentity< R, C, P, B, Precision > > |
| Operator to construct a new matrix with idendity added. More... | |
| struct | Operator< Internal::Identity< Pr > > |
| Object which behaves like an Identity matrix. See TooN::Identity. More... | |
| struct | Operator< Internal::SizedIdentity< Precision > > |
| A variant of Identity which holds a size, allowing dynamic matrices to be constructed. More... | |
| struct | Operator< Internal::ScalarsVector< S, P, B, Precision > > |
| Operator to construct a new vector a a vector with a scalar added to every element. More... | |
| struct | Operator< Internal::ScalarsMatrix< R, C, P, B, Precision > > |
| Operator to construct a new matrix a a matrix with a scalar added to every element. More... | |
| struct | Operator< Internal::Scalars< P > > |
| Generic scalars object. Knows how to be added, knows how to deal with += and so on. See TooN::Ones. More... | |
| struct | Operator< Internal::SizedScalars< P > > |
| Variant of the Operator<Internal::Scalars> object which holds a size to construct dynamic vectors or square matrices. More... | |
| struct | Operator< Internal::RCScalars< P > > |
| Variant of Scalars (see TooN::Ones) which holds two sizes to construct dynamic matrices. More... | |
| struct | Field |
| Determine if two classes are in the same field. More... | |
| struct | Operator< Internal::VPairwise< Op, S1, P1, B1, S2, P2, B2 > > |
| struct | Operator< Internal::VNegate< S, P, A > > |
| struct | Operator< Internal::MPairwise< Op, R1, C1, P1, B1, R2, C2, P2, B2 > > |
| struct | Operator< Internal::MNegate< R, C, P, A > > |
| struct | Operator< Internal::MatrixMultiply< R1, C1, P1, B1, R2, C2, P2, B2 > > |
| struct | Operator< Internal::MatrixVectorMultiply< R, C, P1, B1, Size, P2, B2 > > |
| struct | Operator< Internal::VectorMatrixMultiply< Size, P1, B1, R, C, P2, B2 > > |
| struct | Operator< Internal::MatrixVectorDiagMultiply< R, C, P1, B1, Size, P2, B2 > > |
| struct | Operator< Internal::VectorMatrixDiagMultiply< Size, P1, B1, R, C, P2, B2 > > |
| struct | Operator< Internal::ApplyScalarV< Size, P1, B1, P2, Op > > |
| struct | Operator< Internal::ApplyScalarVL< Size, P1, B1, P2, Op > > |
| struct | Operator< Internal::ApplyScalarM< R, C, P1, B1, P2, Op > > |
| struct | Operator< Internal::ApplyScalarML< R, C, P1, B1, P2, Op > > |
| struct | ReferencePlanarComplex |
| struct | Reference |
| struct | SizeMismatch_< Size, Size > |
| struct | SizeMismatch_< Dynamic, Size > |
| struct | SizeMismatch_< Size, Dynamic > |
| struct | SizeMismatch_< Dynamic, Dynamic > |
| struct | SizeMismatch |
| class | Vector |
| A vector. More... | |
| struct | IsField< fadbad::F< C, N > > |
Typedefs | |
| typedef double | DefaultPrecision |
| typedef int | FortranInteger |
Functions | |
| template<int R, int C, typename Precision , typename Base > | |
| Precision | determinant_gaussian_elimination (const Matrix< R, C, Precision, Base > &A_) |
| template<int R, int C, class P , class B > | |
| P | determinant (const Matrix< R, C, P, B > &A) |
| template<int R, int C, class Precision , class Base > | |
| void | gauss_jordan (Matrix< R, C, Precision, Base > &m) |
| template<int N, typename Precision > | |
| Vector< N, Precision > | gaussian_elimination (Matrix< N, N, Precision > A, Vector< N, Precision > b) |
| template<int R1, int C1, int R2, int C2, typename Precision > | |
| Matrix< Internal::Size3< R1, C1, R2 >::s, C2, Precision > | gaussian_elimination (Matrix< R1, C1, Precision > A, Matrix< R2, C2, Precision > b) |
| Matrix< 2 > | inv (const Matrix< 2 > &m) |
| template<int Size, class Precision , class Base > | |
| TOON_DEPRECATED void | Fill (Vector< Size, Precision, Base > &v, const Precision &p) |
| template<int Rows, int Cols, class Precision , class Base > | |
| TOON_DEPRECATED void | Fill (Matrix< Rows, Cols, Precision, Base > &m, const Precision &p) |
| template<int Size, class Precision , class Base > | |
| Precision | norm (const Vector< Size, Precision, Base > &v) |
| template<int Size, class Precision , class Base > | |
| Precision | norm_sq (const Vector< Size, Precision, Base > &v) |
| template<int Size, class Precision , class Base > | |
| Precision | norm_1 (const Vector< Size, Precision, Base > &v) |
| template<int Size, class Precision , class Base > | |
| Precision | norm_inf (const Vector< Size, Precision, Base > &v) |
| template<int Size, class Precision , class Base > | |
| Precision | norm_2 (const Vector< Size, Precision, Base > &v) |
| template<int Size, class Precision , class Base > | |
| Vector< Size, Precision > | unit (const Vector< Size, Precision, Base > &v) |
| template<int Size, class Precision , class Base > | |
| void | normalize (Vector< Size, Precision, Base > v) |
| template<int Size, class Precision > | |
| void | normalize (Vector< Size, Precision > &v) |
| template<int Size, typename Precision , typename Base > | |
| Vector<(Size==Dynamic?Dynamic:Size-1)+0, Precision > | project (const Vector< Size, Precision, Base > &v) |
| template<int Size, typename Precision , typename Base > | |
| Vector<(Size==Dynamic?Dynamic:Size+1)+0, Precision > | unproject (const Vector< Size, Precision, Base > &v) |
| template<int R, int C, typename Precision , typename Base > | |
| Matrix< R-1, C, Precision > | project (const Matrix< R, C, Precision, Base > &m) |
| template<int C, typename Precision , typename Base > | |
| Matrix<-1, C, Precision > | project (const Matrix<-1, C, Precision, Base > &m) |
| template<int R, int C, typename Precision , typename Base > | |
| Matrix< R+1, C, Precision > | unproject (const Matrix< R, C, Precision, Base > &m) |
| template<int C, typename Precision , typename Base > | |
| Matrix<-1, C, Precision > | unproject (const Matrix<-1, C, Precision, Base > &m) |
| template<int R, int C, typename P , typename B > | |
| P | norm_fro (const Matrix< R, C, P, B > &m) |
| template<int R, int C, typename P , typename B > | |
| P | norm_inf (const Matrix< R, C, P, B > &m) |
| template<int R, int C, typename P , typename B > | |
| P | norm_1 (const Matrix< R, C, P, B > &m) |
| template<int R, int C, typename P , typename B > | |
| Matrix< R, C, P > | exp (const Matrix< R, C, P, B > &m) |
| template<int R, int C, typename P , typename B > | |
| Matrix< R, C, P > | sqrt (const Matrix< R, C, P, B > &m) |
| template<int R, int C, typename P , typename B > | |
| Matrix< R, C, P > | log (const Matrix< R, C, P, B > &m) |
| template<int S, class P , class B > | |
| bool | isfinite (const Vector< S, P, B > &v) |
| template<int S, class P , class B > | |
| bool | isnan (const Vector< S, P, B > &v) |
| template<int Rows, int Cols, typename Precision , typename Base > | |
| void | Symmetrize (Matrix< Rows, Cols, Precision, Base > &m) |
| template<int Rows, int Cols, typename Precision , typename Base > | |
| Precision | trace (const Matrix< Rows, Cols, Precision, Base > &m) |
| template<int Size, class P , class B > | |
| TooN::Matrix< 3, 3, P > | cross_product_matrix (const Vector< Size, P, B > &vec) |
| template<int Size, typename Precision , typename Base > | |
| Precision | min_value (const Vector< Size, Precision, Base > &v) |
| template<int Size, typename Precision , typename Base > | |
| Precision | max_value (const Vector< Size, Precision, Base > &v) |
| template<int R, int C, typename Precision , typename Base > | |
| Precision | min_value (const Matrix< R, C, Precision, Base > &m) |
| template<int R, int C, typename Precision , typename Base > | |
| Precision | max_value (const Matrix< R, C, Precision, Base > &m) |
| template<int R, int C, typename Precision , typename Base > | |
| Vector< Dynamic, Precision > | min_value_vertical (const Matrix< R, C, Precision, Base > &m) |
| template<int R, int C, typename Precision , typename Base > | |
| Vector< Dynamic, Precision > | max_value_vertical (const Matrix< R, C, Precision, Base > &m) |
| template<int R, int C, typename Precision , typename Base > | |
| Vector< Dynamic, Precision > | min_value_horizontal (const Matrix< R, C, Precision, Base > &m) |
| template<int R, int C, typename Precision , typename Base > | |
| Vector< Dynamic, Precision > | max_value_horizontal (const Matrix< R, C, Precision, Base > &m) |
| template<int Size, typename Precision , typename Base > | |
| std::pair< Precision, int > | min_element (const Vector< Size, Precision, Base > &v) |
| template<int Size, typename Precision , typename Base > | |
| std::pair< Precision, int > | max_element (const Vector< Size, Precision, Base > &v) |
| template<int R, int C, typename Precision , typename Base > | |
| std::pair< Precision, std::pair< int, int > > | min_element (const Matrix< R, C, Precision, Base > &m) |
| template<int R, int C, typename Precision , typename Base > | |
| std::pair< Precision, std::pair< int, int > > | max_element (const Matrix< R, C, Precision, Base > &m) |
| template<int R, int C, typename Precision , typename Base > | |
| std::pair< Vector< Dynamic, Precision >, Vector< Dynamic, Precision > > | min_element_vertical (const Matrix< R, C, Precision, Base > &m) |
| template<int R, int C, typename Precision , typename Base > | |
| std::pair< Vector< Dynamic, Precision >, Vector< Dynamic, Precision > > | max_element_vertical (const Matrix< R, C, Precision, Base > &m) |
| template<int R, int C, typename Precision , typename Base > | |
| std::pair< Vector< Dynamic, Precision >, Vector< Dynamic, Precision > > | min_element_horizontal (const Matrix< R, C, Precision, Base > &m) |
| template<int R, int C, typename Precision , typename Base > | |
| std::pair< Vector< Dynamic, Precision >, Vector< Dynamic, Precision > > | max_element_horizontal (const Matrix< R, C, Precision, Base > &m) |
| template<typename Precision > | |
| SE3< Precision > | operator* (const SO3< Precision > &lhs, const SE3< Precision > &rhs) |
| template<int N, typename P > | |
| std::istream & | operator>> (std::istream &, SL< N, P > &) |
| template<int S, typename PV , typename B , int N, typename P > | |
| Vector< N, typename Internal::MultiplyType< P, PV > ::type > | operator* (const SL< N, P > &lhs, const Vector< S, PV, B > &rhs) |
| template<int S, typename PV , typename B , int N, typename P > | |
| Vector< N, typename Internal::MultiplyType< PV, P > ::type > | operator* (const Vector< S, PV, B > &lhs, const SL< N, P > &rhs) |
| template<int R, int C, typename PM , typename A , int N, typename P > | |
| Matrix< N, C, typename Internal::MultiplyType< P, PM > ::type > | operator* (const SL< N, P > &lhs, const Matrix< R, C, PM, A > &rhs) |
| template<int R, int C, typename PM , typename A , int N, typename P > | |
| Matrix< R, N, typename Internal::MultiplyType< PM, P > ::type > | operator* (const Matrix< R, C, PM, A > &lhs, const SL< N, P > &rhs) |
| template<int N, typename P > | |
| std::ostream & | operator<< (std::ostream &out, const SL< N, P > &h) |
| template<typename Precision > | |
| std::istream & | operator>> (std::istream &, SO2< Precision > &) |
| template<typename Precision > | |
| std::istream & | operator>> (std::istream &, SE2< Precision > &) |
| template<typename Precision > | |
| std::istream & | operator>> (std::istream &, SIM2< Precision > &) |
| template<class Precision > | |
| std::istream & | operator>> (std::istream &, SO3< Precision > &) |
| template<class Precision > | |
| std::istream & | operator>> (std::istream &, SE3< Precision > &) |
| template<class Precision > | |
| std::istream & | operator>> (std::istream &, SIM3< Precision > &) |
| template<class Functor , class Precision > | |
| Vector< 2, Precision > | brent_line_search (Precision a, Precision x, Precision b, Precision fx, const Functor &func, int maxiterations, Precision tolerance=sqrt(numeric_limits< Precision >::epsilon()), Precision epsilon=numeric_limits< Precision >::epsilon()) |
| template<class Functor , class Precision > | |
| Vector< 2, Precision > | golden_section_search (Precision a, Precision b, Precision c, Precision fb, const Functor &func, int maxiterations, Precision tol=sqrt(numeric_limits< Precision >::epsilon())) |
| template<class Functor , class Precision > | |
| Vector< 2, Precision > | golden_section_search (Precision a, Precision b, Precision c, const Functor &func, int maxiterations, Precision tol=sqrt(numeric_limits< Precision >::epsilon())) |
| template<int R, int C, class Precision , class Base > | |
| Internal::MatrixStartFill< R, C, Precision, Base > | Fill (Matrix< R, C, Precision, Base > &m) |
| template<int Size, class Precision , class Base > | |
| Internal::VectorStartFill < Size, Precision, Base > | Fill (Vector< Size, Precision, Base > &v) |
| Operator< Internal::Data< N, double > > | Data (double a,...) |
| template<typename Precision > | |
| Operator< Internal::Data< N, Precision > > | Data (const Precision &a,...) |
| template<int S1, typename P1 , typename B1 , int S2, typename P2 , typename B2 > | |
| Vector< Internal::Sizer< S1, S2 >::size, typename Internal::MultiplyType< P1, P2 > ::type > | operator* (const DiagonalMatrix< S1, P1, B1 > &d, const Vector< S2, P2, B2 > &v) |
| template<int S1, typename P1 , typename B1 , int S2, typename P2 , typename B2 > | |
| Vector< Internal::Sizer< S1, S2 >::size, typename Internal::MultiplyType< P1, P2 > ::type > | operator* (const Vector< S1, P1, B1 > &v, const DiagonalMatrix< S2, P2, B2 > &d) |
| template<int S1, typename P1 , typename B1 , int S2, typename P2 , typename B2 > | |
| DiagonalMatrix < Internal::Sizer< S1, S2 > ::size, typename Internal::MultiplyType< P1, P2 > ::type > | operator* (const DiagonalMatrix< S1, P1, B1 > &d1, const DiagonalMatrix< S2, P2, B2 > &d2) |
| template<int R, int C, int Size, typename P1 , typename P2 , typename B1 , typename B2 > | |
| Matrix< R, C, typename Internal::MultiplyType< P1, P2 > ::type > | operator* (const Matrix< R, C, P1, B1 > &m, const DiagonalMatrix< Size, P2, B2 > &d) |
| template<int R, int C, typename P1 , typename B1 , int Size, typename P2 , typename B2 > | |
| Matrix< R, C, typename Internal::MultiplyType< P1, P2 > ::type > | operator* (const DiagonalMatrix< Size, P1, B1 > &d, const Matrix< R, C, P2, B2 > &m) |
| template<template< class > class Op, class Pl , class Pr > | |
| Operator< Op< typename Internal::MultiplyType< Pl, Pr > ::type > > | operator* (const Pl &l, const Operator< Op< Pr > > &r) |
| template<template< class > class Op, class Pl , class Pr > | |
| Operator< Op< typename Internal::MultiplyType< Pl, Pr > ::type > > | operator* (const Operator< Op< Pl > > &l, const Pr &r) |
| template<template< class > class Op, class Pl , class Pr > | |
| Operator< Op< typename Internal::DivideType< Pl, Pr > ::type > > | operator/ (const Operator< Op< Pl > > &l, const Pr &r) |
| template<class Op > | |
| Operator< Op > | operator- (const Operator< Op > &o) |
| template<template< class >class Op> | |
| Operator< Op< DefaultPrecision > > | operator- (const Operator< Op< Internal::One > > &o) |
| template<int S1, int S2, typename P1 , typename P2 , typename B1 , typename B2 > | |
| Vector< Internal::Sizer< S1, S2 >::size, typename Internal::AddType< P1, P2 > ::type > | operator+ (const Vector< S1, P1, B1 > &v1, const Vector< S2, P2, B2 > &v2) |
| template<int S1, int S2, typename P1 , typename P2 , typename B1 , typename B2 > | |
| Vector< Internal::Sizer< S1, S2 >::size, typename Internal::SubtractType< P1, P2 > ::type > | operator- (const Vector< S1, P1, B1 > &v1, const Vector< S2, P2, B2 > &v2) |
| template<int S1, int S2, typename P1 , typename P2 , typename B1 , typename B2 > | |
| Vector< Internal::Sizer< S1, S2 >::size, typename Internal::MultiplyType< P1, P2 > ::type > | diagmult (const Vector< S1, P1, B1 > &v1, const Vector< S2, P2, B2 > &v2) |
| template<int S, typename P , typename A > | |
| Vector< S, P > | operator- (const Vector< S, P, A > &v) |
| template<int Size1, typename Precision1 , typename Base1 , int Size2, typename Precision2 , typename Base2 > | |
| Internal::MultiplyType < Precision1, Precision2 > ::type | operator* (const Vector< Size1, Precision1, Base1 > &v1, const Vector< Size2, Precision2, Base2 > &v2) |
| template<typename P1 , typename P2 , typename B1 , typename B2 > | |
| Vector< 3, typename Internal::MultiplyType< P1, P2 > ::type > | operator^ (const Vector< 3, P1, B1 > &v1, const Vector< 3, P2, B2 > &v2) |
| template<int R1, int R2, int C1, int C2, typename P1 , typename P2 , typename B1 , typename B2 > | |
| Matrix< Internal::Sizer< R1, R2 >::size, Internal::Sizer < C1, C2 >::size, typename Internal::AddType< P1, P2 > ::type > | operator+ (const Matrix< R1, C1, P1, B1 > &m1, const Matrix< R2, C2, P2, B2 > &m2) |
| template<int R1, int R2, int C1, int C2, typename P1 , typename P2 , typename B1 , typename B2 > | |
| Matrix< Internal::Sizer< R1, R2 >::size, Internal::Sizer < C1, C2 >::size, typename Internal::SubtractType< P1, P2 > ::type > | operator- (const Matrix< R1, C1, P1, B1 > &m1, const Matrix< R2, C2, P2, B2 > &m2) |
| template<int R, int C, typename P , typename A > | |
| Matrix< R, C, P > | operator- (const Matrix< R, C, P, A > &v) |
| template<int R1, int C1, int R2, int C2, typename P1 , typename P2 , typename B1 , typename B2 > | |
| Matrix< R1, C2, typename Internal::MultiplyType< P1, P2 > ::type > | operator* (const Matrix< R1, C1, P1, B1 > &m1, const Matrix< R2, C2, P2, B2 > &m2) |
| template<int R, int C, int Size, typename P1 , typename P2 , typename B1 , typename B2 > | |
| Vector< R, typename Internal::MultiplyType< P1, P2 > ::type > | operator* (const Matrix< R, C, P1, B1 > &m, const Vector< Size, P2, B2 > &v) |
| template<int R, int C, typename P1 , typename B1 , int Size, typename P2 , typename B2 > | |
| Vector< C, typename Internal::MultiplyType< P1, P2 > ::type > | operator* (const Vector< Size, P1, B1 > &v, const Matrix< R, C, P2, B2 > &m) |
| template<int R, int C, int Size, typename P1 , typename P2 , typename B1 , typename B2 > | |
| Matrix< R, C, typename Internal::MultiplyType< P1, P2 > ::type > | diagmult (const Matrix< R, C, P1, B1 > &m, const Vector< Size, P2, B2 > &v) |
| template<int R, int C, typename P1 , typename B1 , int Size, typename P2 , typename B2 > | |
| Matrix< R, C, typename Internal::MultiplyType< P1, P2 > ::type > | diagmult (const Vector< Size, P1, B1 > &v, const Matrix< R, C, P2, B2 > &m) |
| template<int Size, typename P1 , typename B1 , typename P2 > | |
| Vector< Size, typename Internal::Multiply::Return< P1, P2 >::Type > | operator* (const Vector< Size, P1, B1 > &v, const P2 &s) |
| template<int Size, typename P1 , typename B1 , typename P2 > | |
| Vector< Size, typename Internal::Divide::Return< P1, P2 >::Type > | operator/ (const Vector< Size, P1, B1 > &v, const P2 &s) |
| template<int Size, typename P1 , typename B1 , typename P2 > | |
| Vector< Size, typename Internal::Multiply::Return< P2, P1 >::Type > | operator* (const P2 &s, const Vector< Size, P1, B1 > &v) |
| template<int R, int C, typename P1 , typename B1 , typename P2 > | |
| Matrix< R, C, typename Internal::Multiply::Return< P1, P2 >::Type > | operator* (const Matrix< R, C, P1, B1 > &m, const P2 &s) |
| template<int R, int C, typename P1 , typename B1 , typename P2 > | |
| Matrix< R, C, typename Internal::Divide::Return< P1, P2 >::Type > | operator/ (const Matrix< R, C, P1, B1 > &m, const P2 &s) |
| template<int R, int C, typename P1 , typename B1 , typename P2 > | |
| Matrix< R, C, typename Internal::Multiply::Return< P2, P1 >::Type > | operator* (const P2 &s, const Matrix< R, C, P1, B1 > &m) |
| template<int Size, typename P1 , typename B1 , typename Op > | |
| Vector< Size, typename Internal::Add::Return< P1, typename Operator< Op > ::Precision >::Type > | operator+ (const Vector< Size, P1, B1 > &v, const Operator< Op > &op) |
| template<int Size, typename P1 , typename B1 , typename Op > | |
| Vector< Size, typename Internal::Add::Return < typename Operator< Op > ::Precision, P1 >::Type > | operator+ (const Operator< Op > &op, const Vector< Size, P1, B1 > &v) |
| template<int Rows, int Cols, typename P1 , typename B1 , typename Op > | |
| Matrix< Rows, Cols, typename Internal::Add::Return< P1, typename Operator< Op > ::Precision >::Type > | operator+ (const Matrix< Rows, Cols, P1, B1 > &m, const Operator< Op > &op) |
| template<int Rows, int Cols, typename P1 , typename B1 , typename Op > | |
| Matrix< Rows, Cols, typename Internal::Add::Return < typename Operator< Op > ::Precision, P1 >::Type > | operator+ (const Operator< Op > &op, const Matrix< Rows, Cols, P1, B1 > &m) |
| template<int Size, typename P1 , typename B1 , typename Op > | |
| Vector< Size, typename Internal::Subtract::Return< P1, typename Operator< Op > ::Precision >::Type > | operator- (const Vector< Size, P1, B1 > &v, const Operator< Op > &op) |
| template<int Size, typename P1 , typename B1 , typename Op > | |
| Vector< Size, typename Internal::Subtract::Return < typename Operator< Op > ::Precision, P1 >::Type > | operator- (const Operator< Op > &op, const Vector< Size, P1, B1 > &v) |
| template<int Rows, int Cols, typename P1 , typename B1 , typename Op > | |
| Matrix< Rows, Cols, typename Internal::Subtract::Return< P1, typename Operator< Op > ::Precision >::Type > | operator- (const Matrix< Rows, Cols, P1, B1 > &m, const Operator< Op > &op) |
| template<int Rows, int Cols, typename P1 , typename B1 , typename Op > | |
| Matrix< Rows, Cols, typename Internal::Subtract::Return < typename Operator< Op > ::Precision, P1 >::Type > | operator- (const Operator< Op > &op, const Matrix< Rows, Cols, P1, B1 > &m) |
| template<int Size, typename Precision , typename Base > | |
| std::ostream & | operator<< (std::ostream &os, const Vector< Size, Precision, Base > &v) |
| template<int Size, typename Precision , typename Base > | |
| std::istream & | operator>> (std::istream &is, Vector< Size, Precision, Base > &v) |
| template<int Rows, int Cols, typename Precision , class Base > | |
| std::ostream & | operator<< (std::ostream &os, const Matrix< Rows, Cols, Precision, Base > &m) |
| template<int Rows, int Cols, typename Precision , typename Base > | |
| std::istream & | operator>> (std::istream &is, Matrix< Rows, Cols, Precision, Base > &m) |
| template<int S1, class P1 , class B1 , int S2, class P2 , class B2 > | |
| void | swap (Vector< S1, P1, B1 > &v1, Vector< S2, P2, B2 > &v2) |
| template<int S1, class P1 , class B1 > | |
| void | swap (Vector< S1, P1, B1 > &v1, Vector< S1, P1, B1 > &v2) |
|
Vector< Dynamic, double, Reference > | wrapVector (double *data, int size) |
|
const Vector< Dynamic, const double, Reference > | wrapVector (const double *data, int size) |
| template<int Size> | |
| Vector< Size, double, Reference > | wrapVector (double *data) |
| template<int Size> | |
| const Vector< Size, const double, Reference > | wrapVector (const double *data) |
| template<class Precision > | |
| Vector< Dynamic, Precision, Reference > | wrapVector (Precision *data, int size) |
| template<class Precision > | |
| const Vector< Dynamic, const Precision, Reference > | wrapVector (const Precision *data, int size) |
| template<int Size, class Precision > | |
| Vector< Size, Precision, Reference > | wrapVector (Precision *data) |
| template<int Size, class Precision > | |
| const Vector< Size, const Precision, Reference > | wrapVector (const Precision *data) |
| template<class F , int S, class P , class B > | |
| Vector< S, P > | numerical_gradient (const F &f, const Vector< S, P, B > &x) |
| template<class F , int S, class P , class B > | |
| Matrix< S, 2, P > | numerical_gradient_with_errors (const F &f, const Vector< S, P, B > &x) |
| template<class F , int S, class P , class B > | |
| pair< Matrix< S, S, P > , Matrix< S, S, P > > | numerical_hessian_with_errors (const F &f, const Vector< S, P, B > &x) |
| template<class F , int S, class P , class B > | |
| Matrix< S, S, P > | numerical_hessian (const F &f, const Vector< S, P, B > &x) |
| template<int N, typename T , typename A , unsigned D> | |
| Vector< N, T > | get_value (const Vector< N, fadbad::F< T, D >, A > &v) |
| template<typename P , int N, typename A > | |
| Vector< N, fadbad::F< P > > | make_fad_vector (const Vector< N, P, A > &val, const unsigned start=0, const unsigned size=N) |
| template<unsigned D, typename P , int N, typename A > | |
| Vector< N, fadbad::F< P, D > > | make_fad_vector (const Vector< N, P, A > &val, const unsigned start=0) |
| template<unsigned D, typename P , int N, typename A > | |
| Vector< N, P > | get_derivative (const Vector< N, fadbad::F< P, D >, A > &val, const int dim) |
| template<unsigned D, typename P , int N, typename A > | |
| Matrix< N, D, P > | get_jacobian (const Vector< N, fadbad::F< P, D >, A > &val) |
| template<int R, int C, typename P , unsigned D, typename A > | |
| Matrix< R, C, P > | get_derivative (const Matrix< R, C, fadbad::F< P, D >, A > &val, const int dim) |
| template<typename P > | |
| SO3< fadbad::F< P > > | make_fad_so3 (int start=0, int size=3) |
| template<typename P , unsigned D> | |
| SO3< fadbad::F< P, D > > | make_fad_so3 (int start=0) |
| template<typename P > | |
| SE3< fadbad::F< P > > | make_fad_se3 (int start=0, int size=6) |
| template<typename P , unsigned D> | |
| SE3< fadbad::F< P, D > > | make_fad_se3 (int start=0) |
| template<typename P > | |
| SE2< fadbad::F< P > > | make_fad_se2 (int start=0, int size=3) |
| template<typename P , unsigned D> | |
| SE2< fadbad::F< P, D > > | make_fad_se2 (int start=0) |
| template<typename P > | |
| SO2< fadbad::F< P > > | make_fad_so2 (int start=0, int size=1) |
| template<typename P , unsigned D> | |
| SO2< fadbad::F< P, D > > | make_fad_so2 (int start=0) |
| template<typename P > | |
| SO3< fadbad::F< P > > | make_left_fad_so3 (const SO3< P > &r, int start=0, int size=3) |
| template<typename P , unsigned D> | |
| SO3< fadbad::F< P, D > > | make_left_fad_so3 (const SO3< P > &r, int start=0) |
| template<typename P > | |
| SE3< fadbad::F< P > > | make_left_fad_se3 (const SE3< P > &t, int start=0, int size=6) |
| template<typename P , unsigned D> | |
| SE3< fadbad::F< P, D > > | make_left_fad_se3 (const SE3< P > &t, int start=0) |
| template<typename P > | |
| SO2< fadbad::F< P > > | make_left_fad_so2 (const SO2< P > &r, int start=0, int size=1) |
| template<typename P , unsigned D> | |
| SO2< fadbad::F< P, D > > | make_left_fad_so2 (const SO2< P > &r, int start=0) |
| template<typename P > | |
| SE2< fadbad::F< P > > | make_left_fad_se2 (const SE2< P > &t, int start=0, int size=3) |
| template<typename P , unsigned D> | |
| SE2< fadbad::F< P, D > > | make_left_fad_se2 (const SE2< P > &t, int start=0) |
| template<int Rows, int Cols> | |
| Matrix< Rows, Cols, double, Reference::RowMajor > | wrapMatrix (double *data) |
| template<int Rows, int Cols> | |
| const Matrix< Rows, Cols, const double, Reference::RowMajor > | wrapMatrix (const double *data) |
| template<int Rows, int Cols, class Precision > | |
| Matrix< Rows, Cols, Precision, Reference::RowMajor > | wrapMatrix (Precision *data) |
| template<int Rows, int Cols, class Precision > | |
| const Matrix< Rows, Cols, const Precision, Reference::RowMajor > | wrapMatrix (const Precision *data) |
| template<int Rows, int Cols> | |
| Matrix< Rows, Cols, double, Reference::RowMajor > | wrapMatrix (double *data, int rows, int cols) |
| template<int Rows, int Cols> | |
| const Matrix< Rows, Cols, const double, Reference::RowMajor > | wrapMatrix (const double *data, int rows, int cols) |
| template<int Rows, int Cols, class Precision > | |
| Matrix< Rows, Cols, Precision, Reference::RowMajor > | wrapMatrix (Precision *data, int rows, int cols) |
| template<int Rows, int Cols, class Precision > | |
| const Matrix< Rows, Cols, const Precision, Reference::RowMajor > | wrapMatrix (const Precision *data, int rows, int cols) |
| template<class Precision > | |
| Matrix< Dynamic, Dynamic, Precision, Reference::RowMajor > | wrapMatrix (Precision *data, int rows, int cols) |
| template<class Precision > | |
| const Matrix< Dynamic, Dynamic, const Precision, Reference::RowMajor > | wrapMatrix (const Precision *data, int rows, int cols) |
Variables | |
| static const double | condition_no = 1e9 |
| static const double | root3 = 1.73205080756887729352744634150587236694280525381038062805580 |
| static const int | Dynamic = -1 |
| static const int | Resizable = -0x7fffffff |
| static const Operator < Internal::Scalars < Internal::One > > | Ones |
| static Operator< Internal::Zero > | Zeros |
| static Operator < Internal::Identity < Internal::One > > | Identity |
Everything lives inside this namespace.
Pretty generic SFINAE introspection generator.
| Precision TooN::min_value | ( | const Vector< Size, Precision, Base > & | v | ) |
Finds the minimal value of a vector.
| v | a vector |
| Precision TooN::max_value | ( | const Vector< Size, Precision, Base > & | v | ) |
Finds the largest value of a vector.
| v | a vector |
| Precision TooN::min_value | ( | const Matrix< R, C, Precision, Base > & | m | ) |
Finds the smallest value of a matrix.
| m | a matrix |
| Precision TooN::max_value | ( | const Matrix< R, C, Precision, Base > & | m | ) |
Finds the largest value of a matrix.
| m | a matrix |
Finds the smallest values of each column of a matrix.
| m | a matrix |
Finds the largest values of each column of a matrix.
| m | a matrix |
Finds the smallest values of each row of a matrix.
| m | a matrix |
Finds the largest values of each row of a matrix.
| m | a matrix |
| std::pair<Precision,int> TooN::min_element | ( | const Vector< Size, Precision, Base > & | v | ) |
Finds the smallest value of a vector and its index.
| v | a vector |
Referenced by DownhillSimplex< N, Precision >::get_best().
| std::pair<Precision,int> TooN::max_element | ( | const Vector< Size, Precision, Base > & | v | ) |
Finds the largest value of a vector and its index.
| v | a vector |
Referenced by DownhillSimplex< N, Precision >::get_worst().
| std::pair<Precision,std::pair<int,int> > TooN::min_element | ( | const Matrix< R, C, Precision, Base > & | m | ) |
Finds the smallest value of a matrix and its row and column.
| m | a matrix |
| std::pair<Precision,std::pair<int,int> > TooN::max_element | ( | const Matrix< R, C, Precision, Base > & | m | ) |
Finds the largest value of a matrix and its row and column.
| m | a matrix |
| std::pair<Vector<Dynamic,Precision>,Vector<Dynamic,Precision> > TooN::min_element_vertical | ( | const Matrix< R, C, Precision, Base > & | m | ) |
Finds the smallest values of each column of a matrix and their indices.
| m | a matrix |
| std::pair<Vector< Dynamic, Precision >,Vector< Dynamic, Precision > > TooN::max_element_vertical | ( | const Matrix< R, C, Precision, Base > & | m | ) |
Finds the largest values of each column of a matrix and their indices.
| m | a matrix |
| std::pair<Vector< Dynamic, Precision >,Vector< Dynamic, Precision > > TooN::min_element_horizontal | ( | const Matrix< R, C, Precision, Base > & | m | ) |
Finds the smallest values of each row of a matrix and their indices.
| m | a matrix |
| std::pair<Vector< Dynamic, Precision >,Vector< Dynamic, Precision > > TooN::max_element_horizontal | ( | const Matrix< R, C, Precision, Base > & | m | ) |
Finds the largest values of each row of a matrix and their indices.
| m | a matrix |
1.7.4