TooN: TooN Namespace Reference

TooN 2.0.0-beta8

- Main Page
- Related Pages
- Modules
- Namespaces
- Classes
- Files

- Namespace List
- Namespace Members

Classes | Typedefs | Functions | Variables
TooN Namespace Reference

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_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? ie, +, -, *, / 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
class | DiagonalMatrix
| A diagonal matrix. More...
struct | Matrix
| A matrix. More...
struct | RowMajor
struct | ColMajor
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 > >
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...
## 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)
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), Precision > | project (const Vector< Size, Precision, Base > &v)
template<int Size, typename Precision , typename Base >
Vector<(Size==Dynamic?Dynamic:Size+1), 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)
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 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.

## Function Documentation

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

Finds the minimal value of a vector.

Parameters:

  v | a 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:

  v | a 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:

  m | a 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:

  m | a 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:

  m | a 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:

  m | a 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:

  m | a 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:

  m | a 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:

  v | a 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:

  v | a 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:

  m | a 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:

  m | a 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:

  m | a 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:

  m | a 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:

  m | a 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:

  m | a matrix

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