access | |
arma_apply_proxy< false, arma_class > | |
arma_apply_proxy< true, arma_class > | |
arma_config | |
arma_counter< eT > | |
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 |
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 | |
cube_ptrs< glue_type, T1 > | Template metaprogram cube_ptrs fills a given array with addresses of cubes from a recursive instance of GlueCube<Tx,Ty, glue_cube_type>. While parsing the recursive instance, if encountered objects are of type OpCube<..>, they are converted to type 'Cube' first |
cube_ptrs< glue_type, GlueCube< T1, T2, glue_type > > | |
cube_ptrs_outcheck< glue_type, T1 > | Template metaprogram cube_ptrs_outcheck builds on 'cube_ptrs' by also checking whether any of the input cubes are aliases of the output cube |
cube_ptrs_outcheck< glue_type, GlueCube< T1, T2, glue_type > > | |
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 > > | |
depth_lhs_cube< glue_cube_type, T1 > | Template metaprogram depth_lhs_cube calculates the number of GlueCube<Tx,Ty, glue_type> instances on the left hand side argument of GlueCube<Tx,Ty, glue_cube_type> i.e. it recursively expands each Tx, until the type of Tx is not "GlueCube<..,.., glue_cube_type>" (i.e the "glue_cube_type" changes) |
depth_lhs_cube< glue_cube_type, GlueCube< T1, T2, glue_cube_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 |
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_cor | |
glue_cov | |
glue_cube_div | Class which implements the immediate element-wise division of two or more cubes |
glue_cube_minus | Class which implements the immediate subtraction of cubes |
glue_cube_plus | Class which implements the immediate addition of cubes |
glue_cube_schur | Class which implements the immediate Schur product (element-wise multiplication) of two or more cubes |
glue_div | Class which implements the immediate element-wise division of two or more matrices |
glue_kron | |
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 of 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 | |
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_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_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_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 | |
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_cor | |
op_cos | |
op_cosh | |
op_cov | |
op_diagmat | Convert a mat/rowvec/colvec to a diagonal matrix |
op_diagmat_vec | |
op_dot | Dot product operation |
op_eps | |
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 operation |
op_norm_dot | Normalised dot product operation |
op_ones_diag | |
op_ones_full | Class for creation of a dense matrix/vector/cube with all elements set to one |
op_pinv | |
op_pow | |
op_pow_s32 | |
op_prod | Class for finding products of values in a matrix (e.g. along rows or columns) |
op_rand | 'generate matrix with random values' operation |
op_randn | 'generate matrix with random values' operation |
op_repmat | |
op_reshape | |
op_scalar_div_post | 'divide matrix/cube by a scalar' operation |
op_scalar_div_pre | 'divide scalar by a matrix/cube' operation |
op_scalar_minus_post | 'subtract scalar from a matrix/cube' operation |
op_scalar_minus_pre | 'subtract matrix/cube from a scalar' operation |
op_scalar_plus | 'add scalar to a matrix/cube' operation |
op_scalar_times | 'multiply matrix/cube by a scalar' operation |
op_shuffle | |
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 |
OpCube< T1, op_type > | Analog of the Op class, intended for cubes |
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 | |
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 | |
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_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< 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_cube< T1 > | |
unwrap_cube< Cube< eT > > | |
unwrap_cube< GlueCube< T1, T2, glue_cube_type > > | |
unwrap_cube< OpCube< T1, op_type > > | |
unwrap_cube< subview_cube< eT > > | |
unwrap_cube_check< T1 > | |
unwrap_cube_check< Cube< eT > > | |
unwrap_cube_check< GlueCube< T1, T2, glue_cube_type > > | |
unwrap_cube_check< OpCube< T1, op_type > > | |
unwrap_cube_check< subview_cube< eT > > | |
unwrap_cube_write< T1 > | If the given object in not a cube, unwrap it into the given 'out' cube (i.e. do not create another cube) and provide a reference to the 'out' cube. if the given object is a cube, set the size of the 'out' cube to be the same as the given object and provide a reference to the given object |
unwrap_cube_write< Cube< eT > > | |
unwrap_cube_write< GlueCube< T1, T2, glue_type > > | |
unwrap_cube_write< OpCube< T1, op_type > > | |
unwrap_cube_write< subview_cube< 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 > > | |
unwrap_write< T1 > | If the given object in not a matrix, unwrap it into the given 'out' matrix (i.e. do not create another matrix) and provide a reference to the 'out' matrix. if the given object is a matrix, set the size of the 'out' matrix to be the same as the given object and provide a reference to the given object |
unwrap_write< Col< eT > > | |
unwrap_write< diagview< eT > > | |
unwrap_write< Glue< T1, T2, glue_type > > | |
unwrap_write< Mat< eT > > | |
unwrap_write< Op< T1, op_type > > | |
unwrap_write< Row< eT > > | |
unwrap_write< 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 |