| 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 |
| One | This 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 > | |
| Slicing | A 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 |
