Classes | Public Types | Public Member Functions | Public Attributes | Protected Member Functions | Protected Attributes | Friends

Mat< eT > Class Template Reference
[Mat]

Dense matrix class. More...

#include <Mat_proto.hpp>

Inheritance diagram for Mat< eT >:
Base< eT, Mat< eT > > Col< eT > Row< eT >

List of all members.

Classes

class  const_row_iterator
class  row_iterator

Public Types

typedef eT elem_type
 the type of elements stored in the matrix
typedef get_pod_type< eT >::result pod_type
 if eT is non-complex, pod_type is same as eT. otherwise, pod_type is the underlying type used by std::complex
typedef eT * iterator
typedef const eT * const_iterator
typedef eT * col_iterator
typedef const eT * const_col_iterator

Public Member Functions

 ~Mat ()
 Mat ()
 Mat (const u32 in_rows, const u32 in_cols)
 construct the matrix to have user specified dimensions
 Mat (const char *text)
 create the matrix from a textual description
const Matoperator= (const char *text)
 create the matrix from a textual description
 Mat (const std::string &text)
 create the matrix from a textual description
const Matoperator= (const std::string &text)
 create the matrix from a textual description
 Mat (eT *aux_mem, const u32 aux_n_rows, const u32 aux_n_cols, const bool copy_aux_mem=true)
 construct a matrix from a given auxiliary array of eTs. //! if copy_aux_mem is true, new memory is allocated and the array is copied. //! if copy_aux_mem is false, the auxiliary array is used directly (without allocating memory and copying). //! the default is to copy the array.
 Mat (const eT *aux_mem, const u32 aux_n_rows, const u32 aux_n_cols)
 construct a matrix from a given auxiliary read-only array of eTs. //! the array is copied.
arma_inline const Matoperator= (const eT val)
 Set the matrix to be equal to the specified scalar. //! NOTE: the size of the matrix will be 1x1.
arma_inline const Matoperator+= (const eT val)
 In-place addition of a scalar to all elements of the matrix.
arma_inline const Matoperator-= (const eT val)
 In-place subtraction of a scalar from all elements of the matrix.
arma_inline const Matoperator*= (const eT val)
 In-place multiplication of all elements of the matrix with a scalar.
arma_inline const Matoperator/= (const eT val)
 In-place division of all elements of the matrix with a scalar.
 Mat (const Mat &m)
 construct a matrix from a given matrix
const Matoperator= (const Mat &m)
 construct a matrix from a given matrix
const Matoperator+= (const Mat &m)
 in-place matrix addition
const Matoperator-= (const Mat &m)
 in-place matrix subtraction
const Matoperator*= (const Mat &m)
 in-place matrix multiplication
const Matoperator%= (const Mat &m)
 in-place element-wise matrix multiplication
const Matoperator/= (const Mat &m)
 in-place element-wise matrix division
template<typename T1 , typename T2 >
 Mat (const Base< pod_type, T1 > &A, const Base< pod_type, T2 > &B)
 Mat (const subview< eT > &X)
 construct a matrix from subview (e.g. construct a matrix from a delayed submatrix operation)
const Matoperator= (const subview< eT > &X)
 construct a matrix from subview (e.g. construct a matrix from a delayed submatrix operation)
const Matoperator+= (const subview< eT > &X)
 in-place matrix addition (using a submatrix on the right-hand-side)
const Matoperator-= (const subview< eT > &X)
 in-place matrix subtraction (using a submatrix on the right-hand-side)
const Matoperator*= (const subview< eT > &X)
 in-place matrix mutiplication (using a submatrix on the right-hand-side)
const Matoperator%= (const subview< eT > &X)
 in-place element-wise matrix mutiplication (using a submatrix on the right-hand-side)
const Matoperator/= (const subview< eT > &X)
 in-place element-wise matrix division (using a submatrix on the right-hand-side)
 Mat (const subview_cube< eT > &X)
 construct a matrix from a subview_cube instance
const Matoperator= (const subview_cube< eT > &X)
 construct a matrix from a subview_cube instance
const Matoperator+= (const subview_cube< eT > &X)
 in-place matrix addition (using a single-slice subcube on the right-hand-side)
const Matoperator-= (const subview_cube< eT > &X)
 in-place matrix subtraction (using a single-slice subcube on the right-hand-side)
const Matoperator*= (const subview_cube< eT > &X)
 in-place matrix mutiplication (using a single-slice subcube on the right-hand-side)
