TooN Namespace Reference

All classes and functions are within 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...
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>
norm_fro (const Matrix< R, C, P, B > &m)
template<int R, int C, typename P, typename B>
norm_inf (const Matrix< R, C, P, B > &m)
template<int R, int C, typename P, typename B>
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)


Detailed Description

All classes and functions are within this namespace.

Function Documentation

template<int R, int C, typename P, typename B>
P TooN::norm_fro ( const Matrix< R, C, P, B > &  m  ) 

Frobenius (root of sum of squares) norm of input matrix m.

template<int R, int C, typename P, typename B>
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

template<int R, int C, typename P, typename B>
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

template<int R, int C, typename P, typename B>
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.

Parameters:
m input matrix, must be square
Returns:
result matrix of the same size/type as input

template<int S, class P, class B>
bool TooN::isfinite ( const Vector< S, P, B > &  v  ) 

Returns true if every element is finite.

template<int S, class P, class B>
bool TooN::isnan ( const Vector< S, P, B > &  v  ) 

Returns true if any element is NaN.

template<int Rows, int Cols, typename Precision, typename Base>
void TooN::Symmetrize ( Matrix< Rows, Cols, Precision, Base > &  m  ) 

Symmetrize a matrix.

template<int Rows, int Cols, typename Precision, typename Base>
Precision TooN::trace ( const Matrix< Rows, Cols, Precision, Base > &  m  ) 

computes the trace of a square matrix


Generated on Thu May 7 20:28:41 2009 for TooN by  doxygen 1.5.3