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 | |
auxlib | Wrapper 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 |
diskio | Class 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_div | Class which implements the immediate element-wise division of two or more matrices |
glue_minus | Class for the minus operation, where the result is always a dense matrix |
glue_minus_diag | Class for the minus operation, where one of the operands is a diagonal matrix |
glue_plus | Class which implements the immediate addition matrices, with the result stored in 'Mat' (dense matrix) |
glue_plus_diag | |
glue_schur | Class which implements the immediate Schur product (element-wise multiplication) of two or more matrices |
glue_schur_diag | |
glue_times | Class 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_diagmat | Convert a mat/rowvec/colvec to a diagonal matrix |
op_diagmat_vec | |
op_dot | Dot 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_max | Class for finding maximum values in a matrix |
op_mean | Class for finding mean values of a matrix |
op_median | Class for finding median values of a matrix |
op_min | Class for finding minimum values in a matrix |
op_neg | 'negate matrix' operation |
op_norm_dot | Normalised dot product operation |
op_ones_diag | |
op_ones_full | Class 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_stddev | Class for finding the standard deviation |
op_sum | Class 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_var | Class for finding variance values of a matrix |
op_zeros | Generate 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_clock | Class for measuring time intervals |