const Matoperator%= (const subview_cube< eT > &X)
 in-place element-wise matrix mutiplication (using a single-slice subcube on the right-hand-side)
const Matoperator/= (const subview_cube< eT > &X)
 in-place element-wise matrix division (using a single-slice subcube on the right-hand-side)
 Mat (const diagview< eT > &X)
 construct a matrix from diagview (e.g. construct a matrix from a delayed diag operation)
const Matoperator= (const diagview< eT > &X)
 construct a matrix from diagview (e.g. construct a matrix from a delayed diag operation)
const Matoperator+= (const diagview< eT > &X)
 in-place matrix addition (using a diagview on the right-hand-side)
const Matoperator-= (const diagview< eT > &X)
 in-place matrix subtraction (using a diagview on the right-hand-side)
const Matoperator*= (const diagview< eT > &X)
 in-place matrix mutiplication (using a diagview on the right-hand-side)
const Matoperator%= (const diagview< eT > &X)
 in-place element-wise matrix mutiplication (using a diagview on the right-hand-side)
const Matoperator/= (const diagview< eT > &X)
 in-place element-wise matrix division (using a diagview on the right-hand-side)
arma_inline subview_row< eT > row (const u32 row_num)
 creation of subview (row vector)
arma_inline const subview_row< eT > row (const u32 row_num) const
 creation of subview (row vector)
arma_inline subview_col< eT > col (const u32 col_num)
 creation of subview (column vector)
arma_inline const subview_col< eT > col (const u32 col_num) const
 creation of subview (column vector)
arma_inline subview< eT > rows (const u32 in_row1, const u32 in_row2)
 creation of subview (submatrix comprised of specified row vectors)
arma_inline const subview< eT > rows (const u32 in_row1, const u32 in_row2) const
 creation of subview (submatrix comprised of specified row vectors)
arma_inline subview< eT > cols (const u32 in_col1, const u32 in_col2)
 creation of subview (submatrix comprised of specified column vectors)
arma_inline const subview< eT > cols (const u32 in_col1, const u32 in_col2) const
 creation of subview (submatrix comprised of specified column vectors)
arma_inline subview< eT > submat (const u32 in_row1, const u32 in_col1, const u32 in_row2, const u32 in_col2)
 creation of subview (submatrix)
arma_inline const subview< eT > submat (const u32 in_row1, const u32 in_col1, const u32 in_row2, const u32 in_col2) const
 creation of subview (generic submatrix)
arma_inline diagview< eT > diag (const s32 in_id=0)
 creation of diagview (diagonal)
arma_inline const diagview< eT > diag (const s32 in_id=0) const
 creation of diagview (diagonal)
void swap_rows (const u32 in_row1, const u32 in_row2)
void swap_cols (const u32 in_col1, const u32 in_col2)
template<typename T1 , typename op_type >
 Mat (const Op< T1, op_type > &X)
 create a matrix from Op, i.e. run the previously delayed unary operations
template<typename T1 , typename op_type >
const Matoperator= (const Op< T1, op_type > &X)
 create a matrix from Op, i.e. run the previously delayed unary operations
template<typename T1 , typename op_type >
const Matoperator+= (const Op< T1, op_type > &X)
 in-place matrix addition, with the right-hand-side operand having delayed operations
template<typename T1 , typename op_type >
const Matoperator-= (const Op< T1, op_type > &X)
 in-place matrix subtraction, with the right-hand-side operand having delayed operations
template<typename T1 , typename op_type >
const Matoperator*= (const Op< T1, op_type > &X)
 in-place matrix multiplication, with the right-hand-side operand having delayed operations
template<typename T1 , typename op_type >
const Matoperator%= (const Op< T1, op_type > &X)
 in-place matrix element-wise multiplication, with the right-hand-side operand having delayed operations
template<typename T1 , typename op_type >
const Matoperator/= (const Op< T1, op_type > &X)
 in-place matrix element-wise division, with the right-hand-side operand having delayed operations
template<typename T1 , typename eop_type >
 Mat (const eOp< T1, eop_type > &X)
 create a matrix from eOp, i.e. run the previously delayed unary operations
template<typename T1 , typename eop_type >
const Matoperator= (const eOp< T1, eop_type > &X)
 create a matrix from eOp, i.e. run the previously delayed unary operations
