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... | |
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... | |
class | IRLS |
Performs iterative reweighted least squares. More... | |
class | LU |
Performs LU decomposition and back substitutes to solve equations. More... | |
class | SE2 |
Represent a two-dimensional Euclidean transformation (a rotation and a translation). More... | |
class | SE3 |
Represent a three-dimensional Euclidean transformation (a rotation and a translation). More... | |
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... | |
struct | ComputeSymEigen |
struct | ComputeSymEigen< 2 > |
class | SymEigen |
Performs eigen decomposition of a matrix. More... | |
struct | IsField |
class | WLS |
Performs weighted least squares computation. More... | |
class | Matrix |
A matrix. More... | |
struct | ConjugateGradient |
This class provides a nonlinear conjugate-gradient optimizer. More... | |
struct | DSBase |
struct | DSBase<-1 > |
class | DownhillSimplex |
This is an implementation of the Downhill Simplex (Nelder & Mead, 1965) algorithm. More... | |
class | DiagonalMatrix |
A diagonal matrix. More... | |
struct | RowMajor |
struct | ColMajor |
struct | Operator |
struct | Reference |
struct | SizeMismatch< Size, Size > |
struct | SizeMismatch<-1, Size > |
struct | SizeMismatch< Size,-1 > |
struct | SizeMismatch<-1,-1 > |
struct | SizeMismatch |
class | Vector |
A vector. 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 > > |
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 > > |
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 | 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 > > |
Typedefs | |
typedef double | DefaultPrecision |
Functions | |
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) |
template<int Size, class Precision, class Base> | |
void | Fill (Vector< Size, Precision, Base > &v, const Precision &p) |
template<int Rows, int Cols, class Precision, class Base> | |
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> | |
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-1, Precision > | project (const Vector< Size, Precision, Base > &v) |
template<typename Precision, typename Base> | |
Vector<-1, Precision > | project (const Vector<-1, Precision, Base > &v) |
template<int Size, typename Precision, typename Base> | |
Vector< Size+1, Precision > | unproject (const Vector< Size, Precision, Base > &v) |
template<typename Precision, typename Base> | |
Vector<-1, Precision > | unproject (const Vector<-1, Precision, Base > &v) |
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 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<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<class Precision> | |
std::istream & | operator>> (std::istream &, SO3< Precision > &) |
template<class Precision> | |
std::istream & | operator>> (std::istream &, SE3< Precision > &) |
template<typename Precision, typename VA, typename MA> | |
void | rodrigues_so3_exp (const Vector< 3, Precision, VA > &w, const Precision A, const Precision B, Matrix< 3, 3, Precision, MA > &R) |
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 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, class P> | |
Operator< Op > | operator- (const Operator< Op > &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< R, 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) |
Vector< Dynamic, double, Reference > | wrapVector (double *data, int size) |
const Vector < Dynamic, double, Reference > | wrapVector (const double *data, int size) |
template<int Size> | |
Vector< Size, double, Reference > | wrapVector (double *data) |
template<int Size> | |
const Vector< Size, double, Reference > | wrapVector (const double *data) |
template<class Precision> | |
Vector< Dynamic, Precision, Reference > | wrapVector (Precision *data, int size) |
template<class Precision> | |
const Vector < Dynamic, 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, Precision, Reference > | wrapVector (const Precision *data) |
P TooN::norm_fro | ( | const Matrix< R, C, P, B > & | m | ) |
Frobenius (root of sum of squares) norm of input matrix m.
P TooN::norm_inf | ( | const Matrix< R, C, P, B > & | m | ) |
row sum norm of input matrix m computes the maximum of the sums of absolute values over rows
P TooN::norm_1 | ( | const Matrix< R, C, P, B > & | m | ) |
col sum norm of input matrix m computes the maximum of the sums of absolute values over columns
Matrix<R, C, P> TooN::exp | ( | const Matrix< R, C, P, B > & | m | ) |
computes the matrix exponential of a matrix m by scaling m by 1/(powers of 2), using Taylor series and squaring again.
m | input matrix, must be square |
bool TooN::isfinite | ( | const Vector< S, P, B > & | v | ) |
Returns true if every element is finite.
bool TooN::isnan | ( | const Vector< S, P, B > & | v | ) |
Returns true if any element is NaN.
void TooN::Symmetrize | ( | Matrix< Rows, Cols, Precision, Base > & | m | ) |
Symmetrize a matrix.
Precision TooN::trace | ( | const Matrix< Rows, Cols, Precision, Base > & | m | ) |
computes the trace of a square matrix