$search

Class List

Here are the classes, structs, unions and interfaces with brief descriptions:
access
arma_ascend_sort_helper< eT >
arma_ascend_sort_helper< std::complex< T > >
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< double > >
arma_cx_only< std::complex< float > >
arma_descend_sort_helper< eT >
arma_descend_sort_helper< std::complex< T > >
junk::arma_elem_size_test
arma_empty_class
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< s16 >
arma_integral_only< s32 >
arma_integral_only< s8 >
arma_integral_only< u16 >
arma_integral_only< u32 >
arma_integral_only< u8 >
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_scalar_only< T >
arma_scalar_only< double >
arma_scalar_only< float >
arma_scalar_only< s16 >
arma_scalar_only< s32 >
arma_scalar_only< s8 >
arma_scalar_only< std::complex< T > >
arma_scalar_only< u16 >
arma_scalar_only< u32 >
arma_scalar_only< u8 >
arma_signed_integral_only< T >
arma_signed_integral_only< s16 >
arma_signed_integral_only< s32 >
arma_signed_integral_only< s8 >
arma_signed_only< T >
arma_signed_only< double >
arma_signed_only< float >
arma_signed_only< s16 >
arma_signed_only< s32 >
arma_signed_only< s8 >
arma_signed_only< std::complex< T > >
arma_sort_index_packet_ascend< T1, T2 >
arma_sort_index_packet_descend< T1, T2 >
arma_type_check_cxx1998< ERROR___INCORRECT_OR_UNSUPPORTED_TYPE >
arma_type_check_cxx1998< false >
arma_unsigned_integral_only< T >
arma_unsigned_integral_only< u16 >
arma_unsigned_integral_only< u32 >
arma_unsigned_integral_only< u8 >
arma_version
arrayops
as_scalar_redirect< N >
as_scalar_redirect< 2 >
as_scalar_redirect< 3 >
auxlibWrapper for accessing external functions defined in ATLAS, LAPACK or BLAS libraries
Base< elem_type, derived >
BaseCube< elem_type, derived >Analog of the Base class, intended for cubes
arma_boost::basic_format< T1, T2 >
arma_boost::basic_format_only< 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 one column)
field< oT >::const_iterator
Mat< eT >::const_row_iterator
conv_to< out_eT >
conv_to< Col< out_eT > >
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 > >
conv_to< Row< out_eT > >
conv_to< std::vector< out_eT > >Conversion to std::vector from Armadillo Base objects
Cube< eT >Dense cube class
Cube_aux
Cube_prealloc
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
diskioClass for saving and loading matrices and fields
eGlue< T1, T2, eglue_type >
eglue_core< eglue_type >
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_randn< eT >
eop_aux_randn< std::complex< T > >
eop_aux_randu< eT >
eop_aux_randu< std::complex< T > >
eop_ceil
eop_conj
eop_core< eop_type >
eop_cos
eop_cosh
eop_eps
eop_exp
eop_exp10
eop_exp2
eop_floor
eop_log
eop_log10
eop_log2
eop_neg
eop_pow
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
eOpCube< T1, eop_type >
eT_promoter< T1, T2 >
field< oT >
field_aux
field_injector< T1 >
field_injector_row< oT >
field_prealloc_n_elem
Col< eT >::fixed< fixed_n_elem >
Cube< eT >::fixed< fixed_n_rows, fixed_n_cols, fixed_n_slices >
Mat< eT >::fixed< fixed_n_rows, fixed_n_cols >
Row< eT >::fixed< fixed_n_elem >
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< do_trans_A, do_trans_B, use_alpha, use_beta >
gemm_emul_large< do_trans_A, do_trans_B, use_alpha, use_beta >
gemm_emul_tinysq< do_trans_A, use_alpha, use_beta >For tiny square matrices, size <= 4x4
gemm_mixed< do_trans_A, do_trans_B, use_alpha, use_beta >Matrix multplication where the matrices have differing element types
gemm_mixed_large< do_trans_A, do_trans_B, use_alpha, use_beta >Matrix multplication where the matrices have differing 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_small< do_trans_A, do_trans_B, use_alpha, use_beta >
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_emul< do_trans_A, use_alpha, use_beta >
gemv_emul_large< 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)
gemv_emul_tinysq< do_trans_A, use_alpha, use_beta >For tiny square matrices, size <= 4x4
Gen< eT, gen_type >Support class for generator functions (eg. zeros, randu, randn, ...)
GenCube< eT, gen_type >Support class for generator functions (eg. zeros, randu, randn, ...)
get_pod_type< T1 >
get_pod_type< std::complex< T2 > >
Glue< T1, T2, glue_type >
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_solve_tr
glue_timesClass 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
glue_toeplitz_circ
GlueCube< T1, T2, glue_type >Analog of the Glue class, intended for Cube objects
injector_end_of_row
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_diagview< T >
is_diagview< diagview< eT > >
is_double< T1 >
is_double< double >
is_eGlue< T >
is_eGlue< eGlue< T1, T2, eglue_type > >
is_eGlueCube< T >
is_eGlueCube< eGlueCube< T1, T2, eglue_type > >
is_eOp< T >
is_eOp< eOp< T1, eop_type > >
is_eOpCube< T >
is_eOpCube< eOpCube< T1, eop_type > >
is_float< T1 >
is_float< float >
is_Gen< T >
is_Gen< Gen< eT, gen_type > >
is_GenCube< T >
is_GenCube< GenCube< eT, gen_type > >
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_mtGlue< T >
is_mtGlue< mtGlue< eT, T1, T2, glue_type > >
is_mtGlueCube< T >
is_mtGlueCube< mtGlueCube< eT, T1, T2, glue_type > >
is_mtOp< T >
is_mtOp< mtOp< eT, T1, op_type > >
is_mtOpCube< T >
is_mtOpCube< mtOpCube< eT, T1, op_type > >
is_non_integral< T >
is_non_integral< double >
is_non_integral< float >
is_non_integral< std::complex< double > >
is_non_integral< std::complex< float > >
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_promotable< T1, T2 >
is_promotable< double, float >
is_promotable< double, s16 >
is_promotable< double, s32 >
is_promotable< double, s8 >
is_promotable< double, std::complex< float > >
is_promotable< double, u16 >
is_promotable< double, u32 >
is_promotable< double, u8 >
is_promotable< float, double >
is_promotable< float, s16 >
is_promotable< float, s32 >
is_promotable< float, s8 >
is_promotable< float, std::complex< double > >
is_promotable< float, u16 >
is_promotable< float, u32 >
is_promotable< float, u8 >
is_promotable< s16, double >
is_promotable< s16, float >
is_promotable< s16, s32 >
is_promotable< s16, s8 >
is_promotable< s16, std::complex< T > >
is_promotable< s16, u16 >
is_promotable< s16, u32 >
is_promotable< s16, u8 >
is_promotable< s32, double >
is_promotable< s32, float >
is_promotable< s32, s16 >
is_promotable< s32, s8 >
is_promotable< s32, std::complex< T > >
is_promotable< s32, u16 >
is_promotable< s32, u32 >
is_promotable< s32, u8 >
is_promotable< s8, double >
is_promotable< s8, float >
is_promotable< s8, s16 >
is_promotable< s8, s32 >
is_promotable< s8, std::complex< T > >
is_promotable< s8, u16 >
is_promotable< s8, u32 >
is_promotable< s8, u8 >
is_promotable< std::complex< double >, float >
is_promotable< std::complex< double >, std::complex< float > >
is_promotable< std::complex< float >, double >
is_promotable< std::complex< float >, std::complex< double > >
is_promotable< std::complex< T >, s16 >
is_promotable< std::complex< T >, s32 >
is_promotable< std::complex< T >, s8 >
is_promotable< std::complex< T >, T >
is_promotable< std::complex< T >, u16 >
is_promotable< std::complex< T >, u32 >
is_promotable< std::complex< T >, u8 >
is_promotable< T, std::complex< T > >
is_promotable< T, T >
is_promotable< u16, double >
is_promotable< u16, float >
is_promotable< u16, s16 >
is_promotable< u16, s32 >
is_promotable< u16, s8 >
is_promotable< u16, std::complex< T > >
is_promotable< u16, u32 >
is_promotable< u16, u8 >
is_promotable< u32, double >
is_promotable< u32, float >
is_promotable< u32, s16 >
is_promotable< u32, s32 >
is_promotable< u32, s8 >
is_promotable< u32, std::complex< T > >
is_promotable< u32, u16 >
is_promotable< u32, u8 >
is_promotable< u8, double >
is_promotable< u8, float >
is_promotable< u8, s16 >
is_promotable< u8, s32 >
is_promotable< u8, s8 >
is_promotable< u8, std::complex< T > >
is_promotable< u8, u16 >
is_promotable< u8, u32 >
is_promotable_ok
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_signed< u16 >
is_signed< u32 >
is_signed< u8 >
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 >
is_sword< T1 >
is_sword< sword >
is_u16< T1 >
is_u16< u16 >
is_u32< T1 >
is_u32< u32 >
is_u8< T1 >
is_u8< u8 >
is_uword< T1 >
is_uword< uword >
field< oT >::iterator
itpp::Mat< eT >Dummy itpp::Mat class, to prevent compilation errors
Mat< eT >Dense matrix class
Mat_aux
mat_injector< T1 >
mat_injector_row< eT >
Math< eT >
priv::Math_helper
mtGlue< out_eT, T1, T2, glue_type >
mtGlueCube< out_eT, T1, T2, glue_type >
mtOp< out_eT, T1, op_type >
mtOpCube< out_eT, T1, op_type >
Op< T1, op_type >
op_abs
op_cdot
op_chol
op_cor
op_cov
op_cumsum_mat
op_cumsum_vec
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_dotDot product operation
op_dotext
op_find
op_fliplr
op_flipud
op_htrans'hermitian transpose' operation
op_htrans2
op_imag
op_inv'invert matrix' operation (general matrices)
op_inv_sympd'invert matrix' operation (symmetric positive definite matrices)
op_inv_tr'invert matrix' operation (triangular matrices)
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_norm_dotNormalised dot product operation
op_pinv
op_princomp
op_prodClass 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_resize
op_shuffle
op_sort
op_stddevClass for finding the standard deviation
op_strans'matrix transpose' operation
op_sumClass for finding sums of values in a matrix (e.g. along rows or columns)
op_symmat
op_sympd
op_trimat
op_varClass 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_htrans > >
partial_unwrap< Op< Col< eT >, op_htrans2 > >
partial_unwrap< Op< Mat< eT >, op_htrans > >
partial_unwrap< Op< Mat< eT >, op_htrans2 > >
partial_unwrap< Op< Row< eT >, op_htrans > >
partial_unwrap< Op< Row< eT >, op_htrans2 > >
partial_unwrap< Op< T1, op_htrans > >
partial_unwrap< Op< T1, op_htrans2 > >
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_htrans > >
partial_unwrap_check< Op< Col< eT >, op_htrans2 > >
partial_unwrap_check< Op< Mat< eT >, op_htrans > >
partial_unwrap_check< Op< Mat< eT >, op_htrans2 > >
partial_unwrap_check< Op< Row< eT >, op_htrans > >
partial_unwrap_check< Op< Row< eT >, op_htrans2 > >
partial_unwrap_check< Op< T1, op_htrans > >
partial_unwrap_check< Op< T1, op_htrans2 > >
partial_unwrap_check< Row< eT > >
Phy< eT >
podarray< eT >A lightweight array for POD types. If the amount of memory requested is small, the stack is used
podarray_prealloc_n_elem
auxlib::pos< row, col >
op_strans::pos< do_flip, row, col >
gemv_emul_tinysq< do_trans_A, use_alpha, use_beta >::pos< row, col >
promote_type< T1, T2 >
Proxy< T1 >
Proxy< Col< eT > >
Proxy< diagview< eT > >
Proxy< eGlue< T1, T2, eglue_type > >
Proxy< eOp< T1, eop_type > >
Proxy< Gen< eT, gen_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 > >
Proxy< subview_elem1< eT, T1 > >
ProxyCube< T1 >
ProxyCube< Cube< eT > >
ProxyCube< eGlueCube< T1, T2, eglue_type > >
ProxyCube< eOpCube< T1, eop_type > >
ProxyCube< GenCube< eT, gen_type > >
ProxyCube< GlueCube< T1, T2, glue_type > >
ProxyCube< mtGlueCube< out_eT, T1, T2, glue_type > >
ProxyCube< mtOpCube< out_eT, T1, op_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 >
running_stat_aux
running_stat_vec< eT >
running_stat_vec_aux
span
span_alt
span_base< Dummy >
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 >
subview_col< eT >
subview_cube< eT >
subview_elem1< eT, T1 >
subview_field< oT >
subview_row< eT >
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_check_mixed< T1 >
unwrap_check_mixed< Col< eT1 > >
unwrap_check_mixed< Mat< eT1 > >
unwrap_check_mixed< Row< eT1 > >
unwrap_cube< T1 >
unwrap_cube< Cube< eT > >
unwrap_cube_check< T1 >
unwrap_cube_check< Cube< eT > >
upgrade_val< T1, T2 >
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_val< T, T >
upgrade_val< T1, std::complex< T > >
itpp::Vec< eT >Dummy itpp::Vec class, to prevent compilation errors
wall_clockClass for measuring time intervals
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Defines


armadillo_matrix
Author(s): Conrad Sanderson - NICTA (www.nicta.com.au), (Wrapper by Sjoerd van den Dries)
autogenerated on Tue Mar 5 12:27:51 2013