template<typename T1 , typename eop_type >
const Matoperator+= (const eOp< T1, eop_type > &X)
template<typename T1 , typename eop_type >
const Matoperator-= (const eOp< T1, eop_type > &X)
template<typename T1 , typename eop_type >
const Matoperator*= (const eOp< T1, eop_type > &X)
template<typename T1 , typename eop_type >
const Matoperator%= (const eOp< T1, eop_type > &X)
template<typename T1 , typename eop_type >
const Matoperator/= (const eOp< T1, eop_type > &X)
template<typename T1 , typename op_type >
 Mat (const mtOp< eT, T1, op_type > &X)
 EXPERIMENTAL.
template<typename T1 , typename op_type >
const Matoperator= (const mtOp< eT, T1, op_type > &X)
 EXPERIMENTAL.
template<typename T1 , typename op_type >
const Matoperator+= (const mtOp< eT, T1, op_type > &X)
 EXPERIMENTAL.
template<typename T1 , typename op_type >
const Matoperator-= (const mtOp< eT, T1, op_type > &X)
 EXPERIMENTAL.
template<typename T1 , typename op_type >
const Matoperator*= (const mtOp< eT, T1, op_type > &X)
 EXPERIMENTAL.
template<typename T1 , typename op_type >
const Matoperator%= (const mtOp< eT, T1, op_type > &X)
 EXPERIMENTAL.
template<typename T1 , typename op_type >
const Matoperator/= (const mtOp< eT, T1, op_type > &X)
 EXPERIMENTAL.
template<typename T1 , typename T2 , typename glue_type >
 Mat (const Glue< T1, T2, glue_type > &X)
 create a matrix from Glue, i.e. run the previously delayed binary operations
template<typename T1 , typename T2 , typename glue_type >
const Matoperator= (const Glue< T1, T2, glue_type > &X)
 create a matrix from Glue, i.e. run the previously delayed binary operations
template<typename T1 , typename T2 , typename glue_type >
const Matoperator+= (const Glue< T1, T2, glue_type > &X)
 in-place matrix addition, with the right-hand-side operands having delayed operations
template<typename T1 , typename T2 , typename glue_type >
const Matoperator-= (const Glue< T1, T2, glue_type > &X)
 in-place matrix subtraction, with the right-hand-side operands having delayed operations
template<typename T1 , typename T2 , typename glue_type >
const Matoperator*= (const Glue< T1, T2, glue_type > &X)
 in-place matrix multiplications, with the right-hand-side operands having delayed operations
template<typename T1 , typename T2 , typename glue_type >
const Matoperator%= (const Glue< T1, T2, glue_type > &X)
 in-place matrix element-wise multiplication, with the right-hand-side operands having delayed operations
template<typename T1 , typename T2 , typename glue_type >
const Matoperator/= (const Glue< T1, T2, glue_type > &X)
 in-place matrix element-wise division, with the right-hand-side operands having delayed operations
template<typename T1 , typename T2 >
const Matoperator+= (const Glue< T1, T2, glue_times > &X)
template<typename T1 , typename T2 >
const Matoperator-= (const Glue< T1, T2, glue_times > &X)
template<typename T1 , typename T2 , typename eglue_type >
 Mat (const eGlue< T1, T2, eglue_type > &X)
 create a matrix from eGlue, i.e. run the previously delayed binary operations
template<typename T1 , typename T2 , typename eglue_type >
const Matoperator= (const eGlue< T1, T2, eglue_type > &X)
 create a matrix from eGlue, i.e. run the previously delayed binary operations
template<typename T1 , typename T2 , typename eglue_type >
const Matoperator+= (const eGlue< T1, T2, eglue_type > &X)
 in-place matrix addition, with the right-hand-side operands having delayed operations
template<typename T1 , typename T2 , typename eglue_type >
const Matoperator-= (const eGlue< T1, T2, eglue_type > &X)
 in-place matrix subtraction, with the right-hand-side operands having delayed operations
template<typename T1 , typename T2 , typename eglue_type >
const Matoperator*= (const eGlue< T1, T2, eglue_type > &X)
template<typename T1 , typename T2 , typename eglue_type >
const Matoperator%= (const eGlue< T1, T2, eglue_type > &X)
template<typename T1 , typename T2 , typename eglue_type >
const Matoperator/= (const eGlue< T1, T2, eglue_type > &X)
template<typename T1 , typename T2 , typename glue_type >
 Mat (const mtGlue< eT, T1, T2, glue_type > &X)
 EXPERIMENTAL: create a matrix from mtGlue, i.e. run the previously delayed binary operations.
