Class List

Here are the classes, structs, unions and interfaces with brief descriptions:
access
arma_apply_proxy< false, arma_class >
arma_apply_proxy< true, arma_class >
arma_config
arma_cx_median_packet< T >
junk::arma_elem_size_test
junk::arma_first_extra_debug_message
arma_ostream
arma_ostream_state
arma_qsort_helper< eT >
arma_qsort_helper< std::complex< T > >
arma_sort_index_packet_ascend< T1, T2 >
arma_sort_index_packet_descend< T1, T2 >
arma_static_assert< true >
arma_type_check< val >
arma_version
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
Base_vec< elem_type, derived_vec >
deprecated::basic_colvec< eT >Class name 'basic_colvec' is deprecated. 'basic_colvec' has been defined as 'Col' for compatibility with Armadillo <= 0.6.2
arma_boost::basic_format< T1, T2 >
deprecated::basic_mat< eT >Class name 'basic_mat' is deprecated. 'basic_mat' has been defined as 'Mat' for compatibility with Armadillo <= 0.6.2
deprecated::basic_math< eT >Class name 'basic_math' is deprecated. 'basic_math' has been defined as 'Math' for compatibility with Armadillo <= 0.6.2
deprecated::basic_rowvec< eT >Class name 'basic_rowvec' is deprecated. 'basic_rowvec' has been defined as 'Row' for compatibility with Armadillo <= 0.6.2
Col< eT >Class for column vectors (matrices with only column)
conv_to< out_eT >
conv_to< Col< out_eT > >
conv_to< itpp::Mat< out_eT > >
conv_to< itpp::Vec< out_eT > >
conv_to< Mat< out_eT > >
conv_to< Row< out_eT > >
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 > >
diagview< eT >Class for storing data required to extract and set the diagonals of a matrix
diskioClass for saving and loading matrices and fields
diskio::is_supported_type< eT >
field< oT >A lightweight 2D container for abitrary objects (the objects must have a copy constructor)
field_aux
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_divClass which implements the immediate element-wise division of two or more matrices
glue_minusClass for the minus operation, where the result is always a dense matrix
glue_minus_diagClass for the minus operation, where one of the operands is a diagonal matrix
glue_plusClass which implements the immediate addition matrices, with the result stored in 'Mat' (dense matrix)
glue_plus_diag
glue_schurClass which implements the immediate Schur product (element-wise multiplication) of two or more matrices
glue_schur_diag
glue_timesClass which implements the immediate multiplication of two or more matrices
glue_times_diag
glue_times_vec
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_diagview< T >
is_diagview< diagview< eT > >
is_double< T1 >
is_double< double >
is_float< T1 >
is_float< float >
is_Glue< T >
is_Glue< Glue< T1, T2, glue_type > >
is_glue_times< T >
is_glue_times< Glue< T1, T2, glue_times > >
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_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_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 >
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
mat_ptrs< glue_type, T1 >Template metaprogram mat_ptrs fills a given array with addresses of matrices from a recursive instance of Glue<Tx,Ty, glue_type>. While parsing the recursive instance, if encountered objects are of type Op<..>, they are converted to type 'Mat' first
mat_ptrs< glue_type, Glue< T1, T2, glue_type > >
mat_ptrs_outcheck< glue_type, T1 >Template metaprogram mat_ptrs_outcheck builds on 'mat_ptrs' by also checking whether any of the input matrices are aliases of the output matrix
mat_ptrs_outcheck< glue_type, Glue< T1, T2, glue_type > >
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_acos
op_acosh
op_asin
op_asinh
op_atan
op_atanh
op_conj
op_cos
op_cosh
op_diagmatConvert a mat/rowvec/colvec to a diagonal matrix
op_diagmat_vec
op_dotDot product operation
op_exp
op_htrans'hermitian transpose' operation (only valid for complex number matrices)
op_inv'invert matrix' operation
op_log
op_log10
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_neg'negate matrix' operation
op_norm_dotNormalised dot product operation
op_ones_diag
op_ones_fullClass for creation of a dense matrix/vector with all elements set to one
op_pow
op_pow_s32
op_rand'generate matrix with random values' operation
op_randn'generate matrix with random values' operation
op_scalar_div_post'divide matrix by a scalar' operation
op_scalar_div_pre'divide scalar by a matrix' operation
op_scalar_minus_post'subtract scalar from matrix' operation
op_scalar_minus_pre'subtract matrix from a scalar' operation
op_scalar_plus'add scalar to matrix' operation
op_scalar_times'multiply matrix by a scalar' operation
op_sin
op_sinh
op_sort
op_sqrt
op_square
op_stddevClass for finding the standard deviation
op_sumClass for finding sums of values in a matrix (e.g. along rows or columns)
op_tan
op_tanh
op_trans'matrix transpose' operation
op_trunc_exp
op_trunc_log
op_varClass for finding variance values of a matrix
op_zerosGenerate matrix/vector with all elements set to zero
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< T1 >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
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
sort_index_result_type_deducer< T >
sort_index_result_type_deducer< Col< eT > >
sort_index_result_type_deducer< Row< eT > >
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_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< diagview< eT > >
unwrap< Glue< T1, T2, glue_type > >
unwrap< Mat< eT > >
unwrap< Op< T1, op_type > >
unwrap< Row< eT > >
unwrap< subview< eT > >
unwrap_check< T1 >
unwrap_check< Col< eT > >
unwrap_check< diagview< eT > >
unwrap_check< Glue< T1, T2, glue_type > >
unwrap_check< Mat< eT > >
unwrap_check< Op< T1, op_type > >
unwrap_check< Row< eT > >
unwrap_check< subview< eT > >
unwrap_to_elem_access< T1 >
unwrap_to_elem_access< Col< eT > >
unwrap_to_elem_access< Glue< T1, T2, glue_type > >
unwrap_to_elem_access< Mat< eT > >
unwrap_to_elem_access< Op< Col< eT >, op_trans > >
unwrap_to_elem_access< Op< Row< eT >, op_trans > >
unwrap_to_elem_access< Op< T1, op_type > >
unwrap_to_elem_access< Row< eT > >
unwrap_to_elem_access< subview< 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. used by: glue_div::apply_mixed(), glue_minus::apply_mixed(), glue_plus::apply_mixed(), glue_schur::apply_mixed() and glue_times::apply_mixed() via gemm_mixed()
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