TooN 2.1
Namespaces | Classes | Typedefs | Functions | Variables
TooN Namespace Reference

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 >
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 >
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 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, ReferencewrapVector (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

Detailed Description

Everything lives inside this namespace.

Pretty generic SFINAE introspection generator.


Function Documentation

Precision TooN::min_value ( const Vector< Size, Precision, Base > &  v)

Finds the minimal value of a vector.

Parameters:
va vector
Returns:
the smallest value of v
Precision TooN::max_value ( const Vector< Size, Precision, Base > &  v)

Finds the largest value of a vector.

Parameters:
va vector
Returns:
the largest value of v
Precision TooN::min_value ( const Matrix< R, C, Precision, Base > &  m)

Finds the smallest value of a matrix.

Parameters:
ma matrix
Returns:
the smallest value of m
Precision TooN::max_value ( const Matrix< R, C, Precision, Base > &  m)

Finds the largest value of a matrix.

Parameters:
ma matrix
Returns:
the largest value of m
Vector<Dynamic,Precision> TooN::min_value_vertical ( const Matrix< R, C, Precision, Base > &  m)

Finds the smallest values of each column of a matrix.

Parameters:
ma matrix
Returns:
a vector of size C
Vector<Dynamic,Precision> TooN::max_value_vertical ( const Matrix< R, C, Precision, Base > &  m)

Finds the largest values of each column of a matrix.

Parameters:
ma matrix
Returns:
a vector of size C
Vector<Dynamic,Precision> TooN::min_value_horizontal ( const Matrix< R, C, Precision, Base > &  m)

Finds the smallest values of each row of a matrix.

Parameters:
ma matrix
Returns:
a vector of size R
Vector<Dynamic,Precision> TooN::max_value_horizontal ( const Matrix< R, C, Precision, Base > &  m)

Finds the largest values of each row of a matrix.

Parameters:
ma matrix
Returns:
a vector of size R
std::pair<Precision,int> TooN::min_element ( const Vector< Size, Precision, Base > &  v)

Finds the smallest value of a vector and its index.

Parameters:
va vector
Returns:
a pair containing the smallest value and its index

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.

Parameters:
va vector
Returns:
a pair containing the largest value and its index

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.

Parameters:
ma matrix
Returns:
a pair containing the smallest value and a pair containing its row and column
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.

Parameters:
ma matrix
Returns:
a pair containing the largest value and a pair containing its row and column
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.

Parameters:
ma matrix
Returns:
a pair of vectors of size C containg the values and their indices
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.

Parameters:
ma matrix
Returns:
a pair of vectors of size C containg the values and their indices
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.

Parameters:
ma matrix
Returns:
a pair of vectors of size R containg the values and their indices
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.

Parameters:
ma matrix
Returns:
a pair of vectors of size R containg the values and their indices