template<typename T1 , typename T2 , typename glue_type >
const Matoperator= (const mtGlue< eT, T1, T2, glue_type > &X)
 EXPERIMENTAL: create a matrix from Glue, i.e. run the previously delayed binary operations.
template<typename T1 , typename T2 , typename glue_type >
const Matoperator+= (const mtGlue< eT, T1, T2, glue_type > &X)
 EXPERIMENTAL: in-place matrix addition, with the right-hand-side operands having delayed operations.
template<typename T1 , typename T2 , typename glue_type >
const Matoperator-= (const mtGlue< eT, T1, T2, glue_type > &X)
 EXPERIMENTAL: in-place matrix subtraction, with the right-hand-side operands having delayed operations.
template<typename T1 , typename T2 , typename glue_type >
const Matoperator*= (const mtGlue< eT, T1, T2, glue_type > &X)
 EXPERIMENTAL: in-place matrix multiplications, with the right-hand-side operands having delayed operations.
template<typename T1 , typename T2 , typename glue_type >
const Matoperator%= (const mtGlue< eT, T1, T2, glue_type > &X)
 EXPERIMENTAL: in-place matrix element-wise multiplication, with the right-hand-side operands having delayed operations.
template<typename T1 , typename T2 , typename glue_type >
const Matoperator/= (const mtGlue< eT, T1, T2, glue_type > &X)
 EXPERIMENTAL: in-place matrix element-wise division, with the right-hand-side operands having delayed operations.
arma_inline eT & operator[] (const u32 i)
 linear element accessor (treats the matrix as a vector); no bounds check.
arma_inline eT operator[] (const u32 i) const
 linear element accessor (treats the matrix as a vector); no bounds check
arma_inline eT & operator() (const u32 i)
 linear element accessor (treats the matrix as a vector); bounds checking not done when ARMA_NO_DEBUG is defined
arma_inline eT operator() (const u32 i) const
 linear element accessor (treats the matrix as a vector); bounds checking not done when ARMA_NO_DEBUG is defined
arma_inline eT & at (const u32 in_row, const u32 in_col)
 element accessor; no bounds check
arma_inline eT at (const u32 in_row, const u32 in_col) const
 element accessor; no bounds check
arma_inline eT & operator() (const u32 in_row, const u32 in_col)
 element accessor; bounds checking not done when ARMA_NO_DEBUG is defined
arma_inline eT operator() (const u32 in_row, const u32 in_col) const
 element accessor; bounds checking not done when ARMA_NO_DEBUG is defined
arma_inline const Matoperator++ ()
 prefix ++
arma_inline void operator++ (int)
 postfix ++ (must not return the object by reference)
arma_inline const Matoperator-- ()
 prefix --
arma_inline void operator-- (int)
 postfix -- (must not return the object by reference)
arma_inline bool is_vec () const
 returns true if the object can be interpreted as a column or row vector
arma_inline bool is_square () const
 returns true if the object has the same number of non-zero rows and columnns
arma_inline bool is_finite () const
 returns true if all of the elements are finite
arma_inline eT * colptr (const u32 in_col)
 returns a pointer to array of eTs for a specified column; no bounds check
arma_inline const eT * colptr (const u32 in_col) const
 returns a pointer to array of eTs for a specified column; no bounds check
arma_inline eT * memptr ()
 returns a pointer to array of eTs used by the matrix
arma_inline const eT * memptr () const
 returns a pointer to array of eTs used by the matrix
void print (const std::string extra_text="") const
 print contents of the matrix (to the cout stream), //! optionally preceding with a user specified line of text. //! the precision and cell width are modified. //! on return, the stream's flags are restored to their original values.
void print (std::ostream &user_stream, const std::string extra_text="") const
 print contents of the matrix to a user specified stream, // optionally preceding with a user specified line of text. //! the precision and cell width are modified. //! on return, the stream's flags are restored to their original values.
void print_trans (const std::string extra_text="") const
 print contents of the transposed version of the matrix (to the cout stream), //! optionally preceding with a user specified line of text. //! the precision and cell width are modified. // on return, the stream's flags are restored to their original values.
