Class List

Here are the classes, structs, unions and interfaces with brief descriptions:
access
arma_blas_type_only< T >
arma_blas_type_only< double >
arma_blas_type_only< float >
arma_blas_type_only< std::complex< double > >
arma_blas_type_only< std::complex< float > >
arma_config
arma_counter< eT >
arma_Cube_only< T >
arma_Cube_only< Cube< eT > >
arma_cx_median_packet< T >
arma_cx_only< T >
arma_cx_only< std::complex< T > >
junk::arma_elem_size_test
junk::arma_first_extra_debug_message
arma_float_only< T >
arma_float_only< double >
arma_float_only< float >
arma_float_or_cx_only< T >
arma_float_or_cx_only< double >
arma_float_or_cx_only< float >
arma_float_or_cx_only< std::complex< double > >
arma_float_or_cx_only< std::complex< float > >
arma_glue_rel_only< T >
arma_glue_rel_only< glue_rel_eq >
arma_glue_rel_only< glue_rel_gt >
arma_glue_rel_only< glue_rel_gteq >
arma_glue_rel_only< glue_rel_lt >
arma_glue_rel_only< glue_rel_lteq >
arma_glue_rel_only< glue_rel_noteq >
arma_integral_only< T >
arma_integral_only< char >
arma_integral_only< int >
arma_integral_only< long >
arma_integral_only< short >
arma_integral_only< unsigned char >
arma_integral_only< unsigned int >
arma_integral_only< unsigned long >
arma_integral_only< unsigned short >
arma_Mat_Col_Row_only< T >
arma_Mat_Col_Row_only< Col< eT > >
arma_Mat_Col_Row_only< Mat< eT > >
arma_Mat_Col_Row_only< Row< eT > >
arma_not_cx< T >
arma_not_cx< std::complex< T > >
arma_not_op_rel< T >
arma_not_op_rel< op_rel_eq >
arma_not_op_rel< op_rel_gt_post >
arma_not_op_rel< op_rel_gt_pre >
arma_not_op_rel< op_rel_gteq_post >
arma_not_op_rel< op_rel_gteq_pre >
arma_not_op_rel< op_rel_lt_post >
arma_not_op_rel< op_rel_lt_pre >
arma_not_op_rel< op_rel_lteq_post >
arma_not_op_rel< op_rel_lteq_pre >
arma_not_op_rel< op_rel_noteq >
arma_op_rel_only< T >
arma_op_rel_only< op_rel_eq >
arma_op_rel_only< op_rel_gt_post >
arma_op_rel_only< op_rel_gt_pre >
arma_op_rel_only< op_rel_gteq_post >
arma_op_rel_only< op_rel_gteq_pre >
arma_op_rel_only< op_rel_lt_post >
arma_op_rel_only< op_rel_lt_pre >
arma_op_rel_only< op_rel_lteq_post >
arma_op_rel_only< op_rel_lteq_pre >
arma_op_rel_only< op_rel_noteq >
arma_ostream
arma_ostream_state
arma_qsort_helper< eT >
arma_qsort_helper< std::complex< T > >
arma_scalar_only< T >
arma_scalar_only< char >
arma_scalar_only< double >
arma_scalar_only< float >
arma_scalar_only< int >
arma_scalar_only< long >
arma_scalar_only< short >
arma_scalar_only< std::complex< T > >
arma_scalar_only< unsigned char >
arma_scalar_only< unsigned int >
arma_scalar_only< unsigned long >
arma_scalar_only< unsigned short >
arma_signed_integral_only< T >
arma_signed_integral_only< char >
arma_signed_integral_only< int >
arma_signed_integral_only< long >
arma_signed_integral_only< short >
arma_sort_index_packet_ascend< T1, T2 >
arma_sort_index_packet_descend< T1, T2 >
arma_static_assert< true >
arma_type_check< val >
arma_unsigned_integral_only< T >
arma_unsigned_integral_only< unsigned char >
arma_unsigned_integral_only< unsigned int >
arma_unsigned_integral_only< unsigned long >
arma_unsigned_integral_only< unsigned short >
arma_version
as_scalar_redirect< N >
as_scalar_redirect< 2 >
as_scalar_redirect< 3 >
auxlibWrapper for accessing external functions defined in ATLAS, LAPACK or BLAS libraries
Base< elem_type, derived >Class for static polymorphism, modelled after the "Curiously Recurring Template Pattern" (CRTP). //! Used for type-safe downcasting in functions that restrict their input(s) to be classes that are //! derived from Base (e.g. Mat, Op, Glue, diagview, subview). //! A Base object can be converted to a Mat object by the unwrap class
BaseCube< elem_type, derived >Analog of the Base class, intended for cubes
BaseVec< elem_type, derived >
arma_boost::basic_format< T1, T2 >
arma_boost::basic_format_only< T >
arma_boost::basic_format_only< basic_format< T > >
arma_boost::basic_format_only< basic_format< T1, T2 > >
arma_boost::char_only< T >
arma_boost::char_only< char >
Col< eT >Class for column vectors (matrices with only column)
field< oT >::const_iterator
Mat< eT >::const_row_iterator
conv_to< out_eT >Conversion from Armadillo Base and BaseCube objects to scalars //! (kept only for compatibility with old code; use as_scalar() instead for Base objects like Mat)
conv_to< Col< out_eT > >Conversion to Armadillo column vectors from Armadillo Base objects, //! as well as from std::vector, itpp::Mat and itpp::Vec
conv_to< Cube< out_eT > >Conversion to Armadillo cubes from Armadillo BaseCube objects
conv_to< itpp::Mat< out_eT > >Conversion to itpp::Mat from Armadillo Base objects
conv_to< itpp::Vec< out_eT > >Conversion to itpp::Vec from Armadillo Base objects
conv_to< Mat< out_eT > >Conversion to Armadillo matrices from Armadillo Base objects, //! as well as from std::vector, itpp::Mat and itpp::Vec
conv_to< Row< out_eT > >Conversion to Armadillo row vectors from Armadillo Base objects, //! as well as from std::vector, itpp::Mat and itpp::Vec
conv_to< std::vector< out_eT > >Conversion to std::vector from Armadillo Base objects
Cube< eT >Dense cube class
Cube_aux
depth_lhs< glue_type, T1 >//! Template metaprogram depth_lhs //! calculates the number of Glue<Tx,Ty, glue_type> instances on the left hand side argument of Glue<Tx,Ty, glue_type> //! i.e. it recursively expands each Tx, until the type of Tx is not "Glue<..,.., glue_type>" (i.e the "glue_type" changes)
depth_lhs< glue_type, Glue< T1, T2, glue_type > >
diagmat_proxy< T1 >
diagmat_proxy< Col< eT > >
diagmat_proxy< Mat< eT > >
diagmat_proxy< Row< eT > >
diagmat_proxy_check< T1 >
diagmat_proxy_check< Col< eT > >
diagmat_proxy_check< Mat< eT > >
diagmat_proxy_check< Row< eT > >
diagview< eT >Class for storing data required to extract and set the diagonals of a matrix
diskioClass for saving and loading matrices and fields
eGlue< T1, T2, eglue_type >
eglue_core< eglue_type >
eglue_cube_core< eglue_type >
eglue_cube_div
eglue_cube_minus
eglue_cube_plus
eglue_cube_schur
eglue_div
eglue_minus
eglue_plus
eglue_schur
eGlueCube< T1, T2, eglue_type >
eOp< T1, eop_type >
eop_abs
eop_acos
eop_acosh
eop_asin
eop_asinh
eop_atan
eop_atanh
eop_auxUse of the SFINAE approach to work around compiler limitations //! http://en.wikipedia.org/wiki/SFINAE
eop_aux_randn< eT >
eop_aux_randn< std::complex< T > >
eop_aux_randu< eT >
eop_aux_randu< std::complex< T > >
eop_conj
eop_core< eop_type >
eop_cos
eop_cosh
eop_cube_abs
eop_cube_acos
eop_cube_acosh
eop_cube_asin
eop_cube_asinh
eop_cube_atan
eop_cube_atanh
eop_cube_conj
eop_cube_core< eop_cube_type >
eop_cube_cos
eop_cube_cosh
eop_cube_eps
eop_cube_exp
eop_cube_log
eop_cube_log10
eop_cube_neg
eop_cube_ones_full
eop_cube_pow
eop_cube_pow_int
eop_cube_randn
eop_cube_randu
eop_cube_scalar_div_post
eop_cube_scalar_div_pre
eop_cube_scalar_minus_post
eop_cube_scalar_minus_pre
eop_cube_scalar_plus
eop_cube_scalar_times
eop_cube_sin
eop_cube_sinh
eop_cube_sqrt
eop_cube_square
eop_cube_tan
eop_cube_tanh
eop_cube_trunc_exp
eop_cube_trunc_log
eop_cube_zeros
eop_eps
eop_exp
eop_log
eop_log10
eop_neg
eop_ones_diag
eop_ones_full
eop_pow
eop_pow_int
eop_randn
eop_randu
eop_scalar_div_post
eop_scalar_div_pre
eop_scalar_minus_post
eop_scalar_minus_pre
eop_scalar_plus
eop_scalar_times
eop_sin
eop_sinh
eop_sqrt
eop_square
eop_tan
eop_tanh
eop_trunc_exp
eop_trunc_log
eop_zeros
eOpCube< T1, eop_type >
eT_promoter< T1, T2 >
field< oT >A lightweight 2D container for abitrary objects //! (the objects must have a copy constructor)
field_aux
force_different_type< T1, T2 >
force_different_type< T1, T1 >
arma_boost::format
arma_boost::format_metaprog< T1 >
arma_boost::format_metaprog< basic_format< T1, T2 > >
gemm< do_trans_A, do_trans_B, use_alpha, use_beta >//! Wrapper for ATLAS/BLAS dgemm function, using template arguments to control the arguments passed to dgemm. //! Matrix 'C' is assumed to have been set to the correct size (i.e. taking into account transposes)
gemm_emul_cache< do_trans_A, do_trans_B, use_alpha, use_beta >//! Partial emulation of ATLAS/BLAS gemm(), using caching for speedup. //! Matrix 'C' is assumed to have been set to the correct size (i.e. taking into account transposes)
gemm_emul_simple< do_trans_A, do_trans_B, use_alpha, use_beta >Partial emulation of ATLAS/BLAS gemm(), non-cached version. //! Matrix 'C' is assumed to have been set to the correct size (i.e. taking into account transposes)
gemm_mixed< do_trans_A, do_trans_B, use_alpha, use_beta >//! Matrix multplication where the matrices have different element types
gemm_mixed_cache< do_trans_A, do_trans_B, use_alpha, use_beta >//! Matrix multplication where the matrices have different element types. //! Uses caching for speedup. //! Matrix 'C' is assumed to have been set to the correct size (i.e. taking into account transposes)
gemm_mixed_simple< do_trans_A, do_trans_B, use_alpha, use_beta >Matrix multplication where the matrices have different element types. //! Simple version (no caching). //! Matrix 'C' is assumed to have been set to the correct size (i.e. taking into account transposes)
gemv< do_trans_A, use_alpha, use_beta >//! Wrapper for ATLAS/BLAS gemv function, using template arguments to control the arguments passed to gemv. //! 'y' is assumed to have been set to the correct size (i.e. taking into account the transpose)
gemv_arma< do_trans_A, use_alpha, use_beta >//! Partial emulation of ATLAS/BLAS gemv(). //! 'y' is assumed to have been set to the correct size (i.e. taking into account the transpose)
get_pod_type< T1 >
get_pod_type< std::complex< T2 > >
Glue< T1, T2, glue_type >Class for storing data required for delayed binary operations, //! such as the operands (e.g. two matrices) and the binary operator (e.g. addition). //! The operands are stored as references (which can be optimised away), //! while the operator is "stored" through the template definition (glue_type). //! The operands can be 'Mat', 'Row', 'Col', 'Op', and 'Glue'. //! Note that as 'Glue' can be one of the operands, more than two matrices can be stored. //! //! For example, we could have: Glue<Mat, Mat, glue_times> //! //! Another example is: Glue< Op<Mat, op_trans>, Op<Mat, op_inv>, glue_times >
glue_conv
glue_cor
glue_cov
glue_cross
glue_join
glue_kron
glue_mixed_div
glue_mixed_minus
glue_mixed_plus
glue_mixed_schur
glue_mixed_times
glue_rel_eq
glue_rel_gt
glue_rel_gteq
glue_rel_lt
glue_rel_lteq
glue_rel_noteq
glue_solve
glue_timesClass which implements the immediate multiplication of two or more matrices
glue_times_diag
glue_times_redirect< N >
glue_times_redirect< 3 >
glue_times_redirect< 4 >
glue_toeplitz
GlueCube< T1, T2, glue_type >Analog of the Glue class, intended for Cube objects
is_arma_cube_type< T1 >
is_arma_type< T1 >
is_Col< T >
is_Col< Col< eT > >
is_complex< T1 >
is_complex< std::complex< eT > >
is_complex_double< T1 >
is_complex_double< std::complex< double > >
is_complex_float< T1 >
is_complex_float< std::complex< float > >
is_Cube< T >
is_Cube< Cube< eT > >
is_cube_generator< T1 >
is_cube_generator< eop_cube_ones_full >
is_cube_generator< eop_cube_randn >
is_cube_generator< eop_cube_randu >
is_cube_generator< eop_cube_zeros >
is_diagview< T >
is_diagview< diagview< eT > >
is_double< T1 >
is_double< double >
is_eGlue< T >
is_eGlue< eGlue< T1, T2, eglue_type > >
is_eOp< T >
is_eOp< eOp< T1, eop_type > >
is_float< T1 >
is_float< float >
is_generator< T1 >
is_generator< eop_ones_full >
is_generator< eop_randn >
is_generator< eop_randu >
is_generator< eop_zeros >
is_Glue< T >
is_Glue< Glue< T1, T2, glue_type > >
is_glue_times< T >
is_glue_times< Glue< T1, T2, glue_times > >
is_glue_times_diag< T >
is_glue_times_diag< Glue< T1, T2, glue_times_diag > >
is_GlueCube< T >
is_GlueCube< GlueCube< T1, T2, glue_type > >
is_Mat< T >
is_Mat< Col< eT > >
is_Mat< Mat< eT > >
is_Mat< Row< eT > >
is_Mat_only< T >
is_Mat_only< Mat< eT > >
is_non_integral< T >
is_Op< T >
is_Op< Op< T1, op_type > >
is_op_diagmat< T >
is_op_diagmat< Op< T1, op_diagmat > >
is_op_rel< T >
is_op_rel< mtOp< out_eT, T1, op_rel_eq > >
is_op_rel< mtOp< out_eT, T1, op_rel_gt_post > >
is_op_rel< mtOp< out_eT, T1, op_rel_gt_pre > >
is_op_rel< mtOp< out_eT, T1, op_rel_gteq_post > >
is_op_rel< mtOp< out_eT, T1, op_rel_gteq_pre > >
is_op_rel< mtOp< out_eT, T1, op_rel_lt_post > >
is_op_rel< mtOp< out_eT, T1, op_rel_lt_pre > >
is_op_rel< mtOp< out_eT, T1, op_rel_lteq_post > >
is_op_rel< mtOp< out_eT, T1, op_rel_lteq_pre > >
is_op_rel< mtOp< out_eT, T1, op_rel_noteq > >
is_OpCube< T >
is_OpCube< OpCube< T1, op_type > >
is_Row< T >
is_Row< Row< eT > >
is_s16< T1 >
is_s16< s16 >
is_s32< T1 >
is_s32< s32 >
is_s8< T1 >
is_s8< s8 >
is_same_type< T1, T2 >
is_same_type< T1, T1 >
is_signed< T >
is_subview< T >
is_subview< subview< eT > >
is_subview_cube< T >
is_subview_cube< subview_cube< eT > >
is_supported_blas_type< T1 >
is_supported_complex< T1 >Check for a weird implementation of the std::complex class
is_supported_complex< std::complex< eT > >
is_supported_complex_double< T1 >
is_supported_complex_double< std::complex< double > >
is_supported_complex_float< T1 >
is_supported_complex_float< std::complex< float > >
is_supported_elem_type< T1 >
diskio::is_supported_type< eT >
is_u16< T1 >
is_u16< u16 >
is_u32< T1 >
is_u32< u32 >
is_u8< T1 >
is_u8< u8 >
isnt_fltpt< T1 >
isnt_fltpt< double >
isnt_fltpt< float >
isnt_fltpt< long double >
isnt_fltpt< std::complex< double > >
isnt_fltpt< std::complex< float > >
isnt_fltpt_false
isnt_same_type< T1, T2 >
isnt_same_type< T1, T1 >
isnt_supported_elem_type< T1 >
isnt_supported_elem_type< double >
isnt_supported_elem_type< float >
isnt_supported_elem_type< s16 >
isnt_supported_elem_type< s32 >
isnt_supported_elem_type< s8 >
isnt_supported_elem_type< std::complex< double > >
isnt_supported_elem_type< std::complex< float > >
isnt_supported_elem_type< u16 >
isnt_supported_elem_type< u32 >
isnt_supported_elem_type< u8 >
isnt_supported_elem_type_false
field< oT >::iterator
Mat< eT >Dense matrix class
itpp::Mat< eT >Dummy itpp::Mat class, to prevent compilation errors
Mat_aux
Math< eT >
mtGlue< out_eT, T1, T2, glue_type >
mtOp< out_eT, T1, op_type >
Op< T1, op_type >Class for storing data required for delayed unary operations, //! such as the operand (e.g. the matrix to which the operation is to be applied) and the unary operator (e.g. inverse). //! The operand is stored as a reference (which can be optimised away), //! while the operator is "stored" through the template definition (op_type). //! The operands can be 'Mat', 'Row', 'Col', 'Op', and 'Glue'. //! Note that as 'Glue' can be one of the operands, more than one matrix can be stored. //! //! For example, we could have: //! Op< Glue< Mat, Mat, glue_times >, op_trans >
op_abs
op_chol
op_cor
op_cov
op_cx_scalar_div_post
op_cx_scalar_div_pre
op_cx_scalar_minus_post
op_cx_scalar_minus_pre
op_cx_scalar_plus
op_cx_scalar_times
op_diagmat
op_diagvec
op_dot//! dot product operation
op_dotext
op_find
op_fliplr
op_flipud
op_htrans'hermitian transpose' operation (only valid for complex number matrices)
op_imag
op_inv'invert matrix' operation
op_maxClass for finding maximum values in a matrix
op_meanClass for finding mean values of a matrix
op_medianClass for finding median values of a matrix
op_minClass for finding minimum values in a matrix
op_norm_dot//! normalised dot product operation
op_pinv
op_princomp
op_princomp_cov
op_prodClass for finding products of values in a matrix (e.g. along rows or columns)
op_real
op_rel_eq
op_rel_gt_post
op_rel_gt_pre
op_rel_gteq_post
op_rel_gteq_pre
op_rel_lt_post
op_rel_lt_pre
op_rel_lteq_post
op_rel_lteq_pre
op_rel_noteq
op_repmat
op_reshape
op_shuffle
op_sort
op_stddevClass for finding the standard deviation
op_sumClass for finding sums of values in a matrix (e.g. along rows or columns)
op_trans'matrix transpose' operation
op_trans2
op_varClass for finding variance values of a matrix
OpCube< T1, op_type >Analog of the Op class, intended for cubes
partial_unwrap< T1 >
partial_unwrap< Col< eT > >
partial_unwrap< eOp< Col< eT >, eop_scalar_times > >
partial_unwrap< eOp< Mat< eT >, eop_scalar_times > >
partial_unwrap< eOp< Row< eT >, eop_scalar_times > >
partial_unwrap< eOp< T1, eop_scalar_times > >
partial_unwrap< Mat< eT > >
partial_unwrap< Op< Col< eT >, op_trans > >
partial_unwrap< Op< Col< eT >, op_trans2 > >
partial_unwrap< Op< Mat< eT >, op_trans > >
partial_unwrap< Op< Mat< eT >, op_trans2 > >
partial_unwrap< Op< Row< eT >, op_trans > >
partial_unwrap< Op< Row< eT >, op_trans2 > >
partial_unwrap< Op< T1, op_trans > >
partial_unwrap< Op< T1, op_trans2 > >
partial_unwrap< Row< eT > >
partial_unwrap_check< T1 >
partial_unwrap_check< Col< eT > >
partial_unwrap_check< eOp< Col< eT >, eop_scalar_times > >
partial_unwrap_check< eOp< Mat< eT >, eop_scalar_times > >
partial_unwrap_check< eOp< Row< eT >, eop_scalar_times > >
partial_unwrap_check< eOp< T1, eop_scalar_times > >
partial_unwrap_check< Mat< eT > >
partial_unwrap_check< Op< Col< eT >, op_trans > >
partial_unwrap_check< Op< Col< eT >, op_trans2 > >
partial_unwrap_check< Op< Mat< eT >, op_trans > >
partial_unwrap_check< Op< Mat< eT >, op_trans2 > >
partial_unwrap_check< Op< Row< eT >, op_trans > >
partial_unwrap_check< Op< Row< eT >, op_trans2 > >
partial_unwrap_check< Op< T1, op_trans > >
partial_unwrap_check< Op< T1, op_trans2 > >
partial_unwrap_check< Row< eT > >
Phy< eT >Physical constants taken from NIST and WolframAlpha on 2009-06-23 //! http://physics.nist.gov/cuu/Constants //! http://www.wolframalpha.com //! See also http://en.wikipedia.org/wiki/Physical_constant
podarray< eT >A lightweight array for POD types. If the amount of memory requested is small, the stack is used
promote_type< T1, T2 >
promote_type< double, float >
promote_type< double, s16 >
promote_type< double, s32 >
promote_type< double, s8 >
promote_type< double, std::complex< float > >
promote_type< double, u16 >
promote_type< double, u32 >
promote_type< double, u8 >
promote_type< float, double >
promote_type< float, s16 >
promote_type< float, s32 >
promote_type< float, s8 >
promote_type< float, std::complex< double > >
promote_type< float, u16 >
promote_type< float, u32 >
promote_type< float, u8 >
promote_type< s16, double >
promote_type< s16, float >
promote_type< s16, s32 >
promote_type< s16, s8 >
promote_type< s16, std::complex< T > >
promote_type< s16, u16 >
promote_type< s16, u32 >
promote_type< s16, u8 >
promote_type< s32, double >
promote_type< s32, float >
promote_type< s32, s16 >
promote_type< s32, s8 >
promote_type< s32, std::complex< T > >
promote_type< s32, u16 >
promote_type< s32, u32 >
promote_type< s32, u8 >
promote_type< s8, double >
promote_type< s8, float >
promote_type< s8, s16 >
promote_type< s8, s32 >
promote_type< s8, std::complex< T > >
promote_type< s8, u16 >
promote_type< s8, u32 >
promote_type< s8, u8 >
promote_type< std::complex< double >, float >
promote_type< std::complex< double >, std::complex< float > >
promote_type< std::complex< float >, double >
promote_type< std::complex< float >, std::complex< double > >
promote_type< std::complex< T >, s16 >
promote_type< std::complex< T >, s32 >
promote_type< std::complex< T >, s8 >
promote_type< std::complex< T >, T >
promote_type< std::complex< T >, u16 >
promote_type< std::complex< T >, u32 >
promote_type< std::complex< T >, u8 >
promote_type< T, std::complex< T > >
promote_type< T, T >
promote_type< u16, double >
promote_type< u16, float >
promote_type< u16, s16 >
promote_type< u16, s32 >
promote_type< u16, s8 >
promote_type< u16, std::complex< T > >
promote_type< u16, u32 >
promote_type< u16, u8 >
promote_type< u32, double >
promote_type< u32, float >
promote_type< u32, s16 >
promote_type< u32, s32 >
promote_type< u32, s8 >
promote_type< u32, std::complex< T > >
promote_type< u32, u16 >
promote_type< u32, u8 >
promote_type< u8, double >
promote_type< u8, float >
promote_type< u8, s16 >
promote_type< u8, s32 >
promote_type< u8, s8 >
promote_type< u8, std::complex< T > >
promote_type< u8, u16 >
promote_type< u8, u32 >
promote_type_ok
Proxy< T1 >
Proxy< Col< eT > >
Proxy< diagview< eT > >
Proxy< eGlue< T1, T2, eglue_type > >
Proxy< eOp< T1, eop_type > >
Proxy< Glue< T1, T2, glue_type > >
Proxy< Mat< eT > >
Proxy< mtGlue< out_eT, T1, T2, glue_type > >
Proxy< mtOp< out_eT, T1, op_type > >
Proxy< Op< T1, op_type > >
Proxy< Row< eT > >
Proxy< subview< eT > >
ProxyCube< T1 >
ProxyCube< Cube< eT > >
ProxyCube< eGlueCube< T1, T2, eglue_type > >
ProxyCube< eOpCube< T1, eop_type > >
ProxyCube< GlueCube< T1, T2, glue_type > >
ProxyCube< OpCube< T1, op_type > >
ProxyCube< subview_cube< eT > >
Row< eT >Class for row vectors (matrices with only one row)
Mat< eT >::row_iterator
running_stat< eT >Class for keeping statistics of a continuously sampled process / signal. //! Useful if the storage of individual samples is not necessary or desired. //! Also useful if the number of samples is not known beforehand or exceeds //! available memory
running_stat_aux
running_stat_vec< eT >Class for keeping statistics of a continuously sampled process / signal. //! Useful if the storage of individual samples is not necessary or desired. //! Also useful if the number of samples is not known beforehand or exceeds //! available memory
running_stat_vec_aux
arma_boost::string_only< T >
arma_boost::string_only< std::string >
strip_diagmat< T1 >
strip_diagmat< Op< T1, op_diagmat > >
strip_inv< T1 >
strip_inv< Op< T1, op_inv > >
subview< eT >Class for storing data required to construct or apply operations to a submatrix //! (i.e. where the submatrix starts and ends as well as a reference/pointer to the original matrix),
subview_col< eT >
subview_cube< eT >Class for storing data required to construct or apply operations to a subcube //! (i.e. where the subcube starts and ends as well as a reference/pointer to the original cube),
subview_field< oT >Class for storing data required to construct or apply operations to a subfield //! (i.e. where the subfield starts and ends as well as a reference/pointer to the original field),
subview_row< eT >
syslib
unwrap< T1 >
unwrap< Col< eT > >
unwrap< Mat< eT > >
unwrap< mtGlue< out_eT, T1, T2, glue_type > >
unwrap< mtOp< out_eT, T1, op_type > >
unwrap< Row< eT > >
unwrap_check< T1 >
unwrap_check< Col< eT > >
unwrap_check< Mat< eT > >
unwrap_check< Row< eT > >
unwrap_cube< T1 >
unwrap_cube< Cube< eT > >
unwrap_cube_check< T1 >
unwrap_cube_check< Cube< eT > >
upgrade_val< T1, T2 >Upgrade_val is used to ensure an operation such as multiplication is possible between two types. //! values are upgraded only where necessary
upgrade_val< double, std::complex< float > >
upgrade_val< float, std::complex< double > >
upgrade_val< std::complex< double >, float >Work around limitations in the complex class (at least as present in gcc 4.1 & 4.3)
upgrade_val< std::complex< double >, std::complex< float > >
upgrade_val< std::complex< float >, double >Ensure we don't lose precision when multiplying a complex number with a higher precision real number
upgrade_val< std::complex< float >, std::complex< double > >Ensure we don't lose precision when multiplying complex numbers with different underlying types
upgrade_val< std::complex< T >, T2 >Upgrade a type to allow multiplication with a complex type e.g. the int in "int * complex<double>" is upgraded to a double
upgrade_val< T, T >
upgrade_val< T1, std::complex< T > >
itpp::Vec< eT >Dummy itpp::Vec class, to prevent compilation errors
wall_clockClass for measuring time intervals