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 > | |
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) |
field< oT >::const_iterator | |
Mat< eT >::const_row_iterator | |
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 |
diskio | Class 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_cross | |
glue_join | |
glue_kron | |
glue_times | Class 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 | |
field< oT >::iterator | |
Mat< eT > | Dense matrix class |
itpp::Mat< eT > | |
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_dot | Dot 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_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_norm_dot | Normalised dot product operation |
op_pinv | |
op_princomp | |
op_princomp_cov | |
op_prod | Class for finding products of values in a matrix (e.g. along rows or columns) |
op_repmat | |
op_reshape | |
op_shuffle | |
op_sort | |
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_trans | 'matrix transpose' operation |
op_trans2 | |
op_var | Class 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) |
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 | |
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_clock | Class for measuring time intervals |