void print_trans (std::ostream &user_stream, const std::string extra_text="") const
 print contents of the transposed version of matrix to a user specified stream, //! optionally preceding with a user specified line of text. //! the precision and cell width are modified. on return, the stream's flags are restored to their original values.
void raw_print (const std::string extra_text="") const
 print contents of the matrix (to the cout stream), //! optionally preceding with a user specified line of text. //! the stream's flags are used as is and are not modified //! (i.e. the precision and cell width are not modified).
void raw_print (std::ostream &user_stream, const std::string extra_text="") const
 print contents of the matrix to a user specified stream, // optionally preceding with a user specified line of text. //! the stream's flags are used as is and are not modified. //! (i.e. the precision and cell width are not modified).
void raw_print_trans (const std::string extra_text="") const
 print contents of the transposed version of the matrix (to the cout stream), //! optionally preceding with a user specified line of text. //! the stream's flags are used as is and are not modified //! (i.e. the precision and cell width are not modified).
void raw_print_trans (std::ostream &user_stream, const std::string extra_text="") const
 print contents of the transposed version of the matrix to a user specified stream, //! optionally preceding with a user specified line of text. //! the stream's flags are used as is and are not modified. //! (i.e. the precision and cell width are not modified).
template<typename eT2 >
void copy_size (const Mat< eT2 > &m)
 change the matrix (without preserving data) to have the same dimensions as the given matrix
void set_size (const u32 in_rows, const u32 in_cols)
 change the matrix to have user specified dimensions (data is not preserved)
arma_hot void fill (const eT val)
 fill the matrix with the specified value
void zeros ()
void zeros (const u32 in_rows, const u32 in_cols)
void ones ()
void ones (const u32 in_rows, const u32 in_cols)
void reset ()
bool save (const std::string name, const file_type type=arma_binary, const bool print_status=true) const
 save the matrix to a file
bool save (std::ostream &os, const file_type type=arma_binary, const bool print_status=true) const
 save the matrix to a stream
bool load (const std::string name, const file_type type=auto_detect, const bool print_status=true)
 load a matrix from a file
bool load (std::istream &is, const file_type type=auto_detect, const bool print_status=true)
 load a matrix from a stream
bool quiet_save (const std::string name, const file_type type=arma_binary) const
 save the matrix to a file, without printing any error messages
bool quiet_save (std::ostream &os, const file_type type=arma_binary) const
 save the matrix to a stream, without printing any error messages
bool quiet_load (const std::string name, const file_type type=auto_detect)
 load a matrix from a file, without printing any error messages
bool quiet_load (std::istream &is, const file_type type=auto_detect)
 load a matrix from a stream, without printing any error messages
iterator begin ()
const_iterator begin () const
iterator end ()
const_iterator end () const
col_iterator begin_col (const u32 col_num)
const_col_iterator begin_col (const u32 col_num) const
col_iterator end_col (const u32 col_num)
const_col_iterator end_col (const u32 col_num) const
row_iterator begin_row (const u32 row_num)
const_row_iterator begin_row (const u32 row_num) const
row_iterator end_row (const u32 row_num)
const_row_iterator end_row (const u32 row_num) const
template<typename T1 , typename T2 >
 Mat (const Base< typename Mat< eT >::pod_type, T1 > &A, const Base< typename Mat< eT >::pod_type, T2 > &B)
 for constructing a complex matrix out of two non-complex matrices

Public Attributes

const u32 n_rows
 number of rows in the matrix (read-only)
const u32 n_cols
 number of columns in the matrix (read-only)
const u32 n_elem
 number of elements in the matrix (read-only)
const bool use_aux_mem
 true if externally managed memory is being used (read-only)
arma_aligned const eT *const mem
 pointer to the memory used by the matrix (memory is read-only)

Protected Member Functions

void init (const u32 in_rows, const u32 in_cols)
 internal matrix construction; if the requested size is small enough, memory from the stack is used. otherwise memory is allocated via 'new'
void init (const std::string &text)
 internal function to create the matrix from a textual description
void init (const Mat &x)
 construct a matrix from a given matrix
 Mat (const char junk, const eT *aux_mem, const u32 aux_n_rows, const u32 aux_n_cols)
 DANGEROUS! Construct a temporary matrix, using auxiliary memory. //! This constructor is NOT intended for usage by user code. //! Its sole purpose is to be used by the Cube class.

Protected Attributes

arma_aligned eT mem_local [16]

Friends

class Cube< eT >
class glue_join

Detailed Description

