access | |
arma_blas_type_only< T > | |
arma_blas_type_only< double > | |
arma_blas_type_only< float > | |
arma_blas_type_only< std::complex< double > > | |
arma_blas_type_only< std::complex< float > > | |
arma_config | |
arma_counter< eT > | |
arma_Cube_only< T > | |
arma_Cube_only< Cube< eT > > | |
arma_cx_median_packet< T > | |
arma_cx_only< T > | |
arma_cx_only< std::complex< 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_float_or_cx_only< T > | |
arma_float_or_cx_only< double > | |
arma_float_or_cx_only< float > | |
arma_float_or_cx_only< std::complex< double > > | |
arma_float_or_cx_only< std::complex< float > > | |
arma_glue_rel_only< T > | |
arma_glue_rel_only< glue_rel_eq > | |
arma_glue_rel_only< glue_rel_gt > | |
arma_glue_rel_only< glue_rel_gteq > | |
arma_glue_rel_only< glue_rel_lt > | |
arma_glue_rel_only< glue_rel_lteq > | |
arma_glue_rel_only< glue_rel_noteq > | |
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_Mat_Col_Row_only< T > | |
arma_Mat_Col_Row_only< Col< eT > > | |
arma_Mat_Col_Row_only< Mat< eT > > | |
arma_Mat_Col_Row_only< Row< eT > > | |
arma_not_cx< T > | |
arma_not_cx< std::complex< T > > | |
arma_not_op_rel< T > | |
arma_not_op_rel< op_rel_eq > | |
arma_not_op_rel< op_rel_gt_post > | |
arma_not_op_rel< op_rel_gt_pre > | |
arma_not_op_rel< op_rel_gteq_post > | |
arma_not_op_rel< op_rel_gteq_pre > | |
arma_not_op_rel< op_rel_lt_post > | |
arma_not_op_rel< op_rel_lt_pre > | |
arma_not_op_rel< op_rel_lteq_post > | |
arma_not_op_rel< op_rel_lteq_pre > | |
arma_not_op_rel< op_rel_noteq > | |
arma_op_rel_only< T > | |
arma_op_rel_only< op_rel_eq > | |
arma_op_rel_only< op_rel_gt_post > | |
arma_op_rel_only< op_rel_gt_pre > | |
arma_op_rel_only< op_rel_gteq_post > | |
arma_op_rel_only< op_rel_gteq_pre > | |
arma_op_rel_only< op_rel_lt_post > | |
arma_op_rel_only< op_rel_lt_pre > | |
arma_op_rel_only< op_rel_lteq_post > | |
arma_op_rel_only< op_rel_lteq_pre > | |
arma_op_rel_only< op_rel_noteq > | |
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 > | |
arma_boost::basic_format_only< T > | |
arma_boost::basic_format_only< basic_format< T > > | |
arma_boost::basic_format_only< basic_format< T1, T2 > > | |
arma_boost::char_only< T > | |
arma_boost::char_only< char > | |
Col< eT > | Class for column vectors (matrices with only column) |
field< oT >::const_iterator | |
Mat< eT >::const_row_iterator | |
conv_to< out_eT > | Conversion from Armadillo Base and BaseCube objects to scalars //! (kept only for compatibility with old code; use as_scalar() instead for Base objects like Mat) |
conv_to< Col< out_eT > > | Conversion to Armadillo column vectors from Armadillo Base objects, //! as well as from std::vector, itpp::Mat and itpp::Vec |
conv_to< Cube< out_eT > > | Conversion to Armadillo cubes from Armadillo BaseCube objects |
conv_to< itpp::Mat< out_eT > > | Conversion to itpp::Mat from Armadillo Base objects |
conv_to< itpp::Vec< out_eT > > | Conversion to itpp::Vec from Armadillo Base objects |
conv_to< Mat< out_eT > > | Conversion to Armadillo matrices from Armadillo Base objects, //! as well as from std::vector, itpp::Mat and itpp::Vec |
conv_to< Row< out_eT > > | Conversion to Armadillo row vectors from Armadillo Base objects, //! as well as from std::vector, itpp::Mat and itpp::Vec |
conv_to< std::vector< out_eT > > | Conversion to std::vector from Armadillo Base objects |
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 | Use of the SFINAE approach to work around compiler limitations //! http://en.wikipedia.org/wiki/SFINAE |
eop_aux_randn< eT > | |
eop_aux_randn< std::complex< T > > | |
eop_aux_randu< eT > | |
eop_aux_randu< 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_randn | |
eop_cube_randu | |
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_randn | |
eop_randu | |
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 > | |
eT_promoter< T1, T2 > | |
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. //! //! For example, we could have: Glue<Mat, Mat, glue_times> //! //! Another example is: Glue< Op<Mat, op_trans>, Op<Mat, op_inv>, glue_times > |
glue_conv | |
glue_cor | |
glue_cov | |
glue_cross | |
glue_join | |
glue_kron | |
glue_mixed_div | |
glue_mixed_minus | |
glue_mixed_plus | |
glue_mixed_schur | |
glue_mixed_times | |
glue_rel_eq | |
glue_rel_gt | |
glue_rel_gteq | |
glue_rel_lt | |
glue_rel_lteq | |
glue_rel_noteq | |
glue_solve | |
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 > | |
glue_toeplitz | |
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_double< T1 > | |
is_complex_double< std::complex< double > > | |
is_complex_float< T1 > | |
is_complex_float< std::complex< float > > | |
is_Cube< T > | |
is_Cube< Cube< eT > > | |
is_cube_generator< T1 > | |
is_cube_generator< eop_cube_ones_full > | |
is_cube_generator< eop_cube_randn > | |
is_cube_generator< eop_cube_randu > | |
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_randn > | |
is_generator< eop_randu > | |
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_op_rel< T > | |
is_op_rel< mtOp< out_eT, T1, op_rel_eq > > | |
is_op_rel< mtOp< out_eT, T1, op_rel_gt_post > > | |
is_op_rel< mtOp< out_eT, T1, op_rel_gt_pre > > | |
is_op_rel< mtOp< out_eT, T1, op_rel_gteq_post > > | |
is_op_rel< mtOp< out_eT, T1, op_rel_gteq_pre > > | |
is_op_rel< mtOp< out_eT, T1, op_rel_lt_post > > | |
is_op_rel< mtOp< out_eT, T1, op_rel_lt_pre > > | |
is_op_rel< mtOp< out_eT, T1, op_rel_lteq_post > > | |
is_op_rel< mtOp< out_eT, T1, op_rel_lteq_pre > > | |
is_op_rel< mtOp< out_eT, T1, op_rel_noteq > > | |
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 > | Dummy itpp::Mat class, to prevent compilation errors |
Mat_aux | |
Math< eT > | |
mtGlue< out_eT, T1, T2, glue_type > | |
mtOp< out_eT, T1, op_type > | |
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. //! //! For example, we could have: //! Op< Glue< Mat, Mat, glue_times >, op_trans > |
op_abs | |
op_chol | |
op_cor | |
op_cov | |
op_cx_scalar_div_post | |
op_cx_scalar_div_pre | |
op_cx_scalar_minus_post | |
op_cx_scalar_minus_pre | |
op_cx_scalar_plus | |
op_cx_scalar_times | |
op_diagmat | |
op_diagvec | |
op_dot | //! dot product operation |
op_dotext | |
op_find | |
op_fliplr | |
op_flipud | |
op_htrans | 'hermitian transpose' operation (only valid for complex number matrices) |
op_imag | |
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_real | |
op_rel_eq | |
op_rel_gt_post | |
op_rel_gt_pre | |
op_rel_gteq_post | |
op_rel_gteq_pre | |
op_rel_lt_post | |
op_rel_lt_pre | |
op_rel_lteq_post | |
op_rel_lteq_pre | |
op_rel_noteq | |
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< mtGlue< out_eT, T1, T2, glue_type > > | |
Proxy< mtOp< out_eT, T1, op_type > > | |
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 | |
arma_boost::string_only< T > | |
arma_boost::string_only< std::string > | |
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< mtGlue< out_eT, T1, T2, glue_type > > | |
unwrap< mtOp< out_eT, T1, op_type > > | |
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 > | Dummy itpp::Vec class, to prevent compilation errors |
wall_clock | Class for measuring time intervals |