|
TooN 2.1
|
Everything lives inside this namespace. More...
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 |
| 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 > > |
| 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 > |
| struct | Field< Lhs, Internal::One > |
| struct | Operator< Internal::Zero > |
| struct | Operator< Internal::RCZero > |
| struct | Operator< Internal::SizedZero > |
| struct | Operator< Internal::AddIdentity< R, C, P, B, Precision > > |
| struct | Operator< Internal::Identity< Pr > > |
| struct | Operator< Internal::SizedIdentity< Precision > > |
| struct | Operator< Internal::ScalarsVector< S, P, B, Precision > > |
| struct | Operator< Internal::ScalarsMatrix< R, C, P, B, Precision > > |
| struct | Operator< Internal::Scalars< P > > |
| struct | Operator< Internal::SizedScalars< P > > |
| struct | Operator< Internal::RCScalars< P > > |
| 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