TooN 2.1
Class List
Here are the classes, structs, unions and interfaces with brief descriptions:
accumulate_element_functor_matrix< Precision, ComparisonFunctor >
accumulate_element_functor_vector< Precision, ComparisonFunctor >
accumulate_element_horizontal_functor< Precision, ComparisonFunctor >
accumulate_element_vertical_functor< Precision, ComparisonFunctor >
accumulate_functor_matrix< Precision, ComparisonFunctor >
accumulate_functor_vector< Precision, ComparisonFunctor >
accumulate_horizontal_functor< Precision, ComparisonFunctor >
accumulate_vertical_functor< Precision, ComparisonFunctor >
Add
AddType< L, R, F >
AddType< L, R, 0 >
Argument_Needed_For_Dynamic_Parameter
BadSlice< 0 >A static slice is OK. This class is used after it has been determined that a slice is OK. It does nothing except provide a callable function. By contrast, if the slice is not OK, then the class is not specified and the function is therefore not callable, and a compile error results
CentralCrossDifferenceSecond< Functor, Precision, Size, Base >Functor wrapper for computing finite difference cross derivatives along a pair of axes
CentralDifferenceGradient< Functor, Precision, Size, Base >Functor wrapper for computing finite differences along an axis
CentralDifferenceSecond< Functor, Precision, Size, Base >Functor wrapper for computing finite difference second derivatives along an axis
CField< L, R >
CheckMOverFill< N, R, C, IsDynamic >
CheckMOverFill< N, R, C, 1 >
CheckOverFill< N, Size >
CheckOverFill< N,-1 >
CheckSlice< Size, Start, Length >Check if a slice is OK. This class is used to see if a slice is OK. It provides a callable function which checks the run-time slice information. If the compile time information is bad, then it will not compile at all. Otherwise, the sizes are checked at run-time. The check will be optimized away if the sizes are known statically
Cholesky< Size, Precision >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
Clean< C >
Clean< C & >
Clean< const C & >
Clean< const C >
Reference::ColMajor
ColMajor
ColSizeHolder< S >
ColStrideHolder< S >
ComputeSymEigen< Size >Compute eigensystems for sizes > 2 Helper struct for computing eigensystems, to allow for specialization on 2x2 matrices
ComputeSymEigen< 2 >Compute 2x2 eigensystems Helper struct for computing eigensystems, specialized on 2x2 matrices
ComputeSymEigen< 3 >Compute 3x3 eigensystems Helper struct for computing eigensystems, specialized on 3x3 matrices
ConjugateGradient< Size, Precision >This class provides a nonlinear conjugate-gradient optimizer
DCheck< N >
DCheck<-1 >
Default
DefaultTypes< Precision >
DiagonalMatrix< Size, Precision, Base >A diagonal matrix
DiagSize< Rows, Cols, D >
DiagSize< Rows, Cols, 0 >
DiagStride< Rs, Cs, D >
DiagStride< Rs, Cs, 0 >
Divide
DivideType< L, R, F >
DivideType< L, R, 0 >
DownhillSimplex< N, Precision >This is an implementation of the Downhill Simplex (Nelder & Mead, 1965) algorithm
Field< L, R >Determine if two classes are in the same field
Field< Internal::One, Rhs >Does One behave as a field with respect to Rhs? Answer: it does is Rhs forms a field
Field< Lhs, Internal::One >Does One behave as a field with respect to Lhs? Answer: it does is Lhs forms a field
GenericMBase< Rows, Cols, Precision, RowStride, ColStride, Mem >
GenericVBase< Size, Precision, Stride, Mem >
GR_SVD< M, N, Precision, WANT_U, WANT_V >Performs SVD and back substitute to solve equations
ILinear< Precision >A reweighting class representing no reweighting in IRLS
IRLS< Size, Precision, Reweight >Performs iterative reweighted least squares
IsField< C >Is a number a field? i.e., +, -, *, / defined
IsField< const C >Specialized for const types
IsField< fadbad::F< C, N > >
IsField< std::complex< C > >
IsStatic< i >
Lapack_Cholesky< Size, Precision >Decomposes a positive-semidefinite symmetric matrix A (such as a covariance) into L*L^T, where L is lower-triangular
LineSearch< Size, Precision, Func >Turn a multidimensional function in to a 1D function by specifying a point and direction
LU< Size, Precision >Performs LU decomposition and back substitutes to solve equations
Matrix< Rows, Cols, Precision, Layout >A matrix
MatrixAlloc< R, C, Precision, FullyStatic >
MatrixAlloc< R, C, Precision, false >
MatrixFiller< N, R, C, P, B >
MatrixSlice< R, C, Precision >
MatrixStartFill< R, C, P, B >
Reference::RowMajor::MLayout< Rows, Cols, Precision >
Reference::ColMajor::MLayout< Rows, Cols, Precision >
Slice< RowStride, ColStride >::MLayout< Rows, Cols, Precision >
RowMajor::MLayout< Rows, Cols, Precision >
ColMajor::MLayout< Rows, Cols, Precision >
Multiply
MultiplyType< L, R, F >
MultiplyType< L, R, 0 >
CheckSlice< Size, Start, Length >::N< Num >Choose a number statically or dynamically
NegType< C >For an instance i of type C, what is the type of -i? Usually the answer is that is it the same type
NegType< One >The type of -One
OneThis class represents 1 and only in all its forms
Operator< T >This is a struct used heavily in TooN internals
Operator< Internal::AddIdentity< R, C, P, B, Precision > >Operator to construct a new matrix with idendity added
Operator< Internal::ApplyScalarM< R, C, P1, B1, P2, Op > >
Operator< Internal::ApplyScalarML< R, C, P1, B1, P2, Op > >
Operator< Internal::ApplyScalarV< Size, P1, B1, P2, Op > >
Operator< Internal::ApplyScalarVL< Size, P1, B1, P2, Op > >
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
Operator< Internal::DiagMatrixOp< Size, Precision, Base > >
Operator< Internal::Identity< Pr > >Object which behaves like an Identity matrix. See TooN::Identity
Operator< Internal::MatrixMultiply< R1, C1, P1, B1, R2, C2, P2, B2 > >
Operator< Internal::MatrixVectorDiagMultiply< R, C, P1, B1, Size, P2, B2 > >
Operator< Internal::MatrixVectorMultiply< R, C, P1, B1, Size, P2, B2 > >
Operator< Internal::MNegate< R, C, P, A > >
Operator< Internal::MPairwise< Op, R1, C1, P1, B1, R2, C2, P2, B2 > >
Operator< Internal::MSE2Mult< Rows, C, PM, A, P > >
Operator< Internal::MSE3Mult< Rows, C, PM, A, P > >
Operator< Internal::MSIM2Mult< Rows, C, PM, A, P > >
Operator< Internal::MSIM3Mult< Rows, C, PM, A, P > >
Operator< Internal::RCScalars< P > >Variant of Scalars (see TooN::Ones) which holds two sizes to construct dynamic matrices
Operator< Internal::RCZero >Variant of the Zeros object which holds two sizes for constructing dynamic matrices
Operator< Internal::Scalars< P > >Generic scalars object. Knows how to be added, knows how to deal with += and so on. See TooN::Ones
Operator< Internal::ScalarsMatrix< R, C, P, B, Precision > >Operator to construct a new matrix a a matrix with a scalar added to every element
Operator< Internal::ScalarsVector< S, P, B, Precision > >Operator to construct a new vector a a vector with a scalar added to every element
Operator< Internal::SE2MMult< R, Cols, PM, A, P > >
Operator< Internal::SE2VMult< S, P, PV, A > >
Operator< Internal::SE3MMult< R, Cols, PM, A, P > >
Operator< Internal::SE3VMult< S, PV, A, P > >
Operator< Internal::SIM2MMult< R, Cols, PM, A, P > >
Operator< Internal::SIM2VMult< S, P, PV, A > >
Operator< Internal::SIM3MMult< R, Cols, PM, A, P > >
Operator< Internal::SIM3VMult< S, PV, A, P > >
Operator< Internal::SizedIdentity< Precision > >A variant of Identity which holds a size, allowing dynamic matrices to be constructed
Operator< Internal::SizedScalars< P > >Variant of the Operator<Internal::Scalars> object which holds a size to construct dynamic vectors or square matrices
Operator< Internal::SizedZero >Variant of the Zeros object which holds a size for constructing dynamic vectors
Operator< Internal::VectorMatrixDiagMultiply< Size, P1, B1, R, C, P2, B2 > >
Operator< Internal::VectorMatrixMultiply< Size, P1, B1, R, C, P2, B2 > >
Operator< Internal::VNegate< S, P, A > >
Operator< Internal::VPairwise< Op, S1, P1, B1, S2, P2, B2 > >
Operator< Internal::VSE2Mult< S, P, PV, A > >
Operator< Internal::VSE3Mult< S, PV, A, P > >
Operator< Internal::VSIM2Mult< S, P, PV, A > >
Operator< Internal::VSIM3Mult< S, PV, A, P > >
Operator< Internal::Zero >Object which behaves like a block of zeros. See TooN::Zeros
overfill< 0 >
PointerToPlanarComplex< std::complex< Precision > >
QR< Rows, Cols, Precision >Performs QR decomposition
QR_Lapack< Rows, Cols, Precision >Performs QR decomposition
Reference
ReferencePlanarComplex
Divide::Return< P1, P2 >
Add::Return< P1, P2 >
Subtract::Return< P1, P2 >
Multiply::Return< P1, P2 >
RobustI< Precision >Robust reweighting (type I) for IRLS
RobustII< Precision >Robust reweighting (type II) for IRLS
RobustIII< Precision >A reweighting class where the objective function tends to a fixed value, rather than infinity
Reference::RowMajor
RowMajor
RowSizeHolder< S >
RowStrideHolder< S >
SE2< Precision >Represent a two-dimensional Euclidean transformation (a rotation and a translation)
SE3< Precision >Represent a three-dimensional Euclidean transformation (a rotation and a translation)
SFINAE_dummy< S >
SIM2< Precision >Represent a two-dimensional Similarity transformation (a rotation, a uniform scale and a translation)
SIM3< Precision >Represent a three-dimensional similarity transformation (a rotation, a scale factor and a translation)
SimpleSizer< i, j >
SimpleSizer< Dynamic, Dynamic >
SimpleSizer< Dynamic, i >
SimpleSizer< i, Dynamic >
Size3< i, j, k >
SizeHolder< s >This struct holds a size using no data for static sizes. This struct holds a size is the size is dynamic, or simply recorcs the number in the type system if the size is static
SizeHolder<-1 >This struct holds a size integer for dynamic sizes
SizeMismatch< Size1, Size2 >
SizeMismatch_< Dynamic, Dynamic >
SizeMismatch_< Dynamic, Size >
SizeMismatch_< Size, Dynamic >
SizeMismatch_< Size, Size >
Sizer< i, j >
Sizer< i, i >
SL< N, Precision >Element from the group SL(n), the NxN matrices M with det(M) = 1
Slice< RowStride, ColStride >
SliceVBase< Stride, Ptr, CPtr, Ref, CRef >
SliceVBase< Stride, Default, Default, Default, Default >
SlicingA tag used to indicate that a slice is being constructed
SO2< Precision >Class to represent a two-dimensional rotation matrix
SO3< Precision >Class to represent a three-dimensional rotation matrix
SQSVD< Size, Precision >Version of SVD forced to be square princiapally here to allow use in WLS
Square< R, C >Provides the static size for a square matrix. In the general case, if R != C, then the matrix is not square and so no size is provided. A compile error results
Square< Dynamic, C >Provides the static size for a square matrix where one dimension is static. The size must be equal to the size of the static dimension
Square< Dynamic, Dynamic >Provides the static size for a square matrix where both dimensions are dynamic. The size must be Dynamic
Square< R, Dynamic >Provides the static size for a square matrix where one dimension is static. The size must be equal to the size of the static dimension
Square< R, R >Provides the static size for a square matrix where both dimensions are the same
StackOrHeap
StackOrHeap< Size, double, 0 >
StackOrHeap< Size, Precision, 0 >
StackOrHeap< Size, Precision, 1 >
StaticSizedAllocator< Size, Precision >This allocator object sets aside memory for a statically sized object. It will put all the data on the stack if there are less then TooN::max_bytes_on_stack of data, otherwise it will use new/delete
StrideHolder< s >
StrideHolder<-1 >
Subtract
SubtractType< L, R, F >
SubtractType< L, R, 0 >
SVD< Rows, Cols, Precision >Performs SVD and back substitute to solve equations
Swap< V1, V2, has_swap >
Swap< V, V, true >
SymEigen< Size, Precision >Performs eigen decomposition of a matrix
template MLayout
template MLayout
template MLayout
template MLayout
template MLayout
template MLayout
template VLayout
template VLayout
template VLayout
template VLayout
template VLayout
VBase
Vector< Size, Precision, Base >A vector
VectorAlloc< Size, Precision >Allocate memory for a static sized Vector. The class switches to heap allocation automatically for large Vectors. Naturally, the vector is not resizable
VectorAlloc< Dynamic, Precision >Allocate memory for a dynamic sized Vector. This is not resizable
VectorAlloc< Resizable, Precision >Allocate memory for a resizable Vector. New elements available after a resize are treated as uninitialized
VectorFiller< N, Size, P, B >
VectorSlice< S, Precision, PtrType, ConstPtrType, RefType, ConstRefType >Hold a pointer to yield a statically sized slice of a Vector. Not resizable
VectorSlice< Dynamic, Precision, PtrType, ConstPtrType, RefType, ConstRefType >Hold a pointer to yield a dynamically sized slice of a Vector. Not resizable
VectorStartFill< Size, P, B >
SliceVBase< Stride, Default, Default, Default, Default >::VLayout< Size, Precision >
VBase::VLayout< Size, Precision >
SliceVBase< Stride, Ptr, CPtr, Ref, CRef >::VLayout< Size, Precision >
Reference::VLayout< Size, Precision >
ReferencePlanarComplex::VLayout< Size, std::complex< Precision > >
WLS< Size, Precision, Decomposition >Performs Gauss-Newton weighted least squares computation