Class Hierarchy

Go to the graphical class hierarchy

This inheritance list is sorted roughly, but not completely, alphabetically:

[detail level 123456]

CSTK::AbsOp< Type >	Template functor which compute the absolute value of a number
CSTK::AcosOp< Type >	Template functor which compute the arc cosine of a number
CSTK::hidden::AlgebraTraits< Derived >	Traits class for the algebra methods
CSTK::hidden::AlgebraTraits< InvertMatrix< Matrix, Size_ > >	Specialization for matrix inversion methods
CSTK::hidden::AlgebraTraits< lapack::MultiLeastSquare< ArrayB_, ArrayA_ > >	Specialization for the lapack::MultiLeastSquare class
CSTK::hidden::AlgebraTraits< lapack::Qr >	Specialization for the Qr class
CSTK::hidden::AlgebraTraits< lapack::Svd >	Specialization for the Svd class
CSTK::hidden::AlgebraTraits< lapack::SymEigen< SquareArray_ > >	Specialization for the lapack::SymEigen class
CSTK::hidden::AlgebraTraits< MultiLeastSquare< ArrayB, ArrayA > >
CSTK::hidden::AlgebraTraits< MultiLeastSquare< ArrayB_, ArrayA_ > >	Specialization for the MultiLeastSquare class
CSTK::hidden::AlgebraTraits< Qr >	Specialization for the Qr class
CSTK::hidden::AlgebraTraits< Svd >
CSTK::hidden::AlgebraTraits< Svd< Array > >
CSTK::hidden::AlgebraTraits< Svd< Array_ > >	Specialization for the Svd class
CSTK::hidden::AlgebraTraits< SymEigen< SquareArray_ > >	Specialization for the Qr class
CSTK::hidden::AlgebraTraits< WeightedSvd< Array, WRows, WCols > >
CSTK::hidden::AlgebraTraits< WeightedSvd< Array_, WRows, WCols > >	Specialization for the WeightedSvd class
CSTK::hidden::AllVisitor< Type_ >	Visitor checking if all the elements of an array are different from zero
CSTK::hidden::AnyVisitor< Type_ >	Visitor checking if at least, one element of an array is different from zero
CSTK::ApplyFunctor< Derived, Functor >	Class allowing applying the functor Functor on a vector or row-vector
CSTK::ApplyFunctorByCol< Derived, Functor >	Class allowing to apply the Functor Functor on each columns of an expression
CSTK::ApplyFunctorByRow< Derived, Functor >	Class allowing to apply the Functor Functor on each rows of an expression
CSTK::ApplyVisitor< Derived, Visitor >	Class allowing to apply a visitor on a vector or a point
CSTK::ApplyWeightedFunctor< Derived, Functor >	Class allowing applying the weighted functor Functor on a vector or row-vector
CSTK::ApplyWeightedFunctorByCol< Derived, Functor >	Class allowing to apply the weighted Functor Functor on each columns of an expression
CSTK::ApplyWeightedFunctorByRow< Derived, Functor >	Class allowing to apply the Functor Functor on each rows of an expression
CSTK::ArrayInitializer< Derived >	Helper class used by the comma initializer operator
CSTK::AsinOp< Type >	Template functor which compute the arc sine of a number
CSTK::Bernoulli_pjParameters	Structure encapsulating the parameters of a Joint Bernoulli model
CSTK::hidden::BinaryColsImpl< Lhs, Rhs, Size_, useForCols_ >	Implement the access to the columns of the BinaryOperator Possible cases are:
CSTK::hidden::BinaryColsImpl< Lhs, Rhs, Size_, Arrays::useLhsOtherSize_ >	Specialization for the case useLhsOtherSize_
CSTK::hidden::BinaryColsImpl< Lhs, Rhs, Size_, Arrays::useLhsSize_ >	Specialization for the case useLhsSize_
CSTK::hidden::BinaryColsImpl< Lhs, Rhs, Size_, Arrays::useRhsOtherSize_ >	Specialization for the case useRhsOtherSize_
CSTK::hidden::BinaryColsImpl< Lhs, Rhs, Size_, Arrays::useRhsSize_ >	Specialization for the case useRhsSize_
CSTK::hidden::BinaryEltImpl< FunctorOp, Lhs, Rhs, LStructure_, RStructure_ >	Helper class giving the Structure of a binary operator
CSTK::hidden::BinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::array2D_, Arrays::array2D_ >
CSTK::hidden::BinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::array2D_, Arrays::diagonal_ >
CSTK::hidden::BinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::array2D_, Arrays::lower_symmetric_ >
CSTK::hidden::BinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::array2D_, Arrays::lower_triangular_ >
CSTK::hidden::BinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::array2D_, Arrays::square_ >
CSTK::hidden::BinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::array2D_, Arrays::symmetric_ >
CSTK::hidden::BinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::array2D_, Arrays::upper_symmetric_ >
CSTK::hidden::BinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::array2D_, Arrays::upper_triangular_ >
CSTK::hidden::BinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::diagonal_, Arrays::array2D_ >
CSTK::hidden::BinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::diagonal_, Arrays::diagonal_ >
CSTK::hidden::BinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::diagonal_, Arrays::lower_symmetric_ >
CSTK::hidden::BinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::diagonal_, Arrays::lower_triangular_ >
CSTK::hidden::BinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::diagonal_, Arrays::point_ >
CSTK::hidden::BinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::diagonal_, Arrays::square_ >
CSTK::hidden::BinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::diagonal_, Arrays::symmetric_ >
CSTK::hidden::BinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::diagonal_, Arrays::upper_symmetric_ >
CSTK::hidden::BinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::diagonal_, Arrays::upper_triangular_ >
CSTK::hidden::BinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::diagonal_, Arrays::vector_ >
CSTK::hidden::BinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::lower_symmetric_, Arrays::array2D_ >
CSTK::hidden::BinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::lower_symmetric_, Arrays::diagonal_ >
CSTK::hidden::BinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::lower_symmetric_, Arrays::lower_symmetric_ >
CSTK::hidden::BinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::lower_symmetric_, Arrays::lower_triangular_ >
CSTK::hidden::BinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::lower_symmetric_, Arrays::square_ >
CSTK::hidden::BinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::lower_symmetric_, Arrays::symmetric_ >
CSTK::hidden::BinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::lower_symmetric_, Arrays::upper_symmetric_ >
CSTK::hidden::BinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::lower_symmetric_, Arrays::upper_triangular_ >
CSTK::hidden::BinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::lower_triangular_, Arrays::array2D_ >
CSTK::hidden::BinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::lower_triangular_, Arrays::diagonal_ >
CSTK::hidden::BinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::lower_triangular_, Arrays::lower_symmetric_ >
CSTK::hidden::BinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::lower_triangular_, Arrays::lower_triangular_ >
CSTK::hidden::BinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::lower_triangular_, Arrays::square_ >
CSTK::hidden::BinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::lower_triangular_, Arrays::symmetric_ >
CSTK::hidden::BinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::lower_triangular_, Arrays::upper_symmetric_ >
CSTK::hidden::BinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::lower_triangular_, Arrays::upper_triangular_ >
CSTK::hidden::BinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::number_, Arrays::number_ >
CSTK::hidden::BinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::point_, Arrays::diagonal_ >
CSTK::hidden::BinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::point_, Arrays::point_ >
CSTK::hidden::BinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::point_, Arrays::vector_ >
CSTK::hidden::BinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::square_, Arrays::array2D_ >
CSTK::hidden::BinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::square_, Arrays::diagonal_ >
CSTK::hidden::BinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::square_, Arrays::lower_symmetric_ >
CSTK::hidden::BinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::square_, Arrays::lower_triangular_ >
CSTK::hidden::BinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::square_, Arrays::square_ >
CSTK::hidden::BinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::square_, Arrays::symmetric_ >
CSTK::hidden::BinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::square_, Arrays::upper_symmetric_ >
CSTK::hidden::BinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::square_, Arrays::upper_triangular_ >
CSTK::hidden::BinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::symmetric_, Arrays::array2D_ >
CSTK::hidden::BinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::symmetric_, Arrays::diagonal_ >
CSTK::hidden::BinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::symmetric_, Arrays::lower_symmetric_ >
CSTK::hidden::BinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::symmetric_, Arrays::lower_triangular_ >
CSTK::hidden::BinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::symmetric_, Arrays::square_ >
CSTK::hidden::BinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::symmetric_, Arrays::symmetric_ >
CSTK::hidden::BinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::symmetric_, Arrays::upper_symmetric_ >
CSTK::hidden::BinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::symmetric_, Arrays::upper_triangular_ >
CSTK::hidden::BinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::upper_symmetric_, Arrays::array2D_ >
CSTK::hidden::BinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::upper_symmetric_, Arrays::diagonal_ >
CSTK::hidden::BinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::upper_symmetric_, Arrays::lower_symmetric_ >
CSTK::hidden::BinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::upper_symmetric_, Arrays::lower_triangular_ >
CSTK::hidden::BinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::upper_symmetric_, Arrays::square_ >
CSTK::hidden::BinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::upper_symmetric_, Arrays::symmetric_ >
CSTK::hidden::BinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::upper_symmetric_, Arrays::upper_symmetric_ >
CSTK::hidden::BinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::upper_symmetric_, Arrays::upper_triangular_ >
CSTK::hidden::BinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::upper_triangular_, Arrays::array2D_ >
CSTK::hidden::BinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::upper_triangular_, Arrays::diagonal_ >
CSTK::hidden::BinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::upper_triangular_, Arrays::lower_symmetric_ >
CSTK::hidden::BinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::upper_triangular_, Arrays::lower_triangular_ >
CSTK::hidden::BinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::upper_triangular_, Arrays::square_ >
CSTK::hidden::BinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::upper_triangular_, Arrays::symmetric_ >
CSTK::hidden::BinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::upper_triangular_, Arrays::upper_symmetric_ >
CSTK::hidden::BinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::upper_triangular_, Arrays::upper_triangular_ >
CSTK::hidden::BinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::vector_, Arrays::diagonal_ >
CSTK::hidden::BinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::vector_, Arrays::point_ >
CSTK::hidden::BinaryEltImpl< FunctorOp, Lhs, Rhs, Arrays::vector_, Arrays::vector_ >
CSTK::hidden::BinaryReturnArray2DType< Type, LhsStructure_, RhsStructure_ >	Helper class to get the correct returned Structure of Functors
CSTK::hidden::BinaryReturnArray2DType< Type, Arrays::array2D_, Arrays::array2D_ >
CSTK::hidden::BinaryReturnArray2DType< Type, Arrays::array2D_, Arrays::diagonal_ >
CSTK::hidden::BinaryReturnArray2DType< Type, Arrays::array2D_, Arrays::lower_triangular_ >
CSTK::hidden::BinaryReturnArray2DType< Type, Arrays::array2D_, Arrays::square_ >
CSTK::hidden::BinaryReturnArray2DType< Type, Arrays::array2D_, Arrays::upper_triangular_ >
CSTK::hidden::BinaryReturnArray2DType< Type, Arrays::diagonal_, Arrays::array2D_ >
CSTK::hidden::BinaryReturnArray2DType< Type, Arrays::diagonal_, Arrays::diagonal_ >
CSTK::hidden::BinaryReturnArray2DType< Type, Arrays::diagonal_, Arrays::lower_triangular_ >
CSTK::hidden::BinaryReturnArray2DType< Type, Arrays::diagonal_, Arrays::square_ >
CSTK::hidden::BinaryReturnArray2DType< Type, Arrays::diagonal_, Arrays::upper_triangular_ >
CSTK::hidden::BinaryReturnArray2DType< Type, Arrays::lower_triangular_, Arrays::array2D_ >
CSTK::hidden::BinaryReturnArray2DType< Type, Arrays::lower_triangular_, Arrays::diagonal_ >
CSTK::hidden::BinaryReturnArray2DType< Type, Arrays::lower_triangular_, Arrays::lower_triangular_ >
CSTK::hidden::BinaryReturnArray2DType< Type, Arrays::lower_triangular_, Arrays::square_ >
CSTK::hidden::BinaryReturnArray2DType< Type, Arrays::lower_triangular_, Arrays::upper_triangular_ >
CSTK::hidden::BinaryReturnArray2DType< Type, Arrays::square_, Arrays::array2D_ >
CSTK::hidden::BinaryReturnArray2DType< Type, Arrays::square_, Arrays::diagonal_ >
CSTK::hidden::BinaryReturnArray2DType< Type, Arrays::square_, Arrays::lower_triangular_ >
CSTK::hidden::BinaryReturnArray2DType< Type, Arrays::square_, Arrays::square_ >
CSTK::hidden::BinaryReturnArray2DType< Type, Arrays::square_, Arrays::upper_triangular_ >
CSTK::hidden::BinaryReturnArray2DType< Type, Arrays::upper_triangular_, Arrays::array2D_ >
CSTK::hidden::BinaryReturnArray2DType< Type, Arrays::upper_triangular_, Arrays::diagonal_ >
CSTK::hidden::BinaryReturnArray2DType< Type, Arrays::upper_triangular_, Arrays::lower_triangular_ >
CSTK::hidden::BinaryReturnArray2DType< Type, Arrays::upper_triangular_, Arrays::square_ >
CSTK::hidden::BinaryReturnArray2DType< Type, Arrays::upper_triangular_, Arrays::upper_triangular_ >
CSTK::hidden::BinaryReturnArray2DType< typenamehidden::Promote< typenamehidden::Traits< Lhs >::Type, typenamehidden::Traits< Rhs >::Type >::result_type, hidden::Traits< Lhs >::structure_, hidden::Traits< Rhs >::structure_ >
CSTK::hidden::BinaryRowsImpl< Lhs, Rhs, Size_, useForRows_ >	Implement the access to the rows of the BinaryOperator Possible cases are:
CSTK::hidden::BinaryRowsImpl< Lhs, Rhs, Size_, Arrays::useLhsOtherSize_ >	Specialization for the case useLhsOtherSize_
CSTK::hidden::BinaryRowsImpl< Lhs, Rhs, Size_, Arrays::useLhsSize_ >	Specialization for the case useLhsSize_
CSTK::hidden::BinaryRowsImpl< Lhs, Rhs, Size_, Arrays::useRhsOtherSize_ >	Specialization for the case useRhsOtherSize_
CSTK::hidden::BinaryRowsImpl< Lhs, Rhs, Size_, Arrays::useRhsSize_ >	Specialization for the case useRhsSize_
CSTK::BitwiseAndOp< Type1, Type2 >	Template functor which compute the bitwise and of two numbers
CSTK::BitwiseAndWithOp< Type >	Template functor to compute the bitwise and with a fixed value
CSTK::BitwiseOrOp< Type1, Type2 >	Template functor which compute the bitwise or of two numbers
CSTK::BitwiseOrWithOp< Type >	Template functor to compute the bitwise or with a fixed value
CSTK::BitwiseXorOp< Type1, Type2 >	Template functor which compute the bitwise xor of two numbers
CSTK::BitwiseXorWithOp< Type >	Template functor to compute the bitwise xor with a fixed value
CSTK::Stat::Bivariate< XTYPE, YTYPE, TContainer1D >	Computation of the bivariate Statistics of two Variables
CSTK::hidden::Block< Type >	This structure encapsulate the data allocated for a block
CSTK::hidden::BlockByPanel< Lhs, Rhs, Result >	Methods to use for C=AB with A divided in blocks and B divided in panels
CSTK::hidden::BlockPanelProduct< Lhs, Rhs, Result >	Methods to use for C=AB with A divided in blocks and B divided in panels
CSTK::hidden::bv< Lhs, Rhs, Result >	Methods to use for C=AV with A a general matrix and V a vector
CSTK::CastOp< Type, OtherType >	Template functor which cast a type to another type
CSTK::Law::CdfcOp< Type >	,
CSTK::Law::CdfOp< Type >	,
►CSTK::CellBase< Type >	Template Base class for the Cell in a list
►CSTK::CellHo< Type >	Template class for the Horizontal Cell of a Horizontal List
CSTK::Cell2D< Type >	Template class for the 2 Dimensional Cells
►CSTK::CellVe< Type >	Template class for the Vertical Cell of a Vertical List
CSTK::Cell2D< Type >	Template class for the 2 Dimensional Cells
CSTK::CG< MultFunctor, ColVector, InitFunctor >	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
CSTK::hidden::CheckShift< Derived, Structure_ >	Utility class allowing to know if in an assignment the destination must be resized or shifted
CSTK::hidden::CheckShift< Derived, Arrays::array2D_ >	Specialization for general array2D_
CSTK::hidden::CheckShift< Derived, Arrays::diagonal_ >	Specialization for diagonal_
CSTK::hidden::CheckShift< Derived, Arrays::lower_triangular_ >	Specialization for lower_triangular_
CSTK::hidden::CheckShift< Derived, Arrays::number_ >
CSTK::hidden::CheckShift< Derived, Arrays::point_ >
CSTK::hidden::CheckShift< Derived, Arrays::square_ >	Specialization for square_
CSTK::hidden::CheckShift< Derived, Arrays::upper_triangular_ >	Specialization for upper_triangular_
CSTK::hidden::CheckShift< Derived, Arrays::vector_ >
CSTK::Stat::ConfusionMatrix< TrueArray, PredArray >	Class computing the confusion matrix given two vectors of integer
CSTK::hidden::Copycat< Derived, Rhs, TStructure_, RhsStructure_ >	Copycat to use at compile time
CSTK::hidden::Copycat< Lhs, Rhs, Arrays::array2D_, Arrays::array2D_ >
CSTK::hidden::Copycat< Lhs, Rhs, Arrays::array2D_, Arrays::diagonal_ >
CSTK::hidden::Copycat< Lhs, Rhs, Arrays::array2D_, Arrays::lower_symmetric_ >
CSTK::hidden::Copycat< Lhs, Rhs, Arrays::array2D_, Arrays::lower_triangular_ >
CSTK::hidden::Copycat< Lhs, Rhs, Arrays::array2D_, Arrays::point_ >
CSTK::hidden::Copycat< Lhs, Rhs, Arrays::array2D_, Arrays::square_ >
CSTK::hidden::Copycat< Lhs, Rhs, Arrays::array2D_, Arrays::symmetric_ >
CSTK::hidden::Copycat< Lhs, Rhs, Arrays::array2D_, Arrays::upper_symmetric_ >
CSTK::hidden::Copycat< Lhs, Rhs, Arrays::array2D_, Arrays::upper_triangular_ >
CSTK::hidden::Copycat< Lhs, Rhs, Arrays::array2D_, Arrays::vector_ >
CSTK::hidden::Copycat< Lhs, Rhs, Arrays::diagonal_, Arrays::diagonal_ >
CSTK::hidden::Copycat< Lhs, Rhs, Arrays::diagonal_, Arrays::point_ >
CSTK::hidden::Copycat< Lhs, Rhs, Arrays::diagonal_, Arrays::vector_ >
CSTK::hidden::Copycat< Lhs, Rhs, Arrays::lower_triangular_, Arrays::lower_triangular_ >
CSTK::hidden::Copycat< Lhs, Rhs, Arrays::number_, Arrays::number_ >
CSTK::hidden::Copycat< Lhs, Rhs, Arrays::point_, Arrays::diagonal_ >
CSTK::hidden::Copycat< Lhs, Rhs, Arrays::point_, Arrays::point_ >
CSTK::hidden::Copycat< Lhs, Rhs, Arrays::point_, Arrays::vector_ >
CSTK::hidden::Copycat< Lhs, Rhs, Arrays::square_, Arrays::array2D_ >
CSTK::hidden::Copycat< Lhs, Rhs, Arrays::square_, Arrays::diagonal_ >
CSTK::hidden::Copycat< Lhs, Rhs, Arrays::square_, Arrays::lower_symmetric_ >
CSTK::hidden::Copycat< Lhs, Rhs, Arrays::square_, Arrays::lower_triangular_ >
CSTK::hidden::Copycat< Lhs, Rhs, Arrays::square_, Arrays::square_ >
CSTK::hidden::Copycat< Lhs, Rhs, Arrays::square_, Arrays::symmetric_ >
CSTK::hidden::Copycat< Lhs, Rhs, Arrays::square_, Arrays::upper_symmetric_ >
CSTK::hidden::Copycat< Lhs, Rhs, Arrays::square_, Arrays::upper_triangular_ >
CSTK::hidden::Copycat< Lhs, Rhs, Arrays::upper_triangular_, Arrays::upper_triangular_ >
CSTK::hidden::Copycat< Lhs, Rhs, Arrays::vector_, Arrays::diagonal_ >
CSTK::hidden::Copycat< Lhs, Rhs, Arrays::vector_, Arrays::point_ >
CSTK::hidden::Copycat< Lhs, Rhs, Arrays::vector_, Arrays::vector_ >
CSTK::hidden::CopycatSelector< Lhs, Rhs, TOrient_ >	Utility class that select if the copy will be by row or by column
CSTK::hidden::CopycatSelector< Lhs, Rhs, Arrays::by_col_ >	Specialization for column oriented arrrays
CSTK::hidden::CopycatSelector< Lhs, Rhs, Arrays::by_row_ >	Specialization for row oriented arrays
CSTK::hidden::CopySubArrayImpl< Array, Type >	This structure regroup the methods to used for copying part of an array in a Block or a Panel
CSTK::CosOp< Type >	Template functor which compute the cosine of a number
CSTK::hidden::CountVisitor< Type_ >	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
CSTK::hidden::CSlice< Derived, SizeRows, SizeCols >	The traits struct CSlice allows to disambiguate return type of the col/row/sub operators for CArray family
CSTK::hidden::CSliceDispatcher< Derived, Size >	Helper allowing to disambiguate SubVector access
CSTK::hidden::CsvToArrayImpl< Type, Array >	Implementation of CsvToArray
CSTK::hidden::CsvToArrayImpl< String, Array2D< OtherType > >
CSTK::hidden::CsvToArrayImpl< Type, Array2D< Type > >
CSTK::hidden::CsvToArrayImpl< Type, CArray< Type > >
CSTK::CubeOp< Type >	Template functor which compute the cube of a number
CSTK::DataFrameToArray2D< Type >	The DataFrameToArray2D class allow to export the data of some TYPE stored in a DataFrame to be exported in an Array2D
CSTK::hidden::DataHandlerTraits< DataHandler, Type >	The DataHandlerTraits will give the type of container furnished by the concrete implementations of the DataHandlerBase class
CSTK::hidden::DataHandlerTraits< DataHandler, Type >	Specialization of the DataHandlerTraits for DataHandler
CSTK::hidden::DataHandlerTraits< KernelHandler, Type >	Specialization of the DataHandlerTraits struct for KernelHandler
CSTK::DefaultFunctor< ColVector >
CSTK::DiagGaussian_muj_sjParameters	Structure encapsulating the parameters of a DiagGaussian_muj_sj model
CSTK::hidden::DiagonalRangeImpl< Lhs, Size_, use_ >	Allow to disambiguate the call to range to use
CSTK::hidden::DiagonalRangeImpl< Lhs, Size_, Arrays::useLhsOtherSize_ >
CSTK::hidden::DiagonalRangeImpl< Lhs, Size_, Arrays::useLhsSize_ >
CSTK::Arrays::DifferenceOp< Lhs, Rhs >	Array difference (by coefficient) Perform the matrix difference coefficient by coefficient of the Array lhs by the Array rhs
CSTK::DifferenceOp< Type1, Type2 >	Template functor which compute the difference of two numbers
CSTK::DifferenceWithOp< Type >	Template functor to add a number to a fixed value
CSTK::hidden::DispatcherChooser< Matrix, Size_, structure_ >	Utility class allowing to choose the dispatcher for inversion matrix
CSTK::hidden::DispatcherChooser< Matrix, Size_, Arrays::array2D_ >	Specialization for general arrays
CSTK::hidden::DispatcherChooser< Matrix, Size_, Arrays::lower_symmetric_ >
CSTK::hidden::DispatcherChooser< Matrix, Size_, Arrays::lower_triangular_ >	Specialization for upper triangular arrays
CSTK::hidden::DispatcherChooser< Matrix, Size_, Arrays::square_ >	Specialization for square arrays
CSTK::hidden::DispatcherChooser< Matrix, Size_, Arrays::symmetric_ >	Specialization for symmetric arrays
CSTK::hidden::DispatcherChooser< Matrix, Size_, Arrays::upper_symmetric_ >	Specialization for symmetric arrays
CSTK::hidden::DispatcherChooser< Matrix, Size_, Arrays::upper_triangular_ >	Specialization for upper triangular arrays
CSTK::DivisionOp< Type1, Type2 >	Template functor which compute the division of two numbers
CSTK::DivisionWithBaseOp< Type, IsInt >	Base class for DivisionWithOp functors
CSTK::DivisionWithBaseOp< Type, false >
►CSTK::DivisionWithBaseOp< Type, hidden::IsInt< Type >::yes >
CSTK::DivisionWithOp< Type >	Template functor to divide a number by a fixed value
CSTK::DivisionWithBaseOp< Type, true >
CSTK::Arrays::DivOp< Lhs, Rhs >	Matricial Division
CSTK::hidden::EltVisitor2DBase< Type_ >	Base class to implement min, max, sum,... visitors for 2D containers
►CSTK::hidden::EltVisitor2DBase< Type >
CSTK::hidden::MaxEltSafeVisitor< Type >	Visitor computing safely the maximal coefficient of the Array
CSTK::hidden::MaxEltVisitor< Type >	Visitor computing the maximal coefficient of the Array
CSTK::hidden::MinEltSafeVisitor< Type >	Visitor computing safely the minimal coefficient with its value and indexes
CSTK::hidden::MinEltVisitor< Type >	Visitor computing the min coefficient with its value and coordinates
CSTK::EqualOp< Type1, Type2 >	Template functor testing if a number is equal to an other number
CSTK::EqualWithOp< Type >	Template functor to test if a number is equal to a fixed value
►CSTK::Exception	Sdk class for all library Exceptions
►CSTK::logic_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)
CSTK::domain_error	Thrown by the library, or by you, to report domain errors (domain in the mathematical sense)
CSTK::invalid_argument	Thrown to report invalid arguments to functions
CSTK::length_error	Thrown when an object is constructed that would exceed its maximum permitted size (e.g., a basic_String instance)
CSTK::out_of_range	This represents an argument whose value is not within the expected range (e.g., boundary checks in basic_String)
►CSTK::runtime_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
CSTK::range_error	Thrown to indicate range errors in internal computations
CSTK::ExpOp< Type >	Template functor which compute the exponential of a number
CSTK::ExportToCsv	Export data to a Csv
CSTK::hidden::FalseType
CSTK::FullStrategyParam	Helper structure encapsulating the parameters of the Full strategy
CSTK::hidden::FunctorParamTraits< Functor, NbParam_ >	Produce the Nth parameter type of Functor
CSTK::hidden::FunctorReturnTypeTraits< Functor >	Produce the return type of the Functor
CSTK::hidden::FunctorSelector< Derived, Functor, isVector_ >	,
CSTK::hidden::FunctorSelector< Derived, Functor, false >	Specialization for general arrays: apply functor to rows or columns of the Derived array
CSTK::hidden::FunctorSelector< Derived, Functor, true >	Specialization for vectors and points
CSTK::hidden::FunctorTraits< Derived, Functor >	, Utility class that will select the type of operator to apply
CSTK::GeqOp< Type1, Type2 >	Template functor testing if a number is greater or equal than an other number
CSTK::GeqThanOp< Type >	Template functor to test if a number is greater or equal than a fixed value
CSTK::hidden::GetIdx< Visitor, Structure_ >	Utility class for getting the result from a visitor acting on a vector or a point
CSTK::hidden::GetIdx< Visitor, Arrays::diagonal_ >
CSTK::hidden::GetIdx< Visitor, Arrays::point_ >
CSTK::hidden::GetIdx< Visitor, Arrays::vector_ >
CSTK::GreaterOp< Type1, Type2 >	Template functor testing if a number is greater than an other number
CSTK::GreaterThanOp< Type >	Template functor to test if a number is greater than a fixed value
CSTK::hidden::HDCovarianceChooser< Id >
CSTK::hidden::HDCovarianceChooser< Clust::HDCovariance_ABkQD_ >
CSTK::hidden::HDCovarianceChooser< Clust::HDCovariance_ABkQDk_ >
CSTK::hidden::HDCovarianceChooser< Clust::HDCovariance_ABkQkD_ >
CSTK::hidden::HDCovarianceChooser< Clust::HDCovariance_ABkQkDk_ >
CSTK::hidden::HDCovarianceChooser< Clust::HDCovariance_ABQkD_ >
CSTK::hidden::HDCovarianceChooser< Clust::HDCovariance_ABQkDk_ >
CSTK::hidden::HDCovarianceChooser< Clust::HDCovariance_AjBkQD_ >
CSTK::hidden::HDCovarianceChooser< Clust::HDCovariance_AjBkQDk_ >
CSTK::hidden::HDCovarianceChooser< Clust::HDCovariance_AjBkQkD_ >
CSTK::hidden::HDCovarianceChooser< Clust::HDCovariance_AjBkQkDk_ >
CSTK::hidden::HDCovarianceChooser< Clust::HDCovariance_AjBQkD_ >
CSTK::hidden::HDCovarianceChooser< Clust::HDCovariance_AjBQkDk_ >
CSTK::hidden::HDCovarianceChooser< Clust::HDCovariance_AjkBkQD_ >
CSTK::hidden::HDCovarianceChooser< Clust::HDCovariance_AjkBkQDk_ >
CSTK::hidden::HDCovarianceChooser< Clust::HDCovariance_AjkBkQkD_ >
CSTK::hidden::HDCovarianceChooser< Clust::HDCovariance_AjkBkQkDk_ >
CSTK::hidden::HDCovarianceChooser< Clust::HDCovariance_AjkBQD_ >
CSTK::hidden::HDCovarianceChooser< Clust::HDCovariance_AjkBQDk_ >
CSTK::hidden::HDCovarianceChooser< Clust::HDCovariance_AjkBQkD_ >
CSTK::hidden::HDCovarianceChooser< Clust::HDCovariance_AjkBQkDk_ >
CSTK::hidden::HDCovarianceChooser< Clust::HDCovariance_AkBkQD_ >
CSTK::hidden::HDCovarianceChooser< Clust::HDCovariance_AkBkQDk_ >
CSTK::hidden::HDCovarianceChooser< Clust::HDCovariance_AkBkQkD_ >
CSTK::hidden::HDCovarianceChooser< Clust::HDCovariance_AkBkQkDk_ >
CSTK::hidden::HDCovarianceChooser< Clust::HDCovariance_AkBQD_ >
CSTK::hidden::HDCovarianceChooser< Clust::HDCovariance_AkBQDk_ >
CSTK::hidden::HDCovarianceChooser< Clust::HDCovariance_AkBQkD_ >
CSTK::hidden::HDCovarianceChooser< Clust::HDCovariance_AkBQkDk_ >
CSTK::HDMatrixModelParameters< Array_ >	Structure storing the parameters of the HD matrix valued mixture
►CSTK::IAAModel< Array >	@
►CSTK::GaussianAAModel< Array >	Gaussian Auto-Associative models
CSTK::LinearAAModel< Array >	A Linear AutoAssociative Model (LAAM) is a generalization of the PCA model for projecting variables on an affine plane of lower dimension
CSTK::Law::IcdfOp< Type >	,
►CSTK::IContainer2D< SizeRows_, SizeCols_ >	Interface base class for 2D containers
►CSTK::Const::IConstArray< Array< Type_, SizeRows_, SizeCols_ > >
CSTK::Const::Array< Type_, SizeRows_, SizeCols_ >	Define the constant general matrix
►CSTK::Const::IConstArray< Identity< Type_, Size_ > >
CSTK::Const::Identity< Type_, Size_ >	Define the constant identity matrix
►CSTK::Const::IConstArray< LowerTriangular< Type_, SizeRows_, SizeCols_ > >
CSTK::Const::LowerTriangular< Type_, SizeRows_, SizeCols_ >	Define the constant lower triangular matrix
►CSTK::Const::IConstArray< Point< Type_, Size_ > >
CSTK::Const::Point< Type_, Size_ >	Define the constant point
►CSTK::Const::IConstArray< Square< Type_, Size_ > >
CSTK::Const::Square< Type_, Size_ >	Define the constant square matrix
►CSTK::Const::IConstArray< UpperTriangular< Type_, SizeRows_, SizeCols_ > >
CSTK::Const::UpperTriangular< Type_, SizeRows_, SizeCols_ >	Define the constant upper triangular matrix
►CSTK::Const::IConstArray< Vector< Type_, Size_ > >
CSTK::Const::Vector< Type_, Size_ >	Define the constant point
►CSTK::IArray2D< Array2D< Type_ > >
CSTK::Array2D< Type_ >	Template two dimensional column (vertically) oriented Array
►CSTK::IArray2D< Array2DDiagonal< Type_ > >
CSTK::Array2DDiagonal< Type_ >	Derivation of the Array2DDiagonal class for square arrays of Real
►CSTK::IArray2D< Array2DLowerTriangular< Type_ > >
CSTK::Array2DLowerTriangular< Type_ >	Declaration of the lower triangular matrix class
►CSTK::IArray2D< Array2DNumber< Type_ > >
CSTK::Array2DNumber< Type_ >	Template number Array
►CSTK::IArray2D< Array2DPoint< Type_ > >
CSTK::Array2DPoint< Type_ >	Template one dimensional horizontal Array
►CSTK::IArray2D< Array2DSquare< Type_ > >
CSTK::Array2DSquare< Type_ >	Derivation of the Array2DSquare class for square arrays of Real
►CSTK::IArray2D< Array2DUpperTriangular< Type_ > >
CSTK::Array2DUpperTriangular< Type_ >	Declaration of the upper triangular matrix class
►CSTK::IArray2D< Array2DVector< Type_ > >
CSTK::Array2DVector< Type_ >	Template one dimensional horizontal Array
CSTK::IArray2D< Array2DPoint< int > >
CSTK::IArray2D< Array2DVector< Real > >
CSTK::IArray2D< Array2DUpperTriangular< Real > >
►CSTK::IArray2D< SArray2D< Type_ > >
CSTK::SArray2D< Type_ >	Template sparse two dimensional column (vertically) oriented Array
►CSTK::IArray2D< SArray2DDiagonal< Type_ > >
CSTK::SArray2DDiagonal< Type_ >	Derivation of the SArray2DDiagonal class for square arrays of Real
►CSTK::IArray2D< SArray2DLowerTriangular< Type_ > >
CSTK::SArray2DLowerTriangular< Type_ >	Declaration of the lower triangular matrix class
►CSTK::IArray2D< SArray2DNumber< Type_ > >
CSTK::SArray2DNumber< Type_ >	Template number Array
►CSTK::IArray2D< SArray2DPoint< Type_ > >
CSTK::SArray2DPoint< Type_ >	Template one dimensional horizontal Array
►CSTK::IArray2D< SArray2DSquare< Type_ > >
CSTK::SArray2DSquare< Type_ >	Derivation of the SArray2DSquare class for square arrays of Real
►CSTK::IArray2D< SArray2DUpperTriangular< Type_ > >
CSTK::SArray2DUpperTriangular< Type_ >	Declaration of the upper triangular matrix class
►CSTK::IArray2D< SArray2DVector< Type_ > >
CSTK::SArray2DVector< Type_ >	Template one dimensional horizontal Array
CSTK::IArray2D< Array2D< Real > >
CSTK::IArray2D< Array2D< Data::Type > >
CSTK::IArray2D< Array2DSquare< Real > >
CSTK::IArray2D< Array2DPoint< Real > >
CSTK::IArray2D< Array2D< int > >
CSTK::IArray2D< Array2DDiagonal< Real > >
CSTK::IArray2D< Array2DVector< Type > >
CSTK::IArray2D< Array2DVector< int > >
CSTK::IContainer2D< hidden::Traits< Array2D< Data::Type > >::sizeRows_, hidden::Traits< Array2D< Data::Type > >::sizeCols_ >
CSTK::IContainer2D< hidden::Traits< Array2D< int > >::sizeRows_, hidden::Traits< Array2D< int > >::sizeCols_ >
CSTK::IContainer2D< hidden::Traits< Array2D< Real > >::sizeRows_, hidden::Traits< Array2D< Real > >::sizeCols_ >
CSTK::IContainer2D< hidden::Traits< Array2D< Type_ > >::sizeRows_, hidden::Traits< Array2D< Type_ > >::sizeCols_ >
CSTK::IContainer2D< hidden::Traits< Array2DDiagonal< Real > >::sizeRows_, hidden::Traits< Array2DDiagonal< Real > >::sizeCols_ >
CSTK::IContainer2D< hidden::Traits< Array2DDiagonal< Type_ > >::sizeRows_, hidden::Traits< Array2DDiagonal< Type_ > >::sizeCols_ >
CSTK::IContainer2D< hidden::Traits< Array2DLowerTriangular< Type_ > >::sizeRows_, hidden::Traits< Array2DLowerTriangular< Type_ > >::sizeCols_ >
CSTK::IContainer2D< hidden::Traits< Array2DNumber< Type_ > >::sizeRows_, hidden::Traits< Array2DNumber< Type_ > >::sizeCols_ >
CSTK::IContainer2D< hidden::Traits< Array2DPoint< int > >::sizeRows_, hidden::Traits< Array2DPoint< int > >::sizeCols_ >
CSTK::IContainer2D< hidden::Traits< Array2DPoint< Real > >::sizeRows_, hidden::Traits< Array2DPoint< Real > >::sizeCols_ >
CSTK::IContainer2D< hidden::Traits< Array2DPoint< Type_ > >::sizeRows_, hidden::Traits< Array2DPoint< Type_ > >::sizeCols_ >
CSTK::IContainer2D< hidden::Traits< Array2DSquare< Real > >::sizeRows_, hidden::Traits< Array2DSquare< Real > >::sizeCols_ >
CSTK::IContainer2D< hidden::Traits< Array2DSquare< Type_ > >::sizeRows_, hidden::Traits< Array2DSquare< Type_ > >::sizeCols_ >
CSTK::IContainer2D< hidden::Traits< Array2DUpperTriangular< Real > >::sizeRows_, hidden::Traits< Array2DUpperTriangular< Real > >::sizeCols_ >
CSTK::IContainer2D< hidden::Traits< Array2DUpperTriangular< Type_ > >::sizeRows_, hidden::Traits< Array2DUpperTriangular< Type_ > >::sizeCols_ >
CSTK::IContainer2D< hidden::Traits< Array2DVector< int > >::sizeRows_, hidden::Traits< Array2DVector< int > >::sizeCols_ >
CSTK::IContainer2D< hidden::Traits< Array2DVector< Real > >::sizeRows_, hidden::Traits< Array2DVector< Real > >::sizeCols_ >
CSTK::IContainer2D< hidden::Traits< Array2DVector< Type > >::sizeRows_, hidden::Traits< Array2DVector< Type > >::sizeCols_ >
CSTK::IContainer2D< hidden::Traits< Array2DVector< Type_ > >::sizeRows_, hidden::Traits< Array2DVector< Type_ > >::sizeCols_ >
CSTK::IContainer2D< hidden::Traits< Array< Type_, SizeRows_, SizeCols_ > >::sizeRows_, hidden::Traits< Array< Type_, SizeRows_, SizeCols_ > >::sizeCols_ >
►CSTK::IContainer2D< hidden::Traits< Derived >::sizeRows_, hidden::Traits< Derived >::sizeCols_ >
CSTK::Const::IConstArray< Derived >
►CSTK::IArray2D< Derived >	Template interface base class for two-dimensional arrays
CSTK::Array2D< Real >
CSTK::Array2D< Data::Type >
CSTK::Array2D< int >
CSTK::Array2DDiagonal< Real >
CSTK::Array2DPoint< int >
CSTK::Array2DPoint< Real >
CSTK::Array2DSquare< Real >
CSTK::Array2DUpperTriangular< Real >
CSTK::Array2DVector< Real >
CSTK::Array2DVector< Type >
CSTK::Array2DVector< int >
►CSTK::ITContainer2D< Derived >	Interface base class for homogeneous 2D containers like allocators
►CSTK::CAllocatorBase< Derived >	Base class for CAllocators
CSTK::OrientedCAllocator< Derived, Arrays::by_col_ >	Specialization for column-oriented Allocators
CSTK::OrientedCAllocator< Derived, Arrays::by_row_ >	Specialization for row-oriented Allocators
CSTK::IContainer2D< hidden::Traits< Identity< Type_, Size_ > >::sizeRows_, hidden::Traits< Identity< Type_, Size_ > >::sizeCols_ >
CSTK::IContainer2D< hidden::Traits< LowerTriangular< Type_, SizeRows_, SizeCols_ > >::sizeRows_, hidden::Traits< LowerTriangular< Type_, SizeRows_, SizeCols_ > >::sizeCols_ >
CSTK::IContainer2D< hidden::Traits< Point< Type_, Size_ > >::sizeRows_, hidden::Traits< Point< Type_, Size_ > >::sizeCols_ >
CSTK::IContainer2D< hidden::Traits< SArray2D< Type_ > >::sizeRows_, hidden::Traits< SArray2D< Type_ > >::sizeCols_ >
CSTK::IContainer2D< hidden::Traits< SArray2DDiagonal< Type_ > >::sizeRows_, hidden::Traits< SArray2DDiagonal< Type_ > >::sizeCols_ >
CSTK::IContainer2D< hidden::Traits< SArray2DLowerTriangular< Type_ > >::sizeRows_, hidden::Traits< SArray2DLowerTriangular< Type_ > >::sizeCols_ >
CSTK::IContainer2D< hidden::Traits< SArray2DNumber< Type_ > >::sizeRows_, hidden::Traits< SArray2DNumber< Type_ > >::sizeCols_ >
CSTK::IContainer2D< hidden::Traits< SArray2DPoint< Type_ > >::sizeRows_, hidden::Traits< SArray2DPoint< Type_ > >::sizeCols_ >
CSTK::IContainer2D< hidden::Traits< SArray2DSquare< Type_ > >::sizeRows_, hidden::Traits< SArray2DSquare< Type_ > >::sizeCols_ >
CSTK::IContainer2D< hidden::Traits< SArray2DUpperTriangular< Type_ > >::sizeRows_, hidden::Traits< SArray2DUpperTriangular< Type_ > >::sizeCols_ >
CSTK::IContainer2D< hidden::Traits< SArray2DVector< Type_ > >::sizeRows_, hidden::Traits< SArray2DVector< Type_ > >::sizeCols_ >
CSTK::IContainer2D< hidden::Traits< Square< Type_, Size_ > >::sizeRows_, hidden::Traits< Square< Type_, Size_ > >::sizeCols_ >
CSTK::IContainer2D< hidden::Traits< UpperTriangular< Type_, SizeRows_, SizeCols_ > >::sizeRows_, hidden::Traits< UpperTriangular< Type_, SizeRows_, SizeCols_ > >::sizeCols_ >
CSTK::IContainer2D< hidden::Traits< Vector< Type_, Size_ > >::sizeRows_, hidden::Traits< Vector< Type_, Size_ > >::sizeCols_ >
►CSTK::IContainer2D< UnknownSize, UnknownSize >
CSTK::DataFrame	DataFrame is a List of Variable with the same number of rows
►CSTK::IDataBridge	Interface class wrapping a data set
CSTK::DataBridge< Data >	Bridge a data set in order to handle its missing values
CSTK::IDataHandler	A DataHandler class allow to store various data set identified with an idData (a string)
CSTK::IdTypeImpl< TYPE >	Implementation of the return type
CSTK::IdTypeImpl< Binary >	Specialization of the IdTypeImpl for the Type Binary
CSTK::IdTypeImpl< Char >	Specialization of the IdTypeImpl for the Type Char
CSTK::IdTypeImpl< Integer >	Specialization of the IdTypeImpl for the type Integer
CSTK::IdTypeImpl< Real >	Specialization of the IdTypeImpl for the Type Real
CSTK::IdTypeImpl< Sign >	Specialization of the IdTypeImpl for the Type Sign
CSTK::IdTypeImpl< String >	Specialization of the IdTypeImpl for the Type String
CSTK::IdTypeImpl< TRange< Size_ > >	Partial Specialization of the IdTypeImpl for the Type TRange
CSTK::hidden::If< Condition, Then, Else >
CSTK::hidden::If< false, Then, Else >
CSTK::hidden::If< true, Then, Else >
►CSTK::Law::ILawBase	Interface base class for all the (univariate/multivariate) probabilities laws
►CSTK::Law::IUnivLaw< Binary >
CSTK::Law::Bernoulli	Bernoulli probability law
►CSTK::Law::IUnivLaw< Real >
CSTK::Law::Beta	Beta distribution law
CSTK::Law::Cauchy	Cauchy distribution law
CSTK::Law::ChiSquared	ChiSquared distribution law
CSTK::Law::Empirical	Empirical distribution law
CSTK::Law::Exponential	Exponential distribution law
CSTK::Law::FisherSnedecor	FisherSnedecor distribution law
CSTK::Law::Gamma	Gamma distribution law
CSTK::Law::LogNormal	LogNormal distribution law
CSTK::Law::Logistic	Logistic distribution law
CSTK::Law::Normal	Normal distribution law
CSTK::Law::Student	Student distribution law
CSTK::Law::Uniform	Class for the Uniform law distribution
CSTK::Law::Weibull	Weibull distribution law
►CSTK::Law::IUnivLaw< Integer >
CSTK::Law::Binomial	Binomial probability law
CSTK::Law::Geometric	Geometric probability law
CSTK::Law::HyperGeometric	HyperGeometric probability law
CSTK::Law::NegativeBinomial	NegativeBinomial probability law
►CSTK::Law::IUnivLaw< int >
CSTK::Law::Categorical	Categorical probability law
CSTK::Law::Poisson	Poisson distribution law
CSTK::Law::UniformDiscrete	Class for the Uniform law distribution
CSTK::Law::IUnivLaw< Type >	Interface base class for all the univariate distributions
►CSTK::MultiLaw::IMultiLaw< RowVector >	Interface base Class for the multivariate distributions
►CSTK::MultiLaw::JointProbability< RowVector, Law::Bernoulli >
CSTK::MultiLaw::JointBernoulli< RowVector >	Implement the Joint Bernoulli probability law
►CSTK::MultiLaw::JointProbability< RowVector, Law::Cauchy >
CSTK::MultiLaw::JointCauchy< RowVector >	Implement the Joint Cauchy probability law
►CSTK::MultiLaw::JointProbability< RowVector, Law::Gamma >
CSTK::MultiLaw::JointGamma< RowVector >	Implement the Joint Gamma probability law
►CSTK::MultiLaw::JointProbability< RowVector, Law::Normal >
CSTK::MultiLaw::JointNormal< RowVector >	Implement the Joint Normal probability law
CSTK::MultiLaw::JointProbability< RowVector, Law >	Joint density class for the multivariate distributions
CSTK::MultiLaw::Normal< RowVector >	Class for the multivariate Normal distribution
►CSTK::IMixture	Interface base class for all the mixture models that will be processed by the composer
►CSTK::IMixtureBridge< CategoricalBridge< Id, Data > >
CSTK::CategoricalBridge< Id, Data >	Template implementation of the IMixtureBridge interface allowing to bridge a STK++ mixture with the composer
►CSTK::IMixtureBridge< DiagGaussianBridge< Id, Data > >
CSTK::DiagGaussianBridge< Id, Data >	Template implementation of the IMixture interface allowing to bridge a STK++ mixture with the composer
►CSTK::IMixtureBridge< GammaBridge< Id, Data > >
CSTK::GammaBridge< Id, Data >	Template implementation of the IMixtureBridge interface allowing to bridge a STK++ mixture with the composer
►CSTK::IMixtureBridge< HDGaussianBridge< Id, Data > >
CSTK::HDGaussianBridge< Id, Data >	Template implementation of the IMixture interface allowing to bridge a STK++ mixture with the composer
►CSTK::IMixtureBridge< HDMatrixGaussianBridge< IdRow, IdCol, Data > >
CSTK::HDMatrixGaussianBridge< IdRow, IdCol, Data >	Template implementation of the IMixture interface allowing to bridge a STK++ mixture with the composer
►CSTK::IMixtureBridge< KmmBridge< Id, Data > >
CSTK::KmmBridge< Id, Data >	Template implementation of the IMixture interface allowing to bridge a STK++ kernel mixture with the composer
►CSTK::IMixtureBridge< PoissonBridge< Id, Data > >
CSTK::PoissonBridge< Id, Data >	Template implementation of the IMixtureBridge interface allowing to bridge a STK++ Poisson mixture with the composer
CSTK::IMixtureBridge< Derived >	Interface base class for the bridges of the STK++ mixture
►CSTK::IMixtureModelBase	Base class for all Mixture model
CSTK::IMixtureModel< Derived >	Main interface class for mixture models
CSTK::InverseOp< Type >	Template functor which compute the inverse of a number
CSTK::hidden::InvertLowerSymMatrixDispatcher< Matrix, Size_ >	Computing the inverse of a lower symmetric matrix
CSTK::hidden::InvertLowerSymMatrixDispatcher< Matrix, 1 >
CSTK::hidden::InvertLowerSymMatrixDispatcher< Matrix, 2 >
CSTK::hidden::InvertLowerSymMatrixDispatcher< Matrix, 3 >
CSTK::hidden::InvertLowerSymMatrixDispatcher< Matrix, 4 >
CSTK::hidden::InvertLowerSymMatrixImpl< Matrix, Size_ >	Implementation of the computation of the inverse of a lower symmetric matrix
CSTK::hidden::InvertLowerTriangularDispatcher< Matrix, Size_ >	Utility class allowing to call the correct static function computing the inverse of a matrix
CSTK::hidden::InvertLowerTriangularDispatcher< Matrix, 1 >
CSTK::hidden::InvertLowerTriangularDispatcher< Matrix, 2 >
CSTK::hidden::InvertLowerTriangularDispatcher< Matrix, 3 >
CSTK::hidden::InvertLowerTriangularDispatcher< Matrix, 4 >
CSTK::hidden::InvertLowerTriangularImpl< Matrix, Size_ >	Implementation of the computation of the inverse of a lower triangular matrix
CSTK::InvertMatrix< Matrix, Size_ >	The InvertMatrix class is a functor class allowing to compute the inverse of a symmetric matrix
CSTK::hidden::InvertMatrixDispatcher< Matrix, Size_ >	Computing the inverse of a matrix
CSTK::hidden::InvertMatrixDispatcher< Matrix, 1 >
CSTK::hidden::InvertMatrixDispatcher< Matrix, 2 >
CSTK::hidden::InvertMatrixDispatcher< Matrix, 3 >
CSTK::hidden::InvertMatrixDispatcher< Matrix, 4 >
CSTK::hidden::InvertMatrixImpl< Matrix, Size_ >	Implementation of the inversion matrix method for general/square matrices
CSTK::hidden::InvertSymImpl< Matrix, Size_ >	Implementation of the computation of the inverse of a lower triangular matrix
CSTK::hidden::InvertSymMatrixDispatcher< Matrix, Size_ >	Computing the inverse of a symmetric matrix
CSTK::hidden::InvertSymMatrixDispatcher< Matrix, 1 >
CSTK::hidden::InvertSymMatrixDispatcher< Matrix, 2 >
CSTK::hidden::InvertSymMatrixDispatcher< Matrix, 3 >
CSTK::hidden::InvertSymMatrixDispatcher< Matrix, 4 >
CSTK::hidden::InvertUpperSymMatrixDispatcher< Matrix, Size_ >	Computing the inverse of a symmetric matrix
CSTK::hidden::InvertUpperSymMatrixDispatcher< Matrix, 1 >
CSTK::hidden::InvertUpperSymMatrixDispatcher< Matrix, 2 >
CSTK::hidden::InvertUpperSymMatrixDispatcher< Matrix, 3 >
CSTK::hidden::InvertUpperSymMatrixDispatcher< Matrix, 4 >
CSTK::hidden::InvertUpperSymMatrixImpl< Matrix, Size_ >	Implementation of the inversion matrix method for upper symmetric matrices
CSTK::hidden::InvertUpperTriangularDispatcher< Matrix, Size_ >	Computing the inverse of a matrix
CSTK::hidden::InvertUpperTriangularDispatcher< Matrix, 1 >
CSTK::hidden::InvertUpperTriangularDispatcher< Matrix, 2 >
CSTK::hidden::InvertUpperTriangularDispatcher< Matrix, 3 >
CSTK::hidden::InvertUpperTriangularDispatcher< Matrix, 4 >
CSTK::hidden::InvertUpperTriangularImpl< Matrix, Size_ >	Implementation of the inversion matrix method for upper triangular matrices
►CSTK::IPage	A IPage is an interface base class for reading and/or writing a page of option in a file
CSTK::AdditiveBSplineRegressionPage	In this Page, we manage the options for the computation of the Additive BSpline regression
CSTK::LocalVariancePage	In this Page, we manage the options for the computation of the LocalVariance
►CSTK::IRecursiveTemplate< Derived >	Interface base class for all classes implementing the curious recursive template paradigm
►CSTK::DataHandlerBase< DataHandler >
CSTK::DataHandler	implementation of the DataHandlerBase class using ReadWriteCsv and Array2D
►CSTK::DataHandlerBase< KernelHandler >
CSTK::KernelHandler	implementation of the DataHandlerBase class for kernel mixture models
►CSTK::DenseIteratorBase< BiDirectionalIterator< Array > >
CSTK::BiDirectionalIterator< Array >	BiDirectionalIterator allows to loop over the element of one dimensional list containers
►CSTK::DenseIteratorBase< ConstBiDirectionalIterator< Array > >
CSTK::ConstBiDirectionalIterator< Array >	ConstBiDirectionalIterator allows to loop over the element of one dimensional list containers
►CSTK::DenseIteratorBase< ConstDenseRandomIterator< Array > >
CSTK::ConstDenseRandomIterator< Array >	ConstDenseRandomIterator allows to loop over the elements of containers Array
►CSTK::DenseIteratorBase< DenseRandomIterator< Array_ > >
CSTK::DenseRandomIterator< Array_ >	DenseRandomIterator allows to loop over the elements of containers Array
►CSTK::IFunction< dloglikelihood >
CSTK::JointGammaModel< Array, WColVector >::dloglikelihood
CSTK::ModelGamma_aj_bj< Data_, WColVector_ >::dloglikelihood
►CSTK::IFunction< invPsi >
CSTK::hidden::invPsi	Functor computing the difference between the psi function and a fixed value
►CSTK::IFunction< invPsiMLog >
CSTK::hidden::invPsiMLog	Functor computing the derivative of the lnLikelihood of a gamma_ajk_bjk model
►CSTK::ILeastSquare< MultiLeastSquare< ArrayB, ArrayA > >
CSTK::MultiLeastSquare< ArrayB, ArrayA >	The class MultiLeastSQquare solve the least square problem when the response b is multidimensional
CSTK::lapack::MultiLeastSquare< ArrayB, ArrayA >	The class MultiLeastSQquare solve the least square problem when the response b is multidimensional
CSTK::IMixtureBridge< CategoricalBridge< Id, Data > >
CSTK::IMixtureBridge< DiagGaussianBridge< Id, Data > >
CSTK::IMixtureBridge< GammaBridge< Id, Data > >
CSTK::IMixtureBridge< HDGaussianBridge< Id, Data > >
CSTK::IMixtureBridge< HDMatrixGaussianBridge< IdRow, IdCol, Data > >
CSTK::IMixtureBridge< KmmBridge< Id, Data > >
CSTK::IMixtureBridge< PoissonBridge< Id, Data > >
CSTK::IMixtureDensity< Categorical_pjk< Array > >
CSTK::IMixtureDensity< Categorical_pk< Array > >
CSTK::IMixtureDensity< DiagGaussian_s< Array > >
CSTK::IMixtureDensity< DiagGaussian_sj< Array > >
CSTK::IMixtureDensity< DiagGaussian_sjk< Array > >
CSTK::IMixtureDensity< DiagGaussian_sjsk< Array > >
CSTK::IMixtureDensity< DiagGaussian_sk< Array > >
CSTK::IMixtureDensity< Gamma_a_bjk< Array > >
CSTK::IMixtureDensity< Gamma_a_bk< Array > >
CSTK::IMixtureDensity< Gamma_aj_bjk< Array > >
CSTK::IMixtureDensity< Gamma_aj_bk< Array > >
CSTK::IMixtureDensity< Gamma_ajk_b< Array > >
CSTK::IMixtureDensity< Gamma_ajk_bj< Array > >
CSTK::IMixtureDensity< Gamma_ajk_bjk< Array > >
CSTK::IMixtureDensity< Gamma_ajk_bk< Array > >
CSTK::IMixtureDensity< Gamma_ak_b< Array > >
CSTK::IMixtureDensity< Gamma_ak_bj< Array > >
CSTK::IMixtureDensity< Gamma_ak_bjk< Array > >
CSTK::IMixtureDensity< Gamma_ak_bk< Array > >
CSTK::IMixtureDensity< HDGaussian_AjkBkQkD< Array > >
►CSTK::IMixtureDensity< HDMatrixGaussianModel< IdRow_, IdCol_, Array_ > >
CSTK::HDMatrixGaussianModel< IdRow_, IdCol_, Array_ >	Main class for HD matrix valued matrix models
CSTK::IMixtureDensity< Kmm_s >
CSTK::IMixtureDensity< Kmm_sk >
CSTK::IMixtureDensity< Poisson_ljk< Array > >
CSTK::IMixtureDensity< Poisson_ljlk< Array > >
CSTK::IMixtureDensity< Poisson_lk< Array > >
►CSTK::IMixtureManager< CategoricalMixtureManager< DataHandler > >
CSTK::CategoricalMixtureManager< DataHandler >	A mixture manager is a factory class for injection dependency in the STK++ derived class of the IMixtureComposer interface class
►CSTK::IMixtureManager< DiagGaussianMixtureManager< DataHandler > >
CSTK::DiagGaussianMixtureManager< DataHandler >	A mixture manager is a factory class for injection dependency in the STK++ derived class of the IMixtureComposer class
►CSTK::IMixtureManager< GammaMixtureManager< DataHandler > >
CSTK::GammaMixtureManager< DataHandler >	A mixture manager is a factory class for injection dependency in the STK++ derived class of the MixtureComposer class
►CSTK::IMixtureManager< KernelMixtureManager >
CSTK::KernelMixtureManager	A mixture manager is a factory class for injection dependency in the STK++ derived class of the MixtureComposer class
►CSTK::IMixtureManager< PoissonMixtureManager< DataHandler > >
CSTK::PoissonMixtureManager< DataHandler >	A mixture manager is a factory class for injection dependency in the STK++ derived class of the MixtureComposer class
CSTK::IMixtureManager< DiagGaussianMixtureManager< DataHandler_ > >
CSTK::IMixtureManager< PoissonMixtureManager< DataHandler_ > >
CSTK::IMixtureManager< GammaMixtureManager< DataHandler_ > >
CSTK::IMixtureManager< CategoricalMixtureManager< DataHandler_ > >
►CSTK::IMultiParameters< JointBernoulliParameters >
CSTK::JointBernoulliParameters	Structure encapsulating the parameters of a Joint Bernoulli model
►CSTK::IMultiParameters< JointGammaParameters >
CSTK::JointGammaParameters	Structure encapsulating the parameters of a Joint Gamma model
►CSTK::IMultiParameters< JointGaussianParameters >
CSTK::JointGaussianParameters	Structure encapsulating the parameters of a Joint Gaussian model
CSTK::IMultiStatModel< Array, CVectorX, JointBernoulliParameters >
►CSTK::IMultiStatModel< Array, WColVector, JointGammaParameters >
CSTK::JointGammaModel< Array, WColVector >	A joint Gamma model is a statistical model of the following form
CSTK::IMultiStatModel< Array, CVectorX, JointGaussianParameters >
►CSTK::IMultiStatModel< ModelBernoulli_pj< Data_, WColVector_ > >
CSTK::ModelBernoulli_pj< Data_, WColVector_ >	A joint Bernoulli model is a statistical model of the form: following form
►CSTK::IMultiStatModel< ModelDiagGaussian_muj_sj< Data_, WColVector_ > >
CSTK::ModelDiagGaussian_muj_sj< Data_, WColVector_ >	A DiagGaussian_muj_sj model is a statistical model of the form: following form
►CSTK::IMultiStatModel< ModelGamma_aj_bj< Data_, WColVector_ > >
CSTK::ModelGamma_aj_bj< Data_, WColVector_ >	A joint Gamma model is a statistical model of the following form
►CSTK::IQr< Qr >
CSTK::Qr	The class Qr perform the QR decomposition of an ArrayXX
CSTK::lapack::Qr	{
►CSTK::ISerie< Seriedl >
CSTK::Funct::Seriedl	This Serie computes
►CSTK::ISerie< Serielog1p >
CSTK::Funct::Serielog1p	This Series computes
►CSTK::ISvd< Svd< Array > >
CSTK::Svd< Array >	The class Svd compute the Singular Value Decomposition of a Array with the Golub-Reinsch Algorithm
►CSTK::ISvd< WeightedSvd< Array, WRows, WCols > >
CSTK::WeightedSvd< Array, WRows, WCols >	This class perform a weighted svd decomposition
►CSTK::ISvd< Svd >
CSTK::lapack::Svd	{
►CSTK::ISymEigen< SymEigen< SquareArray > >
CSTK::SymEigen< SquareArray >	The class SymEigen compute the eigenvalue Decomposition of a symmetric ArrayXX
CSTK::lapack::SymEigen< SquareArray >	{
CSTK::ISymEigen< SymEigen< Array2DSquare< Real > > >
CSTK::ITContainer1D< Array1D< Type_, Size_ > >
CSTK::ITContainer1D< Array1D< STK::TRange< UnknownSize >, Size_ > >
CSTK::ITContainer1D< List1D< IVariable * > >
►CSTK::ITContainer1D< List1D< Type_ > >
CSTK::List1D< Type_ >	Template One dimensional Horizontal List
CSTK::ITContainer1D< Array1D< Law, Size_ > >
CSTK::ITContainer1D< SArray1D< Type_, Size_, NzMax_ > >
CSTK::ITContainer1D< Variable< Type_ > >
CSTK::ITContainer1D< Array1D< STK::BSplineCoefficients< ColVector >, Size_ > >
CSTK::ITContainer1D< Array1D< STK::Variable, Size_ > >
CSTK::ITContainer1D< Array1D< Array_, Size_ > >
CSTK::ITContainer1D< Array1D< STK::CArraySquare, Size_ > >
CSTK::ITContainer1D< Array1D< STK::CArrayVector, Size_ > >
CSTK::ITContainer1D< Array1D< Real, Size_ > >
CSTK::ITContainer1D< Array1D< STK::Stat::Online< Array_, Real >, Size_ > >
CSTK::ITContainer1D< Array1D< STK::Stat::Online< STK::CArraySquare, Real >, Size_ > >
CSTK::ITContainer1D< Array1D< STK::Stat::Online< STK::CArrayVector, Real >, Size_ > >
CSTK::ITContainer1D< Array1D< STK::Stat::Online< Real, Real >, Size_ > >
CSTK::ITContainer1D< Array1D< TaggedKernel, Size_ > >
CSTK::ITContainer1D< Array1D< int, Size_ > >
CSTK::ITContainer1D< Array1D< IndexedValue, Size_ > >
CSTK::ITContainer1D< Array1D< CArray< Real, UnknownSize, UnknownSize, Arrays::by_col_ >, Size_ > >
CSTK::ITContainer1D< Array1D< STK::Stat::Online< CArray< Real, UnknownSize, UnknownSize, Arrays::by_col_ >, Real >, Size_ > >
CSTK::ITContainer1D< Array1D< CArrayPoint< Real, UnknownSize, Arrays::by_col_ >, Size_ > >
CSTK::ITContainer1D< Array1D< STK::Stat::Online< CArrayPoint< Real, UnknownSize, Arrays::by_col_ >, Real >, Size_ > >
CSTK::ITContainer1D< Variable< Real > >
►CSTK::InnerIteratorBase< Array1D< Type_, Size_ >, Array1D< Type_, Size_ >::InnerOperator >
CSTK::Array1D< Type_, Size_ >::InnerOperator
►CSTK::RangeBase< TRange< Size_ > >
CSTK::TRange< SizeRows_ >
CSTK::TRange< SizeCols_ >
CSTK::TRange< sizeRows_ >
CSTK::TRange< sizeCols_ >
CSTK::TRange< Size_ >	Index sub-vector region with fixed size
►CSTK::RangeBase< TRange< UnknownSize > >
CSTK::TRange< UnknownSize >	Index sub-vector region: Specialization when the size is unknown
CSTK::DataHandlerBase< Derived >	A class derived from a DataHandlerBase allows to store various data sets identified by an idData and an idModel
CSTK::DenseIteratorBase< Derived >	IteratorBase is a base class for all iterators on dense arrays/matrix/vector/expressions
CSTK::ILeastSquare< Derived >	The class ILeastSquare is an interface class for the methods solving the least-square problem
CSTK::IMixtureBridge< Derived >	Interface base class for the bridges of the STK++ mixture
►CSTK::IMixtureDensity< Derived >	Base class for all Mixture densities
►CSTK::CategoricalBase< Categorical_pjk< Array > >
CSTK::Categorical_pjk< Array >	The diagonal Categorical mixture model Categorical_pjk is the most general diagonal Categorical model and has a probability function of the form
►CSTK::CategoricalBase< Categorical_pk< Array > >
CSTK::Categorical_pk< Array >	The diagonal Categorical mixture model Categorical_pk is a diagonal Categorical model and has a density function of the form
►CSTK::DiagGaussianBase< DiagGaussian_s< Array > >
CSTK::DiagGaussian_s< Array >	The diagonal DiagGaussian_s mixture model hse a density function of the form
►CSTK::DiagGaussianBase< DiagGaussian_sj< Array > >
CSTK::DiagGaussian_sj< Array >	The diagonal Gaussian mixture model DiagGaussian_sj have a density function of the form
►CSTK::DiagGaussianBase< DiagGaussian_sjk< Array > >
CSTK::DiagGaussian_sjk< Array >	The diagonal Gaussian mixture model DiagGaussian_sjk is the most general diagonal Gaussian model and have a density function of the form
►CSTK::DiagGaussianBase< DiagGaussian_sjsk< Array > >
CSTK::DiagGaussian_sjsk< Array >	The diagonal Gaussian mixture model DiagGaussian_sjsk is an intermediate diagonal Gaussian model with density function of the form
►CSTK::DiagGaussianBase< DiagGaussian_sk< Array > >
CSTK::DiagGaussian_sk< Array >	The diagonal Gaussian mixture model DiagGaussian_sk assumes an equal standard deviation in each cluster and has a density function of the form
►CSTK::GammaBase< Gamma_a_bjk< Array > >
CSTK::Gamma_a_bjk< Array >	Gamma_a_bjk is a mixture model of the following form
►CSTK::GammaBase< Gamma_a_bk< Array > >
CSTK::Gamma_a_bk< Array >	Gamma_a_bk is a mixture model of the following form
►CSTK::GammaBase< Gamma_aj_bjk< Array > >
CSTK::Gamma_aj_bjk< Array >	Gamma_aj_bjk is a mixture model of the following form
►CSTK::GammaBase< Gamma_aj_bk< Array > >
CSTK::Gamma_aj_bk< Array >	Gamma_aj_bk is a mixture model of the following form
►CSTK::GammaBase< Gamma_ajk_b< Array > >
CSTK::Gamma_ajk_b< Array >	Gamma_ajk_b is a mixture model of the following form
►CSTK::GammaBase< Gamma_ajk_bj< Array > >
CSTK::Gamma_ajk_bj< Array >	Gamma_ajk_bj is a mixture model of the following form
►CSTK::GammaBase< Gamma_ajk_bjk< Array > >
CSTK::Gamma_ajk_bjk< Array >	Gamma_ajk_bjk is a mixture model of the following form
►CSTK::GammaBase< Gamma_ajk_bk< Array > >
CSTK::Gamma_ajk_bk< Array >	Gamma_ajk_bk is a mixture model of the following form
►CSTK::GammaBase< Gamma_ak_b< Array > >
CSTK::Gamma_ak_b< Array >	Gamma_ak_b is a mixture model of the following form
►CSTK::GammaBase< Gamma_ak_bj< Array > >
CSTK::Gamma_ak_bj< Array >	Gamma_ak_bj is a mixture model of the following form
►CSTK::GammaBase< Gamma_ak_bjk< Array > >
CSTK::Gamma_ak_bjk< Array >	Gamma_ak_bjk is a mixture model of the following form
►CSTK::GammaBase< Gamma_ak_bk< Array > >
CSTK::Gamma_ak_bk< Array >	Gamma_ak_bk is a mixture model of the following form
►CSTK::HDGaussianBase< HDGaussian_AjkBkQkD< Array > >
CSTK::HDGaussian_AjkBkQkD< Array >	The diagonal Gaussian mixture model HDGaussian_AjkBkQkD is the most general HD Gaussian model and have a density function of the form
►CSTK::KmmBase< Kmm_s >
CSTK::Kmm_s	The Gaussian mixture model Kmm_s is an isotrope Gaussian mixture model on a kernel space
►CSTK::KmmBase< Kmm_sk >
CSTK::Kmm_sk	The Gaussian mixture model Kmm_sk is an isotrope Gaussian mixture model on a kernel space
►CSTK::PoissonBase< Poisson_ljk< Array > >
CSTK::Poisson_ljk< Array >	The Poisson mixture model Poisson_ljk is the most general Poisson model and have a probability function of the form
►CSTK::PoissonBase< Poisson_ljlk< Array > >
CSTK::Poisson_ljlk< Array >	The Poisson mixture model Poisson_ljlk is a Poisson model with a probability function of the form
►CSTK::PoissonBase< Poisson_lk< Array > >
CSTK::Poisson_lk< Array >	The Poisson mixture model Poisson_lk has a probability function of the form
CSTK::CategoricalBase< Derived >	Base class for the Categorical models
CSTK::DiagGaussianBase< Derived >	Base class for the diagonal Gaussian models
CSTK::GammaBase< Derived >	Base class for the gamma models
CSTK::HDGaussianBase< Derived >	Base class for the diagonal Gaussian models
CSTK::KmmBase< Derived >	Base class for the Gaussian Kernel Mixture Models
CSTK::PoissonBase< Derived >	Base class for the Poisson models
►CSTK::IMixtureManager< Derived >	Interface base class for mixture managers
CSTK::CategoricalMixtureManager< DataHandler_ >
CSTK::DiagGaussianMixtureManager< DataHandler_ >
CSTK::GammaMixtureManager< DataHandler_ >
CSTK::PoissonMixtureManager< DataHandler_ >
CSTK::IMixtureModel< Derived >	Main interface class for mixture models
►CSTK::IMultiStatModel< Derived >	Interface base class for all Multivariate Statistical Models
CSTK::JointBernoulliModel< Array, WColVector >	A joint Bernoulli model is a statistical model of the form: following form
CSTK::JointGaussianModel< Array, WColVector >	A joint Gaussian model is a statistical model of the form: following form
CSTK::IQr< Derived >	The class IQr is an interface class for the method computing the QR Decomposition of a ArrayXX
CSTK::ISvd< Derived >	Compute the Singular Value Decomposition of an array
►CSTK::ISymEigen< Derived >	The class ISymEigen is an interface class for the method computing the eigenvalue Decomposition of a symmetric ArrayXX
CSTK::SymEigen< Array2DSquare< Real > >
►CSTK::ITContainer1D< Derived >	Interface base class for homogeneous 1D containers
►CSTK::IArray1D< Array1D< Type_, Size_ > >
CSTK::Array1D< Type_, Size_ >	Template one dimensional Arrays
CSTK::IArray1D< Array1D< STK::TRange< UnknownSize >, Size_ > >
CSTK::IArray1D< Array1D< Law, Size_ > >
►CSTK::IArray1D< SArray1D< Type_, Size_, NzMax_ > >
CSTK::SArray1D< Type_, Size_, NzMax_ >	Template one dimensional Arrays
►CSTK::IArray1D< Variable< Type_ > >
CSTK::Variable< Type_ >	Variable is an implementation of the Base class IVariable using The Array1D class for storing the data
CSTK::IArray1D< Array1D< STK::BSplineCoefficients< ColVector >, Size_ > >
CSTK::IArray1D< Array1D< STK::Variable, Size_ > >
CSTK::IArray1D< Array1D< Array_, Size_ > >
CSTK::IArray1D< Array1D< STK::CArraySquare, Size_ > >
CSTK::IArray1D< Array1D< STK::CArrayVector, Size_ > >
CSTK::IArray1D< Array1D< Real, Size_ > >
CSTK::IArray1D< Array1D< STK::Stat::Online< Array_, Real >, Size_ > >
CSTK::IArray1D< Array1D< STK::Stat::Online< STK::CArraySquare, Real >, Size_ > >
CSTK::IArray1D< Array1D< STK::Stat::Online< STK::CArrayVector, Real >, Size_ > >
CSTK::IArray1D< Array1D< STK::Stat::Online< Real, Real >, Size_ > >
CSTK::IArray1D< Array1D< TaggedKernel, Size_ > >
CSTK::IArray1D< Array1D< int, Size_ > >
CSTK::IArray1D< Array1D< IndexedValue, Size_ > >
CSTK::IArray1D< Array1D< CArray< Real, UnknownSize, UnknownSize, Arrays::by_col_ >, Size_ > >
CSTK::IArray1D< Array1D< STK::Stat::Online< CArray< Real, UnknownSize, UnknownSize, Arrays::by_col_ >, Real >, Size_ > >
CSTK::IArray1D< Array1D< CArrayPoint< Real, UnknownSize, Arrays::by_col_ >, Size_ > >
CSTK::IArray1D< Array1D< STK::Stat::Online< CArrayPoint< Real, UnknownSize, Arrays::by_col_ >, Real >, Size_ > >
CSTK::IArray1D< Variable< Real > >
►CSTK::List1D< IVariable * >
CSTK::DataFrame	DataFrame is a List of Variable with the same number of rows
►CSTK::IArray1D< Derived >	Template one dimensional Array
CSTK::Array1D< STK::TRange< UnknownSize >, sizeCols_ >
CSTK::Array1D< Law >
CSTK::Array1D< STK::BSplineCoefficients< ColVector > >
CSTK::Array1D< STK::Variable >
CSTK::Array1D< Array_ >
CSTK::Array1D< STK::CArraySquare >
CSTK::Array1D< STK::CArrayVector >
CSTK::Array1D< Real >
CSTK::Array1D< STK::Stat::Online< Array_, Real > >
CSTK::Array1D< STK::Stat::Online< STK::CArraySquare, Real > >
CSTK::Array1D< STK::Stat::Online< STK::CArrayVector, Real > >
CSTK::Array1D< STK::Stat::Online< Real, Real > >
CSTK::Array1D< TaggedKernel >
CSTK::Array1D< int, size_ >
CSTK::Array1D< IndexedValue, NzMax_ >
CSTK::Array1D< CArray< Real, UnknownSize, UnknownSize, Arrays::by_col_ > >
CSTK::Array1D< STK::Stat::Online< CArray< Real, UnknownSize, UnknownSize, Arrays::by_col_ >, Real > >
CSTK::Array1D< CArrayPoint< Real, UnknownSize, Arrays::by_col_ > >
CSTK::Array1D< STK::Stat::Online< CArrayPoint< Real, UnknownSize, Arrays::by_col_ >, Real > >
CSTK::Array1D< int >
CSTK::Variable< Real >
CSTK::ISparseArray1D< Derived >	Interface class for SparseArray1D
CSTK::ITContainer2D< Derived >	Interface base class for homogeneous 2D containers like allocators
►CSTK::ITContainerBase< Derived >	Interface base class for 2D containers
CSTK::ITContainer< Derived, Arrays::array2D_ >	Specialization for array2D_
CSTK::ITContainer< Derived, Arrays::diagonal_ >	Specialization for diagonal_
CSTK::ITContainer< Derived, Arrays::lower_symmetric_ >	Specialization for lower_symmetric_
CSTK::ITContainer< Derived, Arrays::lower_triangular_ >	Specialization for lower_triangular_
CSTK::ITContainer< Derived, Arrays::number_ >	Specialization for number_
CSTK::ITContainer< Derived, Arrays::point_ >	Specialization for point_
CSTK::ITContainer< Derived, Arrays::square_ >
CSTK::ITContainer< Derived, Arrays::symmetric_ >
CSTK::ITContainer< Derived, Arrays::upper_symmetric_ >	Specialization for upper_symmetric_
CSTK::ITContainer< Derived, Arrays::upper_triangular_ >	Specialization for upper_triangular_
CSTK::ITContainer< Derived, Arrays::vector_ >	Specialization for vector_
CSTK::InnerIteratorBase< Array, Derived >	InnerIteratorBase is a base class for all iterators on allocators
CSTK::RangeBase< Derived >	Base class for TRange class
CSTK::SparseIteratorBase< Derived >	IteratorBase is a base class for all iterators on dense arrays/matrix/vector/expressions
CSTK::IRecursiveTemplate< Array >
CSTK::IRecursiveTemplate< Array1D< Array_, Size_ > >
CSTK::IRecursiveTemplate< Array1D< CArray< Real, UnknownSize, UnknownSize, Arrays::by_col_ >, Size_ > >
CSTK::IRecursiveTemplate< Array1D< CArrayPoint< Real, UnknownSize, Arrays::by_col_ >, Size_ > >
CSTK::IRecursiveTemplate< Array1D< IndexedValue, Size_ > >
CSTK::IRecursiveTemplate< Array1D< int, Size_ > >
CSTK::IRecursiveTemplate< Array1D< Law, Size_ > >
CSTK::IRecursiveTemplate< Array1D< Real, Size_ > >
CSTK::IRecursiveTemplate< Array1D< STK::BSplineCoefficients< ColVector >, Size_ > >
CSTK::IRecursiveTemplate< Array1D< STK::CArraySquare, Size_ > >
CSTK::IRecursiveTemplate< Array1D< STK::CArrayVector, Size_ > >
CSTK::IRecursiveTemplate< Array1D< STK::Stat::Online< Array_, Real >, Size_ > >
CSTK::IRecursiveTemplate< Array1D< STK::Stat::Online< CArray< Real, UnknownSize, UnknownSize, Arrays::by_col_ >, Real >, Size_ > >
CSTK::IRecursiveTemplate< Array1D< STK::Stat::Online< CArrayPoint< Real, UnknownSize, Arrays::by_col_ >, Real >, Size_ > >
CSTK::IRecursiveTemplate< Array1D< STK::Stat::Online< Real, Real >, Size_ > >
CSTK::IRecursiveTemplate< Array1D< STK::Stat::Online< STK::CArraySquare, Real >, Size_ > >
CSTK::IRecursiveTemplate< Array1D< STK::Stat::Online< STK::CArrayVector, Real >, Size_ > >
CSTK::IRecursiveTemplate< Array1D< STK::TRange< UnknownSize >, Size_ > >
CSTK::IRecursiveTemplate< Array1D< STK::Variable, Size_ > >
CSTK::IRecursiveTemplate< Array1D< TaggedKernel, Size_ > >
CSTK::IRecursiveTemplate< Array1D< Type_, Size_ > >
CSTK::IRecursiveTemplate< Array1D< Type_, Size_ >::InnerOperator >
CSTK::IRecursiveTemplate< BiDirectionalIterator< Array > >
CSTK::IRecursiveTemplate< Categorical_pjk< Array > >
CSTK::IRecursiveTemplate< Categorical_pk< Array > >
CSTK::IRecursiveTemplate< CategoricalBridge< Id, Data > >
CSTK::IRecursiveTemplate< CategoricalMixtureManager< DataHandler > >
CSTK::IRecursiveTemplate< CategoricalMixtureManager< DataHandler_ > >
CSTK::IRecursiveTemplate< ConstBiDirectionalIterator< Array > >
CSTK::IRecursiveTemplate< ConstDenseRandomIterator< Array > >
CSTK::IRecursiveTemplate< DataHandler >
CSTK::IRecursiveTemplate< DenseRandomIterator< Array_ > >
CSTK::IRecursiveTemplate< DiagGaussian_s< Array > >
CSTK::IRecursiveTemplate< DiagGaussian_sj< Array > >
CSTK::IRecursiveTemplate< DiagGaussian_sjk< Array > >
CSTK::IRecursiveTemplate< DiagGaussian_sjsk< Array > >
CSTK::IRecursiveTemplate< DiagGaussian_sk< Array > >
CSTK::IRecursiveTemplate< DiagGaussianBridge< Id, Data > >
CSTK::IRecursiveTemplate< DiagGaussianMixtureManager< DataHandler > >
CSTK::IRecursiveTemplate< DiagGaussianMixtureManager< DataHandler_ > >
CSTK::IRecursiveTemplate< dloglikelihood >
►CSTK::IRecursiveTemplate< Function >
CSTK::IFunction< Function >	Interface base class for functions
CSTK::IRecursiveTemplate< Gamma_a_bjk< Array > >
CSTK::IRecursiveTemplate< Gamma_a_bk< Array > >
CSTK::IRecursiveTemplate< Gamma_aj_bjk< Array > >
CSTK::IRecursiveTemplate< Gamma_aj_bk< Array > >
CSTK::IRecursiveTemplate< Gamma_ajk_b< Array > >
CSTK::IRecursiveTemplate< Gamma_ajk_bj< Array > >
CSTK::IRecursiveTemplate< Gamma_ajk_bjk< Array > >
CSTK::IRecursiveTemplate< Gamma_ajk_bk< Array > >
CSTK::IRecursiveTemplate< Gamma_ak_b< Array > >
CSTK::IRecursiveTemplate< Gamma_ak_bj< Array > >
CSTK::IRecursiveTemplate< Gamma_ak_bjk< Array > >
CSTK::IRecursiveTemplate< Gamma_ak_bk< Array > >
CSTK::IRecursiveTemplate< GammaBridge< Id, Data > >
CSTK::IRecursiveTemplate< GammaMixtureManager< DataHandler > >
CSTK::IRecursiveTemplate< GammaMixtureManager< DataHandler_ > >
CSTK::IRecursiveTemplate< HDGaussian_AjkBkQkD< Array > >
CSTK::IRecursiveTemplate< HDGaussianBridge< Id, Data > >
CSTK::IRecursiveTemplate< HDMatrixGaussianBridge< IdRow, IdCol, Data > >
CSTK::IRecursiveTemplate< HDMatrixGaussianModel< IdRow_, IdCol_, Array_ > >
CSTK::IRecursiveTemplate< invPsi >
CSTK::IRecursiveTemplate< invPsiMLog >
CSTK::IRecursiveTemplate< JointBernoulliParameters >
CSTK::IRecursiveTemplate< JointGammaParameters >
CSTK::IRecursiveTemplate< JointGaussianParameters >
CSTK::IRecursiveTemplate< KernelHandler >
CSTK::IRecursiveTemplate< KernelMixtureManager >
CSTK::IRecursiveTemplate< Kmm_s >
CSTK::IRecursiveTemplate< Kmm_sk >
CSTK::IRecursiveTemplate< KmmBridge< Id, Data > >
CSTK::IRecursiveTemplate< List1D< IVariable * > >
CSTK::IRecursiveTemplate< List1D< Type_ > >
CSTK::IRecursiveTemplate< ModelBernoulli_pj< Data_, WColVector_ > >
CSTK::IRecursiveTemplate< ModelDiagGaussian_muj_sj< Data_, WColVector_ > >
CSTK::IRecursiveTemplate< ModelGamma_aj_bj< Data_, WColVector_ > >
CSTK::IRecursiveTemplate< MultiLeastSquare< ArrayB, ArrayA > >
►CSTK::IRecursiveTemplate< Parameters >
CSTK::IMultiParameters< Parameters >	Interface base class for the parameters of a multivariate model
CSTK::IRecursiveTemplate< Poisson_ljk< Array > >
CSTK::IRecursiveTemplate< Poisson_ljlk< Array > >
CSTK::IRecursiveTemplate< Poisson_lk< Array > >
CSTK::IRecursiveTemplate< PoissonBridge< Id, Data > >
CSTK::IRecursiveTemplate< PoissonMixtureManager< DataHandler > >
CSTK::IRecursiveTemplate< PoissonMixtureManager< DataHandler_ > >
CSTK::IRecursiveTemplate< Qr >
CSTK::IRecursiveTemplate< SArray1D< Type_, Size_, NzMax_ > >
►CSTK::IRecursiveTemplate< Serie >
CSTK::ISerie< Serie >	Interface base class for Series
CSTK::IRecursiveTemplate< Seriedl >
CSTK::IRecursiveTemplate< Serielog1p >
CSTK::IRecursiveTemplate< Svd >
CSTK::IRecursiveTemplate< Svd< Array > >
CSTK::IRecursiveTemplate< SymEigen< Array2DSquare< Real > > >
CSTK::IRecursiveTemplate< SymEigen< SquareArray > >
CSTK::IRecursiveTemplate< TRange< Size_ > >
CSTK::IRecursiveTemplate< TRange< UnknownSize > >
CSTK::IRecursiveTemplate< Variable< Real > >
CSTK::IRecursiveTemplate< Variable< Type_ > >
CSTK::IRecursiveTemplate< WeightedSvd< Array, WRows, WCols > >
►CSTK::IRunnerBase	Abstract base class for all classes having a
CSTK::AdditiveBSplineCoefficients< XArray >
►CSTK::IBasis< Data, ArrayXX >
CSTK::BSplineCoefficients< Data >	Compute the regression B-splines coefficients
CSTK::IBasis< XVector, ArrayXX >
CSTK::ILeastSquare< MultiLeastSquare< ArrayB, ArrayA > >
CSTK::IQr< Qr >
CSTK::IRunnerSupervised< YArray, XArray, VectorX >
CSTK::IRunnerSupervised< YArray, XVector, VectorX >
►CSTK::IRunnerSupervised< YArray, XArray, Weights >
►CSTK::IRegression< YArray, XArray, Weights >	Interface base class for Regression methods
CSTK::AdditiveBSplineRegression< YArray, XArray, Weights >	Compute an additive BSpline, multivalued, regression function using BSpline basis
CSTK::BSplineRegression< YArray, XVector, Weights >	Compute a BSpline, multi-valued, regression function using BSpline basis
CSTK::IRunnerSupervised< Array, Array, Weight >
►CSTK::IRunnerUnsupervised< Array, WColVector >
CSTK::Stat::Multivariate< Array, WColVector, Type >	Computation of the multivariate statistics of a Variable
►CSTK::IRunnerUnsupervised< Array, Weights >
►CSTK::IReducer< Array, Weights >	Interface base class for reducing methods
►CSTK::ILinearReduct< Array, VectorX >
CSTK::LocalVariance< Array >	A LocalVariance is an implementation of the abstract ILinearReduct class
CSTK::ProjectedVariance< Array >	A ProjectedVariance is an implementation of the abstract ILinearReduct interface
CSTK::ILinearReduct< Array, Weights >	A ILinearReduct is an interface base class for reduction method using linear reduction
►CSTK::IRunnerUnsupervised< ColVector, WColVector >
CSTK::IUnivStatModel< ColVector, WColVector, UnivariateLaw >	Base class for all Statistical Models
►CSTK::IRunnerUnsupervised< Array, VectorX >
CSTK::LinearAAModel< Array >	A Linear AutoAssociative Model (LAAM) is a generalization of the PCA model for projecting variables on an affine plane of lower dimension
►CSTK::IRunnerUnsupervised< Array, hidden::Traits< Array >::Col >
CSTK::Stat::Multivariate< Array, Real >	Computation of the Multivariate Statistics of a 2D Container of Real
CSTK::ISvd< Svd< Array > >
CSTK::ISvd< WeightedSvd< Array, WRows, WCols > >
CSTK::ISvd< Svd >
CSTK::ISymEigen< SymEigen< SquareArray > >
CSTK::ISymEigen< SymEigen< Array2DSquare< Real > > >
CSTK::AdditiveBSplineCoefficients< Array >	Compute the regression splines coefficients of an additive model
CSTK::CsvToArray< Array, Type >	The CsvToArray class allow to export the data of some Type stored in a TReadWriteCsv in an Array
CSTK::CvHandler	CvHanler is an utility function for building the submatrix/subvectors needed when using k-folds cross-validation
►CSTK::IBasis< Data, Coefs >	Interface base class for all basis function
CSTK::BSplineCoefficients< XVector >
CSTK::ChebyshevCoefficients< Data, Coefs >	ChebyshevCoefficients class allows to compute the coefficients of a sampled function using Chebyshev polynomials
CSTK::CosinesCoefficients< Data, Coefs >	CosinesCoefficients allows to compute the coefficients of a sampled function using cosines basis functions
CSTK::SinesCoefficients< Data, Coefs >	SinesCoefficients class allows to compute the coefficients of a sampled function using sines basis functions
CSTK::TrigonometricCoefficients< Data, Coefs >	TrigonometricCoefficients class allows to compute the coefficients of a sampled function using sines and cosines basis functions
►CSTK::ICriterion	Interface base class for the selection model criterion
CSTK::AICCriterion	Derived class of Criterion for computing the AIC Criterion The AIC criteria is a penalization of the likelihood given by the formula
CSTK::BICCriterion	Derived class of Criterion for computing the BIC Criterion The Bic criteria is a penalization of the likelihood given by the formula
CSTK::ILeastSquare< Derived >	The class ILeastSquare is an interface class for the methods solving the least-square problem
►CSTK::IMixtureAlgo	Interface base class for the algorithms
CSTK::CEMAlgo	Implementation of the SEM algorithm
CSTK::EMAlgo	Implementation of the EM algorithm
CSTK::SEMAlgo	Implementation of the SEM algorithm
CSTK::SemiSEMAlgo	Implementation of the SemiSEM algorithm
►CSTK::IMixtureAlgoLearn	Interface base class for the learning algorithms
CSTK::ImputeAlgo	Implementation of the ImputeAlgo learning algorithm
CSTK::SimulAlgo	Implementation of the SimulAlgo learning algorithm
►CSTK::IMixtureAlgoPredict	Interface base class for predicting algorithms
CSTK::EMPredict	Implementation of the EMPredict algorithm
CSTK::SemiSEMPredict	Implementation of the SemiSEMPredict algorithm
►CSTK::IMixtureCriterion	Interface base class for the selection model criterion
CSTK::AICMixtureCriterion	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
CSTK::BICMixtureCriterion	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
CSTK::ICLMixtureCriterion	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
CSTK::MLMixtureCriterion	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
►CSTK::IMixtureInit	Interface base class for the initializations
CSTK::ClassInit	Initialization by simulating a realization of the class labels zi accordingly to the initial proportions
CSTK::FuzzyInit	Initialization by simulating the tik accordingly to the initial proportions
CSTK::RandomInit	Implementation of the random initialization
►CSTK::IMixtureStrategy	Interface base class for all the strategies
CSTK::FullStrategy	A FullStrategy is based on the following paradigm:
CSTK::FullStrategy	A FullStrategy is based on the following paradigm:
CSTK::SimpleStrategy	A SimpleStrategy is just nbTry long run
CSTK::SimpleStrategy	A SimpleStrategy is just nbTry long run
CSTK::XemStrategy	A XemStrategy is based on the following paradigm:
CSTK::XemStrategy	A XemStrategy is based on the following paradigm:
CSTK::IQr< Derived >	The class IQr is an interface class for the method computing the QR Decomposition of a ArrayXX
►CSTK::IRunnerSupervised< YArray_, XArray_, Weights_ >	Abstract class for all classes making supervised learning
CSTK::IRegression< YArray, XArray, VectorX >
CSTK::IRegression< YArray, XVector, VectorX >
►CSTK::IRegression< Array, Array, Weight >
CSTK::MultidimRegression< Array, Weight >	The MultidimRegression class allows to regress a multidimensional output variable among a multivariate explanation variable
CSTK::IClassification< YArray_, XArray_, Weights_ >	Interface base class for Regression methods
►CSTK::IRunnerUnsupervised< Array, Weights_ >	Abstract class for all classes making unsupervised learning
CSTK::IReducer< Array, VectorX >
►CSTK::IUnivStatModel< Array, WColVector, Law::Bernoulli >
CSTK::BernoulliModel< Array, WColVector >	A Bernoulli model, is a statistical model of the following form
►CSTK::IRunnerWithData< Array >	Abstract class for all running class based on a data set
CSTK::Stat::Factor< Array >	Computation of the Factors of a 1D Container
CSTK::Stat::MultiFactor< Array >	Computation of the MultiFactors of a 2D Container
CSTK::ISvd< Derived >	Compute the Singular Value Decomposition of an array
CSTK::ISymEigen< Derived >	The class ISymEigen is an interface class for the method computing the eigenvalue Decomposition of a symmetric ArrayXX
CSTK::ImportFromCsv	Import data from a Csv File in a DataFrame
►CSTK::Kernel::IKernel	Interface class for the kernels classes
►CSTK::Kernel::IKernelBase< Array >	Interface Base class for the kernels classes
CSTK::Kernel::Exponential< Array >	[Deprecated] The Exponential Kernel is a kernel of the form
CSTK::Kernel::Gaussian< Array >	The Gaussian Kernel is a kernel of the form
CSTK::Kernel::Hamming< Array >	The Hamming Kernel is a kernel of the form
CSTK::Kernel::Laplace< Array >	The Laplace Kernel is a kernel of the form
CSTK::Kernel::Linear< Array >	The Linear Kernel is a kernel of the form
CSTK::Kernel::Polynomial< Array >	The Polynomial Kernel is a kernel of the form
CSTK::Kernel::RationalQuadratic< Array >	The RationalQuadratic Kernel is a kernel of the form
CSTK::LearnFacade	Facade design pattern
CSTK::PartitionHandler	CvHanler is an utility function for building the submatrix/subvectors needed when creating learning and test data sets
CSTK::StrategyFacade	Facade design pattern
CSTK::hidden::IsArithmetic< T >
CSTK::hidden::IsArithmetic< bool >
CSTK::hidden::IsArithmetic< char >
CSTK::hidden::IsArithmetic< double >
CSTK::hidden::IsArithmetic< float >
CSTK::hidden::IsArithmetic< long double >
CSTK::hidden::IsArithmetic< signed char >
CSTK::hidden::IsArithmetic< signed int >
CSTK::hidden::IsArithmetic< signed long >
CSTK::hidden::IsArithmetic< signed short >
CSTK::hidden::IsArithmetic< unsigned char >
CSTK::hidden::IsArithmetic< unsigned int >
CSTK::hidden::IsArithmetic< unsigned long >
CSTK::hidden::IsArithmetic< unsigned short >
CSTK::hidden::IsEqual< M, N >	Check if T and U are equal
CSTK::IsFiniteOp< Type >	Template functor testing if a number is a finite value
CSTK::IsInfiniteOp< Type >	Template functor testing if a number is an infinite value
CSTK::hidden::IsInt< Type >
CSTK::hidden::IsInt< bool >
CSTK::hidden::IsInt< char >
CSTK::hidden::IsInt< signed char >
CSTK::hidden::IsInt< signed int >
CSTK::hidden::IsInt< signed long >
CSTK::hidden::IsInt< signed short >
CSTK::hidden::IsInt< unsigned char >
CSTK::hidden::IsInt< unsigned int >
CSTK::hidden::IsInt< unsigned long >
CSTK::hidden::IsInt< unsigned short >
CSTK::IsNaOp< Type >	Template functor testing if a number is a NA value
CSTK::hidden::isSame< T, U >	Check if T and U are of the same type
CSTK::hidden::isSame< T, T >
►CSTK::IStatModelBase	Interface base class for all Statistical Models
CSTK::IMultiStatModel< Array, CVectorX, JointBernoulliParameters >
CSTK::IMultiStatModel< Array, WColVector, JointGammaParameters >
CSTK::IMultiStatModel< Array, CVectorX, JointGaussianParameters >
CSTK::IMultiStatModel< ModelBernoulli_pj< Data_, WColVector_ > >
CSTK::IMultiStatModel< ModelDiagGaussian_muj_sj< Data_, WColVector_ > >
CSTK::IMultiStatModel< ModelGamma_aj_bj< Data_, WColVector_ > >
►CSTK::IStatModel< GaussianAAModel< Array > >
CSTK::GaussianAAModel< Array >	Gaussian Auto-Associative models
►CSTK::IStatModel< IGaussianModel< Array > >
►CSTK::IGaussianModel< Array >	Compute the the maximum likelihood estimates of a complete Gaussian statistical model
CSTK::GaussianModel< Array >	Compute the maximum likelihood estimates of a complete Gaussian statistical model
CSTK::IUnivStatModel< Array, WColVector, Law::Bernoulli >
CSTK::IClusterModelBase	Base class for clustering models
►CSTK::IMixtureStatModel	Interface base class for Mixture (composed) model
►CSTK::IMixtureComposer	Base class for Mixture (composed) model
►CSTK::MixtureComposer	Main class for handling composed mixture models
CSTK::MixtureComposerFixedProp	Specialization of the composer for the fixed proportion case
►CSTK::MixtureSemiLearner	Base class for Learning a Mixture mixed model when some classes are known
CSTK::MixtureSemiLearnerFixedProp	Specialization of the composer for the fixed proportion case
►CSTK::IMixtureLearner	Base class for Learner of a Mixture mixed model
CSTK::MixtureLearner	Main class for learning mixture models
CSTK::IMultiStatModel< Derived >	Interface base class for all Multivariate Statistical Models
CSTK::IStatModel< Derived >	Base class for all Statistical Models [Deprecated], have been replaced by IStatModel
CSTK::IUnivStatModel< ColVector, WColVector, UnivariateLaw >	Base class for all Statistical Models
►CSTK::ITContainer< Derived, Structure_ >	Specialized interface class for all arrays (can be either 2D arrays or 1D arrays)
CSTK::ExprBase< Array2D< Type_ > >
CSTK::ExprBase< Array2DDiagonal< Type_ > >
CSTK::ExprBase< Array2DLowerTriangular< Type_ > >
CSTK::ExprBase< Array2DNumber< Type_ > >
CSTK::ExprBase< Array2DPoint< Type_ > >
CSTK::ExprBase< Array2DSquare< Type_ > >
CSTK::ExprBase< Array2DUpperTriangular< Type_ > >
CSTK::ExprBase< Array2DVector< Type_ > >
►CSTK::ExprBase< ArrayByArrayProduct< Lhs, Rhs > >
CSTK::ArrayByArrayProduct< Lhs, Rhs >	Generic expression where a product operator is applied to two expressions
►CSTK::ExprBase< ArrayByDiagonalProduct< Lhs, Rhs > >
CSTK::ArrayByDiagonalProduct< Lhs, Rhs >	Generic expression where a product operator is applied to two expressions
►CSTK::ExprBase< ArrayByVectorProduct< Lhs, Rhs > >
CSTK::ArrayByVectorProduct< Lhs, Rhs >	Generic expression where a product operator is applied to two expressions
►CSTK::ExprBase< BinaryOperator< FunctorOp, Lhs, Rhs > >
CSTK::BinaryOperator< FunctorOp, Lhs, Rhs >	Generic expression where a binary operator is applied to two expressions
CSTK::ExprBase< CArray< Type_, SizeRows_, SizeCols_, Orient_ > >
CSTK::ExprBase< CArrayNumber< Type_, Orient_ > >
CSTK::ExprBase< CArrayPoint< Type_, SizeCols_, Orient_ > >
CSTK::ExprBase< CArraySquare< Type_, Size_, Orient_ > >
CSTK::ExprBase< CArrayVector< Type_, SizeRows_, Orient_ > >
CSTK::ExprBase< Array2DPoint< int > >
►CSTK::ExprBase< ColAccessor< Lhs > >
CSTK::ColAccessor< Lhs >	Generic expression when the column of an expression is accessed
►CSTK::ExprBase< ColOperator< Lhs > >
CSTK::ColOperator< Lhs >	Generic expression when the column of an expression is accessed
CSTK::ExprBase< Array< Type_, SizeRows_, SizeCols_ > >
CSTK::ExprBase< Identity< Type_, Size_ > >
CSTK::ExprBase< LowerTriangular< Type_, SizeRows_, SizeCols_ > >
CSTK::ExprBase< Point< Type_, Size_ > >
CSTK::ExprBase< Square< Type_, Size_ > >
CSTK::ExprBase< UpperTriangular< Type_, SizeRows_, SizeCols_ > >
CSTK::ExprBase< Vector< Type_, Size_ > >
►CSTK::ExprBase< DiagonalByArrayProduct< Lhs, Rhs > >
CSTK::DiagonalByArrayProduct< Lhs, Rhs >	Generic expression where a product operator is applied to two expressions
CSTK::ExprBase< DiagonalGetterAccessor< Lhs > >
►CSTK::ExprBase< DiagonalGetterOperator< Lhs > >
CSTK::DiagonalGetterOperator< Lhs >	Generic expression when we want to get the diagonal of a two-dimensional square expression
CSTK::ExprBase< DiagonalizeAccessor< Lhs > >
►CSTK::ExprBase< DiagonalizeOperator< Lhs > >
CSTK::DiagonalizeOperator< Lhs >	Generic expression when a one dimensional vector/point/idagonal expression is "diagonalized"
►CSTK::ExprBase< DotProduct< Lhs, Rhs > >
CSTK::DotProduct< Lhs, Rhs >	Generic expression where a DotProduct is applied to two expressions
CSTK::ExprBase< CArray< Real, SizeRows_, SizeCols_, Orient_ > >
CSTK::ExprBase< Array2DVector< Real > >
CSTK::ExprBase< LowerSymmetrizeAccessor< Lhs > >
►CSTK::ExprBase< LowerSymmetrizeOperator< Lhs > >
CSTK::LowerSymmetrizeOperator< Lhs >	Generic expression when we want to get the lower-part of a two-dimensional symmetric expression
CSTK::ExprBase< LowerTriangularizeAccessor< Lhs > >
►CSTK::ExprBase< LowerTriangularizeOperator< Lhs > >
CSTK::LowerTriangularizeOperator< Lhs >	Generic expression when we want to get the lower-part of a two-dimensional expression
►CSTK::ExprBase< PointByArrayProduct< Lhs, Rhs > >
CSTK::PointByArrayProduct< Lhs, Rhs >	Generic expression where a product operator is applied to two expressions
CSTK::ExprBase< Array2DUpperTriangular< Real > >
►CSTK::ExprBase< RowAccessor< Lhs > >
CSTK::RowAccessor< Lhs >	Generic expression when the row of an expression is accessed
►CSTK::ExprBase< RowOperator< Lhs > >
CSTK::RowOperator< Lhs >	Generic expression when the row of an expression is accessed
CSTK::ExprBase< SArray2D< Type_ > >
CSTK::ExprBase< SArray2DDiagonal< Type_ > >
CSTK::ExprBase< SArray2DLowerTriangular< Type_ > >
CSTK::ExprBase< SArray2DNumber< Type_ > >
CSTK::ExprBase< SArray2DPoint< Type_ > >
CSTK::ExprBase< SArray2DSquare< Type_ > >
CSTK::ExprBase< SArray2DUpperTriangular< Type_ > >
CSTK::ExprBase< SArray2DVector< Type_ > >
►CSTK::ExprBase< SubAccessor< Lhs, SizeRows_, SizeCols_ > >
CSTK::SubAccessor< Lhs, SizeRows_, SizeCols_ >	Generic expression when the sub-part of an expression is accessed
►CSTK::ExprBase< SubOperator< Lhs, SizeRows_, SizeCols_ > >
CSTK::SubOperator< Lhs, SizeRows_, SizeCols_ >	Generic expression when the sub-part of an expression is accessed
►CSTK::ExprBase< SubVectorAccessor< Lhs, Size_ > >
CSTK::SubVectorAccessorBase< Lhs, Size_, Arrays::diagonal_ >
CSTK::SubVectorAccessorBase< Lhs, Size_, Arrays::point_ >
CSTK::SubVectorAccessorBase< Lhs, Size_, Arrays::vector_ >
►CSTK::ExprBase< SubVectorOperator< Lhs, Size_ > >
CSTK::SubVectorOperatorBase< Lhs, Size_, Arrays::diagonal_ >
CSTK::SubVectorOperatorBase< Lhs, Size_, Arrays::point_ >
CSTK::SubVectorOperatorBase< Lhs, Size_, Arrays::vector_ >
CSTK::ExprBase< CArraySquare< Type, Size_, Orient_ > >
CSTK::ExprBase< CArrayVector< Type, SizeRows_, Orient_ > >
CSTK::ExprBase< CArrayVector< int, SizeRows_, Orient_ > >
CSTK::ExprBase< SymmetrizeAccessor< Lhs > >
►CSTK::ExprBase< SymmetrizeOperator< Lhs > >
CSTK::SymmetrizeOperator< Lhs >	Generic expression when we want to get the upper-part of a two-dimensional symmetric expression
CSTK::ExprBase< TransposeAccessor< Lhs > >
►CSTK::ExprBase< TransposeOperator< Lhs > >
CSTK::TransposeOperator< Lhs >	Generic expression when an expression is transposed
►CSTK::ExprBase< UnaryOperator< UnaryOp, Lhs > >
CSTK::UnaryOperator< UnaryOp, Lhs >	Generic expression when unary operator is applied to an expression
CSTK::ExprBase< UpperSymmetrizeAccessor< Lhs > >
►CSTK::ExprBase< UpperSymmetrizeOperator< Lhs > >
CSTK::UpperSymmetrizeOperator< Lhs >	Generic expression when we want to get the upper-part of a two-dimensional symmetric expression
CSTK::ExprBase< UpperTriangularizeAccessor< Lhs > >
►CSTK::ExprBase< UpperTriangularizeOperator< Lhs > >
CSTK::UpperTriangularizeOperator< Lhs >	Generic expression when we want to get the upper-part of a two-dimensional expression
►CSTK::ExprBase< VectorByPointProduct< Lhs, Rhs > >
CSTK::VectorByPointProduct< Lhs, Rhs >	Generic expression where a product operator is applied to two expressions
►CSTK::ExprBase< VisitorByCol< Derived, Visitor > >
CSTK::VisitorByCol< Derived, Visitor >	Class allowing to apply a visitor on each columns of an expression
►CSTK::ExprBase< VisitorByRow< Derived, Visitor > >
CSTK::VisitorByRow< Derived, Visitor >	Class allowing to apply a visitor on each columns of an expression
CSTK::ExprBase< Array2D< Real > >
CSTK::ExprBase< CArrayPoint< Type, SizeCols_, Orient_ > >
CSTK::ExprBase< CArrayPoint< Real, SizeCols_, Orient_ > >
CSTK::ExprBase< Array2D< Data::Type > >
CSTK::ExprBase< Array2DSquare< Real > >
CSTK::ExprBase< Array2DPoint< Real > >
CSTK::ExprBase< CArraySquare< Real, Size_, Orient_ > >
CSTK::ExprBase< Array2D< int > >
CSTK::ExprBase< CArrayVector< Real, SizeRows_, Orient_ > >
CSTK::ExprBase< Array2DDiagonal< Real > >
CSTK::ExprBase< Array2DVector< Type > >
CSTK::ExprBase< Array2DVector< int > >
CSTK::ExprBase< CArray< int, SizeRows_, SizeCols_, Orient_ > >
CSTK::ExprBase< CArrayPoint< int, SizeCols_, Orient_ > >
CSTK::ExprBase< CArrayPoint< STK::Array2DVector< Type >, SizeCols_, Orient_ > >
CSTK::ExprBase< CArrayPoint< Array2DVector< int >, SizeCols_, Orient_ > >
CSTK::ExprBase< CArrayPoint< EncodingMap, SizeCols_, Orient_ > >
CSTK::ExprBase< CArrayPoint< DecodingMap, SizeCols_, Orient_ > >
CSTK::ITContainer< Array2D< Data::Type >, hidden::Traits< Array2D< Data::Type > >::structure_ >
CSTK::ITContainer< Array2D< int >, hidden::Traits< Array2D< int > >::structure_ >
CSTK::ITContainer< Array2D< Real >, hidden::Traits< Array2D< Real > >::structure_ >
CSTK::ITContainer< Array2D< Type_ >, hidden::Traits< Array2D< Type_ > >::structure_ >
CSTK::ITContainer< Array2DDiagonal< Real >, hidden::Traits< Array2DDiagonal< Real > >::structure_ >
CSTK::ITContainer< Array2DDiagonal< Type_ >, hidden::Traits< Array2DDiagonal< Type_ > >::structure_ >
CSTK::ITContainer< Array2DLowerTriangular< Type_ >, hidden::Traits< Array2DLowerTriangular< Type_ > >::structure_ >
CSTK::ITContainer< Array2DNumber< Type_ >, hidden::Traits< Array2DNumber< Type_ > >::structure_ >
CSTK::ITContainer< Array2DPoint< int >, hidden::Traits< Array2DPoint< int > >::structure_ >
CSTK::ITContainer< Array2DPoint< Real >, hidden::Traits< Array2DPoint< Real > >::structure_ >
CSTK::ITContainer< Array2DPoint< Type_ >, hidden::Traits< Array2DPoint< Type_ > >::structure_ >
CSTK::ITContainer< Array2DSquare< Real >, hidden::Traits< Array2DSquare< Real > >::structure_ >
CSTK::ITContainer< Array2DSquare< Type_ >, hidden::Traits< Array2DSquare< Type_ > >::structure_ >
CSTK::ITContainer< Array2DUpperTriangular< Real >, hidden::Traits< Array2DUpperTriangular< Real > >::structure_ >
CSTK::ITContainer< Array2DUpperTriangular< Type_ >, hidden::Traits< Array2DUpperTriangular< Type_ > >::structure_ >
CSTK::ITContainer< Array2DVector< int >, hidden::Traits< Array2DVector< int > >::structure_ >
CSTK::ITContainer< Array2DVector< Real >, hidden::Traits< Array2DVector< Real > >::structure_ >
CSTK::ITContainer< Array2DVector< Type >, hidden::Traits< Array2DVector< Type > >::structure_ >
CSTK::ITContainer< Array2DVector< Type_ >, hidden::Traits< Array2DVector< Type_ > >::structure_ >
CSTK::ITContainer< Array< Type_, SizeRows_, SizeCols_ >, hidden::Traits< Array< Type_, SizeRows_, SizeCols_ > >::structure_ >
CSTK::ITContainer< ArrayByArrayProduct< Lhs, Rhs >, hidden::Traits< ArrayByArrayProduct< Lhs, Rhs > >::structure_ >
CSTK::ITContainer< ArrayByDiagonalProduct< Lhs, Rhs >, hidden::Traits< ArrayByDiagonalProduct< Lhs, Rhs > >::structure_ >
CSTK::ITContainer< ArrayByVectorProduct< Lhs, Rhs >, hidden::Traits< ArrayByVectorProduct< Lhs, Rhs > >::structure_ >
CSTK::ITContainer< BinaryOperator< FunctorOp, Lhs, Rhs >, hidden::Traits< BinaryOperator< FunctorOp, Lhs, Rhs > >::structure_ >
CSTK::ITContainer< CArray< int, SizeRows_, SizeCols_, Orient_ >, hidden::Traits< CArray< int, SizeRows_, SizeCols_, Orient_ > >::structure_ >
CSTK::ITContainer< CArray< Real, SizeRows_, SizeCols_, Orient_ >, hidden::Traits< CArray< Real, SizeRows_, SizeCols_, Orient_ > >::structure_ >
CSTK::ITContainer< CArray< Type_, SizeRows_, SizeCols_, Orient_ >, hidden::Traits< CArray< Type_, SizeRows_, SizeCols_, Orient_ > >::structure_ >
CSTK::ITContainer< CArrayNumber< Type_, Orient_ >, hidden::Traits< CArrayNumber< Type_, Orient_ > >::structure_ >
CSTK::ITContainer< CArrayPoint< Array2DVector< int >, SizeCols_, Orient_ >, hidden::Traits< CArrayPoint< Array2DVector< int >, SizeCols_, Orient_ > >::structure_ >
CSTK::ITContainer< CArrayPoint< DecodingMap, SizeCols_, Orient_ >, hidden::Traits< CArrayPoint< DecodingMap, SizeCols_, Orient_ > >::structure_ >
CSTK::ITContainer< CArrayPoint< EncodingMap, SizeCols_, Orient_ >, hidden::Traits< CArrayPoint< EncodingMap, SizeCols_, Orient_ > >::structure_ >
CSTK::ITContainer< CArrayPoint< int, SizeCols_, Orient_ >, hidden::Traits< CArrayPoint< int, SizeCols_, Orient_ > >::structure_ >
CSTK::ITContainer< CArrayPoint< Real, SizeCols_, Orient_ >, hidden::Traits< CArrayPoint< Real, SizeCols_, Orient_ > >::structure_ >
CSTK::ITContainer< CArrayPoint< STK::Array2DVector< Type >, SizeCols_, Orient_ >, hidden::Traits< CArrayPoint< STK::Array2DVector< Type >, SizeCols_, Orient_ > >::structure_ >
CSTK::ITContainer< CArrayPoint< Type, SizeCols_, Orient_ >, hidden::Traits< CArrayPoint< Type, SizeCols_, Orient_ > >::structure_ >
CSTK::ITContainer< CArrayPoint< Type_, SizeCols_, Orient_ >, hidden::Traits< CArrayPoint< Type_, SizeCols_, Orient_ > >::structure_ >
CSTK::ITContainer< CArraySquare< Real, Size_, Orient_ >, hidden::Traits< CArraySquare< Real, Size_, Orient_ > >::structure_ >
CSTK::ITContainer< CArraySquare< Type, Size_, Orient_ >, hidden::Traits< CArraySquare< Type, Size_, Orient_ > >::structure_ >
CSTK::ITContainer< CArraySquare< Type_, Size_, Orient_ >, hidden::Traits< CArraySquare< Type_, Size_, Orient_ > >::structure_ >
CSTK::ITContainer< CArrayVector< int, SizeRows_, Orient_ >, hidden::Traits< CArrayVector< int, SizeRows_, Orient_ > >::structure_ >
CSTK::ITContainer< CArrayVector< Real, SizeRows_, Orient_ >, hidden::Traits< CArrayVector< Real, SizeRows_, Orient_ > >::structure_ >
CSTK::ITContainer< CArrayVector< Type, SizeRows_, Orient_ >, hidden::Traits< CArrayVector< Type, SizeRows_, Orient_ > >::structure_ >
CSTK::ITContainer< CArrayVector< Type_, SizeRows_, Orient_ >, hidden::Traits< CArrayVector< Type_, SizeRows_, Orient_ > >::structure_ >
CSTK::ITContainer< ColAccessor< Lhs >, hidden::Traits< ColAccessor< Lhs > >::structure_ >
CSTK::ITContainer< ColOperator< Lhs >, hidden::Traits< ColOperator< Lhs > >::structure_ >
►CSTK::ITContainer< Derived, hidden::Traits< Derived >::structure_ >
►CSTK::ExprBase< Derived >	Base class for template evaluation expressions and visitors
CSTK::ArrayBase< Array2D< Type_ > >
CSTK::ArrayBase< Array2DDiagonal< Type_ > >
CSTK::ArrayBase< Array2DLowerTriangular< Type_ > >
CSTK::ArrayBase< Array2DNumber< Type_ > >
CSTK::ArrayBase< Array2DPoint< Type_ > >
CSTK::ArrayBase< Array2DSquare< Type_ > >
CSTK::ArrayBase< Array2DUpperTriangular< Type_ > >
CSTK::ArrayBase< Array2DVector< Type_ > >
CSTK::ArrayBase< CArray< Type_, SizeRows_, SizeCols_, Orient_ > >
CSTK::ArrayBase< CArrayNumber< Type_, Orient_ > >
CSTK::ArrayBase< CArrayPoint< Type_, SizeCols_, Orient_ > >
CSTK::ArrayBase< CArraySquare< Type_, Size_, Orient_ > >
CSTK::ArrayBase< CArrayVector< Type_, SizeRows_, Orient_ > >
CSTK::ArrayBase< Array2DPoint< int > >
►CSTK::ArrayBase< DiagonalGetterAccessor< Lhs > >
CSTK::DiagonalGetterAccessor< Lhs >	Generic expression when we want to get the diagonal of a two-dimensional square expression
►CSTK::ArrayBase< DiagonalizeAccessor< Lhs > >
CSTK::DiagonalizeAccessor< Lhs >	Generic expression when a one dimensional vector/point/idagonal expression is "diagonalized"
CSTK::ArrayBase< CArray< Real, SizeRows_, SizeCols_, Orient_ > >
CSTK::ArrayBase< Array2DVector< Real > >
►CSTK::ArrayBase< LowerSymmetrizeAccessor< Lhs > >
CSTK::LowerSymmetrizeAccessor< Lhs >	Generic expression when we want to get the lower-part of a two-dimensional symmetric expression
►CSTK::ArrayBase< LowerTriangularizeAccessor< Lhs > >
CSTK::LowerTriangularizeAccessor< Lhs >	Generic expression when we want to get the lower-part of a two-dimensional expression
CSTK::ArrayBase< Array2DUpperTriangular< Real > >
CSTK::ArrayBase< SArray2D< Type_ > >
CSTK::ArrayBase< SArray2DDiagonal< Type_ > >
CSTK::ArrayBase< SArray2DLowerTriangular< Type_ > >
CSTK::ArrayBase< SArray2DNumber< Type_ > >
CSTK::ArrayBase< SArray2DPoint< Type_ > >
CSTK::ArrayBase< SArray2DSquare< Type_ > >
CSTK::ArrayBase< SArray2DUpperTriangular< Type_ > >
CSTK::ArrayBase< SArray2DVector< Type_ > >
CSTK::ArrayBase< CArraySquare< Type, Size_, Orient_ > >
CSTK::ArrayBase< CArrayVector< Type, SizeRows_, Orient_ > >
CSTK::ArrayBase< CArrayVector< int, SizeRows_, Orient_ > >
►CSTK::ArrayBase< SymmetrizeAccessor< Lhs > >
CSTK::SymmetrizeAccessor< Lhs >	Generic expression when we want to get the upper-part of a two-dimensional symmetric expression
►CSTK::ArrayBase< TransposeAccessor< Lhs > >
CSTK::TransposeAccessor< Lhs >	Generic expression when an expression is transposed
►CSTK::ArrayBase< UpperSymmetrizeAccessor< Lhs > >
CSTK::UpperSymmetrizeAccessor< Lhs >	Generic expression when we want to get the upper-part of a two-dimensional symmetric expression
►CSTK::ArrayBase< UpperTriangularizeAccessor< Lhs > >
CSTK::UpperTriangularizeAccessor< Lhs >	Generic expression when we want to get the upper-part of a two-dimensional expression
CSTK::ArrayBase< Array2D< Real > >
CSTK::ArrayBase< CArrayPoint< Type, SizeCols_, Orient_ > >
CSTK::ArrayBase< CArrayPoint< Real, SizeCols_, Orient_ > >
CSTK::ArrayBase< Array2D< Data::Type > >
CSTK::ArrayBase< Array2DSquare< Real > >
CSTK::ArrayBase< Array2DPoint< Real > >
CSTK::ArrayBase< CArraySquare< Real, Size_, Orient_ > >
CSTK::ArrayBase< Array2D< int > >
CSTK::ArrayBase< CArrayVector< Real, SizeRows_, Orient_ > >
CSTK::ArrayBase< Array2DDiagonal< Real > >
CSTK::ArrayBase< Array2DVector< Type > >
CSTK::ArrayBase< Array2DVector< int > >
CSTK::ArrayBase< CArray< int, SizeRows_, SizeCols_, Orient_ > >
CSTK::ArrayBase< CArrayPoint< int, SizeCols_, Orient_ > >
CSTK::ArrayBase< CArrayPoint< STK::Array2DVector< Type >, SizeCols_, Orient_ > >
CSTK::ArrayBase< CArrayPoint< Array2DVector< int >, SizeCols_, Orient_ > >
CSTK::ArrayBase< CArrayPoint< EncodingMap, SizeCols_, Orient_ > >
CSTK::ArrayBase< CArrayPoint< DecodingMap, SizeCols_, Orient_ > >
CSTK::Const::IConstArray< Array< Type_, SizeRows_, SizeCols_ > >
CSTK::Const::IConstArray< Identity< Type_, Size_ > >
CSTK::Const::IConstArray< LowerTriangular< Type_, SizeRows_, SizeCols_ > >
CSTK::Const::IConstArray< Point< Type_, Size_ > >
CSTK::Const::IConstArray< Square< Type_, Size_ > >
CSTK::Const::IConstArray< UpperTriangular< Type_, SizeRows_, SizeCols_ > >
CSTK::Const::IConstArray< Vector< Type_, Size_ > >
►CSTK::ArrayBase< Derived >	Base class for template arrays
CSTK::IArray2D< Array2D< Type_ > >
CSTK::IArray2D< Array2DDiagonal< Type_ > >
CSTK::IArray2D< Array2DLowerTriangular< Type_ > >
CSTK::IArray2D< Array2DNumber< Type_ > >
CSTK::IArray2D< Array2DPoint< Type_ > >
CSTK::IArray2D< Array2DSquare< Type_ > >
CSTK::IArray2D< Array2DUpperTriangular< Type_ > >
CSTK::IArray2D< Array2DVector< Type_ > >
CSTK::IArray2D< Array2DPoint< int > >
CSTK::IArray2D< Array2DVector< Real > >
CSTK::IArray2D< Array2DUpperTriangular< Real > >
CSTK::IArray2D< SArray2D< Type_ > >
CSTK::IArray2D< SArray2DDiagonal< Type_ > >
CSTK::IArray2D< SArray2DLowerTriangular< Type_ > >
CSTK::IArray2D< SArray2DNumber< Type_ > >
CSTK::IArray2D< SArray2DPoint< Type_ > >
CSTK::IArray2D< SArray2DSquare< Type_ > >
CSTK::IArray2D< SArray2DUpperTriangular< Type_ > >
CSTK::IArray2D< SArray2DVector< Type_ > >
CSTK::IArray2D< Array2D< Real > >
CSTK::IArray2D< Array2D< Data::Type > >
CSTK::IArray2D< Array2DSquare< Real > >
CSTK::IArray2D< Array2DPoint< Real > >
CSTK::IArray2D< Array2D< int > >
CSTK::IArray2D< Array2DDiagonal< Real > >
CSTK::IArray2D< Array2DVector< Type > >
CSTK::IArray2D< Array2DVector< int > >
►CSTK::ICArray< CArray< Type_, SizeRows_, SizeCols_, Orient_ > >
CSTK::CArray< Type_, SizeRows_, SizeCols_, Orient_ >	A CArray is a two dimensional array with a continuous storage like a C-array
►CSTK::ICArray< CArrayNumber< Type_, Orient_ > >
CSTK::CArrayNumber< Type_, Orient_ >	Specialization for the number case
►CSTK::ICArray< CArrayPoint< Type_, SizeCols_, Orient_ > >
CSTK::CArrayPoint< Type_, SizeCols_, Orient_ >	Declaration of the point case
►CSTK::ICArray< CArraySquare< Type_, Size_, Orient_ > >
CSTK::CArraySquare< Type_, Size_, Orient_ >	Specialization for the square case
►CSTK::ICArray< CArrayVector< Type_, SizeRows_, Orient_ > >
CSTK::CArrayVector< Type_, SizeRows_, Orient_ >	Specialization for the vector case
CSTK::ICArray< CArray< Real, SizeRows_, SizeCols_, Orient_ > >
CSTK::ICArray< CArraySquare< Type, Size_, Orient_ > >
CSTK::ICArray< CArrayVector< Type, SizeRows_, Orient_ > >
CSTK::ICArray< CArrayVector< int, SizeRows_, Orient_ > >
CSTK::ICArray< CArrayPoint< Type, SizeCols_, Orient_ > >
CSTK::ICArray< CArrayPoint< Real, SizeCols_, Orient_ > >
CSTK::ICArray< CArraySquare< Real, Size_, Orient_ > >
CSTK::ICArray< CArrayVector< Real, SizeRows_, Orient_ > >
CSTK::ICArray< CArray< int, SizeRows_, SizeCols_, Orient_ > >
CSTK::ICArray< CArrayPoint< int, SizeCols_, Orient_ > >
CSTK::ICArray< CArrayPoint< STK::Array2DVector< Type >, SizeCols_, Orient_ > >
CSTK::ICArray< CArrayPoint< Array2DVector< int >, SizeCols_, Orient_ > >
CSTK::ICArray< CArrayPoint< EncodingMap, SizeCols_, Orient_ > >
CSTK::ICArray< CArrayPoint< DecodingMap, SizeCols_, Orient_ > >
CSTK::IArray2D< Derived >	Template interface base class for two-dimensional arrays
►CSTK::ICArray< Derived >	S
CSTK::CArray< Real, UnknownSize, UnknownSize, Arrays::by_col_ >
CSTK::CArray< int, UnknownSize, UnknownSize, Arrays::by_col_ >
CSTK::CArrayPoint< Type, sizeCols_ >
CSTK::CArrayPoint< Real, UnknownSize, Arrays::by_col_ >
CSTK::CArrayPoint< int, UnknownSize, Arrays::by_col_ >
CSTK::CArrayPoint< STK::Array2DVector< Type > >
CSTK::CArrayPoint< Array2DVector< int > >
CSTK::CArrayPoint< EncodingMap >
CSTK::CArrayPoint< DecodingMap >
CSTK::CArraySquare< Type, size_ >
CSTK::CArraySquare< Real, UnknownSize, Arrays::by_col_ >
CSTK::CArrayVector< Type, size_ >
CSTK::CArrayVector< int, UnknownSize, Arrays::by_col_ >
CSTK::CArrayVector< Type, sizeRows_ >
CSTK::CArrayVector< Real, UnknownSize, Arrays::by_col_ >
CSTK::Const::IConstArray< Derived >
CSTK::ITContainer< DiagonalByArrayProduct< Lhs, Rhs >, hidden::Traits< DiagonalByArrayProduct< Lhs, Rhs > >::structure_ >
CSTK::ITContainer< DiagonalGetterAccessor< Lhs >, hidden::Traits< DiagonalGetterAccessor< Lhs > >::structure_ >
CSTK::ITContainer< DiagonalGetterOperator< Lhs >, hidden::Traits< DiagonalGetterOperator< Lhs > >::structure_ >
CSTK::ITContainer< DiagonalizeAccessor< Lhs >, hidden::Traits< DiagonalizeAccessor< Lhs > >::structure_ >
CSTK::ITContainer< DiagonalizeOperator< Lhs >, hidden::Traits< DiagonalizeOperator< Lhs > >::structure_ >
CSTK::ITContainer< DotProduct< Lhs, Rhs >, hidden::Traits< DotProduct< Lhs, Rhs > >::structure_ >
CSTK::ITContainer< Identity< Type_, Size_ >, hidden::Traits< Identity< Type_, Size_ > >::structure_ >
CSTK::ITContainer< LowerSymmetrizeAccessor< Lhs >, hidden::Traits< LowerSymmetrizeAccessor< Lhs > >::structure_ >
CSTK::ITContainer< LowerSymmetrizeOperator< Lhs >, hidden::Traits< LowerSymmetrizeOperator< Lhs > >::structure_ >
CSTK::ITContainer< LowerTriangular< Type_, SizeRows_, SizeCols_ >, hidden::Traits< LowerTriangular< Type_, SizeRows_, SizeCols_ > >::structure_ >
CSTK::ITContainer< LowerTriangularizeAccessor< Lhs >, hidden::Traits< LowerTriangularizeAccessor< Lhs > >::structure_ >
CSTK::ITContainer< LowerTriangularizeOperator< Lhs >, hidden::Traits< LowerTriangularizeOperator< Lhs > >::structure_ >
CSTK::ITContainer< Point< Type_, Size_ >, hidden::Traits< Point< Type_, Size_ > >::structure_ >
CSTK::ITContainer< PointByArrayProduct< Lhs, Rhs >, hidden::Traits< PointByArrayProduct< Lhs, Rhs > >::structure_ >
CSTK::ITContainer< RowAccessor< Lhs >, hidden::Traits< RowAccessor< Lhs > >::structure_ >
CSTK::ITContainer< RowOperator< Lhs >, hidden::Traits< RowOperator< Lhs > >::structure_ >
CSTK::ITContainer< SArray2D< Type_ >, hidden::Traits< SArray2D< Type_ > >::structure_ >
CSTK::ITContainer< SArray2DDiagonal< Type_ >, hidden::Traits< SArray2DDiagonal< Type_ > >::structure_ >
CSTK::ITContainer< SArray2DLowerTriangular< Type_ >, hidden::Traits< SArray2DLowerTriangular< Type_ > >::structure_ >
CSTK::ITContainer< SArray2DNumber< Type_ >, hidden::Traits< SArray2DNumber< Type_ > >::structure_ >
CSTK::ITContainer< SArray2DPoint< Type_ >, hidden::Traits< SArray2DPoint< Type_ > >::structure_ >
CSTK::ITContainer< SArray2DSquare< Type_ >, hidden::Traits< SArray2DSquare< Type_ > >::structure_ >
CSTK::ITContainer< SArray2DUpperTriangular< Type_ >, hidden::Traits< SArray2DUpperTriangular< Type_ > >::structure_ >
CSTK::ITContainer< SArray2DVector< Type_ >, hidden::Traits< SArray2DVector< Type_ > >::structure_ >
CSTK::ITContainer< Square< Type_, Size_ >, hidden::Traits< Square< Type_, Size_ > >::structure_ >
CSTK::ITContainer< SubAccessor< Lhs, SizeRows_, SizeCols_ >, hidden::Traits< SubAccessor< Lhs, SizeRows_, SizeCols_ > >::structure_ >
CSTK::ITContainer< SubOperator< Lhs, SizeRows_, SizeCols_ >, hidden::Traits< SubOperator< Lhs, SizeRows_, SizeCols_ > >::structure_ >
CSTK::ITContainer< SubVectorAccessor< Lhs, Size_ >, hidden::Traits< SubVectorAccessor< Lhs, Size_ > >::structure_ >
CSTK::ITContainer< SubVectorOperator< Lhs, Size_ >, hidden::Traits< SubVectorOperator< Lhs, Size_ > >::structure_ >
CSTK::ITContainer< SymmetrizeAccessor< Lhs >, hidden::Traits< SymmetrizeAccessor< Lhs > >::structure_ >
CSTK::ITContainer< SymmetrizeOperator< Lhs >, hidden::Traits< SymmetrizeOperator< Lhs > >::structure_ >
CSTK::ITContainer< TransposeAccessor< Lhs >, hidden::Traits< TransposeAccessor< Lhs > >::structure_ >
CSTK::ITContainer< TransposeOperator< Lhs >, hidden::Traits< TransposeOperator< Lhs > >::structure_ >
CSTK::ITContainer< UnaryOperator< UnaryOp, Lhs >, hidden::Traits< UnaryOperator< UnaryOp, Lhs > >::structure_ >
CSTK::ITContainer< UpperSymmetrizeAccessor< Lhs >, hidden::Traits< UpperSymmetrizeAccessor< Lhs > >::structure_ >
CSTK::ITContainer< UpperSymmetrizeOperator< Lhs >, hidden::Traits< UpperSymmetrizeOperator< Lhs > >::structure_ >
CSTK::ITContainer< UpperTriangular< Type_, SizeRows_, SizeCols_ >, hidden::Traits< UpperTriangular< Type_, SizeRows_, SizeCols_ > >::structure_ >
CSTK::ITContainer< UpperTriangularizeAccessor< Lhs >, hidden::Traits< UpperTriangularizeAccessor< Lhs > >::structure_ >
CSTK::ITContainer< UpperTriangularizeOperator< Lhs >, hidden::Traits< UpperTriangularizeOperator< Lhs > >::structure_ >
CSTK::ITContainer< Vector< Type_, Size_ >, hidden::Traits< Vector< Type_, Size_ > >::structure_ >
CSTK::ITContainer< VectorByPointProduct< Lhs, Rhs >, hidden::Traits< VectorByPointProduct< Lhs, Rhs > >::structure_ >
CSTK::ITContainer< VisitorByCol< Derived, Visitor >, hidden::Traits< VisitorByCol< Derived, Visitor > >::structure_ >
CSTK::ITContainer< VisitorByRow< Derived, Visitor >, hidden::Traits< VisitorByRow< Derived, Visitor > >::structure_ >
CSTK::hidden::IteratorTraits< Derived >	,
CSTK::hidden::IteratorTraits< BiDirectionalIterator< Array > >
CSTK::hidden::IteratorTraits< BiDirectionalIterator< Array_ > >	Specialization for the BiDirectionalIterator iterator class
CSTK::hidden::IteratorTraits< ConstBiDirectionalIterator< Array > >
CSTK::hidden::IteratorTraits< ConstBiDirectionalIterator< Array_ > >	Specialization for the ConstBiDirectionalIterator iterator class
CSTK::hidden::IteratorTraits< ConstDenseRandomIterator< Array > >
CSTK::hidden::IteratorTraits< ConstDenseRandomIterator< Array_ > >	Specialization of the IteratorTraits for the ConstDenseRandomIterator iterator class
CSTK::hidden::IteratorTraits< DenseRandomIterator< Array_ > >	Specialization of the IteratorTraits class for the DenseRandomIterator iterator class
►CSTK::IVariable	IVariable is an Interface class for all Variables classes
CSTK::Variable< Real >
CSTK::Variable< Type_ >	Variable is an implementation of the Base class IVariable using The Array1D class for storing the data
CSTK::LeqOp< Type1, Type2 >	Template functor testing if a number is less or equal than an other number
CSTK::LeqThanOp< Type >	Template functor to test if a number is less or equal than a fixed value
CSTK::LessOp< Type1, Type2 >	Template functor testing if a number is less than an other number
CSTK::LessThanOp< Type >	Template functor to test if a number is less than a fixed value
CSTK::Law::LogCdfcOp< Type >	,
CSTK::Law::LogCdfOp< Type >	,
CSTK::LogicalAndOp< Type1, Type2 >	Template functor which compute the logical and of two numbers
CSTK::LogicalAndWithOp< Type >	Template functor computing logical and with a fixed value
CSTK::LogicalOrOp< Type1, Type2 >	Template functor which compute the logical or of two numbers
CSTK::LogicalOrWithOp< Type >	Template functor computing logical and with a fixed value
CSTK::LogOp< Type >	Template functor which compute the logarithm of a number
CSTK::Law::LogPdfOp< Type >	,
CSTK::MaxOp< Type1, Type2 >	Template functor which compute the maximum of two numbers
CSTK::Stat::MaxOp< Derived >	Compute the maximal value of the variable V
CSTK::Stat::MaxSafeOp< Derived >	Compute safely the maximal value of the variable V
CSTK::hidden::MaxSafeVisitor< Type_ >	Visitor computing safely the max of all the coefficients of the Array
CSTK::hidden::MaxVisitor< Type_ >	Visitor computing the max of all the coefficients of the Array
CSTK::MaxWithOp< Type >	Template functor to compute the minimum with a fixed value
CSTK::Stat::MeanOp< Derived >	Compute the mean of the variable V
CSTK::Stat::MeanSafeOp< Derived >	Compute safely mean of the variable V
CSTK::hidden::MeanSafeVisitor< Type_ >	Visitor computing safely the mean of all the coefficients of the Array
CSTK::hidden::MeanVisitor< Type_ >	Visitor computing the mean of all the coefficients of the Array
CSTK::hidden::MemChooser< int, Type_ >	:: :: fundamental types
CSTK::hidden::MemChooser< 0, Type_ >	Specialization for other types using loop and operator=
CSTK::hidden::MemChooser< 1, Type_ >	Specialization for fundamental types
CSTK::hidden::MemHandler< Type_, Size_ >	Helper class allowing to free memory (or not)
CSTK::hidden::MemHandler< Type_, UnknownSize >	Specialization for dynamic size arrays
CSTK::MinOp< Type1, Type2 >	Template functor which compute the minimum of two numbers
CSTK::Stat::MinOp< Derived >	Compute the minimal value of the variable V
CSTK::Stat::MinSafeOp< Derived >	Compute safely the minimal value of the variable V
CSTK::hidden::MinSafeVisitor< Type_ >	Visitor computing safely the min of all the coefficients of the Array
CSTK::hidden::MinVisitor< Type_ >	Visitor computing the min of all the coefficients of the Array
CSTK::MinWithOp< Type >	Template functor to compute the minimum between a fixed value
CSTK::hidden::MixtureBridgeTraits< Derived >	MixtureBridgeTraits struct for bridged mixtures The traits struct MixtureBridgeTraits must be specialized for any Mixture deriving from the Interface IMixtureBridge
CSTK::hidden::MixtureBridgeTraits< CategoricalBridge< Clust::Categorical_pjk_, Data_ > >	Partial specialization of the MixtureBridgeTraits for the Categorical_pjk model
CSTK::hidden::MixtureBridgeTraits< CategoricalBridge< Clust::Categorical_pk_, Data_ > >	Partial specialization of the MixtureBridgeTraits for the Categorical_pk model
CSTK::hidden::MixtureBridgeTraits< CategoricalBridge< Id, Data > >
CSTK::hidden::MixtureBridgeTraits< DiagGaussianBridge< Clust::Gaussian_s_, Data_ > >	Partial specialization of the MixtureBridgeTraits for the DiagGaussian_s model
CSTK::hidden::MixtureBridgeTraits< DiagGaussianBridge< Clust::Gaussian_sj_, Data_ > >	Partial specialization of the MixtureBridgeTraits for the DiagGaussian_sj model
CSTK::hidden::MixtureBridgeTraits< DiagGaussianBridge< Clust::Gaussian_sjk_, Data_ > >	Partial specialization of the MixtureBridgeTraits for the DiagGaussian_sjk model
CSTK::hidden::MixtureBridgeTraits< DiagGaussianBridge< Clust::Gaussian_sjsk_, Data_ > >	Partial specialization of the MixtureBridgeTraits for the DiagGaussian_sjsk model
CSTK::hidden::MixtureBridgeTraits< DiagGaussianBridge< Clust::Gaussian_sk_, Data_ > >	Partial specialization of the MixtureBridgeTraits for the DiagGaussian_sk model
CSTK::hidden::MixtureBridgeTraits< DiagGaussianBridge< Id, Data > >
CSTK::hidden::MixtureBridgeTraits< GammaBridge< Clust::Gamma_a_bjk_, Data_ > >	Partial specialization of the MixtureBridgeTraits for the Gamma_a_bjk_ model
CSTK::hidden::MixtureBridgeTraits< GammaBridge< Clust::Gamma_a_bk_, Data_ > >	Partial specialization of the MixtureBridgeTraits for the Gamma_a_bk_ model
CSTK::hidden::MixtureBridgeTraits< GammaBridge< Clust::Gamma_aj_bjk_, Data_ > >	Partial specialization of the MixtureBridgeTraits for the Gamma_aj_bjk_ model
CSTK::hidden::MixtureBridgeTraits< GammaBridge< Clust::Gamma_aj_bk_, Data_ > >	Partial specialization of the MixtureBridgeTraits for the Gamma_aj_bk_ model
CSTK::hidden::MixtureBridgeTraits< GammaBridge< Clust::Gamma_ajk_b_, Data_ > >	Partial specialization of the MixtureBridgeTraits for the Gamma_ajk_b_ model
CSTK::hidden::MixtureBridgeTraits< GammaBridge< Clust::Gamma_ajk_bj_, Data_ > >	Partial specialization of the MixtureBridgeTraits for the Gamma_ajk_bj_ model
CSTK::hidden::MixtureBridgeTraits< GammaBridge< Clust::Gamma_ajk_bjk_, Data_ > >	Partial specialization of the MixtureBridgeTraits for the Gamma_ajk_bjk_ model
CSTK::hidden::MixtureBridgeTraits< GammaBridge< Clust::Gamma_ajk_bk_, Data_ > >	Partial specialization of the MixtureBridgeTraits for the Gamma_ajk_bk_ model
CSTK::hidden::MixtureBridgeTraits< GammaBridge< Clust::Gamma_ak_b_, Data_ > >	Partial specialization of the MixtureBridgeTraits for the Gamma_ak_b_ model
CSTK::hidden::MixtureBridgeTraits< GammaBridge< Clust::Gamma_ak_bj_, Data_ > >	Partial specialization of the MixtureBridgeTraits for the Gamma_ak_bj_ model
CSTK::hidden::MixtureBridgeTraits< GammaBridge< Clust::Gamma_ak_bjk_, Data_ > >	Partial specialization of the MixtureBridgeTraits for the Gamma_ak_bjk_ model
CSTK::hidden::MixtureBridgeTraits< GammaBridge< Clust::Gamma_ak_bk_, Data_ > >	Partial specialization of the MixtureBridgeTraits for the Gamma_ak_bk_ model
CSTK::hidden::MixtureBridgeTraits< GammaBridge< Id, Data > >
CSTK::hidden::MixtureBridgeTraits< HDGaussianBridge< Clust::HDGaussian_AjkBkQkD_, Data_ > >	Partial specialization of the MixtureBridgeTraits for the HDGaussian_ajk_bk_qk_d_ model
CSTK::hidden::MixtureBridgeTraits< HDGaussianBridge< Id, Data > >
CSTK::hidden::MixtureBridgeTraits< HDMatrixGaussianBridge< IdRow, IdCol, Data > >
CSTK::hidden::MixtureBridgeTraits< HDMatrixGaussianBridge< IdRow_, IdCol_, Data_ > >	Partial specialization of the MixtureBridgeTraits for the HDCovariance_AjkBkQkDk model
CSTK::hidden::MixtureBridgeTraits< KmmBridge< Clust::Kmm_s_, Data_ > >	Partial specialization of the MixtureBridgeTraits for the Kmm_s_ model
CSTK::hidden::MixtureBridgeTraits< KmmBridge< Clust::Kmm_sk_, Data_ > >	Partial specialization of the MixtureBridgeTraits for the Kmm_sk_ model
CSTK::hidden::MixtureBridgeTraits< KmmBridge< Id, Data > >
CSTK::hidden::MixtureBridgeTraits< PoissonBridge< Clust::Poisson_ljk_, Data_ > >	Partial specialization of the MixtureBridgeTraits for the STK::Poisson_ljk mixture model
CSTK::hidden::MixtureBridgeTraits< PoissonBridge< Clust::Poisson_ljlk_, Data_ > >	Partial specialization of the MixtureBridgeTraits for the STK::Poisson_ljlk mixture model
CSTK::hidden::MixtureBridgeTraits< PoissonBridge< Clust::Poisson_lk_, Data_ > >	Partial specialization of the MixtureBridgeTraits for the STK::Poisson_lk mixture model
CSTK::hidden::MixtureBridgeTraits< PoissonBridge< Id, Data > >
CSTK::MixtureComposerFacade< DataHandler_ >	The MixtureComposerFacade allows to interact with a composer for estimating a mixture model with less effort
CSTK::hidden::MixtureManagerTraits< Manager >	Main class for the mixture managers traits policy
CSTK::hidden::MixtureManagerTraits< CategoricalMixtureManager< DataHandler_ > >	Partial specialization for CategoricalMixtureManager
CSTK::hidden::MixtureManagerTraits< DiagGaussianMixtureManager< DataHandler_ > >	Specialization for Clust::Categorical_ mixtures
CSTK::hidden::MixtureManagerTraits< GammaMixtureManager< DataHandler_ > >	Specialization for GammaMixtureManager
CSTK::hidden::MixtureManagerTraits< KernelMixtureManager >	Specialization for KernelMixtureManager
CSTK::hidden::MixtureManagerTraits< PoissonMixtureManager< DataHandler_ > >	Partial specialization for PoissonMixtureManager
CSTK::Clust::MixtureTraits< Mixture >	Main class for the mixtures traits policy
CSTK::hidden::MixtureTraits< Mixture >	Main class for the mixtures traits policy
CSTK::hidden::MixtureTraits< Categorical_pjk< Array > >
CSTK::hidden::MixtureTraits< Categorical_pjk< Array_ > >	Traits class for the Categorical_pjk traits policy
CSTK::hidden::MixtureTraits< Categorical_pk< Array > >
CSTK::hidden::MixtureTraits< Categorical_pk< Array_ > >	Traits class for the Categorical_pk traits policy
CSTK::hidden::MixtureTraits< Derived >
CSTK::hidden::MixtureTraits< DiagGaussian_s< Array > >
CSTK::hidden::MixtureTraits< DiagGaussian_s< Array_ > >	Traits class for the DiagGaussian_s traits policy
CSTK::hidden::MixtureTraits< DiagGaussian_sj< Array > >
CSTK::hidden::MixtureTraits< DiagGaussian_sj< Array_ > >	Traits class for the Gaussian_s traits policy
CSTK::hidden::MixtureTraits< DiagGaussian_sjk< Array > >
CSTK::hidden::MixtureTraits< DiagGaussian_sjk< Array_ > >	Traits class for the DiagGaussian_sjk traits policy
CSTK::hidden::MixtureTraits< DiagGaussian_sjsk< Array > >
CSTK::hidden::MixtureTraits< DiagGaussian_sjsk< Array_ > >	Traits class for the DiagGaussian_sjsk traits policy
CSTK::hidden::MixtureTraits< DiagGaussian_sk< Array > >
CSTK::hidden::MixtureTraits< DiagGaussian_sk< Array_ > >	Traits class for the DiagGaussian_sk traits policy
CSTK::hidden::MixtureTraits< Gamma_a_bjk< Array > >
CSTK::hidden::MixtureTraits< Gamma_a_bjk< Array_ > >	Traits class for the Gamma_a_bjk traits policy
CSTK::hidden::MixtureTraits< Gamma_a_bk< Array > >
CSTK::hidden::MixtureTraits< Gamma_a_bk< Array_ > >	Traits class for the Gamma_a_bk traits policy
CSTK::hidden::MixtureTraits< Gamma_aj_bjk< Array > >
CSTK::hidden::MixtureTraits< Gamma_aj_bjk< Array_ > >	Traits class for the Gamma_aj_bjk traits policy
CSTK::hidden::MixtureTraits< Gamma_aj_bk< Array > >
CSTK::hidden::MixtureTraits< Gamma_aj_bk< Array_ > >	Traits class for the Gamma_aj_bk traits policy
CSTK::hidden::MixtureTraits< Gamma_ajk_b< Array > >
CSTK::hidden::MixtureTraits< Gamma_ajk_b< Array_ > >	Traits class for the Gamma_ajk_b traits policy
CSTK::hidden::MixtureTraits< Gamma_ajk_bj< Array > >
CSTK::hidden::MixtureTraits< Gamma_ajk_bj< Array_ > >	Traits class for the Gamma_ajk_bj traits policy
CSTK::hidden::MixtureTraits< Gamma_ajk_bjk< Array > >
CSTK::hidden::MixtureTraits< Gamma_ajk_bjk< Array_ > >	Traits class for the Gamma_ajk_bjk traits policy
CSTK::hidden::MixtureTraits< Gamma_ajk_bk< Array > >
CSTK::hidden::MixtureTraits< Gamma_ajk_bk< Array_ > >	Traits class for the Gamma_ajk_bk traits policy
CSTK::hidden::MixtureTraits< Gamma_ak_b< Array > >
CSTK::hidden::MixtureTraits< Gamma_ak_b< Array_ > >	Traits class for the Gamma_ak_b traits policy
CSTK::hidden::MixtureTraits< Gamma_ak_bj< Array > >
CSTK::hidden::MixtureTraits< Gamma_ak_bj< Array_ > >	Traits class for the Gamma_ak_bj traits policy
CSTK::hidden::MixtureTraits< Gamma_ak_bjk< Array > >
CSTK::hidden::MixtureTraits< Gamma_ak_bjk< Array_ > >	Traits class for the Gamma_ak_bjk traits policy
CSTK::hidden::MixtureTraits< Gamma_ak_bk< Array > >
CSTK::hidden::MixtureTraits< Gamma_ak_bk< Array_ > >	Traits class for the Gamma_ak_bk traits policy
CSTK::hidden::MixtureTraits< HDGaussian_AjkBkQkD< Array > >
CSTK::hidden::MixtureTraits< HDGaussian_AjkBkQkD_< Array_ > >	Traits class for the MixtureHDGaussian_ajk_bk_qk_d traits policy
CSTK::hidden::MixtureTraits< HDMatrixGaussianModel< IdRow_, IdCol_, Array_ > >	Traits class for the HDMatrixGaussianModel traits policy
CSTK::hidden::MixtureTraits< Kmm_s >	MixtureTraits class for the Kmm_s traits policy
CSTK::hidden::MixtureTraits< Kmm_sk >	Traits class for the Kmm_sk traits policy
CSTK::hidden::MixtureTraits< Poisson_ljk< Array > >
CSTK::hidden::MixtureTraits< Poisson_ljk< Array_ > >	Traits class for the Poisson_ljk traits policy
CSTK::hidden::MixtureTraits< Poisson_ljlk< Array > >
CSTK::hidden::MixtureTraits< Poisson_ljlk< Array_ > >	Traits class for the Poisson_ljlk traits policy
CSTK::hidden::MixtureTraits< Poisson_lk< Array > >
CSTK::hidden::MixtureTraits< Poisson_lk< Array_ > >	Traits class for the Poisson_lk traits policy
CSTK::ModelGamma_aj_bjParameters	Structure encapsulating the parameters of a Joint Gamma model
CSTK::ModelParameters< Id >	Struct storing the parameters of the mixture
CSTK::ModelParameters< Clust::Categorical_pjk_ >	Structure encapsulating the parameters of a Categorical_pjk model
CSTK::ModelParameters< Clust::Categorical_pk_ >	Structure encapsulating the parameters of a Categorical_pk model
CSTK::ModelParameters< Clust::Gaussian_s_ >	Structure encapsulating the parameters of a STK::DiagGaussian_s model
CSTK::ModelParameters< Clust::Gaussian_sj_ >	Structure encapsulating the parameters of a STK::DiagGaussian_sj model
CSTK::ModelParameters< Clust::Gaussian_sjk_ >	Structure encapsulating the parameters of a STK::DiagGaussian_sjk model
CSTK::ModelParameters< Clust::Gaussian_sjsk_ >	Structure encapsulating the parameters of a Gaussian_sjsk mixture model
CSTK::ModelParameters< Clust::Gaussian_sk_ >	Structure encapsulating the parameters of a STK::DiagGaussian_sk model
CSTK::ModelParameters< Clust::HDGaussian_AjkBkQkD_ >	Structure encapsulating the parameters of a MixturGaussian_sj model
CSTK::ModelParameters< Clust::Kmm_s_ >	Structure encapsulating the parameters of a Kmm_s model
CSTK::ModelParameters< Clust::Kmm_sk_ >	Structure encapsulating the parameters of a Kmm_sk model
CSTK::ModelParameters< Clust::Poisson_ljk_ >	Structure encapsulating the parameters of a Poisson_ljlk model
CSTK::ModelParameters< Clust::Poisson_ljlk_ >	Structure encapsulating the parameters of a Poisson_ljlk model
CSTK::ModelParameters< Clust::Poisson_lk_ >	Structure encapsulating the parameters of a Poisson_lk model
CSTK::hidden::ModelTraits< Data >
CSTK::hidden::ModelTraits< GaussianAAModel< Data_ > >
CSTK::hidden::ModelTraits< IGaussianModel< Data_ > >
CSTK::ModuloOp< Type1, Type2 >	Template functor which compute the modulo of two numbers
CSTK::ModuloWithOp< Type >	Template functor to compute the minimum with a fixed value
►CMTRand	Generate unsigner 32 bits random number using the Merdsenne Twister Algorithm
CSTK::RandBase	Class for the Base random generator
CSTK::hidden::MultCoefImpl< Lhs, Rhs, Result >	This structure regroup the methods to used after block multiplication in order to perform the product of the remaining rows and columns
CSTK::hidden::MultImpl< Type >	This structure regroup all the methods using only pointers on the Type
CSTK::Arrays::MultLeftTransposeOp< Lhs, Rhs >	Array multiplication Perform the matrix product of the transposed Array lhs by the Array rhs
CSTK::Arrays::MultOp< Lhs, Rhs >	Array multiplication Perform the matrix product of the Array lhs by the Array rhs
CSTK::hidden::MultPointArray< Lhs, Rhs, Result >	This structure regroup the products between a point and different kind of array
CSTK::Arrays::MultRightTransposeOp< Lhs, Rhs >	Array multiplication Perform the matrix product of the Array lhs by the transposed Array rhs
CSTK::NegOp< Type >	Template functor giving the not value
►CSTK::hidden::NoAssignOperator	Classes inheriting NoAssignOperator should not generate a default operator=
CSTK::ITContainerBase< Derived >	Interface base class for 2D containers
CSTK::NotEqualOp< Type1, Type2 >	Template functor testing if a number is not equal to an other number
CSTK::NotEqualWithOp< Type >	Template functor to test if a number is different than a fixed value
►Cstd::numeric_limits
CSTK::Arithmetic< Type >	Arithmetic properties of STK fundamental types
CSTK::Arithmetic< Binary >	Specialization for Binary
CSTK::Arithmetic< Char >	Specialization of the struct Arithmetic for Char
CSTK::Arithmetic< Integer >	Specialization for Integer (long)
CSTK::Arithmetic< Real >	Specialization for Real
CSTK::Arithmetic< Sign >	Specialization for Sign
CSTK::Arithmetic< String >	Specialization for String
CSTK::Arithmetic< TRange< Size_ > >	Partial Specialization for TRange
CSTK::Stat::Online< Array, Type >
CSTK::Stat::Online< Array, Real >	Computation online of the statistics of a Real set of variable
CSTK::Stat::Online< CArrayPoint< Real, UnknownSize, Arrays::by_col_ >, Real >
CSTK::Stat::Online< Real, Real >	Computation online of the statistics of a Real set of variable
CSTK::Stat::Online< STK::CArrayVector, Real >
CSTK::hidden::OperatorHelper< Lhs, Rhs, UnaryFunctor, BinaryFunctor >	Allow to disambiguate the case expr + number from the case expr + other_expr
CSTK::hidden::OperatorImpl< Functor, Lhs, Rhs, isNumber >	Allow to disambiguate the case expr + number from the case expr + other_expr
CSTK::hidden::OperatorImpl< Functor, Lhs, Rhs, false >
CSTK::hidden::OperatorImpl< Functor, Lhs, Rhs, true >
CSTK::hidden::OperatorSelector< Lhs, Rhs, operatorType_ >	Helper defining the return type of the selector involving expressions of the form expr + number and expr + other_expr
CSTK::hidden::OperatorSelector< Lhs, Rhs, Arrays::bitwiseAndOp_ >	Specialization for operator&
CSTK::hidden::OperatorSelector< Lhs, Rhs, Arrays::bitwiseOrOp_ >	Specialization for operator|
CSTK::hidden::OperatorSelector< Lhs, Rhs, Arrays::bitwiseXorOp_ >	Specialization for operator^
CSTK::hidden::OperatorSelector< Lhs, Rhs, Arrays::differenceOp_ >	Specialization for operator-
CSTK::hidden::OperatorSelector< Lhs, Rhs, Arrays::divisionOp_ >	Specialization for operator/
CSTK::hidden::OperatorSelector< Lhs, Rhs, Arrays::equalOp_ >	Specialization for operator==
CSTK::hidden::OperatorSelector< Lhs, Rhs, Arrays::greaterThanOp_ >	Specialization for operator>
CSTK::hidden::OperatorSelector< Lhs, Rhs, Arrays::greaterThanOrEqualOp_ >	Specialization for operator>=
CSTK::hidden::OperatorSelector< Lhs, Rhs, Arrays::lessThanOp_ >	Specialization for operator<
CSTK::hidden::OperatorSelector< Lhs, Rhs, Arrays::lessThanOrEqualOp_ >	Specialization for operator<=
CSTK::hidden::OperatorSelector< Lhs, Rhs, Arrays::logicalAndOp_ >	Specialization for operator&&
CSTK::hidden::OperatorSelector< Lhs, Rhs, Arrays::logicalOrOp_ >	Specialization for operator||
CSTK::hidden::OperatorSelector< Lhs, Rhs, Arrays::maxOp_ >	Specialization for operator max
CSTK::hidden::OperatorSelector< Lhs, Rhs, Arrays::minOp_ >	Specialization for operator min
CSTK::hidden::OperatorSelector< Lhs, Rhs, Arrays::moduloOp_ >	Specialization for operator%
CSTK::hidden::OperatorSelector< Lhs, Rhs, Arrays::notEqualOp_ >	Specialization for operator!=
CSTK::hidden::OperatorSelector< Lhs, Rhs, Arrays::productOp_ >	Specialization for operator*
CSTK::hidden::OperatorSelector< Lhs, Rhs, Arrays::sumOp_ >	Specialization for operator+
CSTK::OppositeOp< Type >	Template functor which compute the opposite of a number
CSTK::Option	Option class allow to store the value of an option from a IPage
►CSTK::OrientedCAllocator< Derived, Orient_ >
►CSTK::StructuredCAllocator< CAllocator< Type_, SizeRows_, SizeCols_, Orient_ >, SizeRows_, SizeCols_ >
CSTK::CAllocator< Type_, SizeRows_, SizeCols_, Orient_ >	Allocator for dense Array classes
►CSTK::StructuredCAllocator< CAllocator< Type_, SizeRows_, UnknownSize, Orient_ >, SizeRows_, UnknownSize >
CSTK::CAllocator< Type_, SizeRows_, UnknownSize, Orient_ >	Specialized Allocator for the dense Arrays classes
►CSTK::StructuredCAllocator< CAllocator< Type_, UnknownSize, SizeCols_, Orient_ >, UnknownSize, SizeCols_ >
CSTK::CAllocator< Type_, UnknownSize, SizeCols_, Orient_ >	Specialized Allocator for the dense Arrays classes
►CSTK::StructuredCAllocator< CAllocator< Type_, UnknownSize, UnknownSize, Orient_ >, UnknownSize, UnknownSize >
CSTK::CAllocator< Type_, UnknownSize, UnknownSize, Orient_ >	Specialized Allocator for the dense Arrays classes
CSTK::OrientedCAllocator< CAllocator< Type_, SizeRows_, SizeCols_, Orient_ >, hidden::Traits< CAllocator< Type_, SizeRows_, SizeCols_, Orient_ > >::orient_ >
CSTK::OrientedCAllocator< CAllocator< Type_, SizeRows_, UnknownSize, Orient_ >, hidden::Traits< CAllocator< Type_, SizeRows_, UnknownSize, Orient_ > >::orient_ >
CSTK::OrientedCAllocator< CAllocator< Type_, UnknownSize, SizeCols_, Orient_ >, hidden::Traits< CAllocator< Type_, UnknownSize, SizeCols_, Orient_ > >::orient_ >
CSTK::OrientedCAllocator< CAllocator< Type_, UnknownSize, UnknownSize, Orient_ >, hidden::Traits< CAllocator< Type_, UnknownSize, UnknownSize, Orient_ > >::orient_ >
►CSTK::OrientedCAllocator< Derived, hidden::Traits< Derived >::orient_ >
CSTK::StructuredCAllocator< Derived, SizeRows_, SizeCols_ >	Base class for the general by_col_ structured case
CSTK::StructuredCAllocator< Derived, 1, 1 >	Specialization for the number_ case
CSTK::StructuredCAllocator< Derived, 1, SizeCols_ >	Specialization for the point_ case (derived class is a RowVector)
CSTK::StructuredCAllocator< Derived, SizeRows_, 1 >	Specialization for the vector_ case
CSTK::hidden::Panel< Type >	This structure encapsulate the data allocated for a panel
CSTK::hidden::PanelBlockProduct< Lhs, Rhs, Result >	Methods to use for C=AB with A divided in panels and B divided in blocks
CSTK::hidden::PanelByBlock< Lhs, Rhs, Result >	Methods to use for C=AB with A divided in panels and B divided in blocks
►CSTK::ParametersGammaBase	Base class of the Gamma models Parameter Handler
CSTK::ModelParameters< Clust::Gamma_a_bjk_ >	Structure encapsulating the parameters of a Gamma_a_bjk_ mixture model
CSTK::ModelParameters< Clust::Gamma_a_bk_ >	Structure encapsulating the parameters of a Gamma_a_bk_ mixture model
CSTK::ModelParameters< Clust::Gamma_aj_bjk_ >	Structure encapsulating the parameters of a Gamma_aj_bjk_ mixture model
CSTK::ModelParameters< Clust::Gamma_aj_bk_ >	Structure encapsulating the parameters of a Gamma_aj_bk_ mixture model
CSTK::ModelParameters< Clust::Gamma_ajk_b_ >	Structure encapsulating the parameters of a Gamma_ajk_b_ mixture model
CSTK::ModelParameters< Clust::Gamma_ajk_bj_ >	Structure encapsulating the parameters of a Gamma_ajk_bj_ mixture model
CSTK::ModelParameters< Clust::Gamma_ajk_bjk_ >	Structure encapsulating the parameters of a Gamma_ajk_bjk_ mixture model
CSTK::ModelParameters< Clust::Gamma_ajk_bk_ >	Structure encapsulating the parameters of a Gamma_ajk_bk_ mixture model
CSTK::ModelParameters< Clust::Gamma_ak_b_ >	Structure encapsulating the parameters of a Gamma_ak_b_ mixture model
CSTK::ModelParameters< Clust::Gamma_ak_bj_ >	Structure encapsulating the parameters of a Gamma_ak_bj_ mixture model
CSTK::ModelParameters< Clust::Gamma_ak_bjk_ >	Structure encapsulating the parameters of a Gamma_ak_bjk_ mixture model
CSTK::ModelParameters< Clust::Gamma_ak_bk_ >	Structure encapsulating the parameters of a Gamma_ak_bk_ mixture model
CSTK::PCG< MultFunctor, CondFunctor, ColVector, InitFunctor >	In most cases, preconditioning is necessary to ensure fast convergence of the conjugate gradient method
CSTK::Law::PdfOp< Type >	,
CSTK::PowOp< Type >	Template functor to raise a number to a power
CSTK::hidden::FunctorParamTraits< Functor, NbParam_ >::Void::Private
CSTK::Arrays::Product< Lhs, Rhs >	Array product (by coefficient) Perform the matrix product coefficient by coefficient of the Array lhs by the Array rhs
CSTK::hidden::ProductArray2DReturnType< Type, LStructure_, RStructure_ >	Helper class to get the correct returned Type for Array2D* classes when a product is performed between two arrays
CSTK::hidden::ProductArray2DReturnType< Type, Arrays::array2D_, Arrays::point_ >
CSTK::hidden::ProductArray2DReturnType< Type, Arrays::array2D_, Arrays::vector_ >
CSTK::hidden::ProductArray2DReturnType< Type, Arrays::array2D_, RStructure_ >
CSTK::hidden::ProductArray2DReturnType< Type, Arrays::diagonal_, Arrays::array2D_ >
CSTK::hidden::ProductArray2DReturnType< Type, Arrays::diagonal_, Arrays::diagonal_ >
CSTK::hidden::ProductArray2DReturnType< Type, Arrays::diagonal_, Arrays::lower_triangular_ >
CSTK::hidden::ProductArray2DReturnType< Type, Arrays::diagonal_, Arrays::point_ >
CSTK::hidden::ProductArray2DReturnType< Type, Arrays::diagonal_, Arrays::square_ >
CSTK::hidden::ProductArray2DReturnType< Type, Arrays::diagonal_, Arrays::upper_triangular_ >
CSTK::hidden::ProductArray2DReturnType< Type, Arrays::diagonal_, Arrays::vector_ >
CSTK::hidden::ProductArray2DReturnType< Type, Arrays::lower_triangular_, Arrays::diagonal_ >
CSTK::hidden::ProductArray2DReturnType< Type, Arrays::lower_triangular_, Arrays::lower_triangular_ >
CSTK::hidden::ProductArray2DReturnType< Type, Arrays::lower_triangular_, Arrays::point_ >
CSTK::hidden::ProductArray2DReturnType< Type, Arrays::lower_triangular_, Arrays::vector_ >
CSTK::hidden::ProductArray2DReturnType< Type, Arrays::lower_triangular_, RStructure_ >
CSTK::hidden::ProductArray2DReturnType< Type, Arrays::point_, Arrays::array2D_ >
CSTK::hidden::ProductArray2DReturnType< Type, Arrays::point_, Arrays::diagonal_ >
CSTK::hidden::ProductArray2DReturnType< Type, Arrays::point_, Arrays::lower_triangular_ >
CSTK::hidden::ProductArray2DReturnType< Type, Arrays::point_, Arrays::point_ >
CSTK::hidden::ProductArray2DReturnType< Type, Arrays::point_, Arrays::square_ >
CSTK::hidden::ProductArray2DReturnType< Type, Arrays::point_, Arrays::upper_triangular_ >
CSTK::hidden::ProductArray2DReturnType< Type, Arrays::point_, Arrays::vector_ >
CSTK::hidden::ProductArray2DReturnType< Type, Arrays::square_, Arrays::array2D_ >
CSTK::hidden::ProductArray2DReturnType< Type, Arrays::square_, Arrays::diagonal_ >
CSTK::hidden::ProductArray2DReturnType< Type, Arrays::square_, Arrays::lower_triangular_ >
CSTK::hidden::ProductArray2DReturnType< Type, Arrays::square_, Arrays::point_ >
CSTK::hidden::ProductArray2DReturnType< Type, Arrays::square_, Arrays::square_ >
CSTK::hidden::ProductArray2DReturnType< Type, Arrays::square_, Arrays::upper_triangular_ >
CSTK::hidden::ProductArray2DReturnType< Type, Arrays::square_, Arrays::vector_ >
CSTK::hidden::ProductArray2DReturnType< Type, Arrays::upper_triangular_, Arrays::diagonal_ >
CSTK::hidden::ProductArray2DReturnType< Type, Arrays::upper_triangular_, Arrays::point_ >
CSTK::hidden::ProductArray2DReturnType< Type, Arrays::upper_triangular_, Arrays::upper_triangular_ >
CSTK::hidden::ProductArray2DReturnType< Type, Arrays::upper_triangular_, Arrays::vector_ >
CSTK::hidden::ProductArray2DReturnType< Type, Arrays::upper_triangular_, RStructure_ >
CSTK::hidden::ProductArray2DReturnType< Type, Arrays::vector_, Arrays::point_ >
CSTK::hidden::ProductArray2DReturnType< Type, Arrays::vector_, RStructure_ >
CSTK::hidden::ProductArray2DReturnType< Type, Lhs::structure_, Rhs::structure_ >
CSTK::hidden::ProductDispatcher< Lhs, Rhs, Result, lhsStructure_, RhsStructure_ >	Dispatcher allowing to choose th e way to multiply two expressions
CSTK::hidden::ProductDispatcher< Lhs, Rhs, Result, Arrays::array2D_, Arrays::array2D_ >	Specialization for the array2d by array2D case
CSTK::hidden::ProductDispatcher< Lhs, Rhs, Result, Arrays::array2D_, Arrays::square_ >
CSTK::hidden::ProductDispatcher< Lhs, Rhs, Result, Arrays::array2D_, Arrays::vector_ >
CSTK::hidden::ProductDispatcher< Lhs, Rhs, Result, Arrays::point_, Arrays::array2D_ >
CSTK::hidden::ProductDispatcher< Lhs, Rhs, Result, Arrays::point_, Arrays::square_ >
CSTK::hidden::ProductDispatcher< Lhs, Rhs, Result, Arrays::point_, RhsStructure_ >
CSTK::hidden::ProductDispatcher< Lhs, Rhs, Result, Arrays::square_, Arrays::array2D_ >
CSTK::hidden::ProductDispatcher< Lhs, Rhs, Result, Arrays::square_, Arrays::square_ >
CSTK::hidden::ProductDispatcher< Lhs, Rhs, Result, Arrays::square_, Arrays::vector_ >
CSTK::hidden::ProductDispatcher< Lhs, Rhs, Result, lhsStructure_, Arrays::vector_ >
CSTK::ProductOp< Type1, Type2 >	Template functor which compute the product of two numbers
CSTK::hidden::ProductSelector< Lhs, Rhs, LStructure_, RStructure_ >	Helper class to select the correct ProductReturnType
CSTK::hidden::ProductSelector< Lhs, Rhs, Arrays::diagonal_, Arrays::diagonal_ >
CSTK::hidden::ProductSelector< Lhs, Rhs, Arrays::diagonal_, Arrays::vector_ >
CSTK::hidden::ProductSelector< Lhs, Rhs, Arrays::diagonal_, RStructure_ >
CSTK::hidden::ProductSelector< Lhs, Rhs, Arrays::number_, RStructure_ >
CSTK::hidden::ProductSelector< Lhs, Rhs, Arrays::point_, Arrays::diagonal_ >
CSTK::hidden::ProductSelector< Lhs, Rhs, Arrays::point_, Arrays::point_ >
CSTK::hidden::ProductSelector< Lhs, Rhs, Arrays::point_, Arrays::vector_ >
CSTK::hidden::ProductSelector< Lhs, Rhs, Arrays::point_, RStructure_ >
CSTK::hidden::ProductSelector< Lhs, Rhs, Arrays::vector_, Arrays::point_ >
CSTK::hidden::ProductSelector< Lhs, Rhs, Arrays::vector_, Arrays::vector_ >
CSTK::hidden::ProductSelector< Lhs, Rhs, LStructure_, Arrays::diagonal_ >
CSTK::hidden::ProductSelector< Lhs, Rhs, LStructure_, Arrays::number_ >
CSTK::hidden::ProductSelector< Lhs, Rhs, LStructure_, Arrays::vector_ >
CSTK::hidden::ProductSizeRowsBySizeCols< Size1, Size2 >	Convenient structure for computing the product of two template integer parameters without overflow
CSTK::hidden::ProductSizeRowsBySizeCols< 1, 1 >
CSTK::hidden::ProductSizeRowsBySizeCols< 1, Size2 >
CSTK::hidden::ProductSizeRowsBySizeCols< 1, UnknownSize >
CSTK::hidden::ProductSizeRowsBySizeCols< Size1, 1 >
CSTK::hidden::ProductSizeRowsBySizeCols< Size1, UnknownSize >
CSTK::hidden::ProductSizeRowsBySizeCols< UnknownSize, 1 >
CSTK::hidden::ProductSizeRowsBySizeCols< UnknownSize, Size2 >
CSTK::hidden::ProductSizeRowsBySizeCols< UnknownSize, UnknownSize >
CSTK::hidden::ProductSizesHelper< isSmallSize1, isSmallSize2, Size1, Size2 >
CSTK::hidden::ProductSizesHelper< false, false, Size1, Size2 >
CSTK::hidden::ProductTraits< Lhs, Rhs, LStructure_, RStructure_ >	,
CSTK::hidden::ProductTraits< Lhs, Rhs, Arrays::array2D_, Arrays::square_ >	Specialization for lhs is array2D
CSTK::hidden::ProductTraits< Lhs, Rhs, Arrays::array2D_, RStructure_ >	Specialization for lhs is array2D
CSTK::hidden::ProductTraits< Lhs, Rhs, Arrays::lower_triangular_, Arrays::lower_triangular_ >
CSTK::hidden::ProductTraits< Lhs, Rhs, Arrays::lower_triangular_, Arrays::square_ >
CSTK::hidden::ProductTraits< Lhs, Rhs, Arrays::lower_triangular_, RStructure_ >
CSTK::hidden::ProductTraits< Lhs, Rhs, Arrays::square_, Arrays::square_ >
CSTK::hidden::ProductTraits< Lhs, Rhs, Arrays::square_, RStructure_ >
CSTK::hidden::ProductTraits< Lhs, Rhs, Arrays::upper_triangular_, Arrays::square_ >
CSTK::hidden::ProductTraits< Lhs, Rhs, Arrays::upper_triangular_, Arrays::upper_triangular_ >
CSTK::hidden::ProductTraits< Lhs, Rhs, Arrays::upper_triangular_, RStructure_ >
CSTK::hidden::ProductTraits< Lhs, Rhs, LStructure_, Arrays::square_ >
CSTK::ProductWithOp< Type >	Template functor computing the product of a number by a fixed value
CSTK::ProductWithOp< bool >	Specialization for boolean
CSTK::hidden::Promote< Type1, Type2 >	Convenient struct to Promote the result Type of some binary functors
CSTK::hidden::Promote< Type, Type >	Specialization when we have the same type
CSTK::Proxy< Type >	The Proxy class allow to surdefine operators and methods for every kind of class without using dynamic_cast
CSTK::Proxy< String >	Specialization of the Proxy class for String
CSTK::hidden::RandApplier< Type >	Visitor putting a choosen random variable
CSTK::hidden::RandGaussApplier< Type >	Visitor setting Gaussian random variables
CSTK::hidden::RandUnifApplier< Type >	Applier setting uniform random numbers
CSTK::hidden::RawVec< Type >	This structure encapsulate the data allocated for a block
CSTK::ReadWritePages	Allow to handle a file of option containing pages
CSTK::hidden::RemoveConst< Type_ >
CSTK::hidden::RemoveConst< Type_ const & >
CSTK::hidden::RemoveConst< Type_ const >
CSTK::hidden::resizeSelector< Lhs, Rhs, TStructure_ >	Utility class that select the resize method to call
CSTK::hidden::resizeSelector< Lhs, Rhs, Arrays::diagonal_ >	Specialization for the diagonal_ case
CSTK::hidden::resizeSelector< Lhs, Rhs, Arrays::number_ >	Specialization for the number_ case
CSTK::hidden::resizeSelector< Lhs, Rhs, Arrays::point_ >	Specialization for the point_ case
CSTK::hidden::resizeSelector< Lhs, Rhs, Arrays::square_ >	Specialization for the square_ case
CSTK::hidden::resizeSelector< Lhs, Rhs, Arrays::vector_ >	Specialization for the vector_ case
►Chidden::Traits::RowRange
CSTK::BiDirectionalIterator< Array >	BiDirectionalIterator allows to loop over the element of one dimensional list containers
CSTK::ConstBiDirectionalIterator< Array >	ConstBiDirectionalIterator allows to loop over the element of one dimensional list containers
CSTK::ConstDenseRandomIterator< Array >	ConstDenseRandomIterator allows to loop over the elements of containers Array
►Chidden::Traits::RowRange
CSTK::DenseRandomIterator< Array_ >	DenseRandomIterator allows to loop over the elements of containers Array
CSTK::SafeInverseOp< Type >	Template functor which compute safely the inverse of a number
CSTK::SafeOp< Type >	Template functor which return a default value if the value is NA
CSTK::SimpleStrategyParam	Helper structure encapsulating the parameters of the simple strategy
CSTK::SinOp< Type >	Template functor which compute the sine of a number
CSTK::hidden::SliceVisitorSelector< Derived, Visitor, byCol >	Utility class that will select the type of operator to apply
CSTK::hidden::SliceVisitorSelector< Derived, Visitor, false >	Specialization if the visitor has to be applied by row
CSTK::hidden::SliceVisitorSelector< Derived, Visitor, true >	Specialization if the visitor has to be applied by col
CSTK::SqrtOp< Type >	Template functor which compute the square root of a number
CSTK::SquareOp< Type >	Template functor which compute the square of a number
CSTK::StaticAssert< condition >
CSTK::StaticAssert< false >
CSTK::StaticAssert< true >
CSTK::hidden::StatModelTraits< Derived >	Policy trait class for (Stat) Model classes
CSTK::hidden::StatModelTraits< Array >
CSTK::hidden::StatModelTraits< ModelBernoulli_pj< Data_, WColVector_ > >	Partial specialization of the StatModelTraits for the ModelBernoulli_pj model
CSTK::hidden::StatModelTraits< ModelDiagGaussian_muj_sj< Data_, WColVector_ > >	Partial specialization of the StatModelTraits for the ModelDiagGaussian_muj_sj model
CSTK::hidden::StatModelTraits< ModelGamma_aj_bj< Data_, WColVector_ > >	Partial specialization of the StatModelTraits for the ModelGamma_aj_bj model
CSTK::SubstractToOp< Type >	Template functor to subtract a number to a fixed value
CSTK::SubVectorAccessorBase< Lhs, Size_, Structure_ >
►CSTK::SubVectorAccessorBase< Lhs, Size_, hidden::Traits< SubVectorAccessor< Lhs, Size_ > >::structure_ >
CSTK::SubVectorAccessor< Lhs, Size_ >
CSTK::SubVectorOperatorBase< Lhs, Size_, Structure_ >	Specialization for point_
►CSTK::SubVectorOperatorBase< Lhs, Size_, hidden::Traits< SubVectorOperator< Lhs, Size_ > >::structure_ >
CSTK::SubVectorOperator< Lhs, Size_ >	Generic expression when the sub-part of an expression is accessed (specialization for vectors)
CSTK::Arrays::SumOp< Lhs, Rhs >	Array sum (by coefficient) Perform the matrix sum coefficient by coefficient of the Array lhs by the Array rhs
CSTK::Stat::SumOp< Derived >	Compute the sum of the variable V
CSTK::SumOp< Type1, Type2 >	Template functor which compute the sum of two numbers
CSTK::Stat::SumSafeOp< Derived >	Compute safely the sum of the variable V
CSTK::hidden::SumVisitor< Type_ >	Visitor computing the sum of all the coefficients of the Array
CSTK::SumWithOp< Type >	Template functor to add a number to a fixed value
CSTK::TanOp< Type >	Template functor which compute the tan of a number
CSTK::TestEndOfLineOp	Template functor testing if a Char is an end of line
CSTK::hidden::Traits< Derived >	,
CSTK::hidden::Traits< Array >
CSTK::hidden::Traits< Array1D< Array_, Size_ > >
CSTK::hidden::Traits< Array1D< CArray< Real, UnknownSize, UnknownSize, Arrays::by_col_ >, Size_ > >
CSTK::hidden::Traits< Array1D< CArrayPoint< Real, UnknownSize, Arrays::by_col_ >, Size_ > >
CSTK::hidden::Traits< Array1D< IndexedValue, Size_ > >
CSTK::hidden::Traits< Array1D< int, Size_ > >
CSTK::hidden::Traits< Array1D< Law, Size_ > >
CSTK::hidden::Traits< Array1D< Real, Size_ > >
CSTK::hidden::Traits< Array1D< STK::BSplineCoefficients< ColVector >, Size_ > >
CSTK::hidden::Traits< Array1D< STK::CArraySquare, Size_ > >
CSTK::hidden::Traits< Array1D< STK::CArrayVector, Size_ > >
CSTK::hidden::Traits< Array1D< STK::Stat::Online< Array_, Real >, Size_ > >
CSTK::hidden::Traits< Array1D< STK::Stat::Online< CArray< Real, UnknownSize, UnknownSize, Arrays::by_col_ >, Real >, Size_ > >
CSTK::hidden::Traits< Array1D< STK::Stat::Online< CArrayPoint< Real, UnknownSize, Arrays::by_col_ >, Real >, Size_ > >
CSTK::hidden::Traits< Array1D< STK::Stat::Online< Real, Real >, Size_ > >
CSTK::hidden::Traits< Array1D< STK::Stat::Online< STK::CArraySquare, Real >, Size_ > >
CSTK::hidden::Traits< Array1D< STK::Stat::Online< STK::CArrayVector, Real >, Size_ > >
CSTK::hidden::Traits< Array1D< STK::TRange< UnknownSize >, Size_ > >
CSTK::hidden::Traits< Array1D< STK::Variable, Size_ > >
CSTK::hidden::Traits< Array1D< TaggedKernel, Size_ > >
CSTK::hidden::Traits< Array1D< Type_, Size_ > >	Specialization of the Traits class for Array1D class
CSTK::hidden::Traits< Array2D< Type_ > >	Specialization of the Traits class for the Array2D class
CSTK::hidden::Traits< Array2DDiagonal< Type_ > >	Specialization of the Traits class for the Array2DDiagonal class
CSTK::hidden::Traits< Array2DLowerTriangular< Type_ > >	Specialization of the Traits class for the Array2DLowerTriangular class
CSTK::hidden::Traits< Array2DNumber< Type_ > >	Specialization of the Traits class for Array2DNumber class
CSTK::hidden::Traits< Array2DPoint< Type_ > >	Specialization of the Traits class for Array2DPoint class
CSTK::hidden::Traits< Array2DSquare< Type_ > >	Specialization of the Traits class for the Array2DSquare class
CSTK::hidden::Traits< Array2DUpperTriangular< Type_ > >	Specialization of the Traits class for the Array2DUpperTriangular class
CSTK::hidden::Traits< Array2DVector< Type_ > >	Specialization of the Traits class for the Array2DVector class
CSTK::hidden::Traits< ArrayByArrayProduct< Lhs, Rhs > >	Traits class for the ArrayByArrayProduct class
CSTK::hidden::Traits< ArrayByDiagonalProduct< Lhs, Rhs > >	Traits class for array2d by diagonal product
CSTK::hidden::Traits< ArrayByVectorProduct >
CSTK::hidden::Traits< ArrayByVectorProduct< Lhs, Rhs > >	Traits class for the ArrayByVectorProduct class
CSTK::hidden::Traits< BinaryOperator< FunctorOp, Lhs, Rhs > >	Traits class for the BinaryOperator
CSTK::hidden::Traits< CAllocator< Type_, SizeRows_, SizeCols_, Orient_ > >	Specialization of Traits class for CAllocator
CSTK::hidden::Traits< CArray< int, SizeRows_, SizeCols_, Orient_ > >
CSTK::hidden::Traits< CArray< Real, SizeRows_, SizeCols_, Orient_ > >
CSTK::hidden::Traits< CArray< Type_, SizeRows_, SizeCols_, Orient_ > >	Specialization of the Traits class for CArray class
CSTK::hidden::Traits< CArrayNumber< Type_, Orient_ > >	Specialization of the Traits class for CArrayNumber class
CSTK::hidden::Traits< CArrayPoint< Array2DVector< int >, SizeCols_, Orient_ > >
CSTK::hidden::Traits< CArrayPoint< DecodingMap, SizeCols_, Orient_ > >
CSTK::hidden::Traits< CArrayPoint< EncodingMap, SizeCols_, Orient_ > >
CSTK::hidden::Traits< CArrayPoint< int, SizeCols_, Orient_ > >
CSTK::hidden::Traits< CArrayPoint< Real, SizeCols_, Orient_ > >
CSTK::hidden::Traits< CArrayPoint< STK::Array2DVector< Type >, SizeCols_, Orient_ > >
CSTK::hidden::Traits< CArrayPoint< Type, SizeCols_, Orient_ > >
CSTK::hidden::Traits< CArrayPoint< Type_, SizeCols_, Orient_ > >	Specialization of the Traits class for CArray class
CSTK::hidden::Traits< CArraySquare< Real, Size_, Orient_ > >
CSTK::hidden::Traits< CArraySquare< Type, Size_, Orient_ > >
CSTK::hidden::Traits< CArraySquare< Type_, Size_, Orient_ > >	Specialization of the Traits class for CArray class
CSTK::hidden::Traits< CArrayVector< int, SizeRows_, Orient_ > >
CSTK::hidden::Traits< CArrayVector< Real, SizeRows_, Orient_ > >
CSTK::hidden::Traits< CArrayVector< Type, SizeRows_, Orient_ > >
CSTK::hidden::Traits< CArrayVector< Type_, SizeRows_, Orient_ > >	Specialization of the Traits class for CArrayVector class
CSTK::hidden::Traits< ColAccessor< Lhs > >	Traits class for the column accessor operator
CSTK::hidden::Traits< ColOperator< Lhs > >	Traits class for the column operator
CSTK::hidden::Traits< Const::Array< Type_, SizeRows_, SizeCols_ > >	Traits class for the general constant matrix
CSTK::hidden::Traits< Const::Identity< Type_, Size_ > >	Traits class for the identity constant matrix
CSTK::hidden::Traits< Const::LowerTriangular< Type_, SizeRows_, SizeCols_ > >	Traits class for the lower triangular constant matrix
CSTK::hidden::Traits< Const::Point< Type_, Size_ > >	Traits class for the constant vector_
CSTK::hidden::Traits< Const::Square< Type_, Size_ > >	Traits class for the square constant matrix
CSTK::hidden::Traits< Const::UpperTriangular< Type_, SizeRows_, SizeCols_ > >	Traits class for the upper triangular constant matrix
CSTK::hidden::Traits< Const::Vector< Type_, Size_ > >	Traits class for the identity constant matrix
CSTK::hidden::Traits< DiagonalByArrayProduct< Lhs, Rhs > >	Traits class for the DiagonalByArrayProduct class
CSTK::hidden::Traits< DiagonalGetterAccessor< Lhs > >	Traits class for DiagonalGetterAccessor operator
CSTK::hidden::Traits< DiagonalGetterOperator< Lhs > >	Traits class for DiagonalGetterOperator operator
CSTK::hidden::Traits< DiagonalizeAccessor< Lhs > >	Traits class for DiagonalizeAccessor operator
CSTK::hidden::Traits< DiagonalizeOperator< Lhs > >	Traits class for DiagonalizeOperator operator
CSTK::hidden::Traits< DotProduct >
CSTK::hidden::Traits< DotProduct< Lhs, Rhs > >	Traits class for the DotProduct class
CSTK::hidden::Traits< List1D< IVariable * > >
CSTK::hidden::Traits< List1D< Type_ > >	Specialization of the Traits class for List1D class
CSTK::hidden::Traits< LowerSymmetrizeAccessor< Lhs > >	Traits class for LowerSymmetrizeAccessor operator
CSTK::hidden::Traits< LowerSymmetrizeOperator< Lhs > >	Traits class for LowerSymmetrizeOperator operator
CSTK::hidden::Traits< LowerTriangularizeAccessor< Lhs > >	Traits class for LowerTriangularizeAccessor operator
CSTK::hidden::Traits< LowerTriangularizeOperator< Lhs > >	Traits class for UpperTriangularizeOperator operator
CSTK::hidden::Traits< PointByArrayProduct >
CSTK::hidden::Traits< PointByArrayProduct< Lhs, Rhs > >	Traits class for the PointByArrayProduct
CSTK::hidden::Traits< RowAccessor< Lhs > >	Traits class for the row accessor
CSTK::hidden::Traits< RowOperator< Lhs > >	Traits class for the row operator
CSTK::hidden::Traits< SArray1D< Type_, Size_, NzMax_ > >	Specialization of the Traits class for SArray1D class
CSTK::hidden::Traits< SArray2D< Type_ > >	Specialization of the Traits class for the SArray2D class
CSTK::hidden::Traits< SArray2DDiagonal< Type_ > >	Specialization of the Traits class for the SArray2DDiagonal class
CSTK::hidden::Traits< SArray2DLowerTriangular< Type_ > >	Specialization of the Traits class for the SArray2DLowerTriangular class
CSTK::hidden::Traits< SArray2DNumber< Type_ > >	Specialization of the Traits class for SArray2DNumber class
CSTK::hidden::Traits< SArray2DPoint< Type_ > >	Specialization of the Traits class for SArray2DPoint class
CSTK::hidden::Traits< SArray2DSquare< Type_ > >	Specialization of the Traits class for the SArray2DSquare class
CSTK::hidden::Traits< SArray2DUpperTriangular< Type_ > >	Specialization of the Traits class for the SArray2DUpperTriangular class
CSTK::hidden::Traits< SArray2DVector< Type_ > >	Specialization of the Traits class for the SArray2DVector class
CSTK::hidden::Traits< SquareArray >
CSTK::hidden::Traits< SubAccessor< Lhs, SizeRows_, SizeCols_ > >	Traits class for the sub accessor
CSTK::hidden::Traits< SubOperator< Lhs, SizeRows_, SizeCols_ > >	Traits class for the sub operator
CSTK::hidden::Traits< SubVectorAccessor< Lhs, Size_ > >	Traits class for the sub vector accessor
CSTK::hidden::Traits< SubVectorOperator< Lhs, Size_ > >	Traits class for the sub vector operator
CSTK::hidden::Traits< SymmetrizeAccessor< Lhs > >	Traits class for SymmetrizeAccessor operator
CSTK::hidden::Traits< SymmetrizeOperator< Lhs > >	Traits class for SymmetrizeOperator operator
CSTK::hidden::Traits< TransposeAccessor< Lhs > >	Traits class for the transposed operator
CSTK::hidden::Traits< TransposeOperator< Lhs > >	Traits class for the transposed operator
CSTK::hidden::Traits< UnaryOperator< UnaryOp, Lhs > >	Traits class for the unary operators
CSTK::hidden::Traits< UpperSymmetrizeAccessor< Lhs > >	Traits class for UpperSymmetrizeAccessor operator
CSTK::hidden::Traits< UpperSymmetrizeOperator< Lhs > >	Traits class for UpperSymmetrizeOperator operator
CSTK::hidden::Traits< UpperTriangularizeAccessor< Lhs > >	Traits class for UpperTriangularizeAccessor operator
CSTK::hidden::Traits< UpperTriangularizeOperator< Lhs > >	Traits class for UpperTriangularizeOperator operator
CSTK::hidden::Traits< Variable< Real > >
CSTK::hidden::Traits< Variable< Type_ > >	Specialization of the Traits struct for Variable class
CSTK::hidden::Traits< VectorByPointProduct< Lhs, Rhs > >	Traits class for the VectorByPointProduct class
CSTK::hidden::Traits< VisitorByCol< Derived, Visitor > >	Traits class for the unary operators
CSTK::hidden::Traits< VisitorByRow< Derived, Visitor > >	Traits class for the VisitorByRow class
CSTK::hidden::TransposeTraits< Structure_ >	Helper Traits class for transposed operator
CSTK::hidden::TransposeTraits< Arrays::lower_symmetric_ >	Specialization for lower_triangular_
CSTK::hidden::TransposeTraits< Arrays::lower_triangular_ >	Specialization for lower_triangular_
CSTK::hidden::TransposeTraits< Arrays::point_ >	Specialization for point_
CSTK::hidden::TransposeTraits< Arrays::upper_symmetric_ >	Specialization for upper_triangular_
CSTK::hidden::TransposeTraits< Arrays::upper_triangular_ >	Specialization for upper_triangular_
CSTK::hidden::TransposeTraits< Arrays::vector_ >	Specialization for vector_
CSTK::TReadWriteCsv< Type >	TReadWriteCsv class : allow to write and/or to read a csv file
CSTK::TReadWriteCsv< String >
CSTK::TRef< ref_ >	Base class for all referencing containers
CSTK::TRef< 0 >
►CSTK::TRef< 1 >
CSTK::ArrayByArrayProduct< Lhs, Rhs >	Generic expression where a product operator is applied to two expressions
CSTK::ArrayByDiagonalProduct< Lhs, Rhs >	Generic expression where a product operator is applied to two expressions
CSTK::ArrayByVectorProduct< Lhs, Rhs >	Generic expression where a product operator is applied to two expressions
CSTK::BinaryOperator< FunctorOp, Lhs, Rhs >	Generic expression where a binary operator is applied to two expressions
CSTK::ColAccessor< Lhs >	Generic expression when the column of an expression is accessed
CSTK::ColOperator< Lhs >	Generic expression when the column of an expression is accessed
CSTK::DiagonalByArrayProduct< Lhs, Rhs >	Generic expression where a product operator is applied to two expressions
CSTK::DiagonalGetterAccessor< Lhs >	Generic expression when we want to get the diagonal of a two-dimensional square expression
CSTK::DiagonalGetterOperator< Lhs >	Generic expression when we want to get the diagonal of a two-dimensional square expression
CSTK::DiagonalizeAccessor< Lhs >	Generic expression when a one dimensional vector/point/idagonal expression is "diagonalized"
CSTK::DiagonalizeOperator< Lhs >	Generic expression when a one dimensional vector/point/idagonal expression is "diagonalized"
CSTK::DotProduct< Lhs, Rhs >	Generic expression where a DotProduct is applied to two expressions
CSTK::LowerSymmetrizeAccessor< Lhs >	Generic expression when we want to get the lower-part of a two-dimensional symmetric expression
CSTK::LowerSymmetrizeOperator< Lhs >	Generic expression when we want to get the lower-part of a two-dimensional symmetric expression
CSTK::LowerTriangularizeAccessor< Lhs >	Generic expression when we want to get the lower-part of a two-dimensional expression
CSTK::LowerTriangularizeOperator< Lhs >	Generic expression when we want to get the lower-part of a two-dimensional expression
CSTK::PointByArrayProduct< Lhs, Rhs >	Generic expression where a product operator is applied to two expressions
CSTK::RowAccessor< Lhs >	Generic expression when the row of an expression is accessed
CSTK::RowOperator< Lhs >	Generic expression when the row of an expression is accessed
CSTK::SubAccessor< Lhs, SizeRows_, SizeCols_ >	Generic expression when the sub-part of an expression is accessed
CSTK::SubOperator< Lhs, SizeRows_, SizeCols_ >	Generic expression when the sub-part of an expression is accessed
CSTK::SubVectorAccessor< Lhs, Size_ >
CSTK::SubVectorOperator< Lhs, Size_ >	Generic expression when the sub-part of an expression is accessed (specialization for vectors)
CSTK::SymmetrizeAccessor< Lhs >	Generic expression when we want to get the upper-part of a two-dimensional symmetric expression
CSTK::SymmetrizeOperator< Lhs >	Generic expression when we want to get the upper-part of a two-dimensional symmetric expression
CSTK::TransposeAccessor< Lhs >	Generic expression when an expression is transposed
CSTK::TransposeOperator< Lhs >	Generic expression when an expression is transposed
CSTK::UnaryOperator< UnaryOp, Lhs >	Generic expression when unary operator is applied to an expression
CSTK::UpperSymmetrizeAccessor< Lhs >	Generic expression when we want to get the upper-part of a two-dimensional symmetric expression
CSTK::UpperSymmetrizeOperator< Lhs >	Generic expression when we want to get the upper-part of a two-dimensional symmetric expression
CSTK::UpperTriangularizeAccessor< Lhs >	Generic expression when we want to get the upper-part of a two-dimensional expression
CSTK::UpperTriangularizeOperator< Lhs >	Generic expression when we want to get the upper-part of a two-dimensional expression
CSTK::VectorByPointProduct< Lhs, Rhs >	Generic expression where a product operator is applied to two expressions
CSTK::VisitorByCol< Derived, Visitor >	Class allowing to apply a visitor on each columns of an expression
CSTK::VisitorByRow< Derived, Visitor >	Class allowing to apply a visitor on each columns of an expression
►CSTK::TRef<-1 >
CSTK::List1D< IVariable * >
CSTK::MemAllocator< PtrCol, sizeCols_ >
CSTK::List1D< Type_ >	Template One dimensional Horizontal List
CSTK::MemAllocator< Type_, Size_ >	Template base class for all Allocator classes
CSTK::MemSAllocator< Type_, NzMax_, Size_ >	Memory allocator for sparse Array classes
CSTK::MemSAllocator1D< Type_, NzMax_ >	Memory allocator for sparse vectors classes
CSTK::hidden::TrueType
CSTK::UnaryOperatorBase< UnaryOp, Lhs >
CSTK::Stat::Univariate< TContainer1D, Type >
CSTK::Stat::Univariate< TContainer1D, Real >	Computation of the univariate Statistics of a Real Variable
CSTK::hidden::UsedFunctor< Functor, NbParam_ >	The functor to use
CSTK::hidden::UsedFunctor< Functor, 1 >
CSTK::hidden::UsedFunctor< Functor, 2 >
CSTK::hidden::UsedFunctor< Functor, 3 >
CSTK::hidden::UsedFunctor< Functor, 4 >
CSTK::hidden::ValueApplier< Type >	Visitor putting a constant value
CSTK::Stat::VarianceOp< Derived >	Compute the variance of the variable V
CSTK::Stat::VarianceSafeOp< Derived >	Compute safely the variance of the variable V
CSTK::Stat::VarianceWithFixedMeanOp< Derived >	Compute the variance of the variable V when the mean is given
CSTK::Stat::VarianceWithFixedMeanSafeOp< Derived >	Compute safely the variance of the variable V when the mean is given
CSTK::hidden::vb< Lhs, Rhs, Result >	Methods to use for C=PB with P a point and B a matrix
CSTK::hidden::VisitorArrayImpl< Visitor, Derived, SizeRows_, SizeCols_ >
CSTK::hidden::VisitorArrayImpl< 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
CSTK::hidden::VisitorArrayImpl< 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
CSTK::hidden::VisitorArrayImpl< Visitor, Derived, UnknownSize, 1 >	Specialization of VisitorArrayImpl when the number of columns is one and the number of rows is unknown
CSTK::hidden::VisitorArrayImpl< Visitor, Derived, UnknownSize, SizeCols_ >	Specialization of VisitorArrayImpl when the number of columns is less than MaxUnrollSlice and the number of rows is unknown
CSTK::hidden::VisitorArrayNoUnrollImpl< Visitor, Derived, Orient_, SizeRows_, SizeCols_ >
CSTK::hidden::VisitorArrayNoUnrollImpl< Visitor, Derived, Arrays::by_col_, UnknownSize, UnknownSize >	Specialization for general 2D arrays, data stored by column and dimensions not known at compile time
CSTK::hidden::VisitorArrayNoUnrollImpl< Visitor, Derived, Arrays::by_row_, UnknownSize, UnknownSize >	Specialization for general 2D arrays, data stored by rows and dimensions are not known at compile time
CSTK::hidden::VisitorArrayUnrollImpl< Visitor, Derived, Orient_, SizeRows_, SizeCols_ >
CSTK::hidden::VisitorArrayUnrollImpl< Visitor, Derived, Arrays::by_col_, 1, 1 >	Specialization for the general case with 1 row and 1 column arrays
CSTK::hidden::VisitorArrayUnrollImpl< Visitor, Derived, Arrays::by_col_, SizeRows_, 1 >	Specialization for the Arrays with 1 column
CSTK::hidden::VisitorArrayUnrollImpl< 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
CSTK::hidden::VisitorArrayUnrollImpl< Visitor, Derived, Arrays::by_row_, 1, 1 >	Specialization for the general case with 1 row and 1 column arrays
CSTK::hidden::VisitorArrayUnrollImpl< Visitor, Derived, Arrays::by_row_, 1, SizeCols_ >	Specialization for the arrays with 1 column (Vector)
CSTK::hidden::VisitorArrayUnrollImpl< 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
CSTK::VisitorByColBase< Derived, Visitor >
CSTK::hidden::VisitorDiagonalImpl< Visitor, Derived, Size_ >	A VisitorDiagonalImpl allow to unroll the visit of a Diagonal tab if possible
CSTK::hidden::VisitorDiagonalImpl< Visitor, Derived, 1 >	Specialization for diagonal tab of size one
CSTK::hidden::VisitorDiagonalImpl< Visitor, Derived, UnknownSize >	Specialization when the size is unknown
CSTK::hidden::VisitorLowerImpl< Visitor, Derived, orient_ >
CSTK::hidden::VisitorLowerImpl< Visitor, Derived, Arrays::by_col_ >	Specialization for the general case with column oriented arrays
CSTK::hidden::VisitorLowerImpl< Visitor, Derived, Arrays::by_row_ >	Specialization for the general case with row oriented arrays
CSTK::hidden::VisitorNumberImpl< Visitor, Derived >	Specialization for the general case with 1 row and 1 column arrays
CSTK::hidden::VisitorPointImpl< Visitor, Derived, Size_ >	A VisitorPointImpl allow to unroll the visit of a row-vector if possible
CSTK::hidden::VisitorPointImpl< Visitor, Derived, 1 >	Specialization for the RowVectors with one columns
CSTK::hidden::VisitorPointImpl< Visitor, Derived, UnknownSize >	Specialization when the size is unknown
CSTK::hidden::VisitorSelector< Visitor, Derived >	Visitor selector
CSTK::hidden::VisitorSelectorHelper< Visitor, Derived, Structure_ >	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)
CSTK::hidden::VisitorSelectorHelper< Visitor, Derived, Arrays::diagonal_ >	Specialization for the diagonal arrays
CSTK::hidden::VisitorSelectorHelper< Visitor, Derived, Arrays::lower_triangular_ >	Specialization for the lower triangular arrays
CSTK::hidden::VisitorSelectorHelper< Visitor, Derived, Arrays::number_ >	Specialization for the numbers
CSTK::hidden::VisitorSelectorHelper< Visitor, Derived, Arrays::point_ >	Specialization for the row vectors
CSTK::hidden::VisitorSelectorHelper< Visitor, Derived, Arrays::upper_triangular_ >	Specialization for the upper triangular arrays
CSTK::hidden::VisitorSelectorHelper< Visitor, Derived, Arrays::vector_ >	Specialization for the vectors
CSTK::hidden::VisitorUnrollCol< Visitor, Derived, SizeRows_, SizeCols_ >	Unroll the column baseIdx + SizeCols_ -1
CSTK::hidden::VisitorUnrollCol< Visitor, Derived, 1, SizeCols_ >	Specialization for the arrays with 1 row (Point)
CSTK::hidden::VisitorUnrollRow< Visitor, Derived, SizeRows_, SizeCols_ >	Unroll the row baseIdx + SizeRows_ -1
CSTK::hidden::VisitorUnrollRow< Visitor, Derived, SizeRows_, 1 >	Specialization for the arrays with 1 column
CSTK::hidden::VisitorUpperImpl< Visitor, Derived, orient_ >
CSTK::hidden::VisitorUpperImpl< Visitor, Derived, Arrays::by_col_ >	Specialization for the general case with column oriented arrays
CSTK::hidden::VisitorUpperImpl< Visitor, Derived, Arrays::by_row_ >	Specialization for the general case with row oriented arrays
CSTK::hidden::VisitorVectorImpl< Visitor, Derived, Size_ >	A visitor Vector allow to unroll the visit of a vector if possible
CSTK::hidden::VisitorVectorImpl< Visitor, Derived, 1 >	Specialization for the vectors with 1 row
CSTK::hidden::VisitorVectorImpl< Visitor, Derived, UnknownSize >	Specialization when the size is unknown
CSTK::hidden::FunctorParamTraits< Functor, NbParam_ >::Void
CSTK::hidden::MixtureManagerTraits< KernelMixtureManager >::Void
CSTK::hidden::ModelTraits< GaussianAAModel< Data_ > >::Void
CSTK::hidden::ModelTraits< IGaussianModel< Data_ > >::Void
CSTK::hidden::Traits< Array2D< Type_ > >::Void
CSTK::hidden::Traits< Array2DDiagonal< Type_ > >::Void
CSTK::hidden::Traits< Array2DLowerTriangular< Type_ > >::Void
CSTK::hidden::Traits< Array2DSquare< Type_ > >::Void
CSTK::hidden::Traits< Array2DUpperTriangular< Type_ > >::Void
CSTK::hidden::Traits< SArray2D< Type_ > >::Void
CSTK::hidden::Traits< SArray2DDiagonal< Type_ > >::Void
CSTK::hidden::Traits< SArray2DLowerTriangular< Type_ > >::Void
CSTK::hidden::Traits< SArray2DSquare< Type_ > >::Void
CSTK::hidden::Traits< SArray2DUpperTriangular< Type_ > >::Void
CSTK::XemStrategyParam	Helper structure encapsulating the parameters of the Xem strategy
CArray1D< Type_, Size_ > *const
Cbool
CColVector const *
Cint
CXArray const *
CXVector const *
CYArray
CYArray const *