template<typename eT>
class Mat< eT >

Dense matrix class.

Definition at line 23 of file Mat_proto.hpp.


Member Typedef Documentation

template<typename eT>
typedef eT Mat< eT >::elem_type

the type of elements stored in the matrix

Definition at line 27 of file Mat_proto.hpp.

template<typename eT>
typedef get_pod_type<eT>::result Mat< eT >::pod_type

if eT is non-complex, pod_type is same as eT. otherwise, pod_type is the underlying type used by std::complex

Definition at line 28 of file Mat_proto.hpp.

template<typename eT>
typedef eT* Mat< eT >::iterator

Definition at line 242 of file Mat_proto.hpp.

template<typename eT>
typedef const eT* Mat< eT >::const_iterator

Definition at line 243 of file Mat_proto.hpp.

template<typename eT>
typedef eT* Mat< eT >::col_iterator

Definition at line 245 of file Mat_proto.hpp.

template<typename eT>
typedef const eT* Mat< eT >::const_col_iterator

Definition at line 246 of file Mat_proto.hpp.


Constructor & Destructor Documentation

template<typename eT>
template<typename T1 , typename T2 >
Mat< eT >::Mat ( const Base< pod_type, T1 > &  A,
const Base< pod_type, T2 > &  B 
) [inline, explicit]

Friends And Related Function Documentation

template<typename eT>
friend class Cube< eT > [friend]

Definition at line 321 of file Mat_proto.hpp.

template<typename eT>
friend class glue_join [friend]

Definition at line 322 of file Mat_proto.hpp.


Member Data Documentation

template<typename eT>
const u32 Mat< eT >::n_rows

number of rows in the matrix (read-only)

Definition at line 30 of file Mat_proto.hpp.

Referenced by op_var::apply(), op_trans::apply(), op_sum::apply(), op_stddev::apply(), op_sort::apply(), op_shuffle::apply(), op_reshape::apply(), op_repmat::apply(), op_prod::apply(), op_min::apply(), op_median::apply(), op_mean::apply(), op_max::apply(), op_flipud::apply(), op_diagmat::apply(), glue_times_diag::apply(), glue_times::apply(), glue_solve::apply(), glue_join::apply(), glue_cross::apply(), gemv_arma< do_trans_A, use_alpha, use_beta >::apply(), gemm_mixed_simple< do_trans_A, do_trans_B, use_alpha, use_beta >::apply(), gemm_mixed_cache< do_trans_A, do_trans_B, use_alpha, use_beta >::apply(), gemm_emul_simple< do_trans_A, do_trans_B, use_alpha, use_beta >::apply(), gemm_emul_cache< do_trans_A, do_trans_B, use_alpha, use_beta >::apply(), as_scalar_redirect< 3 >::apply(), as_scalar_redirect< 2 >::apply(), gemv< do_trans_A, use_alpha, use_beta >::apply_blas_type(), gemm< do_trans_A, do_trans_B, use_alpha, use_beta >::apply_blas_type(), glue_times::apply_inplace(), eop_core< eop_type >::apply_inplace_div(), eglue_core< eglue_type >::apply_inplace_div(), eop_core< eop_type >::apply_inplace_minus(), eglue_core< eglue_type >::apply_inplace_minus(), glue_times::apply_inplace_plus(), eop_core< eop_type >::apply_inplace_plus(), eglue_core< eglue_type >::apply_inplace_plus(), eop_core< eop_type >::apply_inplace_schur(), eglue_core< eglue_type >::apply_inplace_schur(), op_trans::apply_noalias(), eglue_core< eglue_type >::apply_unwrap(), arma_assert_mul_size(), arma_assert_same_size(), as_scalar_diag(), Mat< eT >::at(), Mat< eT >::begin_row(), auxlib::chol(), Mat< eT >::colptr(), Mat< eT >::cols(), Row< eT >::copy_size(), Mat< eT >::copy_size(), Col< eT >::copy_size(), auxlib::det(), Mat< eT >::diag(), diagmat_proxy_check< Mat< eT > >::diagmat_proxy_check(), diagmat_proxy_check< T1 >::diagmat_proxy_check(), op_cor::direct_cor(), glue_cor::direct_cor(), op_cov::direct_cov(), glue_cov::direct_cov(), glue_kron::direct_kron(), op_pinv::direct_pinv(), op_princomp::direct_princomp(), op_dotext::direct_rowvec_diagmat_colvec(), op_dotext::direct_rowvec_invdiagmat_colvec(), op_dotext::direct_rowvec_mat_colvec(), op_dotext::direct_rowvec_transmat_colvec(), subview< eT >::div_inplace(), diagview< eT >::div_inplace(), auxlib::eig_gen(), auxlib::eig_sym(), Mat< eT >::end_col(), Mat< eT >::end_row(), subview< eT >::extract(), Mat< eT >::init(), auxlib::inv_inplace(), auxlib::inv_noalias(), Mat< eT >::is_square(), Mat< eT >::is_vec(), diskio::load_arma_ascii(), diskio::load_raw_ascii(), auxlib::log_det(), auxlib::lu(), subview< eT >::minus_inplace(), diagview< eT >::minus_inplace(), glue_times::mul_storage_cost(), Mat< eT >::operator()(), subview< eT >::plus_inplace(), diagview< eT >::plus_inplace(), arma_ostream::print(), auxlib::qr(), Mat< eT >::row(), Mat< eT >::rows(), diskio::save_arma_ascii(), diskio::save_arma_binary(), diskio::save_pgm_binary(), diskio::save_ppm_binary(), diskio::save_raw_ascii(), subview< eT >::schur_inplace(), diagview< eT >::schur_inplace(), auxlib::solve(), auxlib::solve_od(), auxlib::solve_ud(), Mat< eT >::submat(), auxlib::svd(), Mat< eT >::swap_cols(), Mat< eT >::swap_rows(), trace(), running_stat_vec_aux::update_stats(), and Mat< eT >::~Mat().

