| ►NSTK | The namespace STK is the main domain space of the Statistical ToolKit project |
| ►NArrays | Namespace Arrays contain the enum and utilities method used by the containers classes |
| CDifferenceOp | Array difference (by coefficient) Perform the matrix difference coefficient by coefficient of the Array lhs by the Array rhs |
| CDivOp | Matricial Division |
| CMultLeftTransposeOp | Array multiplication Perform the matrix product of the transposed Array lhs by the Array rhs |
| CMultOp | Array multiplication Perform the matrix product of the Array lhs by the Array rhs |
| CMultRightTransposeOp | Array multiplication Perform the matrix product of the Array lhs by the transposed Array rhs |
| CProduct | Array product (by coefficient) Perform the matrix product coefficient by coefficient of the Array lhs by the Array rhs |
| CSumOp | Array sum (by coefficient) Perform the matrix sum coefficient by coefficient of the Array lhs by the Array rhs |
| ►NClust | The namespace Clust enclose all the enum and utilities functions needed by the Clustering project |
| CMixtureTraits | Main class for the mixtures traits policy |
| ►NConst | Namespace enclosing the usual mathematical constants and the constant arrays or structures |
| CArray | Define the constant general matrix |
| CIConstArray | |
| CIdentity | Define the constant identity matrix |
| CLowerTriangular | Define the constant lower triangular matrix |
| CPoint | Define the constant point |
| CSquare | Define the constant square matrix |
| CUpperTriangular | Define the constant upper triangular matrix |
| CVector | Define the constant point |
| ►NFunct | The namespace Funct enclose all usual and special functions |
| CSeriedl | This Serie computes |
| CSerielog1p | This Series computes |
| ►Nhidden | The hidden namespace enclose the classes and methods which are used internally by the STK++ classes |
| CAlgebraTraits | Traits class for the algebra methods |
| CAlgebraTraits< InvertMatrix< Matrix, Size_ > > | Specialization for matrix inversion methods |
| CAlgebraTraits< lapack::MultiLeastSquare< ArrayB_, ArrayA_ > > | Specialization for the lapack::MultiLeastSquare class |
| CAlgebraTraits< lapack::Qr > | Specialization for the Qr class |
| CAlgebraTraits< lapack::Svd > | Specialization for the Svd class |
| CAlgebraTraits< lapack::SymEigen< SquareArray_ > > | Specialization for the lapack::SymEigen class |
| CAlgebraTraits< MultiLeastSquare< ArrayB_, ArrayA_ > > | Specialization for the MultiLeastSquare class |
| CAlgebraTraits< Qr > | Specialization for the Qr class |
| CAlgebraTraits< Svd< Array_ > > | Specialization for the Svd class |
| CAlgebraTraits< SymEigen< SquareArray_ > > | Specialization for the Qr class |
| CAlgebraTraits< WeightedSvd< Array_, WRows, WCols > > | Specialization for the WeightedSvd class |
| CAllVisitor | Visitor checking if all the elements of an array are different from zero |
| CAnyVisitor | Visitor checking if at least, one element of an array is different from zero |
| CBinaryColsImpl | Implement the access to the columns of the BinaryOperator Possible cases are: |
| CBinaryColsImpl< Lhs, Rhs, Size_, Arrays::useLhsOtherSize_ > | Specialization for the case useLhsOtherSize_ |
| CBinaryColsImpl< Lhs, Rhs, Size_, Arrays::useLhsSize_ > | Specialization for the case useLhsSize_ |
| CBinaryColsImpl< Lhs, Rhs, Size_, Arrays::useRhsOtherSize_ > | Specialization for the case useRhsOtherSize_ |
| CBinaryColsImpl< Lhs, Rhs, Size_, Arrays::useRhsSize_ > | Specialization for the case useRhsSize_ |
| CBinaryEltImpl | Helper class giving the Structure of a binary operator |
| CBinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::array2D_, Arrays::array2D_ > | |
| CBinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::array2D_, Arrays::diagonal_ > | |
| CBinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::array2D_, Arrays::lower_symmetric_ > | |
| CBinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::array2D_, Arrays::lower_triangular_ > | |
| CBinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::array2D_, Arrays::square_ > | |
| CBinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::array2D_, Arrays::symmetric_ > | |
| CBinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::array2D_, Arrays::upper_symmetric_ > | |
| CBinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::array2D_, Arrays::upper_triangular_ > | |
| CBinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::diagonal_, Arrays::array2D_ > | |
| CBinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::diagonal_, Arrays::diagonal_ > | |
| CBinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::diagonal_, Arrays::lower_symmetric_ > | |
| CBinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::diagonal_, Arrays::lower_triangular_ > | |
| CBinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::diagonal_, Arrays::point_ > | |
| CBinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::diagonal_, Arrays::square_ > | |
| CBinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::diagonal_, Arrays::symmetric_ > | |
| CBinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::diagonal_, Arrays::upper_symmetric_ > | |
| CBinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::diagonal_, Arrays::upper_triangular_ > | |
| CBinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::diagonal_, Arrays::vector_ > | |
| CBinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::lower_symmetric_, Arrays::array2D_ > | |
| CBinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::lower_symmetric_, Arrays::diagonal_ > | |
| CBinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::lower_symmetric_, Arrays::lower_symmetric_ > | |
| CBinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::lower_symmetric_, Arrays::lower_triangular_ > | |
| CBinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::lower_symmetric_, Arrays::square_ > | |
| CBinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::lower_symmetric_, Arrays::symmetric_ > | |
| CBinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::lower_symmetric_, Arrays::upper_symmetric_ > | |
| CBinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::lower_symmetric_, Arrays::upper_triangular_ > | |
| CBinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::lower_triangular_, Arrays::array2D_ > | |
| CBinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::lower_triangular_, Arrays::diagonal_ > | |
| CBinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::lower_triangular_, Arrays::lower_symmetric_ > | |
| CBinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::lower_triangular_, Arrays::lower_triangular_ > | |
| CBinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::lower_triangular_, Arrays::square_ > | |
| CBinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::lower_triangular_, Arrays::symmetric_ > | |
| CBinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::lower_triangular_, Arrays::upper_symmetric_ > | |
| CBinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::lower_triangular_, Arrays::upper_triangular_ > | |
| CBinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::number_, Arrays::number_ > | |
| CBinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::point_, Arrays::diagonal_ > | |
| CBinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::point_, Arrays::point_ > | |
| CBinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::point_, Arrays::vector_ > | |
| CBinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::square_, Arrays::array2D_ > | |
| CBinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::square_, Arrays::diagonal_ > | |
| CBinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::square_, Arrays::lower_symmetric_ > | |
| CBinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::square_, Arrays::lower_triangular_ > | |
| CBinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::square_, Arrays::square_ > | |
| CBinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::square_, Arrays::symmetric_ > | |
| CBinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::square_, Arrays::upper_symmetric_ > | |
| CBinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::square_, Arrays::upper_triangular_ > | |
| CBinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::symmetric_, Arrays::array2D_ > | |
| CBinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::symmetric_, Arrays::diagonal_ > | |
| CBinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::symmetric_, Arrays::lower_symmetric_ > | |
| CBinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::symmetric_, Arrays::lower_triangular_ > | |
| CBinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::symmetric_, Arrays::square_ > | |
| CBinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::symmetric_, Arrays::symmetric_ > | |
| CBinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::symmetric_, Arrays::upper_symmetric_ > | |
| CBinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::symmetric_, Arrays::upper_triangular_ > | |
| CBinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::upper_symmetric_, Arrays::array2D_ > | |
| CBinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::upper_symmetric_, Arrays::diagonal_ > | |
| CBinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::upper_symmetric_, Arrays::lower_symmetric_ > | |
| CBinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::upper_symmetric_, Arrays::lower_triangular_ > | |
| CBinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::upper_symmetric_, Arrays::square_ > | |
| CBinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::upper_symmetric_, Arrays::symmetric_ > | |
| CBinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::upper_symmetric_, Arrays::upper_symmetric_ > | |
| CBinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::upper_symmetric_, Arrays::upper_triangular_ > | |
| CBinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::upper_triangular_, Arrays::array2D_ > | |
| CBinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::upper_triangular_, Arrays::diagonal_ > | |
| CBinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::upper_triangular_, Arrays::lower_symmetric_ > | |
| CBinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::upper_triangular_, Arrays::lower_triangular_ > | |
| CBinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::upper_triangular_, Arrays::square_ > | |
| CBinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::upper_triangular_, Arrays::symmetric_ > | |
| CBinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::upper_triangular_, Arrays::upper_symmetric_ > | |
| CBinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::upper_triangular_, Arrays::upper_triangular_ > | |
| CBinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::vector_, Arrays::diagonal_ > | |
| CBinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::vector_, Arrays::point_ > | |
| CBinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::vector_, Arrays::vector_ > | |
| CBinaryReturnArray2DType | Helper class to get the correct returned Structure of Functors |
| CBinaryReturnArray2DType< Type, Arrays::array2D_, Arrays::array2D_ > | |
| CBinaryReturnArray2DType< Type, Arrays::array2D_, Arrays::diagonal_ > | |
| CBinaryReturnArray2DType< Type, Arrays::array2D_, Arrays::lower_triangular_ > | |
| CBinaryReturnArray2DType< Type, Arrays::array2D_, Arrays::square_ > | |
| CBinaryReturnArray2DType< Type, Arrays::array2D_, Arrays::upper_triangular_ > | |
| CBinaryReturnArray2DType< Type, Arrays::diagonal_, Arrays::array2D_ > | |
| CBinaryReturnArray2DType< Type, Arrays::diagonal_, Arrays::diagonal_ > | |
| CBinaryReturnArray2DType< Type, Arrays::diagonal_, Arrays::lower_triangular_ > | |
| CBinaryReturnArray2DType< Type, Arrays::diagonal_, Arrays::square_ > | |
| CBinaryReturnArray2DType< Type, Arrays::diagonal_, Arrays::upper_triangular_ > | |
| CBinaryReturnArray2DType< Type, Arrays::lower_triangular_, Arrays::array2D_ > | |
| CBinaryReturnArray2DType< Type, Arrays::lower_triangular_, Arrays::diagonal_ > | |
| CBinaryReturnArray2DType< Type, Arrays::lower_triangular_, Arrays::lower_triangular_ > | |
| CBinaryReturnArray2DType< Type, Arrays::lower_triangular_, Arrays::square_ > | |
| CBinaryReturnArray2DType< Type, Arrays::lower_triangular_, Arrays::upper_triangular_ > | |
| CBinaryReturnArray2DType< Type, Arrays::square_, Arrays::array2D_ > | |
| CBinaryReturnArray2DType< Type, Arrays::square_, Arrays::diagonal_ > | |
| CBinaryReturnArray2DType< Type, Arrays::square_, Arrays::lower_triangular_ > | |
| CBinaryReturnArray2DType< Type, Arrays::square_, Arrays::square_ > | |
| CBinaryReturnArray2DType< Type, Arrays::square_, Arrays::upper_triangular_ > | |
| CBinaryReturnArray2DType< Type, Arrays::upper_triangular_, Arrays::array2D_ > | |
| CBinaryReturnArray2DType< Type, Arrays::upper_triangular_, Arrays::diagonal_ > | |
| CBinaryReturnArray2DType< Type, Arrays::upper_triangular_, Arrays::lower_triangular_ > | |
| CBinaryReturnArray2DType< Type, Arrays::upper_triangular_, Arrays::square_ > | |
| CBinaryReturnArray2DType< Type, Arrays::upper_triangular_, Arrays::upper_triangular_ > | |
| CBinaryRowsImpl | Implement the access to the rows of the BinaryOperator Possible cases are: |
| CBinaryRowsImpl< Lhs, Rhs, Size_, Arrays::useLhsOtherSize_ > | Specialization for the case useLhsOtherSize_ |
| CBinaryRowsImpl< Lhs, Rhs, Size_, Arrays::useLhsSize_ > | Specialization for the case useLhsSize_ |
| CBinaryRowsImpl< Lhs, Rhs, Size_, Arrays::useRhsOtherSize_ > | Specialization for the case useRhsOtherSize_ |
| CBinaryRowsImpl< Lhs, Rhs, Size_, Arrays::useRhsSize_ > | Specialization for the case useRhsSize_ |
| CBlock | This structure encapsulate the data allocated for a block |
| CBlockByPanel | Methods to use for C=AB with A divided in blocks and B divided in panels |
| CBlockPanelProduct | Methods to use for C=AB with A divided in blocks and B divided in panels |
| Cbv | Methods to use for C=AV with A a general matrix and V a vector |
| CCheckShift | Utility class allowing to know if in an assignment the destination must be resized or shifted |
| CCheckShift< Derived, Arrays::array2D_ > | Specialization for general array2D_ |
| CCheckShift< Derived, Arrays::diagonal_ > | Specialization for diagonal_ |
| CCheckShift< Derived, Arrays::lower_triangular_ > | Specialization for lower_triangular_ |
| CCheckShift< Derived, Arrays::number_ > | |
| CCheckShift< Derived, Arrays::point_ > | |
| CCheckShift< Derived, Arrays::square_ > | Specialization for square_ |
| CCheckShift< Derived, Arrays::upper_triangular_ > | Specialization for upper_triangular_ |
| CCheckShift< Derived, Arrays::vector_ > | |
| CCopycat | Copycat to use at compile time |
| CCopycat< Lhs, Rhs, Arrays::array2D_, Arrays::array2D_ > | |
| CCopycat< Lhs, Rhs, Arrays::array2D_, Arrays::diagonal_ > | |
| CCopycat< Lhs, Rhs, Arrays::array2D_, Arrays::lower_symmetric_ > | |
| CCopycat< Lhs, Rhs, Arrays::array2D_, Arrays::lower_triangular_ > | |
| CCopycat< Lhs, Rhs, Arrays::array2D_, Arrays::point_ > | |
| CCopycat< Lhs, Rhs, Arrays::array2D_, Arrays::square_ > | |
| CCopycat< Lhs, Rhs, Arrays::array2D_, Arrays::symmetric_ > | |
| CCopycat< Lhs, Rhs, Arrays::array2D_, Arrays::upper_symmetric_ > | |
| CCopycat< Lhs, Rhs, Arrays::array2D_, Arrays::upper_triangular_ > | |
| CCopycat< Lhs, Rhs, Arrays::array2D_, Arrays::vector_ > | |
| CCopycat< Lhs, Rhs, Arrays::diagonal_, Arrays::diagonal_ > | |
| CCopycat< Lhs, Rhs, Arrays::diagonal_, Arrays::point_ > | |
| CCopycat< Lhs, Rhs, Arrays::diagonal_, Arrays::vector_ > | |
| CCopycat< Lhs, Rhs, Arrays::lower_triangular_, Arrays::lower_triangular_ > | |
| CCopycat< Lhs, Rhs, Arrays::number_, Arrays::number_ > | |
| CCopycat< Lhs, Rhs, Arrays::point_, Arrays::diagonal_ > | |
| CCopycat< Lhs, Rhs, Arrays::point_, Arrays::point_ > | |
| CCopycat< Lhs, Rhs, Arrays::point_, Arrays::vector_ > | |
| CCopycat< Lhs, Rhs, Arrays::square_, Arrays::array2D_ > | |
| CCopycat< Lhs, Rhs, Arrays::square_, Arrays::diagonal_ > | |
| CCopycat< Lhs, Rhs, Arrays::square_, Arrays::lower_symmetric_ > | |
| CCopycat< Lhs, Rhs, Arrays::square_, Arrays::lower_triangular_ > | |
| CCopycat< Lhs, Rhs, Arrays::square_, Arrays::square_ > | |
| CCopycat< Lhs, Rhs, Arrays::square_, Arrays::symmetric_ > | |
| CCopycat< Lhs, Rhs, Arrays::square_, Arrays::upper_symmetric_ > | |
| CCopycat< Lhs, Rhs, Arrays::square_, Arrays::upper_triangular_ > | |
| CCopycat< Lhs, Rhs, Arrays::upper_triangular_, Arrays::upper_triangular_ > | |
| CCopycat< Lhs, Rhs, Arrays::vector_, Arrays::diagonal_ > | |
| CCopycat< Lhs, Rhs, Arrays::vector_, Arrays::point_ > | |
| CCopycat< Lhs, Rhs, Arrays::vector_, Arrays::vector_ > | |
| CCopycatSelector | Utility class that select if the copy will be by row or by column |
| CCopycatSelector< Lhs, Rhs, Arrays::by_col_ > | Specialization for column oriented arrrays |
| CCopycatSelector< Lhs, Rhs, Arrays::by_row_ > | Specialization for row oriented arrays |
| CCopySubArrayImpl | This structure regroup the methods to used for copying part of an array in a Block or a Panel |
| CCountVisitor | Visitor counting the number of not-zero element in an array This visitor can be used in conjunction with the comparison operators in order to get the number of element matching a condition |
| CCSlice | The traits struct CSlice allows to disambiguate return type of the col/row/sub operators for CArray family |
| CCSliceDispatcher | Helper allowing to disambiguate SubVector access |
| CCsvToArrayImpl | Implementation of CsvToArray |
| CCsvToArrayImpl< String, Array2D< OtherType > > | |
| CCsvToArrayImpl< Type, Array2D< Type > > | |
| CCsvToArrayImpl< Type, CArray< Type > > | |
| CDataHandlerTraits | The DataHandlerTraits will give the type of container furnished by the concrete implementations of the DataHandlerBase class |
| CDataHandlerTraits< DataHandler, Type > | Specialization of the DataHandlerTraits for DataHandler |
| CDataHandlerTraits< KernelHandler, Type > | Specialization of the DataHandlerTraits struct for KernelHandler |
| CDiagonalRangeImpl | Allow to disambiguate the call to range to use |
| CDiagonalRangeImpl< Lhs, Size_, Arrays::useLhsOtherSize_ > | |
| CDiagonalRangeImpl< Lhs, Size_, Arrays::useLhsSize_ > | |
| CDispatcherChooser | Utility class allowing to choose the dispatcher for inversion matrix |
| CDispatcherChooser< Matrix, Size_, Arrays::array2D_ > | Specialization for general arrays |
| CDispatcherChooser< Matrix, Size_, Arrays::lower_symmetric_ > | |
| CDispatcherChooser< Matrix, Size_, Arrays::lower_triangular_ > | Specialization for upper triangular arrays |
| CDispatcherChooser< Matrix, Size_, Arrays::square_ > | Specialization for square arrays |
| CDispatcherChooser< Matrix, Size_, Arrays::symmetric_ > | Specialization for symmetric arrays |
| CDispatcherChooser< Matrix, Size_, Arrays::upper_symmetric_ > | Specialization for symmetric arrays |
| CDispatcherChooser< Matrix, Size_, Arrays::upper_triangular_ > | Specialization for upper triangular arrays |
| CEltVisitor2DBase | Base class to implement min, max, sum,... visitors for 2D containers |
| CFalseType | |
| ►CFunctorParamTraits | Produce the Nth parameter type of Functor |
| ►CVoid | |
| CPrivate | |
| CFunctorReturnTypeTraits | Produce the return type of the Functor |
| CFunctorSelector | , |
| CFunctorSelector< Derived, Functor, false > | Specialization for general arrays: apply functor to rows or columns of the Derived array |
| CFunctorSelector< Derived, Functor, true > | Specialization for vectors and points |
| CFunctorTraits | , Utility class that will select the type of operator to apply |
| CGetIdx | Utility class for getting the result from a visitor acting on a vector or a point |
| CGetIdx< Visitor, Arrays::diagonal_ > | |
| CGetIdx< Visitor, Arrays::point_ > | |
| CGetIdx< Visitor, Arrays::vector_ > | |
| CHDCovarianceChooser | |
| CHDCovarianceChooser< Clust::HDCovariance_ABkQD_ > | |
| CHDCovarianceChooser< Clust::HDCovariance_ABkQDk_ > | |
| CHDCovarianceChooser< Clust::HDCovariance_ABkQkD_ > | |
| CHDCovarianceChooser< Clust::HDCovariance_ABkQkDk_ > | |
| CHDCovarianceChooser< Clust::HDCovariance_ABQkD_ > | |
| CHDCovarianceChooser< Clust::HDCovariance_ABQkDk_ > | |
| CHDCovarianceChooser< Clust::HDCovariance_AjBkQD_ > | |
| CHDCovarianceChooser< Clust::HDCovariance_AjBkQDk_ > | |
| CHDCovarianceChooser< Clust::HDCovariance_AjBkQkD_ > | |
| CHDCovarianceChooser< Clust::HDCovariance_AjBkQkDk_ > | |
| CHDCovarianceChooser< Clust::HDCovariance_AjBQkD_ > | |
| CHDCovarianceChooser< Clust::HDCovariance_AjBQkDk_ > | |
| CHDCovarianceChooser< Clust::HDCovariance_AjkBkQD_ > | |
| CHDCovarianceChooser< Clust::HDCovariance_AjkBkQDk_ > | |
| CHDCovarianceChooser< Clust::HDCovariance_AjkBkQkD_ > | |
| CHDCovarianceChooser< Clust::HDCovariance_AjkBkQkDk_ > | |
| CHDCovarianceChooser< Clust::HDCovariance_AjkBQD_ > | |
| CHDCovarianceChooser< Clust::HDCovariance_AjkBQDk_ > | |
| CHDCovarianceChooser< Clust::HDCovariance_AjkBQkD_ > | |
| CHDCovarianceChooser< Clust::HDCovariance_AjkBQkDk_ > | |
| CHDCovarianceChooser< Clust::HDCovariance_AkBkQD_ > | |
| CHDCovarianceChooser< Clust::HDCovariance_AkBkQDk_ > | |
| CHDCovarianceChooser< Clust::HDCovariance_AkBkQkD_ > | |
| CHDCovarianceChooser< Clust::HDCovariance_AkBkQkDk_ > | |
| CHDCovarianceChooser< Clust::HDCovariance_AkBQD_ > | |
| CHDCovarianceChooser< Clust::HDCovariance_AkBQDk_ > | |
| CHDCovarianceChooser< Clust::HDCovariance_AkBQkD_ > | |
| CHDCovarianceChooser< Clust::HDCovariance_AkBQkDk_ > | |
| CIf | |
| CIf< false, Then, Else > | |
| CIf< true, Then, Else > | |
| CInvertLowerSymMatrixDispatcher | Computing the inverse of a lower symmetric matrix |
| CInvertLowerSymMatrixDispatcher< Matrix, 1 > | |
| CInvertLowerSymMatrixDispatcher< Matrix, 2 > | |
| CInvertLowerSymMatrixDispatcher< Matrix, 3 > | |
| CInvertLowerSymMatrixDispatcher< Matrix, 4 > | |
| CInvertLowerSymMatrixImpl | Implementation of the computation of the inverse of a lower symmetric matrix |
| CInvertLowerTriangularDispatcher | Utility class allowing to call the correct static function computing the inverse of a matrix |
| CInvertLowerTriangularDispatcher< Matrix, 1 > | |
| CInvertLowerTriangularDispatcher< Matrix, 2 > | |
| CInvertLowerTriangularDispatcher< Matrix, 3 > | |
| CInvertLowerTriangularDispatcher< Matrix, 4 > | |
| CInvertLowerTriangularImpl | Implementation of the computation of the inverse of a lower triangular matrix |
| CInvertMatrixDispatcher | Computing the inverse of a matrix |
| CInvertMatrixDispatcher< Matrix, 1 > | |
| CInvertMatrixDispatcher< Matrix, 2 > | |
| CInvertMatrixDispatcher< Matrix, 3 > | |
| CInvertMatrixDispatcher< Matrix, 4 > | |
| CInvertMatrixImpl | Implementation of the inversion matrix method for general/square matrices |
| CInvertSymImpl | Implementation of the computation of the inverse of a lower triangular matrix |
| CInvertSymMatrixDispatcher | Computing the inverse of a symmetric matrix |
| CInvertSymMatrixDispatcher< Matrix, 1 > | |
| CInvertSymMatrixDispatcher< Matrix, 2 > | |
| CInvertSymMatrixDispatcher< Matrix, 3 > | |
| CInvertSymMatrixDispatcher< Matrix, 4 > | |
| CInvertUpperSymMatrixDispatcher | Computing the inverse of a symmetric matrix |
| CInvertUpperSymMatrixDispatcher< Matrix, 1 > | |
| CInvertUpperSymMatrixDispatcher< Matrix, 2 > | |
| CInvertUpperSymMatrixDispatcher< Matrix, 3 > | |
| CInvertUpperSymMatrixDispatcher< Matrix, 4 > | |
| CInvertUpperSymMatrixImpl | Implementation of the inversion matrix method for upper symmetric matrices |
| CInvertUpperTriangularDispatcher | Computing the inverse of a matrix |
| CInvertUpperTriangularDispatcher< Matrix, 1 > | |
| CInvertUpperTriangularDispatcher< Matrix, 2 > | |
| CInvertUpperTriangularDispatcher< Matrix, 3 > | |
| CInvertUpperTriangularDispatcher< Matrix, 4 > | |
| CInvertUpperTriangularImpl | Implementation of the inversion matrix method for upper triangular matrices |
| CinvPsi | Functor computing the difference between the psi function and a fixed value |
| CinvPsiMLog | Functor computing the derivative of the lnLikelihood of a gamma_ajk_bjk model |
| CIsArithmetic | |
| CIsArithmetic< bool > | |
| CIsArithmetic< char > | |
| CIsArithmetic< double > | |
| CIsArithmetic< float > | |
| CIsArithmetic< long double > | |
| CIsArithmetic< signed char > | |
| CIsArithmetic< signed int > | |
| CIsArithmetic< signed long > | |
| CIsArithmetic< signed short > | |
| CIsArithmetic< unsigned char > | |
| CIsArithmetic< unsigned int > | |
| CIsArithmetic< unsigned long > | |
| CIsArithmetic< unsigned short > | |
| CIsEqual | Check if T and U are equal |
| CIsInt | |
| CIsInt< bool > | |
| CIsInt< char > | |
| CIsInt< signed char > | |
| CIsInt< signed int > | |
| CIsInt< signed long > | |
| CIsInt< signed short > | |
| CIsInt< unsigned char > | |
| CIsInt< unsigned int > | |
| CIsInt< unsigned long > | |
| CIsInt< unsigned short > | |
| CisSame | Check if T and U are of the same type |
| CisSame< T, T > | |
| CIteratorTraits | , |
| CIteratorTraits< BiDirectionalIterator< Array_ > > | Specialization for the BiDirectionalIterator iterator class |
| CIteratorTraits< ConstBiDirectionalIterator< Array_ > > | Specialization for the ConstBiDirectionalIterator iterator class |
| CIteratorTraits< ConstDenseRandomIterator< Array_ > > | Specialization of the IteratorTraits for the ConstDenseRandomIterator iterator class |
| CIteratorTraits< DenseRandomIterator< Array_ > > | Specialization of the IteratorTraits class for the DenseRandomIterator iterator class |
| CMaxEltSafeVisitor | Visitor computing safely the maximal coefficient of the Array |
| CMaxEltVisitor | Visitor computing the maximal coefficient of the Array |
| CMaxSafeVisitor | Visitor computing safely the max of all the coefficients of the Array |
| CMaxVisitor | Visitor computing the max of all the coefficients of the Array |
| CMeanSafeVisitor | Visitor computing safely the mean of all the coefficients of the Array |
| CMeanVisitor | Visitor computing the mean of all the coefficients of the Array |
| CMemChooser | :: :: fundamental types |
| CMemChooser< 0, Type_ > | Specialization for other types using loop and operator= |
| CMemChooser< 1, Type_ > | Specialization for fundamental types |
| CMemHandler | Helper class allowing to free memory (or not) |
| CMemHandler< Type_, UnknownSize > | Specialization for dynamic size arrays |
| CMinEltSafeVisitor | Visitor computing safely the minimal coefficient with its value and indexes |
| CMinEltVisitor | Visitor computing the min coefficient with its value and coordinates |
| CMinSafeVisitor | Visitor computing safely the min of all the coefficients of the Array |
| CMinVisitor | Visitor computing the min of all the coefficients of the Array |
| CMixtureBridgeTraits | MixtureBridgeTraits struct for bridged mixtures The traits struct MixtureBridgeTraits must be specialized for any Mixture deriving from the Interface IMixtureBridge |
| CMixtureBridgeTraits< CategoricalBridge< Clust::Categorical_pjk_, Data_ > > | Partial specialization of the MixtureBridgeTraits for the Categorical_pjk model |
| CMixtureBridgeTraits< CategoricalBridge< Clust::Categorical_pk_, Data_ > > | Partial specialization of the MixtureBridgeTraits for the Categorical_pk model |
| CMixtureBridgeTraits< DiagGaussianBridge< Clust::Gaussian_s_, Data_ > > | Partial specialization of the MixtureBridgeTraits for the DiagGaussian_s model |
| CMixtureBridgeTraits< DiagGaussianBridge< Clust::Gaussian_sj_, Data_ > > | Partial specialization of the MixtureBridgeTraits for the DiagGaussian_sj model |
| CMixtureBridgeTraits< DiagGaussianBridge< Clust::Gaussian_sjk_, Data_ > > | Partial specialization of the MixtureBridgeTraits for the DiagGaussian_sjk model |
| CMixtureBridgeTraits< DiagGaussianBridge< Clust::Gaussian_sjsk_, Data_ > > | Partial specialization of the MixtureBridgeTraits for the DiagGaussian_sjsk model |
| CMixtureBridgeTraits< DiagGaussianBridge< Clust::Gaussian_sk_, Data_ > > | Partial specialization of the MixtureBridgeTraits for the DiagGaussian_sk model |
| CMixtureBridgeTraits< GammaBridge< Clust::Gamma_a_bjk_, Data_ > > | Partial specialization of the MixtureBridgeTraits for the Gamma_a_bjk_ model |
| CMixtureBridgeTraits< GammaBridge< Clust::Gamma_a_bk_, Data_ > > | Partial specialization of the MixtureBridgeTraits for the Gamma_a_bk_ model |
| CMixtureBridgeTraits< GammaBridge< Clust::Gamma_aj_bjk_, Data_ > > | Partial specialization of the MixtureBridgeTraits for the Gamma_aj_bjk_ model |
| CMixtureBridgeTraits< GammaBridge< Clust::Gamma_aj_bk_, Data_ > > | Partial specialization of the MixtureBridgeTraits for the Gamma_aj_bk_ model |
| CMixtureBridgeTraits< GammaBridge< Clust::Gamma_ajk_b_, Data_ > > | Partial specialization of the MixtureBridgeTraits for the Gamma_ajk_b_ model |
| CMixtureBridgeTraits< GammaBridge< Clust::Gamma_ajk_bj_, Data_ > > | Partial specialization of the MixtureBridgeTraits for the Gamma_ajk_bj_ model |
| CMixtureBridgeTraits< GammaBridge< Clust::Gamma_ajk_bjk_, Data_ > > | Partial specialization of the MixtureBridgeTraits for the Gamma_ajk_bjk_ model |
| CMixtureBridgeTraits< GammaBridge< Clust::Gamma_ajk_bk_, Data_ > > | Partial specialization of the MixtureBridgeTraits for the Gamma_ajk_bk_ model |
| CMixtureBridgeTraits< GammaBridge< Clust::Gamma_ak_b_, Data_ > > | Partial specialization of the MixtureBridgeTraits for the Gamma_ak_b_ model |
| CMixtureBridgeTraits< GammaBridge< Clust::Gamma_ak_bj_, Data_ > > | Partial specialization of the MixtureBridgeTraits for the Gamma_ak_bj_ model |
| CMixtureBridgeTraits< GammaBridge< Clust::Gamma_ak_bjk_, Data_ > > | Partial specialization of the MixtureBridgeTraits for the Gamma_ak_bjk_ model |
| CMixtureBridgeTraits< GammaBridge< Clust::Gamma_ak_bk_, Data_ > > | Partial specialization of the MixtureBridgeTraits for the Gamma_ak_bk_ model |
| CMixtureBridgeTraits< HDGaussianBridge< Clust::HDGaussian_AjkBkQkD_, Data_ > > | Partial specialization of the MixtureBridgeTraits for the HDGaussian_ajk_bk_qk_d_ model |
| CMixtureBridgeTraits< HDMatrixGaussianBridge< IdRow_, IdCol_, Data_ > > | Partial specialization of the MixtureBridgeTraits for the HDCovariance_AjkBkQkDk model |
| CMixtureBridgeTraits< KmmBridge< Clust::Kmm_s_, Data_ > > | Partial specialization of the MixtureBridgeTraits for the Kmm_s_ model |
| CMixtureBridgeTraits< KmmBridge< Clust::Kmm_sk_, Data_ > > | Partial specialization of the MixtureBridgeTraits for the Kmm_sk_ model |
| CMixtureBridgeTraits< PoissonBridge< Clust::Poisson_ljk_, Data_ > > | Partial specialization of the MixtureBridgeTraits for the STK::Poisson_ljk mixture model |
| CMixtureBridgeTraits< PoissonBridge< Clust::Poisson_ljlk_, Data_ > > | Partial specialization of the MixtureBridgeTraits for the STK::Poisson_ljlk mixture model |
| CMixtureBridgeTraits< PoissonBridge< Clust::Poisson_lk_, Data_ > > | Partial specialization of the MixtureBridgeTraits for the STK::Poisson_lk mixture model |
| CMixtureManagerTraits | Main class for the mixture managers traits policy |
| CMixtureManagerTraits< CategoricalMixtureManager< DataHandler_ > > | Partial specialization for CategoricalMixtureManager |
| CMixtureManagerTraits< DiagGaussianMixtureManager< DataHandler_ > > | Specialization for Clust::Categorical_ mixtures |
| CMixtureManagerTraits< GammaMixtureManager< DataHandler_ > > | Specialization for GammaMixtureManager |
| ►CMixtureManagerTraits< KernelMixtureManager > | Specialization for KernelMixtureManager |
| CVoid | |
| CMixtureManagerTraits< PoissonMixtureManager< DataHandler_ > > | Partial specialization for PoissonMixtureManager |
| CMixtureTraits | Main class for the mixtures traits policy |
| CMixtureTraits< Categorical_pjk< Array_ > > | Traits class for the Categorical_pjk traits policy |
| CMixtureTraits< Categorical_pk< Array_ > > | Traits class for the Categorical_pk traits policy |
| CMixtureTraits< DiagGaussian_s< Array_ > > | Traits class for the DiagGaussian_s traits policy |
| CMixtureTraits< DiagGaussian_sj< Array_ > > | Traits class for the Gaussian_s traits policy |
| CMixtureTraits< DiagGaussian_sjk< Array_ > > | Traits class for the DiagGaussian_sjk traits policy |
| CMixtureTraits< DiagGaussian_sjsk< Array_ > > | Traits class for the DiagGaussian_sjsk traits policy |
| CMixtureTraits< DiagGaussian_sk< Array_ > > | Traits class for the DiagGaussian_sk traits policy |
| CMixtureTraits< Gamma_a_bjk< Array_ > > | Traits class for the Gamma_a_bjk traits policy |
| CMixtureTraits< Gamma_a_bk< Array_ > > | Traits class for the Gamma_a_bk traits policy |
| CMixtureTraits< Gamma_aj_bjk< Array_ > > | Traits class for the Gamma_aj_bjk traits policy |
| CMixtureTraits< Gamma_aj_bk< Array_ > > | Traits class for the Gamma_aj_bk traits policy |
| CMixtureTraits< Gamma_ajk_b< Array_ > > | Traits class for the Gamma_ajk_b traits policy |
| CMixtureTraits< Gamma_ajk_bj< Array_ > > | Traits class for the Gamma_ajk_bj traits policy |
| CMixtureTraits< Gamma_ajk_bjk< Array_ > > | Traits class for the Gamma_ajk_bjk traits policy |
| CMixtureTraits< Gamma_ajk_bk< Array_ > > | Traits class for the Gamma_ajk_bk traits policy |
| CMixtureTraits< Gamma_ak_b< Array_ > > | Traits class for the Gamma_ak_b traits policy |
| CMixtureTraits< Gamma_ak_bj< Array_ > > | Traits class for the Gamma_ak_bj traits policy |
| CMixtureTraits< Gamma_ak_bjk< Array_ > > | Traits class for the Gamma_ak_bjk traits policy |
| CMixtureTraits< Gamma_ak_bk< Array_ > > | Traits class for the Gamma_ak_bk traits policy |
| CMixtureTraits< HDGaussian_AjkBkQkD_< Array_ > > | Traits class for the MixtureHDGaussian_ajk_bk_qk_d traits policy |
| CMixtureTraits< HDMatrixGaussianModel< IdRow_, IdCol_, Array_ > > | Traits class for the HDMatrixGaussianModel traits policy |
| CMixtureTraits< Kmm_s > | MixtureTraits class for the Kmm_s traits policy |
| CMixtureTraits< Kmm_sk > | Traits class for the Kmm_sk traits policy |
| CMixtureTraits< Poisson_ljk< Array_ > > | Traits class for the Poisson_ljk traits policy |
| CMixtureTraits< Poisson_ljlk< Array_ > > | Traits class for the Poisson_ljlk traits policy |
| CMixtureTraits< Poisson_lk< Array_ > > | Traits class for the Poisson_lk traits policy |
| CModelTraits | |
| ►CModelTraits< GaussianAAModel< Data_ > > | |
| CVoid | |
| ►CModelTraits< IGaussianModel< Data_ > > | |
| CVoid | |
| CMultCoefImpl | This structure regroup the methods to used after block multiplication in order to perform the product of the remaining rows and columns |
| CMultImpl | This structure regroup all the methods using only pointers on the Type |
| CMultPointArray | This structure regroup the products between a point and different kind of array |
| CNoAssignOperator | Classes inheriting NoAssignOperator should not generate a default operator= |
| COperatorHelper | Allow to disambiguate the case expr + number from the case expr + other_expr |
| COperatorImpl | Allow to disambiguate the case expr + number from the case expr + other_expr |
| COperatorImpl< Functor, Lhs, Rhs, false > | |
| COperatorImpl< Functor, Lhs, Rhs, true > | |
| COperatorSelector | Helper defining the return type of the selector involving expressions of the form expr + number and expr + other_expr |
| COperatorSelector< Lhs, Rhs, Arrays::bitwiseAndOp_ > | Specialization for operator& |
| COperatorSelector< Lhs, Rhs, Arrays::bitwiseOrOp_ > | Specialization for operator| |
| COperatorSelector< Lhs, Rhs, Arrays::bitwiseXorOp_ > | Specialization for operator^ |
| COperatorSelector< Lhs, Rhs, Arrays::differenceOp_ > | Specialization for operator- |
| COperatorSelector< Lhs, Rhs, Arrays::divisionOp_ > | Specialization for operator/ |
| COperatorSelector< Lhs, Rhs, Arrays::equalOp_ > | Specialization for operator== |
| COperatorSelector< Lhs, Rhs, Arrays::greaterThanOp_ > | Specialization for operator> |
| COperatorSelector< Lhs, Rhs, Arrays::greaterThanOrEqualOp_ > | Specialization for operator>= |
| COperatorSelector< Lhs, Rhs, Arrays::lessThanOp_ > | Specialization for operator< |
| COperatorSelector< Lhs, Rhs, Arrays::lessThanOrEqualOp_ > | Specialization for operator<= |
| COperatorSelector< Lhs, Rhs, Arrays::logicalAndOp_ > | Specialization for operator&& |
| COperatorSelector< Lhs, Rhs, Arrays::logicalOrOp_ > | Specialization for operator|| |
| COperatorSelector< Lhs, Rhs, Arrays::maxOp_ > | Specialization for operator max |
| COperatorSelector< Lhs, Rhs, Arrays::minOp_ > | Specialization for operator min |
| COperatorSelector< Lhs, Rhs, Arrays::moduloOp_ > | Specialization for operator% |
| COperatorSelector< Lhs, Rhs, Arrays::notEqualOp_ > | Specialization for operator!= |
| COperatorSelector< Lhs, Rhs, Arrays::productOp_ > | Specialization for operator* |
| COperatorSelector< Lhs, Rhs, Arrays::sumOp_ > | Specialization for operator+ |
| CPanel | This structure encapsulate the data allocated for a panel |
| CPanelBlockProduct | Methods to use for C=AB with A divided in panels and B divided in blocks |
| CPanelByBlock | Methods to use for C=AB with A divided in panels and B divided in blocks |
| CProductArray2DReturnType | Helper class to get the correct returned Type for Array2D* classes when a product is performed between two arrays |
| CProductArray2DReturnType< Type, Arrays::array2D_, Arrays::point_ > | |
| CProductArray2DReturnType< Type, Arrays::array2D_, Arrays::vector_ > | |
| CProductArray2DReturnType< Type, Arrays::array2D_, RStructure_ > | |
| CProductArray2DReturnType< Type, Arrays::diagonal_, Arrays::array2D_ > | |
| CProductArray2DReturnType< Type, Arrays::diagonal_, Arrays::diagonal_ > | |
| CProductArray2DReturnType< Type, Arrays::diagonal_, Arrays::lower_triangular_ > | |
| CProductArray2DReturnType< Type, Arrays::diagonal_, Arrays::point_ > | |
| CProductArray2DReturnType< Type, Arrays::diagonal_, Arrays::square_ > | |
| CProductArray2DReturnType< Type, Arrays::diagonal_, Arrays::upper_triangular_ > | |
| CProductArray2DReturnType< Type, Arrays::diagonal_, Arrays::vector_ > | |
| CProductArray2DReturnType< Type, Arrays::lower_triangular_, Arrays::diagonal_ > | |
| CProductArray2DReturnType< Type, Arrays::lower_triangular_, Arrays::lower_triangular_ > | |
| CProductArray2DReturnType< Type, Arrays::lower_triangular_, Arrays::point_ > | |
| CProductArray2DReturnType< Type, Arrays::lower_triangular_, Arrays::vector_ > | |
| CProductArray2DReturnType< Type, Arrays::lower_triangular_, RStructure_ > | |
| CProductArray2DReturnType< Type, Arrays::point_, Arrays::array2D_ > | |
| CProductArray2DReturnType< Type, Arrays::point_, Arrays::diagonal_ > | |
| CProductArray2DReturnType< Type, Arrays::point_, Arrays::lower_triangular_ > | |
| CProductArray2DReturnType< Type, Arrays::point_, Arrays::point_ > | |
| CProductArray2DReturnType< Type, Arrays::point_, Arrays::square_ > | |
| CProductArray2DReturnType< Type, Arrays::point_, Arrays::upper_triangular_ > | |
| CProductArray2DReturnType< Type, Arrays::point_, Arrays::vector_ > | |
| CProductArray2DReturnType< Type, Arrays::square_, Arrays::array2D_ > | |
| CProductArray2DReturnType< Type, Arrays::square_, Arrays::diagonal_ > | |
| CProductArray2DReturnType< Type, Arrays::square_, Arrays::lower_triangular_ > | |
| CProductArray2DReturnType< Type, Arrays::square_, Arrays::point_ > | |
| CProductArray2DReturnType< Type, Arrays::square_, Arrays::square_ > | |
| CProductArray2DReturnType< Type, Arrays::square_, Arrays::upper_triangular_ > | |
| CProductArray2DReturnType< Type, Arrays::square_, Arrays::vector_ > | |
| CProductArray2DReturnType< Type, Arrays::upper_triangular_, Arrays::diagonal_ > | |
| CProductArray2DReturnType< Type, Arrays::upper_triangular_, Arrays::point_ > | |
| CProductArray2DReturnType< Type, Arrays::upper_triangular_, Arrays::upper_triangular_ > | |
| CProductArray2DReturnType< Type, Arrays::upper_triangular_, Arrays::vector_ > | |
| CProductArray2DReturnType< Type, Arrays::upper_triangular_, RStructure_ > | |
| CProductArray2DReturnType< Type, Arrays::vector_, Arrays::point_ > | |
| CProductArray2DReturnType< Type, Arrays::vector_, RStructure_ > | |
| CProductDispatcher | Dispatcher allowing to choose th e way to multiply two expressions |
| CProductDispatcher< Lhs, Rhs, Result, Arrays::array2D_, Arrays::array2D_ > | Specialization for the array2d by array2D case |
| CProductDispatcher< Lhs, Rhs, Result, Arrays::array2D_, Arrays::square_ > | |
| CProductDispatcher< Lhs, Rhs, Result, Arrays::array2D_, Arrays::vector_ > | |
| CProductDispatcher< Lhs, Rhs, Result, Arrays::point_, Arrays::array2D_ > | |
| CProductDispatcher< Lhs, Rhs, Result, Arrays::point_, Arrays::square_ > | |
| CProductDispatcher< Lhs, Rhs, Result, Arrays::point_, RhsStructure_ > | |
| CProductDispatcher< Lhs, Rhs, Result, Arrays::square_, Arrays::array2D_ > | |
| CProductDispatcher< Lhs, Rhs, Result, Arrays::square_, Arrays::square_ > | |
| CProductDispatcher< Lhs, Rhs, Result, Arrays::square_, Arrays::vector_ > | |
| CProductDispatcher< Lhs, Rhs, Result, lhsStructure_, Arrays::vector_ > | |
| CProductSelector | Helper class to select the correct ProductReturnType |
| CProductSelector< Lhs, Rhs, Arrays::diagonal_, Arrays::diagonal_ > | |
| CProductSelector< Lhs, Rhs, Arrays::diagonal_, Arrays::vector_ > | |
| CProductSelector< Lhs, Rhs, Arrays::diagonal_, RStructure_ > | |
| CProductSelector< Lhs, Rhs, Arrays::number_, RStructure_ > | |
| CProductSelector< Lhs, Rhs, Arrays::point_, Arrays::diagonal_ > | |
| CProductSelector< Lhs, Rhs, Arrays::point_, Arrays::point_ > | |
| CProductSelector< Lhs, Rhs, Arrays::point_, Arrays::vector_ > | |
| CProductSelector< Lhs, Rhs, Arrays::point_, RStructure_ > | |
| CProductSelector< Lhs, Rhs, Arrays::vector_, Arrays::point_ > | |
| CProductSelector< Lhs, Rhs, Arrays::vector_, Arrays::vector_ > | |
| CProductSelector< Lhs, Rhs, LStructure_, Arrays::diagonal_ > | |
| CProductSelector< Lhs, Rhs, LStructure_, Arrays::number_ > | |
| CProductSelector< Lhs, Rhs, LStructure_, Arrays::vector_ > | |
| CProductSizeRowsBySizeCols | Convenient structure for computing the product of two template integer parameters without overflow |
| CProductSizeRowsBySizeCols< 1, 1 > | |
| CProductSizeRowsBySizeCols< 1, Size2 > | |
| CProductSizeRowsBySizeCols< 1, UnknownSize > | |
| CProductSizeRowsBySizeCols< Size1, 1 > | |
| CProductSizeRowsBySizeCols< Size1, UnknownSize > | |
| CProductSizeRowsBySizeCols< UnknownSize, 1 > | |
| CProductSizeRowsBySizeCols< UnknownSize, Size2 > | |
| CProductSizeRowsBySizeCols< UnknownSize, UnknownSize > | |
| CProductSizesHelper | |
| CProductSizesHelper< false, false, Size1, Size2 > | |
| CProductTraits | , |
| CProductTraits< Lhs, Rhs, Arrays::array2D_, Arrays::square_ > | Specialization for lhs is array2D |
| CProductTraits< Lhs, Rhs, Arrays::array2D_, RStructure_ > | Specialization for lhs is array2D |
| CProductTraits< Lhs, Rhs, Arrays::lower_triangular_, Arrays::lower_triangular_ > | |
| CProductTraits< Lhs, Rhs, Arrays::lower_triangular_, Arrays::square_ > | |
| CProductTraits< Lhs, Rhs, Arrays::lower_triangular_, RStructure_ > | |
| CProductTraits< Lhs, Rhs, Arrays::square_, Arrays::square_ > | |
| CProductTraits< Lhs, Rhs, Arrays::square_, RStructure_ > | |
| CProductTraits< Lhs, Rhs, Arrays::upper_triangular_, Arrays::square_ > | |
| CProductTraits< Lhs, Rhs, Arrays::upper_triangular_, Arrays::upper_triangular_ > | |
| CProductTraits< Lhs, Rhs, Arrays::upper_triangular_, RStructure_ > | |
| CProductTraits< Lhs, Rhs, LStructure_, Arrays::square_ > | |
| CPromote | Convenient struct to Promote the result Type of some binary functors |
| CPromote< Type, Type > | Specialization when we have the same type |
| CRandApplier | Visitor putting a choosen random variable |
| CRandGaussApplier | Visitor setting Gaussian random variables |
| CRandUnifApplier | Applier setting uniform random numbers |
| CRawVec | This structure encapsulate the data allocated for a block |
| CRemoveConst | |
| CRemoveConst< Type_ const & > | |
| CRemoveConst< Type_ const > | |
| CresizeSelector | Utility class that select the resize method to call |
| CresizeSelector< Lhs, Rhs, Arrays::diagonal_ > | Specialization for the diagonal_ case |
| CresizeSelector< Lhs, Rhs, Arrays::number_ > | Specialization for the number_ case |
| CresizeSelector< Lhs, Rhs, Arrays::point_ > | Specialization for the point_ case |
| CresizeSelector< Lhs, Rhs, Arrays::square_ > | Specialization for the square_ case |
| CresizeSelector< Lhs, Rhs, Arrays::vector_ > | Specialization for the vector_ case |
| CSliceVisitorSelector | Utility class that will select the type of operator to apply |
| CSliceVisitorSelector< Derived, Visitor, false > | Specialization if the visitor has to be applied by row |
| CSliceVisitorSelector< Derived, Visitor, true > | Specialization if the visitor has to be applied by col |
| CStatModelTraits | Policy trait class for (Stat) Model classes |
| CStatModelTraits< ModelBernoulli_pj< Data_, WColVector_ > > | Partial specialization of the StatModelTraits for the ModelBernoulli_pj model |
| CStatModelTraits< ModelDiagGaussian_muj_sj< Data_, WColVector_ > > | Partial specialization of the StatModelTraits for the ModelDiagGaussian_muj_sj model |
| CStatModelTraits< ModelGamma_aj_bj< Data_, WColVector_ > > | Partial specialization of the StatModelTraits for the ModelGamma_aj_bj model |
| CSumVisitor | Visitor computing the sum of all the coefficients of the Array |
| CTraits | , |
| CTraits< Array1D< Type_, Size_ > > | Specialization of the Traits class for Array1D class |
| ►CTraits< Array2D< Type_ > > | Specialization of the Traits class for the Array2D class |
| CVoid | |
| ►CTraits< Array2DDiagonal< Type_ > > | Specialization of the Traits class for the Array2DDiagonal class |
| CVoid | |
| ►CTraits< Array2DLowerTriangular< Type_ > > | Specialization of the Traits class for the Array2DLowerTriangular class |
| CVoid | |
| CTraits< Array2DNumber< Type_ > > | Specialization of the Traits class for Array2DNumber class |
| CTraits< Array2DPoint< Type_ > > | Specialization of the Traits class for Array2DPoint class |
| ►CTraits< Array2DSquare< Type_ > > | Specialization of the Traits class for the Array2DSquare class |
| CVoid | |
| ►CTraits< Array2DUpperTriangular< Type_ > > | Specialization of the Traits class for the Array2DUpperTriangular class |
| CVoid | |
| CTraits< Array2DVector< Type_ > > | Specialization of the Traits class for the Array2DVector class |
| CTraits< ArrayByArrayProduct< Lhs, Rhs > > | Traits class for the ArrayByArrayProduct class |
| CTraits< ArrayByDiagonalProduct< Lhs, Rhs > > | Traits class for array2d by diagonal product |
| CTraits< ArrayByVectorProduct< Lhs, Rhs > > | Traits class for the ArrayByVectorProduct class |
| CTraits< BinaryOperator< FunctorOp, Lhs, Rhs > > | Traits class for the BinaryOperator |
| CTraits< CAllocator< Type_, SizeRows_, SizeCols_, Orient_ > > | Specialization of Traits class for CAllocator |
| CTraits< CArray< Type_, SizeRows_, SizeCols_, Orient_ > > | Specialization of the Traits class for CArray class |
| CTraits< CArrayNumber< Type_, Orient_ > > | Specialization of the Traits class for CArrayNumber class |
| CTraits< CArrayPoint< Type_, SizeCols_, Orient_ > > | Specialization of the Traits class for CArray class |
| CTraits< CArraySquare< Type_, Size_, Orient_ > > | Specialization of the Traits class for CArray class |
| CTraits< CArrayVector< Type_, SizeRows_, Orient_ > > | Specialization of the Traits class for CArrayVector class |
| CTraits< ColAccessor< Lhs > > | Traits class for the column accessor operator |
| CTraits< ColOperator< Lhs > > | Traits class for the column operator |
| CTraits< Const::Array< Type_, SizeRows_, SizeCols_ > > | Traits class for the general constant matrix |
| CTraits< Const::Identity< Type_, Size_ > > | Traits class for the identity constant matrix |
| CTraits< Const::LowerTriangular< Type_, SizeRows_, SizeCols_ > > | Traits class for the lower triangular constant matrix |
| CTraits< Const::Point< Type_, Size_ > > | Traits class for the constant vector_ |
| CTraits< Const::Square< Type_, Size_ > > | Traits class for the square constant matrix |
| CTraits< Const::UpperTriangular< Type_, SizeRows_, SizeCols_ > > | Traits class for the upper triangular constant matrix |
| CTraits< Const::Vector< Type_, Size_ > > | Traits class for the identity constant matrix |
| CTraits< DiagonalByArrayProduct< Lhs, Rhs > > | Traits class for the DiagonalByArrayProduct class |
| CTraits< DiagonalGetterAccessor< Lhs > > | Traits class for DiagonalGetterAccessor operator |
| CTraits< DiagonalGetterOperator< Lhs > > | Traits class for DiagonalGetterOperator operator |
| CTraits< DiagonalizeAccessor< Lhs > > | Traits class for DiagonalizeAccessor operator |
| CTraits< DiagonalizeOperator< Lhs > > | Traits class for DiagonalizeOperator operator |
| CTraits< DotProduct< Lhs, Rhs > > | Traits class for the DotProduct class |
| CTraits< List1D< Type_ > > | Specialization of the Traits class for List1D class |
| CTraits< LowerSymmetrizeAccessor< Lhs > > | Traits class for LowerSymmetrizeAccessor operator |
| CTraits< LowerSymmetrizeOperator< Lhs > > | Traits class for LowerSymmetrizeOperator operator |
| CTraits< LowerTriangularizeAccessor< Lhs > > | Traits class for LowerTriangularizeAccessor operator |
| CTraits< LowerTriangularizeOperator< Lhs > > | Traits class for UpperTriangularizeOperator operator |
| CTraits< PointByArrayProduct< Lhs, Rhs > > | Traits class for the PointByArrayProduct |
| CTraits< RowAccessor< Lhs > > | Traits class for the row accessor |
| CTraits< RowOperator< Lhs > > | Traits class for the row operator |
| CTraits< SArray1D< Type_, Size_, NzMax_ > > | Specialization of the Traits class for SArray1D class |
| ►CTraits< SArray2D< Type_ > > | Specialization of the Traits class for the SArray2D class |
| CVoid | |
| ►CTraits< SArray2DDiagonal< Type_ > > | Specialization of the Traits class for the SArray2DDiagonal class |
| CVoid | |
| ►CTraits< SArray2DLowerTriangular< Type_ > > | Specialization of the Traits class for the SArray2DLowerTriangular class |
| CVoid | |
| CTraits< SArray2DNumber< Type_ > > | Specialization of the Traits class for SArray2DNumber class |
| CTraits< SArray2DPoint< Type_ > > | Specialization of the Traits class for SArray2DPoint class |
| ►CTraits< SArray2DSquare< Type_ > > | Specialization of the Traits class for the SArray2DSquare class |
| CVoid | |
| ►CTraits< SArray2DUpperTriangular< Type_ > > | Specialization of the Traits class for the SArray2DUpperTriangular class |
| CVoid | |
| CTraits< SArray2DVector< Type_ > > | Specialization of the Traits class for the SArray2DVector class |
| CTraits< SubAccessor< Lhs, SizeRows_, SizeCols_ > > | Traits class for the sub accessor |
| CTraits< SubOperator< Lhs, SizeRows_, SizeCols_ > > | Traits class for the sub operator |
| CTraits< SubVectorAccessor< Lhs, Size_ > > | Traits class for the sub vector accessor |
| CTraits< SubVectorOperator< Lhs, Size_ > > | Traits class for the sub vector operator |
| CTraits< SymmetrizeAccessor< Lhs > > | Traits class for SymmetrizeAccessor operator |
| CTraits< SymmetrizeOperator< Lhs > > | Traits class for SymmetrizeOperator operator |
| CTraits< TransposeAccessor< Lhs > > | Traits class for the transposed operator |
| CTraits< TransposeOperator< Lhs > > | Traits class for the transposed operator |
| CTraits< UnaryOperator< UnaryOp, Lhs > > | Traits class for the unary operators |
| CTraits< UpperSymmetrizeAccessor< Lhs > > | Traits class for UpperSymmetrizeAccessor operator |
| CTraits< UpperSymmetrizeOperator< Lhs > > | Traits class for UpperSymmetrizeOperator operator |
| CTraits< UpperTriangularizeAccessor< Lhs > > | Traits class for UpperTriangularizeAccessor operator |
| CTraits< UpperTriangularizeOperator< Lhs > > | Traits class for UpperTriangularizeOperator operator |
| CTraits< Variable< Type_ > > | Specialization of the Traits struct for Variable class |
| CTraits< VectorByPointProduct< Lhs, Rhs > > | Traits class for the VectorByPointProduct class |
| CTraits< VisitorByCol< Derived, Visitor > > | Traits class for the unary operators |
| CTraits< VisitorByRow< Derived, Visitor > > | Traits class for the VisitorByRow class |
| CTransposeTraits | Helper Traits class for transposed operator |
| CTransposeTraits< Arrays::lower_symmetric_ > | Specialization for lower_triangular_ |
| CTransposeTraits< Arrays::lower_triangular_ > | Specialization for lower_triangular_ |
| CTransposeTraits< Arrays::point_ > | Specialization for point_ |
| CTransposeTraits< Arrays::upper_symmetric_ > | Specialization for upper_triangular_ |
| CTransposeTraits< Arrays::upper_triangular_ > | Specialization for upper_triangular_ |
| CTransposeTraits< Arrays::vector_ > | Specialization for vector_ |
| CTrueType | |
| CUsedFunctor | The functor to use |
| CUsedFunctor< Functor, 1 > | |
| CUsedFunctor< Functor, 2 > | |
| CUsedFunctor< Functor, 3 > | |
| CUsedFunctor< Functor, 4 > | |
| CValueApplier | Visitor putting a constant value |
| Cvb | Methods to use for C=PB with P a point and B a matrix |
| CVisitorArrayImpl | |
| CVisitorArrayImpl< Visitor, Derived, 1, UnknownSize > | Specialization of VisitorArrayImpl when the number of rows is 1 and the number of column is unknown or greater than MaxUnrollSlice |
| CVisitorArrayImpl< Visitor, Derived, SizeRows_, UnknownSize > | Specialization of VisitorArrayImpl when the number of rows is less than MaxUnrollSlice and the number of column is unknown or greater than MaxUnrollSlice |
| CVisitorArrayImpl< Visitor, Derived, UnknownSize, 1 > | Specialization of VisitorArrayImpl when the number of columns is one and the number of rows is unknown |
| CVisitorArrayImpl< Visitor, Derived, UnknownSize, SizeCols_ > | Specialization of VisitorArrayImpl when the number of columns is less than MaxUnrollSlice and the number of rows is unknown |
| CVisitorArrayNoUnrollImpl | |
| CVisitorArrayNoUnrollImpl< Visitor, Derived, Arrays::by_col_, UnknownSize, UnknownSize > | Specialization for general 2D arrays, data stored by column and dimensions not known at compile time |
| CVisitorArrayNoUnrollImpl< Visitor, Derived, Arrays::by_row_, UnknownSize, UnknownSize > | Specialization for general 2D arrays, data stored by rows and dimensions are not known at compile time |
| CVisitorArrayUnrollImpl | |
| CVisitorArrayUnrollImpl< Visitor, Derived, Arrays::by_col_, 1, 1 > | Specialization for the general case with 1 row and 1 column arrays |
| CVisitorArrayUnrollImpl< Visitor, Derived, Arrays::by_col_, SizeRows_, 1 > | Specialization for the Arrays with 1 column |
| CVisitorArrayUnrollImpl< Visitor, Derived, Arrays::by_col_, SizeRows_, SizeCols_ > | Specialization for the general case when we unroll the rows and the and the columns with a column oriented arrays |
| CVisitorArrayUnrollImpl< Visitor, Derived, Arrays::by_row_, 1, 1 > | Specialization for the general case with 1 row and 1 column arrays |
| CVisitorArrayUnrollImpl< Visitor, Derived, Arrays::by_row_, 1, SizeCols_ > | Specialization for the arrays with 1 column (Vector) |
| CVisitorArrayUnrollImpl< Visitor, Derived, Arrays::by_row_, SizeRows_, SizeCols_ > | Specialization for the general case when we unroll the rows and the columns with a row oriented arrays |
| CVisitorDiagonalImpl | A VisitorDiagonalImpl allow to unroll the visit of a Diagonal tab if possible |
| CVisitorDiagonalImpl< Visitor, Derived, 1 > | Specialization for diagonal tab of size one |
| CVisitorDiagonalImpl< Visitor, Derived, UnknownSize > | Specialization when the size is unknown |
| CVisitorLowerImpl | |
| CVisitorLowerImpl< Visitor, Derived, Arrays::by_col_ > | Specialization for the general case with column oriented arrays |
| CVisitorLowerImpl< Visitor, Derived, Arrays::by_row_ > | Specialization for the general case with row oriented arrays |
| CVisitorNumberImpl | Specialization for the general case with 1 row and 1 column arrays |
| CVisitorPointImpl | A VisitorPointImpl allow to unroll the visit of a row-vector if possible |
| CVisitorPointImpl< Visitor, Derived, 1 > | Specialization for the RowVectors with one columns |
| CVisitorPointImpl< Visitor, Derived, UnknownSize > | Specialization when the size is unknown |
| CVisitorSelector | Visitor selector |
| CVisitorSelectorHelper | Helper for the Visitor selector: allow to select the correct implementation to instantiate for arrays and square arrays when only one dimension (rows or columns but not both) |
| CVisitorSelectorHelper< Visitor, Derived, Arrays::diagonal_ > | Specialization for the diagonal arrays |
| CVisitorSelectorHelper< Visitor, Derived, Arrays::lower_triangular_ > | Specialization for the lower triangular arrays |
| CVisitorSelectorHelper< Visitor, Derived, Arrays::number_ > | Specialization for the numbers |
| CVisitorSelectorHelper< Visitor, Derived, Arrays::point_ > | Specialization for the row vectors |
| CVisitorSelectorHelper< Visitor, Derived, Arrays::upper_triangular_ > | Specialization for the upper triangular arrays |
| CVisitorSelectorHelper< Visitor, Derived, Arrays::vector_ > | Specialization for the vectors |
| CVisitorUnrollCol | Unroll the column baseIdx + SizeCols_ -1 |
| CVisitorUnrollCol< Visitor, Derived, 1, SizeCols_ > | Specialization for the arrays with 1 row (Point) |
| CVisitorUnrollRow | Unroll the row baseIdx + SizeRows_ -1
|
| CVisitorUnrollRow< Visitor, Derived, SizeRows_, 1 > | Specialization for the arrays with 1 column |
| CVisitorUpperImpl | |
| CVisitorUpperImpl< Visitor, Derived, Arrays::by_col_ > | Specialization for the general case with column oriented arrays |
| CVisitorUpperImpl< Visitor, Derived, Arrays::by_row_ > | Specialization for the general case with row oriented arrays |
| CVisitorVectorImpl | A visitor Vector allow to unroll the visit of a vector if possible |
| CVisitorVectorImpl< Visitor, Derived, 1 > | Specialization for the vectors with 1 row |
| CVisitorVectorImpl< Visitor, Derived, UnknownSize > | Specialization when the size is unknown |
| ►NKernel | This is the namespace for the Kernels |
| CExponential | [Deprecated] The Exponential Kernel is a kernel of the form |
| CGaussian | The Gaussian Kernel is a kernel of the form |
| CHamming | The Hamming Kernel is a kernel of the form |
| CIKernel | Interface class for the kernels classes |
| CIKernelBase | Interface Base class for the kernels classes |
| CLaplace | The Laplace Kernel is a kernel of the form |
| CLinear | The Linear Kernel is a kernel of the form |
| CPolynomial | The Polynomial Kernel is a kernel of the form |
| CRationalQuadratic | The RationalQuadratic Kernel is a kernel of the form |
| ►Nlapack | Namespace enclosing the wrappers of the lapack routines |
| CMultiLeastSquare | The class MultiLeastSQquare solve the least square problem when the response b is multidimensional |
| CQr | { |
| CSvd | { |
| CSymEigen | { |
| ►NLaw | This is the namespace enclosing the classes handling the usual probabilities Laws |
| CBernoulli | Bernoulli probability law |
| CBeta | Beta distribution law |
| CBinomial | Binomial probability law |
| CCategorical | Categorical probability law |
| CCauchy | Cauchy distribution law |
| CCdfcOp | , |
| CCdfOp | , |
| CChiSquared | ChiSquared distribution law |
| CEmpirical | Empirical distribution law |
| CExponential | Exponential distribution law |
| CFisherSnedecor | FisherSnedecor distribution law |
| CGamma | Gamma distribution law |
| CGeometric | Geometric probability law |
| CHyperGeometric | HyperGeometric probability law |
| CIcdfOp | , |
| CILawBase | Interface base class for all the (univariate/multivariate) probabilities laws |
| CIUnivLaw | Interface base class for all the univariate distributions |
| CLogCdfcOp | , |
| CLogCdfOp | , |
| CLogistic | Logistic distribution law |
| CLogNormal | LogNormal distribution law |
| CLogPdfOp | , |
| CNegativeBinomial | NegativeBinomial probability law |
| CNormal | Normal distribution law |
| CPdfOp | , |
| CPoisson | Poisson distribution law |
| CStudent | Student distribution law |
| CUniform | Class for the Uniform law distribution |
| CUniformDiscrete | Class for the Uniform law distribution |
| CWeibull | Weibull distribution law |
| ►NMultiLaw | This is the namespace enclosing the classes handling the multivariate probabilities Laws |
| CIMultiLaw | Interface base Class for the multivariate distributions |
| CJointBernoulli | Implement the Joint Bernoulli probability law |
| CJointCauchy | Implement the Joint Cauchy probability law |
| CJointGamma | Implement the Joint Gamma probability law |
| CJointNormal | Implement the Joint Normal probability law |
| CJointProbability | Joint density class for the multivariate distributions |
| CNormal | Class for the multivariate Normal distribution |
| ►NStat | This is the namespace for the statistical treatment |
| CBivariate | Computation of the bivariate Statistics of two Variables |
| CConfusionMatrix | Class computing the confusion matrix given two vectors of integer |
| CFactor | Computation of the Factors of a 1D Container |
| CMaxOp | Compute the maximal value of the variable V |
| CMaxSafeOp | Compute safely the maximal value of the variable V |
| CMeanOp | Compute the mean of the variable V |
| CMeanSafeOp | Compute safely mean of the variable V |
| CMinOp | Compute the minimal value of the variable V |
| CMinSafeOp | Compute safely the minimal value of the variable V |
| CMultiFactor | Computation of the MultiFactors of a 2D Container |
| CMultivariate | Computation of the multivariate statistics of a Variable |
| CMultivariate< Array, Real > | Computation of the Multivariate Statistics of a 2D Container of Real |
| COnline | |
| COnline< Array, Real > | Computation online of the statistics of a Real set of variable |
| COnline< Real, Real > | Computation online of the statistics of a Real set of variable |
| CSumOp | Compute the sum of the variable V |
| CSumSafeOp | Compute safely the sum of the variable V |
| CUnivariate | |
| CUnivariate< TContainer1D, Real > | Computation of the univariate Statistics of a Real Variable |
| CVarianceOp | Compute the variance of the variable V |
| CVarianceSafeOp | Compute safely the variance of the variable V |
| CVarianceWithFixedMeanOp | Compute the variance of the variable V when the mean is given |
| CVarianceWithFixedMeanSafeOp | Compute safely the variance of the variable V when the mean is given |
| CAbsOp | Template functor which compute the absolute value of a number |
| CAcosOp | Template functor which compute the arc cosine of a number |
| CAdditiveBSplineCoefficients | Compute the regression splines coefficients of an additive model |
| CAdditiveBSplineRegression | Compute an additive BSpline, multivalued, regression function using BSpline basis |
| CAdditiveBSplineRegressionPage | In this Page, we manage the options for the computation of the Additive BSpline regression |
| CAICCriterion | Derived class of Criterion for computing the AIC Criterion The AIC criteria is a penalization of the likelihood given by the formula |
| CAICMixtureCriterion | Derived class of Criterion for computing the AIC Criterion The AIC criteria of a given model M is a penalization of the likelihood given by the formula |
| CApplyFunctor | Class allowing applying the functor Functor on a vector or row-vector |
| CApplyFunctorByCol | Class allowing to apply the Functor Functor on each columns of an expression |
| CApplyFunctorByRow | Class allowing to apply the Functor Functor on each rows of an expression |
| CApplyVisitor | Class allowing to apply a visitor on a vector or a point |
| CApplyWeightedFunctor | Class allowing applying the weighted functor Functor on a vector or row-vector |
| CApplyWeightedFunctorByCol | Class allowing to apply the weighted Functor Functor on each columns of an expression |
| CApplyWeightedFunctorByRow | Class allowing to apply the Functor Functor on each rows of an expression |
| CArithmetic | Arithmetic properties of STK fundamental types |
| CArithmetic< Binary > | Specialization for Binary |
| CArithmetic< Char > | Specialization of the struct Arithmetic for Char |
| CArithmetic< Integer > | Specialization for Integer (long) |
| CArithmetic< Real > | Specialization for Real |
| CArithmetic< Sign > | Specialization for Sign |
| CArithmetic< String > | Specialization for String |
| CArithmetic< TRange< Size_ > > | Partial Specialization for TRange |
| ►CArray1D | Template one dimensional Arrays |
| CInnerOperator | |
| CArray2D | Template two dimensional column (vertically) oriented Array |
| CArray2DDiagonal | Derivation of the Array2DDiagonal class for square arrays of Real |
| CArray2DLowerTriangular | Declaration of the lower triangular matrix class |
| CArray2DNumber | Template number Array |
| CArray2DPoint | Template one dimensional horizontal Array |
| CArray2DSquare | Derivation of the Array2DSquare class for square arrays of Real |
| CArray2DUpperTriangular | Declaration of the upper triangular matrix class |
| CArray2DVector | Template one dimensional horizontal Array |
| CArrayBase | Base class for template arrays |
| CArrayByArrayProduct | Generic expression where a product operator is applied to two expressions |
| CArrayByDiagonalProduct | Generic expression where a product operator is applied to two expressions |
| CArrayByVectorProduct | Generic expression where a product operator is applied to two expressions |
| CArrayInitializer | Helper class used by the comma initializer operator |
| CAsinOp | Template functor which compute the arc sine of a number |
| CBernoulli_pjParameters | Structure encapsulating the parameters of a Joint Bernoulli model |
| CBernoulliModel | A Bernoulli model, is a statistical model of the following form |
| CBICCriterion | Derived class of Criterion for computing the BIC Criterion The Bic criteria is a penalization of the likelihood given by the formula |
| CBICMixtureCriterion | Derived class of Criterion for computing the BIC Criterion The Bic criteria of a model M is a penalization of the likelihood given by the formula |
| CBiDirectionalIterator | BiDirectionalIterator allows to loop over the element of one dimensional list containers |
| CBinaryOperator | Generic expression where a binary operator is applied to two expressions |
| CBitwiseAndOp | Template functor which compute the bitwise and of two numbers |
| CBitwiseAndWithOp | Template functor to compute the bitwise and with a fixed value |
| CBitwiseOrOp | Template functor which compute the bitwise or of two numbers |
| CBitwiseOrWithOp | Template functor to compute the bitwise or with a fixed value |
| CBitwiseXorOp | Template functor which compute the bitwise xor of two numbers |
| CBitwiseXorWithOp | Template functor to compute the bitwise xor with a fixed value |
| CBSplineCoefficients | Compute the regression B-splines coefficients |
| CBSplineRegression | Compute a BSpline, multi-valued, regression function using BSpline basis |
| CCAllocator | Allocator for dense Array classes |
| CCAllocator< Type_, SizeRows_, UnknownSize, Orient_ > | Specialized Allocator for the dense Arrays classes |
| CCAllocator< Type_, UnknownSize, SizeCols_, Orient_ > | Specialized Allocator for the dense Arrays classes |
| CCAllocator< Type_, UnknownSize, UnknownSize, Orient_ > | Specialized Allocator for the dense Arrays classes |
| CCAllocatorBase | Base class for CAllocators |
| CCArray | A CArray is a two dimensional array with a continuous storage like a C-array |
| CCArrayNumber | Specialization for the number case |
| CCArrayPoint | Declaration of the point case |
| CCArraySquare | Specialization for the square case |
| CCArrayVector | Specialization for the vector case |
| CCastOp | Template functor which cast a type to another type |
| CCategorical_pjk | The diagonal Categorical mixture model Categorical_pjk is the most general diagonal Categorical model and has a probability function of the form |
| CCategorical_pk | The diagonal Categorical mixture model Categorical_pk is a diagonal Categorical model and has a density function of the form |
| CCategoricalBase | Base class for the Categorical models |
| CCategoricalBridge | Template implementation of the IMixtureBridge interface allowing to bridge a STK++ mixture with the composer |
| CCategoricalMixtureManager | A mixture manager is a factory class for injection dependency in the STK++ derived class of the IMixtureComposer interface class |
| CCell2D | Template class for the 2 Dimensional Cells |
| CCellBase | Template Base class for the Cell in a list |
| CCellHo | Template class for the Horizontal Cell of a Horizontal List |
| CCellVe | Template class for the Vertical Cell of a Vertical List |
| CCEMAlgo | Implementation of the SEM algorithm |
| CCG | The conjugate gradient method is an algorithm for the numerical solution of particular systems of linear equations, namely those whose matrix is symmetric and positive-definite |
| CChebyshevCoefficients | ChebyshevCoefficients class allows to compute the coefficients of a sampled function using Chebyshev polynomials |
| CClassInit | Initialization by simulating a realization of the class labels zi accordingly to the initial proportions |
| CColAccessor | Generic expression when the column of an expression is accessed |
| CColOperator | Generic expression when the column of an expression is accessed |
| CConstBiDirectionalIterator | ConstBiDirectionalIterator allows to loop over the element of one dimensional list containers |
| CConstDenseRandomIterator | ConstDenseRandomIterator allows to loop over the elements of containers Array |
| CCosinesCoefficients | CosinesCoefficients allows to compute the coefficients of a sampled function using cosines basis functions |
| CCosOp | Template functor which compute the cosine of a number |
| CCsvToArray | The CsvToArray class allow to export the data of some Type stored in a TReadWriteCsv in an Array |
| CCubeOp | Template functor which compute the cube of a number |
| CCvHandler | CvHanler is an utility function for building the submatrix/subvectors needed when using k-folds cross-validation |
| CDataBridge | Bridge a data set in order to handle its missing values |
| CDataFrame | DataFrame is a List of Variable with the same number of rows |
| CDataFrameToArray2D | The DataFrameToArray2D class allow to export the data of some TYPE stored in a DataFrame to be exported in an Array2D |
| CDataHandler | implementation of the DataHandlerBase class using ReadWriteCsv and Array2D |
| CDataHandlerBase | A class derived from a DataHandlerBase allows to store various data sets identified by an idData and an idModel |
| CDefaultFunctor | |
| CDenseIteratorBase | IteratorBase is a base class for all iterators on dense arrays/matrix/vector/expressions |
| CDenseRandomIterator | DenseRandomIterator allows to loop over the elements of containers Array |
| CDiagGaussian_muj_sjParameters | Structure encapsulating the parameters of a DiagGaussian_muj_sj model |
| CDiagGaussian_s | The diagonal DiagGaussian_s mixture model hse a density function of the form |
| CDiagGaussian_sj | The diagonal Gaussian mixture model DiagGaussian_sj have a density function of the form |
| CDiagGaussian_sjk | The diagonal Gaussian mixture model DiagGaussian_sjk is the most general diagonal Gaussian model and have a density function of the form |
| CDiagGaussian_sjsk | The diagonal Gaussian mixture model DiagGaussian_sjsk is an intermediate diagonal Gaussian model with density function of the form |
| CDiagGaussian_sk | The diagonal Gaussian mixture model DiagGaussian_sk assumes an equal standard deviation in each cluster and has a density function of the form |
| CDiagGaussianBase | Base class for the diagonal Gaussian models |
| CDiagGaussianBridge | Template implementation of the IMixture interface allowing to bridge a STK++ mixture with the composer |
| CDiagGaussianMixtureManager | A mixture manager is a factory class for injection dependency in the STK++ derived class of the IMixtureComposer class |
| CDiagonalByArrayProduct | Generic expression where a product operator is applied to two expressions |
| CDiagonalGetterAccessor | Generic expression when we want to get the diagonal of a two-dimensional square expression |
| CDiagonalGetterOperator | Generic expression when we want to get the diagonal of a two-dimensional square expression |
| CDiagonalizeAccessor | Generic expression when a one dimensional vector/point/idagonal expression is "diagonalized" |
| CDiagonalizeOperator | Generic expression when a one dimensional vector/point/idagonal expression is "diagonalized" |
| CDifferenceOp | Template functor which compute the difference of two numbers |
| CDifferenceWithOp | Template functor to add a number to a fixed value |
| CDivisionOp | Template functor which compute the division of two numbers |
| CDivisionWithBaseOp | Base class for DivisionWithOp functors |
| CDivisionWithBaseOp< Type, false > | |
| CDivisionWithBaseOp< Type, true > | |
| CDivisionWithOp | Template functor to divide a number by a fixed value |
| Cdomain_error | Thrown by the library, or by you, to report domain errors (domain in the mathematical sense) |
| CDotProduct | Generic expression where a DotProduct is applied to two expressions |
| CEMAlgo | Implementation of the EM algorithm |
| CEMPredict | Implementation of the EMPredict algorithm |
| CEqualOp | Template functor testing if a number is equal to an other number |
| CEqualWithOp | Template functor to test if a number is equal to a fixed value |
| CException | Sdk class for all library Exceptions |
| CExpOp | Template functor which compute the exponential of a number |
| CExportToCsv | Export data to a Csv |
| CExprBase | Base class for template evaluation expressions and visitors |
| CFullStrategy | A FullStrategy is based on the following paradigm: |
| CFullStrategyParam | Helper structure encapsulating the parameters of the Full strategy |
| CFuzzyInit | Initialization by simulating the tik accordingly to the initial proportions |
| CGamma_a_bjk | Gamma_a_bjk is a mixture model of the following form |
| CGamma_a_bk | Gamma_a_bk is a mixture model of the following form |
| CGamma_aj_bjk | Gamma_aj_bjk is a mixture model of the following form |
| CGamma_aj_bk | Gamma_aj_bk is a mixture model of the following form |
| CGamma_ajk_b | Gamma_ajk_b is a mixture model of the following form |
| CGamma_ajk_bj | Gamma_ajk_bj is a mixture model of the following form |
| CGamma_ajk_bjk | Gamma_ajk_bjk is a mixture model of the following form |
| CGamma_ajk_bk | Gamma_ajk_bk is a mixture model of the following form |
| CGamma_ak_b | Gamma_ak_b is a mixture model of the following form |
| CGamma_ak_bj | Gamma_ak_bj is a mixture model of the following form |
| CGamma_ak_bjk | Gamma_ak_bjk is a mixture model of the following form |
| CGamma_ak_bk | Gamma_ak_bk is a mixture model of the following form |
| CGammaBase | Base class for the gamma models |
| CGammaBridge | Template implementation of the IMixtureBridge interface allowing to bridge a STK++ mixture with the composer |
| CGammaMixtureManager | A mixture manager is a factory class for injection dependency in the STK++ derived class of the MixtureComposer class |
| CGaussianAAModel | Gaussian Auto-Associative models |
| CGaussianModel | Compute the maximum likelihood estimates of a complete Gaussian statistical model |
| CGeqOp | Template functor testing if a number is greater or equal than an other number |
| CGeqThanOp | Template functor to test if a number is greater or equal than a fixed value |
| CGreaterOp | Template functor testing if a number is greater than an other number |
| CGreaterThanOp | Template functor to test if a number is greater than a fixed value |
| CHDGaussian_AjkBkQkD | The diagonal Gaussian mixture model HDGaussian_AjkBkQkD is the most general HD Gaussian model and have a density function of the form |
| CHDGaussianBase | Base class for the diagonal Gaussian models |
| CHDGaussianBridge | Template implementation of the IMixture interface allowing to bridge a STK++ mixture with the composer |
| CHDMatrixGaussianBridge | Template implementation of the IMixture interface allowing to bridge a STK++ mixture with the composer |
| CHDMatrixGaussianModel | Main class for HD matrix valued matrix models |
| CHDMatrixModelParameters | Structure storing the parameters of the HD matrix valued mixture |
| CIAAModel | @ |
| CIArray1D | Template one dimensional Array |
| CIArray2D | Template interface base class for two-dimensional arrays |
| CIBasis | Interface base class for all basis function |
| CICArray | S |
| CIClassification | Interface base class for Regression methods |
| CICLMixtureCriterion | Derived class of IMixtureCriterion for computing the ICL Criterion The ICL criteria of a model M is a penalization of the likelihood given by the formula |
| CIClusterModelBase | Base class for clustering models |
| CIContainer2D | Interface base class for 2D containers |
| CICriterion | Interface base class for the selection model criterion |
| CIDataBridge | Interface class wrapping a data set |
| CIDataHandler | A DataHandler class allow to store various data set identified with an idData (a string) |
| CIdTypeImpl | Implementation of the return type |
| CIdTypeImpl< Binary > | Specialization of the IdTypeImpl for the Type Binary |
| CIdTypeImpl< Char > | Specialization of the IdTypeImpl for the Type Char |
| CIdTypeImpl< Integer > | Specialization of the IdTypeImpl for the type Integer |
| CIdTypeImpl< Real > | Specialization of the IdTypeImpl for the Type Real |
| CIdTypeImpl< Sign > | Specialization of the IdTypeImpl for the Type Sign |
| CIdTypeImpl< String > | Specialization of the IdTypeImpl for the Type String |
| CIdTypeImpl< TRange< Size_ > > | Partial Specialization of the IdTypeImpl for the Type TRange |
| CIFunction | Interface base class for functions |
| CIGaussianModel | Compute the the maximum likelihood estimates of a complete Gaussian statistical model |
| CILeastSquare | The class ILeastSquare is an interface class for the methods solving the least-square problem |
| CILinearReduct | A ILinearReduct is an interface base class for reduction method using linear reduction |
| CIMixture | Interface base class for all the mixture models that will be processed by the composer |
| CIMixtureAlgo | Interface base class for the algorithms |
| CIMixtureAlgoLearn | Interface base class for the learning algorithms |
| CIMixtureAlgoPredict | Interface base class for predicting algorithms |
| CIMixtureBridge | Interface base class for the bridges of the STK++ mixture |
| CIMixtureComposer | Base class for Mixture (composed) model |
| CIMixtureCriterion | Interface base class for the selection model criterion |
| CIMixtureDensity | Base class for all Mixture densities |
| CIMixtureInit | Interface base class for the initializations |
| CIMixtureLearner | Base class for Learner of a Mixture mixed model |
| CIMixtureManager | Interface base class for mixture managers |
| CIMixtureModel | Main interface class for mixture models |
| CIMixtureModelBase | Base class for all Mixture model |
| CIMixtureStatModel | Interface base class for Mixture (composed) model |
| CIMixtureStrategy | Interface base class for all the strategies |
| CImportFromCsv | Import data from a Csv File in a DataFrame |
| CImputeAlgo | Implementation of the ImputeAlgo learning algorithm |
| CIMultiParameters | Interface base class for the parameters of a multivariate model |
| CIMultiStatModel | Interface base class for all Multivariate Statistical Models |
| CInnerIteratorBase | InnerIteratorBase is a base class for all iterators on allocators |
| Cinvalid_argument | Thrown to report invalid arguments to functions |
| CInverseOp | Template functor which compute the inverse of a number |
| CInvertMatrix | The InvertMatrix class is a functor class allowing to compute the inverse of a symmetric matrix |
| CIPage | A IPage is an interface base class for reading and/or writing a page of option in a file |
| CIQr | The class IQr is an interface class for the method computing the QR Decomposition of a ArrayXX |
| CIRecursiveTemplate | Interface base class for all classes implementing the curious recursive template paradigm |
| CIReducer | Interface base class for reducing methods |
| CIRegression | Interface base class for Regression methods |
| CIRunnerBase | Abstract base class for all classes having a |
| CIRunnerSupervised | Abstract class for all classes making supervised learning |
| CIRunnerUnsupervised | Abstract class for all classes making unsupervised learning |
| CIRunnerWithData | Abstract class for all running class based on a data set |
| CISerie | Interface base class for Series |
| CIsFiniteOp | Template functor testing if a number is a finite value |
| CIsInfiniteOp | Template functor testing if a number is an infinite value |
| CIsNaOp | Template functor testing if a number is a NA value |
| CISparseArray1D | Interface class for SparseArray1D |
| CIStatModel | Base class for all Statistical Models [Deprecated], have been replaced by IStatModel |
| CIStatModelBase | Interface base class for all Statistical Models |
| CISvd | Compute the Singular Value Decomposition of an array |
| CISymEigen | The class ISymEigen is an interface class for the method computing the eigenvalue Decomposition of a symmetric ArrayXX |
| CITContainer | Specialized interface class for all arrays (can be either 2D arrays or 1D arrays) |
| CITContainer1D | Interface base class for homogeneous 1D containers |
| CITContainer2D | Interface base class for homogeneous 2D containers like allocators |
| CITContainer< Derived, Arrays::array2D_ > | Specialization for array2D_ |
| CITContainer< Derived, Arrays::diagonal_ > | Specialization for diagonal_ |
| CITContainer< Derived, Arrays::lower_symmetric_ > | Specialization for lower_symmetric_ |
| CITContainer< Derived, Arrays::lower_triangular_ > | Specialization for lower_triangular_ |
| CITContainer< Derived, Arrays::number_ > | Specialization for number_ |
| CITContainer< Derived, Arrays::point_ > | Specialization for point_ |
| CITContainer< Derived, Arrays::square_ > | |
| CITContainer< Derived, Arrays::symmetric_ > | |
| CITContainer< Derived, Arrays::upper_symmetric_ > | Specialization for upper_symmetric_ |
| CITContainer< Derived, Arrays::upper_triangular_ > | Specialization for upper_triangular_ |
| CITContainer< Derived, Arrays::vector_ > | Specialization for vector_ |
| CITContainerBase | Interface base class for 2D containers |
| CIUnivStatModel | Base class for all Statistical Models |
| CIVariable | IVariable is an Interface class for all Variables classes |
| CJointBernoulliModel | A joint Bernoulli model is a statistical model of the form: following form |
| CJointBernoulliParameters | Structure encapsulating the parameters of a Joint Bernoulli model |
| ►CJointGammaModel | A joint Gamma model is a statistical model of the following form |
| Cdloglikelihood | |
| CJointGammaParameters | Structure encapsulating the parameters of a Joint Gamma model |
| CJointGaussianModel | A joint Gaussian model is a statistical model of the form: following form |
| CJointGaussianParameters | Structure encapsulating the parameters of a Joint Gaussian model |
| CKernelHandler | implementation of the DataHandlerBase class for kernel mixture models |
| CKernelMixtureManager | A mixture manager is a factory class for injection dependency in the STK++ derived class of the MixtureComposer class |
| CKmm_s | The Gaussian mixture model Kmm_s is an isotrope Gaussian mixture model on a kernel space |
| CKmm_sk | The Gaussian mixture model Kmm_sk is an isotrope Gaussian mixture model on a kernel space |
| CKmmBase | Base class for the Gaussian Kernel Mixture Models |
| CKmmBridge | Template implementation of the IMixture interface allowing to bridge a STK++ kernel mixture with the composer |
| CLearnFacade | Facade design pattern |
| Clength_error | Thrown when an object is constructed that would exceed its maximum permitted size (e.g., a basic_String instance) |
| CLeqOp | Template functor testing if a number is less or equal than an other number |
| CLeqThanOp | Template functor to test if a number is less or equal than a fixed value |
| CLessOp | Template functor testing if a number is less than an other number |
| CLessThanOp | Template functor to test if a number is less than a fixed value |
| CLinearAAModel | A Linear AutoAssociative Model (LAAM) is a generalization of the PCA model for projecting variables on an affine plane of lower dimension |
| CList1D | Template One dimensional Horizontal List |
| CLocalVariance | A LocalVariance is an implementation of the abstract ILinearReduct class |
| CLocalVariancePage | In this Page, we manage the options for the computation of the LocalVariance |
| Clogic_error | Logic errors represent problems in the internal logic of a program; in theory, these are preventable, and even detectable before the program runs (e.g., violations of class invariants) |
| CLogicalAndOp | Template functor which compute the logical and of two numbers |
| CLogicalAndWithOp | Template functor computing logical and with a fixed value |
| CLogicalOrOp | Template functor which compute the logical or of two numbers |
| CLogicalOrWithOp | Template functor computing logical and with a fixed value |
| CLogOp | Template functor which compute the logarithm of a number |
| CLowerSymmetrizeAccessor | Generic expression when we want to get the lower-part of a two-dimensional symmetric expression |
| CLowerSymmetrizeOperator | Generic expression when we want to get the lower-part of a two-dimensional symmetric expression |
| CLowerTriangularizeAccessor | Generic expression when we want to get the lower-part of a two-dimensional expression |
| CLowerTriangularizeOperator | Generic expression when we want to get the lower-part of a two-dimensional expression |
| CMaxOp | Template functor which compute the maximum of two numbers |
| CMaxWithOp | Template functor to compute the minimum with a fixed value |
| CMemAllocator | Template base class for all Allocator classes |
| CMemSAllocator | Memory allocator for sparse Array classes |
| CMemSAllocator1D | Memory allocator for sparse vectors classes |
| CMinOp | Template functor which compute the minimum of two numbers |
| CMinWithOp | Template functor to compute the minimum between a fixed value |
| CMixtureComposer | Main class for handling composed mixture models |
| CMixtureComposerFacade | The MixtureComposerFacade allows to interact with a composer for estimating a mixture model with less effort |
| CMixtureComposerFixedProp | Specialization of the composer for the fixed proportion case |
| CMixtureLearner | Main class for learning mixture models |
| CMixtureSemiLearner | Base class for Learning a Mixture mixed model when some classes are known |
| CMixtureSemiLearnerFixedProp | Specialization of the composer for the fixed proportion case |
| CMLMixtureCriterion | Derived class of Criterion for computing the Maximum Likelihood Criterion This criterion does not penalize the model and return minux two times the log likelihood of the model |
| CModelBernoulli_pj | A joint Bernoulli model is a statistical model of the form: following form |
| CModelDiagGaussian_muj_sj | A DiagGaussian_muj_sj model is a statistical model of the form: following form |
| ►CModelGamma_aj_bj | A joint Gamma model is a statistical model of the following form |
| Cdloglikelihood | |
| CModelGamma_aj_bjParameters | Structure encapsulating the parameters of a Joint Gamma model |
| CModelParameters | Struct storing the parameters of the mixture |
| CModelParameters< Clust::Categorical_pjk_ > | Structure encapsulating the parameters of a Categorical_pjk model |
| CModelParameters< Clust::Categorical_pk_ > | Structure encapsulating the parameters of a Categorical_pk model |
| CModelParameters< Clust::Gamma_a_bjk_ > | Structure encapsulating the parameters of a Gamma_a_bjk_ mixture model |
| CModelParameters< Clust::Gamma_a_bk_ > | Structure encapsulating the parameters of a Gamma_a_bk_ mixture model |
| CModelParameters< Clust::Gamma_aj_bjk_ > | Structure encapsulating the parameters of a Gamma_aj_bjk_ mixture model |
| CModelParameters< Clust::Gamma_aj_bk_ > | Structure encapsulating the parameters of a Gamma_aj_bk_ mixture model |
| CModelParameters< Clust::Gamma_ajk_b_ > | Structure encapsulating the parameters of a Gamma_ajk_b_ mixture model |
| CModelParameters< Clust::Gamma_ajk_bj_ > | Structure encapsulating the parameters of a Gamma_ajk_bj_ mixture model |
| CModelParameters< Clust::Gamma_ajk_bjk_ > | Structure encapsulating the parameters of a Gamma_ajk_bjk_ mixture model |
| CModelParameters< Clust::Gamma_ajk_bk_ > | Structure encapsulating the parameters of a Gamma_ajk_bk_ mixture model |
| CModelParameters< Clust::Gamma_ak_b_ > | Structure encapsulating the parameters of a Gamma_ak_b_ mixture model |
| CModelParameters< Clust::Gamma_ak_bj_ > | Structure encapsulating the parameters of a Gamma_ak_bj_ mixture model |
| CModelParameters< Clust::Gamma_ak_bjk_ > | Structure encapsulating the parameters of a Gamma_ak_bjk_ mixture model |
| CModelParameters< Clust::Gamma_ak_bk_ > | Structure encapsulating the parameters of a Gamma_ak_bk_ mixture model |
| CModelParameters< Clust::Gaussian_s_ > | Structure encapsulating the parameters of a STK::DiagGaussian_s model |
| CModelParameters< Clust::Gaussian_sj_ > | Structure encapsulating the parameters of a STK::DiagGaussian_sj model |
| CModelParameters< Clust::Gaussian_sjk_ > | Structure encapsulating the parameters of a STK::DiagGaussian_sjk model |
| CModelParameters< Clust::Gaussian_sjsk_ > | Structure encapsulating the parameters of a Gaussian_sjsk mixture model |
| CModelParameters< Clust::Gaussian_sk_ > | Structure encapsulating the parameters of a STK::DiagGaussian_sk model |
| CModelParameters< Clust::HDGaussian_AjkBkQkD_ > | Structure encapsulating the parameters of a MixturGaussian_sj model |
| CModelParameters< Clust::Kmm_s_ > | Structure encapsulating the parameters of a Kmm_s model |
| CModelParameters< Clust::Kmm_sk_ > | Structure encapsulating the parameters of a Kmm_sk model |
| CModelParameters< Clust::Poisson_ljk_ > | Structure encapsulating the parameters of a Poisson_ljlk model |
| CModelParameters< Clust::Poisson_ljlk_ > | Structure encapsulating the parameters of a Poisson_ljlk model |
| CModelParameters< Clust::Poisson_lk_ > | Structure encapsulating the parameters of a Poisson_lk model |
| CModuloOp | Template functor which compute the modulo of two numbers |
| CModuloWithOp | Template functor to compute the minimum with a fixed value |
| CMultidimRegression | The MultidimRegression class allows to regress a multidimensional output variable among a multivariate explanation variable |
| CMultiLeastSquare | The class MultiLeastSQquare solve the least square problem when the response b is multidimensional |
| CNegOp | Template functor giving the not value |
| CNotEqualOp | Template functor testing if a number is not equal to an other number |
| CNotEqualWithOp | Template functor to test if a number is different than a fixed value |
| COppositeOp | Template functor which compute the opposite of a number |
| COption | Option class allow to store the value of an option from a IPage |
| COrientedCAllocator | |
| COrientedCAllocator< Derived, Arrays::by_col_ > | Specialization for column-oriented Allocators |
| COrientedCAllocator< Derived, Arrays::by_row_ > | Specialization for row-oriented Allocators |
| Cout_of_range | This represents an argument whose value is not within the expected range (e.g., boundary checks in basic_String) |
| CParametersGammaBase | Base class of the Gamma models Parameter Handler |
| CPartitionHandler | CvHanler is an utility function for building the submatrix/subvectors needed when creating learning and test data sets |
| CPCG | In most cases, preconditioning is necessary to ensure fast convergence of the conjugate gradient method |
| CPointByArrayProduct | Generic expression where a product operator is applied to two expressions |
| CPoisson_ljk | The Poisson mixture model Poisson_ljk is the most general Poisson model and have a probability function of the form |
| CPoisson_ljlk | The Poisson mixture model Poisson_ljlk is a Poisson model with a probability function of the form |
| CPoisson_lk | The Poisson mixture model Poisson_lk has a probability function of the form |
| CPoissonBase | Base class for the Poisson models |
| CPoissonBridge | Template implementation of the IMixtureBridge interface allowing to bridge a STK++ Poisson mixture with the composer |
| CPoissonMixtureManager | A mixture manager is a factory class for injection dependency in the STK++ derived class of the MixtureComposer class |
| CPowOp | Template functor to raise a number to a power |
| CProductOp | Template functor which compute the product of two numbers |
| CProductWithOp | Template functor computing the product of a number by a fixed value |
| CProductWithOp< bool > | Specialization for boolean |
| CProjectedVariance | A ProjectedVariance is an implementation of the abstract ILinearReduct interface |
| CProxy | The Proxy class allow to surdefine operators and methods for every kind of class without using dynamic_cast |
| CProxy< String > | Specialization of the Proxy class for String |
| CQr | The class Qr perform the QR decomposition of an ArrayXX |
| CRandBase | Class for the Base random generator |
| CRandomInit | Implementation of the random initialization |
| Crange_error | Thrown to indicate range errors in internal computations |
| CRangeBase | Base class for TRange class |
| CReadWritePages | Allow to handle a file of option containing pages |
| CRowAccessor | Generic expression when the row of an expression is accessed |
| CRowOperator | Generic expression when the row of an expression is accessed |
| Cruntime_error | Runtime errors represent problems outside the scope of a program; they cannot be easily predicted and can generally only be caught as the program executes |
| CSafeInverseOp | Template functor which compute safely the inverse of a number |
| CSafeOp | Template functor which return a default value if the value is NA |
| CSArray1D | Template one dimensional Arrays |
| CSArray2D | Template sparse two dimensional column (vertically) oriented Array |
| CSArray2DDiagonal | Derivation of the SArray2DDiagonal class for square arrays of Real |
| CSArray2DLowerTriangular | Declaration of the lower triangular matrix class |
| CSArray2DNumber | Template number Array |
| CSArray2DPoint | Template one dimensional horizontal Array |
| CSArray2DSquare | Derivation of the SArray2DSquare class for square arrays of Real |
| CSArray2DUpperTriangular | Declaration of the upper triangular matrix class |
| CSArray2DVector | Template one dimensional horizontal Array |
| CSEMAlgo | Implementation of the SEM algorithm |
| CSemiSEMAlgo | Implementation of the SemiSEM algorithm |
| CSemiSEMPredict | Implementation of the SemiSEMPredict algorithm |
| CSimpleStrategy | A SimpleStrategy is just nbTry long run |
| CSimpleStrategyParam | Helper structure encapsulating the parameters of the simple strategy |
| CSimulAlgo | Implementation of the SimulAlgo learning algorithm |
| CSinesCoefficients | SinesCoefficients class allows to compute the coefficients of a sampled function using sines basis functions |
| CSinOp | Template functor which compute the sine of a number |
| CSparseIteratorBase | IteratorBase is a base class for all iterators on dense arrays/matrix/vector/expressions |
| CSqrtOp | Template functor which compute the square root of a number |
| CSquareOp | Template functor which compute the square of a number |
| CStaticAssert | |
| CStaticAssert< false > | |
| CStaticAssert< true > | |
| CStrategyFacade | Facade design pattern |
| CStructuredCAllocator | Base class for the general by_col_ structured case |
| CStructuredCAllocator< Derived, 1, 1 > | Specialization for the number_ case |
| CStructuredCAllocator< Derived, 1, SizeCols_ > | Specialization for the point_ case (derived class is a RowVector) |
| CStructuredCAllocator< Derived, SizeRows_, 1 > | Specialization for the vector_ case |
| CSubAccessor | Generic expression when the sub-part of an expression is accessed |
| CSubOperator | Generic expression when the sub-part of an expression is accessed |
| CSubstractToOp | Template functor to subtract a number to a fixed value |
| CSubVectorAccessor | |
| CSubVectorAccessorBase | |
| CSubVectorAccessorBase< Lhs, Size_, Arrays::diagonal_ > | |
| CSubVectorAccessorBase< Lhs, Size_, Arrays::point_ > | |
| CSubVectorAccessorBase< Lhs, Size_, Arrays::vector_ > | |
| CSubVectorOperator | Generic expression when the sub-part of an expression is accessed (specialization for vectors) |
| CSubVectorOperatorBase | Specialization for point_ |
| CSubVectorOperatorBase< Lhs, Size_, Arrays::diagonal_ > | |
| CSubVectorOperatorBase< Lhs, Size_, Arrays::point_ > | |
| CSubVectorOperatorBase< Lhs, Size_, Arrays::vector_ > | |
| CSumOp | Template functor which compute the sum of two numbers |
| CSumWithOp | Template functor to add a number to a fixed value |
| CSvd | The class Svd compute the Singular Value Decomposition of a Array with the Golub-Reinsch Algorithm |
| CSymEigen | The class SymEigen compute the eigenvalue Decomposition of a symmetric ArrayXX |
| CSymmetrizeAccessor | Generic expression when we want to get the upper-part of a two-dimensional symmetric expression |
| CSymmetrizeOperator | Generic expression when we want to get the upper-part of a two-dimensional symmetric expression |
| CTanOp | Template functor which compute the tan of a number |
| CTestEndOfLineOp | Template functor testing if a Char is an end of line |
| CTRange | Index sub-vector region with fixed size |
| CTRange< UnknownSize > | Index sub-vector region: Specialization when the size is unknown |
| CTransposeAccessor | Generic expression when an expression is transposed |
| CTransposeOperator | Generic expression when an expression is transposed |
| CTReadWriteCsv | TReadWriteCsv class : allow to write and/or to read a csv file |
| CTRef | Base class for all referencing containers |
| CTRef< 0 > | |
| CTRef< 1 > | |
| CTRef<-1 > | |
| CTrigonometricCoefficients | TrigonometricCoefficients class allows to compute the coefficients of a sampled function using sines and cosines basis functions |
| CUnaryOperator | Generic expression when unary operator is applied to an expression |
| CUnaryOperatorBase | |
| CUpperSymmetrizeAccessor | Generic expression when we want to get the upper-part of a two-dimensional symmetric expression |
| CUpperSymmetrizeOperator | Generic expression when we want to get the upper-part of a two-dimensional symmetric expression |
| CUpperTriangularizeAccessor | Generic expression when we want to get the upper-part of a two-dimensional expression |
| CUpperTriangularizeOperator | Generic expression when we want to get the upper-part of a two-dimensional expression |
| CVariable | Variable is an implementation of the Base class IVariable using The Array1D class for storing the data |
| CVectorByPointProduct | Generic expression where a product operator is applied to two expressions |
| CVisitorByCol | Class allowing to apply a visitor on each columns of an expression |
| CVisitorByColBase | |
| CVisitorByRow | Class allowing to apply a visitor on each columns of an expression |
| CWeightedSvd | This class perform a weighted svd decomposition |
| CXemStrategy | A XemStrategy is based on the following paradigm: |
| CXemStrategyParam | Helper structure encapsulating the parameters of the Xem strategy |
| CMTRand | Generate unsigner 32 bits random number using the Merdsenne Twister Algorithm |
1.9.8