Class List

Here are the classes, structs, unions and interfaces with brief descriptions:
access
arma_config
arma_counter< eT >
arma_cx_median_packet< 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_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_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 >
Col< eT >Class for column vectors (matrices with only column)
conv_to< out_eT >
conv_to< Col< out_eT > >
conv_to< Cube< out_eT > >
conv_to< itpp::Mat< out_eT > >
conv_to< itpp::Vec< out_eT > >
conv_to< Mat< out_eT > >
conv_to< Row< out_eT > >
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_aux
eop_aux_rand< eT >
eop_aux_rand< std::complex< T > >
eop_aux_randn< eT >
eop_aux_randn< 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_rand
eop_cube_randn
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_rand
eop_randn
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 >
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
glue_cor
glue_cov
glue_kron
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 >
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< std::complex< float > >
is_complex_double< T1 >
is_complex_double< std::complex< double > >
is_complex_float< T1 >
is_Cube< T >
is_Cube< Cube< eT > >
is_cube_generator< T1 >
is_cube_generator< eop_cube_ones_full >
is_cube_generator< eop_cube_rand >
is_cube_generator< eop_cube_randn >
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_rand >
is_generator< eop_randn >
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_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
itpp::Mat< eT >
Mat< eT >Dense matrix class
Mat_aux
Math< eT >
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
op_cor
op_cov
op_diagmat
op_diagvec
op_dotDot product operation
op_dotext
op_fliplr
op_flipud
op_htrans'hermitian transpose' operation (only valid for complex number matrices)
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_dotNormalised 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_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< 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)
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
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< 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 >
wall_clockClass for measuring time intervals