template<typename eT>
const u32 Mat< eT >::n_cols

number of columns in the matrix (read-only)

Definition at line 31 of file Mat_proto.hpp.

Referenced by op_var::apply(), op_trans::apply(), op_sum::apply(), op_stddev::apply(), op_sort::apply(), op_shuffle::apply(), op_reshape::apply(), op_repmat::apply(), op_prod::apply(), op_min::apply(), op_median::apply(), op_mean::apply(), op_max::apply(), op_fliplr::apply(), glue_times_diag::apply(), glue_times::apply(), glue_solve::apply(), glue_mixed_times::apply(), glue_join::apply(), glue_cross::apply(), glue_conv::apply(), gemv_arma< do_trans_A, use_alpha, use_beta >::apply(), gemm_mixed_simple< do_trans_A, do_trans_B, use_alpha, use_beta >::apply(), gemm_mixed_cache< do_trans_A, do_trans_B, use_alpha, use_beta >::apply(), gemm_emul_simple< do_trans_A, do_trans_B, use_alpha, use_beta >::apply(), gemm_emul_cache< do_trans_A, do_trans_B, use_alpha, use_beta >::apply(), as_scalar_redirect< 3 >::apply(), as_scalar_redirect< 2 >::apply(), gemv< do_trans_A, use_alpha, use_beta >::apply_blas_type(), gemm< do_trans_A, do_trans_B, use_alpha, use_beta >::apply_blas_type(), glue_times::apply_inplace(), eop_core< eop_type >::apply_inplace_div(), eglue_core< eglue_type >::apply_inplace_div(), eop_core< eop_type >::apply_inplace_minus(), eglue_core< eglue_type >::apply_inplace_minus(), glue_times::apply_inplace_plus(), eop_core< eop_type >::apply_inplace_plus(), eglue_core< eglue_type >::apply_inplace_plus(), eop_core< eop_type >::apply_inplace_schur(), eglue_core< eglue_type >::apply_inplace_schur(), op_trans::apply_noalias(), eglue_core< eglue_type >::apply_unwrap(), arma_assert_mul_size(), arma_assert_same_size(), as_scalar_diag(), Mat< eT >::begin_col(), Mat< eT >::col(), Mat< eT >::cols(), Row< eT >::copy_size(), Mat< eT >::copy_size(), Col< eT >::copy_size(), auxlib::det(), Mat< eT >::diag(), diagmat_proxy_check< Mat< eT > >::diagmat_proxy_check(), diagmat_proxy_check< T1 >::diagmat_proxy_check(), glue_kron::direct_kron(), op_pinv::direct_pinv(), op_princomp::direct_princomp(), op_dotext::direct_rowvec_mat_colvec(), op_dotext::direct_rowvec_transmat_colvec(), subview< eT >::div_inplace(), diagview< eT >::div_inplace(), auxlib::eig_gen(), auxlib::eig_sym(), Mat< eT >::end_col(), subview< eT >::extract(), Mat< eT >::init(), auxlib::inv_inplace(), auxlib::inv_noalias(), Mat< eT >::is_square(), Mat< eT >::is_vec(), diskio::load_arma_ascii(), diskio::load_raw_ascii(), auxlib::log_det(), auxlib::lu(), Mat< eT >::Mat(), subview< eT >::minus_inplace(), diagview< eT >::minus_inplace(), glue_times::mul_storage_cost(), Mat< eT >::operator()(), subview< eT >::plus_inplace(), diagview< eT >::plus_inplace(), arma_ostream::print(), auxlib::qr(), Mat< eT >::rows(), diskio::save_arma_ascii(), diskio::save_arma_binary(), diskio::save_pgm_binary(), diskio::save_ppm_binary(), diskio::save_raw_ascii(), subview< eT >::schur_inplace(), diagview< eT >::schur_inplace(), auxlib::solve(), auxlib::solve_od(), auxlib::solve_ud(), Mat< eT >::submat(), auxlib::svd(), Mat< eT >::swap_cols(), Mat< eT >::swap_rows(), trace(), running_stat_vec_aux::update_stats(), and Mat< eT >::~Mat().

template<typename eT>
const u32 Mat< eT >::n_elem

number of elements in the matrix (read-only)

Definition at line 32 of file Mat_proto.hpp.

Referenced by op_var::apply(), op_trans2::apply(), op_sum::apply(), op_stddev::apply(), op_sort::apply(), op_reshape::apply(), op_repmat::apply(), op_prod::apply(), op_min::apply(), op_median::apply(), op_mean::apply(), op_max::apply(), op_diagmat::apply(), glue_toeplitz::apply(), glue_join::apply(), glue_cross::apply(), glue_conv::apply(), gemm_mixed< do_trans_A, do_trans_B, use_alpha, use_beta >::apply(), gemm< do_trans_A, do_trans_B, use_alpha, use_beta >::apply(), as_scalar_redirect< 3 >::apply(), as_scalar_redirect< 2 >::apply(), as_scalar_redirect< N >::apply(), gemv< do_trans_A, use_alpha, use_beta >::apply_blas_type(), gemm< do_trans_A, do_trans_B, use_alpha, use_beta >::apply_blas_type(), op_trans::apply_noalias(), op_norm_dot::apply_unwrap(), op_dot::apply_unwrap(), eglue_core< eglue_type >::apply_unwrap(), as_scalar_diag(), chol(), glue_cor::direct_cor(), glue_cov::direct_cov(), op_pinv::direct_pinv(), op_princomp::direct_princomp(), op_dotext::direct_rowvec_invdiagvec_colvec(), Mat< eT >::end(), Mat< eT >::fill(), conv_to< Col< out_eT > >::from(), conv_to< Row< out_eT > >::from(), conv_to< Mat< out_eT > >::from(), Mat< eT >::init(), Mat< eT >::is_finite(), Mat< eT >::is_square(), diskio::load_arma_binary(), diskio::load_pgm_binary(), diskio::load_ppm_binary(), Mat< eT >::Mat(), max(), mean(), median(), min(), Mat< eT >::operator%=(), Mat< eT >::operator()(), Mat< eT >::operator*=(), Mat< eT >::operator+=(), Mat< eT >::operator-=(), Mat< eT >::operator/=(), Mat_aux::postfix_mm(), Mat_aux::postfix_pp(), Mat_aux::prefix_mm(), Mat_aux::prefix_pp(), arma_ostream::print(), prod(), auxlib::qr(), rank(), diskio::save_arma_binary(), diskio::save_pgm_binary(), diskio::save_ppm_binary(), solve(), stddev(), running_stat_vec_aux::update_stats(), var(), and Mat< eT >::~Mat().

template<typename eT>
const bool Mat< eT >::use_aux_mem

true if externally managed memory is being used (read-only)

Definition at line 33 of file Mat_proto.hpp.

Referenced by Mat< eT >::init(), and Mat< eT >::~Mat().

template<typename eT>
arma_aligned eT Mat< eT >::mem_local[16] [protected]

Definition at line 38 of file Mat_proto.hpp.

Referenced by glue_join::apply(), Mat< eT >::init(), and Mat< eT >::~Mat().