Col

Classes

class  Col< eT >
 Class for column vectors (matrices with only column). More...

Functions

 Col::Col ()
 construct an empty column vector
 Col::Col (const u32 n_elem)
 construct a column vector with the specified number of n_elem
 Col::Col (const u32 in_rows, const u32 in_cols)
 Col::Col (const char *text)
 construct a column vector from specified text
const ColCol::operator= (const char *text)
 construct a column vector from specified text
 Col::Col (const std::string &text)
 construct a column vector from specified text
const ColCol::operator= (const std::string &text)
 construct a column vector from specified text
 Col::Col (const Col &X)
 construct a column vector from a given column vector
const ColCol::operator= (const Col &X)
 construct a column vector from a given column vector
 Col::Col (const Mat< eT > &X)
 construct a column vector from a given matrix; the matrix must have exactly one column
const ColCol::operator= (const Mat< eT > &X)
 construct a column vector from a given matrix; the matrix must have exactly one column
const ColCol::operator*= (const Mat< eT > &X)
 Col::Col (eT *aux_mem, const u32 aux_n_rows, const u32 aux_n_cols, const bool copy_aux_mem=true)
 construct a column vector from a given auxiliary array of eTs
 Col::Col (const eT *aux_mem, const u32 aux_n_rows, const u32 aux_n_cols)
 construct a column vector from a given auxiliary array of eTs
 Col::Col (eT *aux_mem, const u32 aux_length, const bool copy_aux_mem=true)
 construct a column vector from a given auxiliary array of eTs
 Col::Col (const eT *aux_mem, const u32 aux_length)
 construct a column vector from a given auxiliary array of eTs
template<typename T1 , typename T2 >
 Col::Col (const Base< pod_type, T1 > &A, const Base< pod_type, T2 > &B)
 Col::Col (const subview< eT > &X)
 construct a column vector from given a submatrix; the submatrix must have exactly one column
const ColCol::operator= (const subview< eT > &X)
 construct a column vector from given a submatrix; the submatrix must have exactly one column
const ColCol::operator*= (const subview< eT > &X)
 in-place matrix mutiplication (using a submatrix on the right-hand-side)
 Col::Col (const subview_cube< eT > &X)
 construct a column vector from given a subcube; the subcube must have exactly one column
const ColCol::operator= (const subview_cube< eT > &X)
 construct a column vector from given a subcube; the subcube must have exactly one column
const ColCol::operator*= (const subview_cube< eT > &X)
 in-place matrix mutiplication (using a single-slice subcube on the right-hand-side)
 Col::Col (const diagview< eT > &X)
 construct a column vector from given a diagview
const ColCol::operator= (const diagview< eT > &X)
 construct a column vector from given a diagview
const ColCol::operator*= (const diagview< eT > &X)
 in-place matrix mutiplication (using a diagview on the right-hand-side)
arma_inline eT & Col::row (const u32 row_num)
 creation of subview (row vector)
arma_inline eT Col::row (const u32 row_num) const
 creation of subview (row vector)
arma_inline subview_col< eT > Col::rows (const u32 in_row1, const u32 in_row2)
 creation of subview (submatrix comprised of specified row vectors)
arma_inline const subview_col< eT > Col::rows (const u32 in_row1, const u32 in_row2) const
 creation of subview (submatrix comprised of specified row vectors)
template<typename T1 , typename op_type >
 Col::Col (const Op< T1, op_type > &X)
 construct a column vector from Op, i.e. run the previously delayed operations; the result of the operations must have exactly one column
template<typename T1 , typename op_type >
const ColCol::operator= (const Op< T1, op_type > &X)
 construct a column vector from Op, i.e. run the previously delayed operations; the result of the operations must have exactly one column
template<typename T1 , typename op_type >
const ColCol::operator*= (const Op< T1, op_type > &X)
 in-place matrix multiplication, with the right-hand-side operand having delayed operations
template<typename T1 , typename eop_type >
 Col::Col (const eOp< T1, eop_type > &X)
template<typename T1 , typename eop_type >
const ColCol::operator= (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 ColCol::operator*= (const eOp< T1, eop_type > &X)
template<typename T1 , typename op_type >
 Col::Col (const mtOp< eT, T1, op_type > &X)
template<typename T1 , typename op_type >
const ColCol::operator= (const mtOp< eT, T1, op_type > &X)
 EXPERIMENTAL.
template<typename T1 , typename op_type >
const ColCol::operator*= (const mtOp< eT, T1, op_type > &X)
 EXPERIMENTAL.
template<typename T1 , typename T2 , typename glue_type >
 Col::Col (const Glue< T1, T2, glue_type > &X)
 construct a column vector from Glue, i.e. run the previously delayed operations; the result of the operations must have exactly one column
template<typename T1 , typename T2 , typename glue_type >
const ColCol::operator= (const Glue< T1, T2, glue_type > &X)
 construct a column vector from Glue, i.e. run the previously delayed operations; the result of the operations must have exactly one column
template<typename T1 , typename T2 , typename glue_type >
const ColCol::operator*= (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 eglue_type >
 Col::Col (const eGlue< T1, T2, eglue_type > &X)
template<typename T1 , typename T2 , typename eglue_type >
const ColCol::operator= (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 ColCol::operator*= (const eGlue< T1, T2, eglue_type > &X)
template<typename T1 , typename T2 , typename glue_type >
 Col::Col (const mtGlue< eT, T1, T2, glue_type > &X)
template<typename T1 , typename T2 , typename glue_type >
const ColCol::operator= (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 ColCol::operator*= (const mtGlue< eT, T1, T2, glue_type > &X)
 EXPERIMENTAL: in-place matrix multiplications, with the right-hand-side operands having delayed operations.
void Col::set_size (const u32 n_elem)
 change the number of rows
void Col::set_size (const u32 n_rows, const u32 n_cols)
 change the number of n_rows (this function re-implements mat::set_size() in order to check the number of columns)
template<typename eT2 >
void Col::copy_size (const Mat< eT2 > &m)
 change the number of n_rows (this function re-implements mat::copy_size() in order to check the number of columns)
void Col::zeros ()
void Col::zeros (const u32 n_elem)
void Col::zeros (const u32 n_rows, const u32 n_cols)
void Col::ones ()
void Col::ones (const u32 n_elem)
void Col::ones (const u32 n_rows, const u32 n_cols)
void Col::load (const std::string name, const file_type type=auto_detect, const bool print_status=true)
 load a matrix from a file
void Col::load (std::istream &is, const file_type type=auto_detect, const bool print_status=true)
 load a matrix from a stream
void Col::quiet_load (const std::string name, const file_type type=auto_detect)
 load a matrix from a file, without printing any error messages
void Col::quiet_load (std::istream &is, const file_type type=auto_detect)
 load a matrix from a stream, without printing any error messages
row_iterator Col::begin_row (const u32 row_num)
const_row_iterator Col::begin_row (const u32 row_num) const
row_iterator Col::end_row (const u32 row_num)
const_row_iterator Col::end_row (const u32 row_num) const

Function Documentation

template<typename eT >
Col< eT >::Col (  )  [inline, inherited]

construct an empty column vector

Definition at line 24 of file Col_meat.hpp.

00025   : Mat<eT>()
00026   {
00027   arma_extra_debug_sigprint();
00028   }

template<typename eT >
Col< eT >::Col ( const u32  n_elem  )  [inline, explicit, inherited]

construct a column vector with the specified number of n_elem

Definition at line 35 of file Col_meat.hpp.

00036   : Mat<eT>(in_n_elem, 1)
00037   {
00038   arma_extra_debug_sigprint();
00039   }

template<typename eT >
Col< eT >::Col ( const u32  in_rows,
const u32  in_cols 
) [inline, inherited]

Definition at line 45 of file Col_meat.hpp.

00046   : Mat<eT>(in_n_rows, in_n_cols)
00047   {
00048   arma_extra_debug_sigprint();
00049   
00050   arma_debug_check( (Mat<eT>::n_cols > 1), "Col(): incompatible dimensions" );
00051   }

template<typename eT >
Col< eT >::Col ( const char *  text  )  [inline, inherited]

construct a column vector from specified text

Definition at line 58 of file Col_meat.hpp.

References access::rw().

00059   : Mat<eT>(text)
00060   {
00061   arma_extra_debug_sigprint();
00062   
00063   std::swap( access::rw(Mat<eT>::n_rows), access::rw(Mat<eT>::n_cols) );
00064   
00065   arma_debug_check( (Mat<eT>::n_cols > 1), "Col(): incompatible dimensions" );
00066   }

template<typename eT >
const Col< eT > & Col< eT >::operator= ( const char *  text  )  [inline, inherited]

construct a column vector from specified text

Reimplemented from Mat< eT >.

Definition at line 74 of file Col_meat.hpp.

References access::rw().

Referenced by Col< eT >::operator=().

00075   {
00076   arma_extra_debug_sigprint();
00077   
00078   Mat<eT>::operator=(text);
00079   
00080   std::swap( access::rw(Mat<eT>::n_rows), access::rw(Mat<eT>::n_cols) );
00081   
00082   arma_debug_check( (Mat<eT>::n_cols > 1), "Col(): incompatible dimensions" );
00083   
00084   return *this;
00085   }

template<typename eT >
Col< eT >::Col ( const std::string &  text  )  [inline, inherited]

construct a column vector from specified text

Definition at line 92 of file Col_meat.hpp.

References access::rw().

00093   : Mat<eT>(text)
00094   {
00095   arma_extra_debug_sigprint();
00096   
00097   std::swap( access::rw(Mat<eT>::n_rows), access::rw(Mat<eT>::n_cols) );
00098   
00099   arma_debug_check( (Mat<eT>::n_cols > 1), "Col(): incompatible dimensions" );
00100   }

template<typename eT >
const Col< eT > & Col< eT >::operator= ( const std::string &  text  )  [inline, inherited]

construct a column vector from specified text

Reimplemented from Mat< eT >.

Definition at line 108 of file Col_meat.hpp.

References Col< eT >::operator=(), and access::rw().

00109   {
00110   arma_extra_debug_sigprint();
00111   
00112   Mat<eT>::operator=(text);
00113   
00114   std::swap( access::rw(Mat<eT>::n_rows), access::rw(Mat<eT>::n_cols) );
00115   
00116   arma_debug_check( (Mat<eT>::n_cols > 1), "Col(): incompatible dimensions" );
00117   
00118   return *this;
00119   }

template<typename eT >
Col< eT >::Col ( const Col< eT > &  X  )  [inline, inherited]

construct a column vector from a given column vector

Definition at line 126 of file Col_meat.hpp.

00127   : Mat<eT>(X)
00128   {
00129   arma_extra_debug_sigprint();
00130   }

template<typename eT >
const Col< eT > & Col< eT >::operator= ( const Col< eT > &  X  )  [inline, inherited]

construct a column vector from a given column vector

Reimplemented from Mat< eT >.

Definition at line 138 of file Col_meat.hpp.

References Col< eT >::operator=().

00139   {
00140   arma_extra_debug_sigprint();
00141   
00142   Mat<eT>::operator=(X);
00143   
00144   return *this;
00145   }

template<typename eT>
Col< eT >::Col ( const Mat< eT > &  X  )  [inline, inherited]

construct a column vector from a given matrix; the matrix must have exactly one column

Definition at line 152 of file Col_meat.hpp.

00153   : Mat<eT>(X)
00154   {
00155   arma_extra_debug_sigprint();
00156   
00157   arma_debug_check( (Mat<eT>::n_cols > 1), "Col(): incompatible dimensions" );
00158   }

template<typename eT>
const Col< eT > & Col< eT >::operator= ( const Mat< eT > &  X  )  [inline, inherited]

construct a column vector from a given matrix; the matrix must have exactly one column

Definition at line 166 of file Col_meat.hpp.

References Col< eT >::operator=().

00167   {
00168   arma_extra_debug_sigprint();
00169   
00170   Mat<eT>::operator=(X);
00171   
00172   arma_debug_check( (Mat<eT>::n_cols > 1), "Col(): incompatible dimensions" );
00173   
00174   return *this;
00175   }

template<typename eT>
const Col< eT > & Col< eT >::operator*= ( const Mat< eT > &  X  )  [inline, inherited]

Definition at line 182 of file Col_meat.hpp.

Referenced by Col< eT >::operator*=().

00183   {
00184   arma_extra_debug_sigprint();
00185   
00186   Mat<eT>::operator*=(X);
00187   
00188   arma_debug_check( (Mat<eT>::n_cols > 1), "Col(): incompatible dimensions" );
00189   
00190   return *this;
00191   }

template<typename eT>
Col< eT >::Col ( eT *  aux_mem,
const u32  aux_n_rows,
const u32  aux_n_cols,
const bool  copy_aux_mem = true 
) [inline, inherited]

construct a column vector from a given auxiliary array of eTs

Definition at line 198 of file Col_meat.hpp.

00199   : Mat<eT>(aux_mem, aux_n_rows, aux_n_cols, copy_aux_mem)
00200   {
00201   arma_extra_debug_sigprint();
00202   
00203   arma_debug_check( (Mat<eT>::n_cols > 1), "Col(): incompatible dimensions" );
00204   }

template<typename eT>
Col< eT >::Col ( const eT *  aux_mem,
const u32  aux_n_rows,
const u32  aux_n_cols 
) [inline, inherited]

construct a column vector from a given auxiliary array of eTs

Definition at line 211 of file Col_meat.hpp.

00212   : Mat<eT>(aux_mem, aux_n_rows, aux_n_cols)
00213   {
00214   arma_extra_debug_sigprint();
00215   
00216   arma_debug_check( (Mat<eT>::n_cols > 1), "Col(): incompatible dimensions" );
00217   }

template<typename eT>
Col< eT >::Col ( eT *  aux_mem,
const u32  aux_length,
const bool  copy_aux_mem = true 
) [inline, inherited]

construct a column vector from a given auxiliary array of eTs

Definition at line 224 of file Col_meat.hpp.

00225   : Mat<eT>(aux_mem, aux_length, 1, copy_aux_mem)
00226   {
00227   arma_extra_debug_sigprint();
00228   
00229 //   set_size(aux_length, 1);
00230 // 
00231 //   arma_check( (Mat<eT>::n_elem != aux_length), "Col::Col(): don't know how to handle the given array" );
00232 // 
00233 //   syslib::copy_elem( Mat<eT>::memptr(), aux_mem, Mat<eT>::n_elem );
00234   }

template<typename eT>
Col< eT >::Col ( const eT *  aux_mem,
const u32  aux_length 
) [inline, inherited]

construct a column vector from a given auxiliary array of eTs

Definition at line 241 of file Col_meat.hpp.

00242   : Mat<eT>(aux_mem, aux_length, 1)
00243   {
00244   arma_extra_debug_sigprint();
00245   
00246 //   set_size(aux_length, 1);
00247 // 
00248 //   arma_check( (Mat<eT>::n_elem != aux_length), "Col::Col(): don't know how to handle the given array" );
00249 // 
00250 //   syslib::copy_elem( Mat<eT>::memptr(), aux_mem, Mat<eT>::n_elem );
00251   }

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

Definition at line 259 of file Col_meat.hpp.

00263   : Mat<eT>(A,B)
00264   {
00265   arma_extra_debug_sigprint();
00266   
00267   arma_debug_check( (Mat<eT>::n_cols > 1), "Col(): incompatible dimensions" );
00268   }

template<typename eT>
Col< eT >::Col ( const subview< eT > &  X  )  [inline, inherited]

construct a column vector from given a submatrix; the submatrix must have exactly one column

Definition at line 275 of file Col_meat.hpp.

00276   : Mat<eT>(X)
00277   {
00278   arma_extra_debug_sigprint();
00279   
00280   arma_debug_check( (Mat<eT>::n_cols > 1), "Col(): incompatible dimensions" );
00281   }

template<typename eT>
const Col< eT > & Col< eT >::operator= ( const subview< eT > &  X  )  [inline, inherited]

construct a column vector from given a submatrix; the submatrix must have exactly one column

Reimplemented from Mat< eT >.

Definition at line 289 of file Col_meat.hpp.

References Col< eT >::operator=().

00290   {
00291   arma_extra_debug_sigprint();
00292   
00293   Mat<eT>::operator=(X);
00294   
00295   arma_debug_check( (Mat<eT>::n_cols > 1), "Col(): incompatible dimensions" );
00296   
00297   return *this;
00298   }

template<typename eT>
const Col< eT > & Col< eT >::operator*= ( const subview< eT > &  X  )  [inline, inherited]

in-place matrix mutiplication (using a submatrix on the right-hand-side)

Reimplemented from Mat< eT >.

Definition at line 305 of file Col_meat.hpp.

References Col< eT >::operator*=().

00306   {
00307   arma_extra_debug_sigprint();
00308   
00309   Mat<eT>::operator*=(X);
00310   
00311   arma_debug_check( (Mat<eT>::n_cols > 1), "Col(): incompatible dimensions" );
00312   
00313   return *this;
00314   }

template<typename eT>
Col< eT >::Col ( const subview_cube< eT > &  X  )  [inline, inherited]

construct a column vector from given a subcube; the subcube must have exactly one column

Definition at line 321 of file Col_meat.hpp.

00322   : Mat<eT>(X)
00323   {
00324   arma_extra_debug_sigprint();
00325   
00326   arma_debug_check( (Mat<eT>::n_cols > 1), "Col(): incompatible dimensions" );
00327   }

template<typename eT>
const Col< eT > & Col< eT >::operator= ( const subview_cube< eT > &  X  )  [inline, inherited]

construct a column vector from given a subcube; the subcube must have exactly one column

Reimplemented from Mat< eT >.

Definition at line 335 of file Col_meat.hpp.

References Col< eT >::operator=().

00336   {
00337   arma_extra_debug_sigprint();
00338   
00339   Mat<eT>::operator=(X);
00340   
00341   arma_debug_check( (Mat<eT>::n_cols > 1), "Col(): incompatible dimensions" );
00342   
00343   return *this;
00344   }

template<typename eT>
const Col< eT > & Col< eT >::operator*= ( const subview_cube< eT > &  X  )  [inline, inherited]

in-place matrix mutiplication (using a single-slice subcube on the right-hand-side)

Reimplemented from Mat< eT >.

Definition at line 351 of file Col_meat.hpp.

References Col< eT >::operator*=().

00352   {
00353   arma_extra_debug_sigprint();
00354   
00355   Mat<eT>::operator*=(X);
00356   
00357   arma_debug_check( (Mat<eT>::n_cols > 1), "Col(): incompatible dimensions" );
00358   
00359   return *this;
00360   }

template<typename eT>
Col< eT >::Col ( const diagview< eT > &  X  )  [inline, inherited]

construct a column vector from given a diagview

Definition at line 367 of file Col_meat.hpp.

00368   : Mat<eT>(X)
00369   {
00370   arma_extra_debug_sigprint();
00371   
00372   arma_debug_check( (Mat<eT>::n_cols > 1), "Col(): incompatible dimensions" );
00373   }

template<typename eT>
const Col< eT > & Col< eT >::operator= ( const diagview< eT > &  X  )  [inline, inherited]

construct a column vector from given a diagview

Reimplemented from Mat< eT >.

Definition at line 381 of file Col_meat.hpp.

References Col< eT >::operator=().

00382   {
00383   arma_extra_debug_sigprint();
00384   
00385   Mat<eT>::operator=(X);
00386   
00387   arma_debug_check( (Mat<eT>::n_cols > 1), "Col(): incompatible dimensions" );
00388   
00389   return *this;
00390   }

template<typename eT>
const Col< eT > & Col< eT >::operator*= ( const diagview< eT > &  X  )  [inline, inherited]

in-place matrix mutiplication (using a diagview on the right-hand-side)

Reimplemented from Mat< eT >.

Definition at line 397 of file Col_meat.hpp.

References Col< eT >::operator*=().

00398   {
00399   arma_extra_debug_sigprint();
00400   
00401   Mat<eT>::operator*=(X);
00402   
00403   arma_debug_check( (Mat<eT>::n_cols > 1), "Col(): incompatible dimensions" );
00404   
00405   return *this;
00406   }

template<typename eT >
arma_inline eT & Col< eT >::row ( const u32  row_num  )  [inline, inherited]

creation of subview (row vector)

Reimplemented from Mat< eT >.

Definition at line 413 of file Col_meat.hpp.

References access::rw().

00414   {
00415   arma_debug_check( (row_num >= Mat<eT>::n_rows), "Col::row(): out of bounds" );
00416   
00417   return access::rw(Mat<eT>::mem[row_num]);
00418   }

template<typename eT >
arma_inline eT Col< eT >::row ( const u32  row_num  )  const [inline, inherited]

creation of subview (row vector)

Reimplemented from Mat< eT >.

Definition at line 425 of file Col_meat.hpp.

00427   {
00428   arma_debug_check( (row_num >= Mat<eT>::n_rows), "Col::row(): out of bounds" );
00429   
00430   return Mat<eT>::mem[row_num];
00431   }

template<typename eT >
arma_inline subview_col< eT > Col< eT >::rows ( const u32  in_row1,
const u32  in_row2 
) [inline, inherited]

creation of subview (submatrix comprised of specified row vectors)

Reimplemented from Mat< eT >.

Definition at line 438 of file Col_meat.hpp.

Referenced by op_pinv::direct_pinv(), and op_princomp::direct_princomp().

00439   {
00440   arma_debug_check( ( (in_row1 > in_row2) || (in_row2 >= Mat<eT>::n_rows) ), "Col::rows(): indices out of bounds or incorrectly used");
00441   
00442   return subview_col<eT>(*this, 0, in_row1, in_row2);
00443   }

template<typename eT >
arma_inline const subview_col< eT > Col< eT >::rows ( const u32  in_row1,
const u32  in_row2 
) const [inline, inherited]

creation of subview (submatrix comprised of specified row vectors)

Reimplemented from Mat< eT >.

Definition at line 450 of file Col_meat.hpp.

00452   {
00453   arma_debug_check( ( (in_row1 > in_row2) || (in_row2 >= Mat<eT>::n_rows) ), "Col::rows(): indices out of bounds or incorrectly used");
00454   
00455   return subview_col<eT>(*this, 0, in_row1, in_row2);
00456   }

template<typename eT >
template<typename T1 , typename op_type >
Col< eT >::Col ( const Op< T1, op_type > &  X  )  [inline, inherited]

construct a column vector from Op, i.e. run the previously delayed operations; the result of the operations must have exactly one column

Definition at line 464 of file Col_meat.hpp.

00465   : Mat<eT>(X)
00466   {
00467   arma_extra_debug_sigprint();
00468   
00469   arma_debug_check( (Mat<eT>::n_cols > 1), "Col(): incompatible dimensions" );
00470   }

template<typename eT >
template<typename T1 , typename op_type >
const Col< eT > & Col< eT >::operator= ( const Op< T1, op_type > &  X  )  [inline, inherited]

construct a column vector from Op, i.e. run the previously delayed operations; the result of the operations must have exactly one column

Reimplemented from Mat< eT >.

Definition at line 479 of file Col_meat.hpp.

References Col< eT >::operator=().

00480   {
00481   arma_extra_debug_sigprint();
00482   
00483   Mat<eT>::operator=(X);
00484   arma_debug_check( (Mat<eT>::n_cols > 1), "Col(): incompatible dimensions" );
00485   return *this;
00486   }

template<typename eT >
template<typename T1 , typename op_type >
const Col< eT > & Col< eT >::operator*= ( const Op< T1, op_type > &  X  )  [inline, inherited]

in-place matrix multiplication, with the right-hand-side operand having delayed operations

Reimplemented from Mat< eT >.

Definition at line 494 of file Col_meat.hpp.

References Col< eT >::operator*=().

00495   {
00496   arma_extra_debug_sigprint();
00497   
00498   Mat<eT>::operator*=(X);
00499   
00500   arma_debug_check( (Mat<eT>::n_cols > 1), "Col(): incompatible dimensions" );
00501   
00502   return *this;
00503   }

template<typename eT >
template<typename T1 , typename eop_type >
Col< eT >::Col ( const eOp< T1, eop_type > &  X  )  [inline, inherited]

Definition at line 510 of file Col_meat.hpp.

00511   : Mat<eT>(X)
00512   {
00513   arma_extra_debug_sigprint();
00514   
00515   arma_debug_check( (Mat<eT>::n_cols > 1), "Col(): incompatible dimensions" );
00516   }

template<typename eT >
template<typename T1 , typename eop_type >
const Col< eT > & Col< eT >::operator= ( const eOp< T1, eop_type > &  X  )  [inline, inherited]

create a matrix from eOp, i.e. run the previously delayed unary operations

Reimplemented from Mat< eT >.

Definition at line 524 of file Col_meat.hpp.

References Col< eT >::operator=().

00525   {
00526   arma_extra_debug_sigprint();
00527   
00528   Mat<eT>::operator=(X);
00529   arma_debug_check( (Mat<eT>::n_cols > 1), "Col(): incompatible dimensions" );
00530   return *this;
00531   }

template<typename eT >
template<typename T1 , typename eop_type >
const Col< eT > & Col< eT >::operator*= ( const eOp< T1, eop_type > &  X  )  [inline, inherited]

Reimplemented from Mat< eT >.

Definition at line 539 of file Col_meat.hpp.

References Col< eT >::operator*=().

00540   {
00541   arma_extra_debug_sigprint();
00542   
00543   Mat<eT>::operator*=(X);
00544   
00545   arma_debug_check( (Mat<eT>::n_cols > 1), "Col(): incompatible dimensions" );
00546   
00547   return *this;
00548   }

template<typename eT>
template<typename T1 , typename op_type >
Col< eT >::Col ( const mtOp< eT, T1, op_type > &  X  )  [inline, inherited]

Definition at line 555 of file Col_meat.hpp.

00556   : Mat<eT>(X)
00557   {
00558   arma_extra_debug_sigprint();
00559   
00560   arma_debug_check( (Mat<eT>::n_cols > 1), "Col(): incompatible dimensions" );
00561   }

template<typename eT>
template<typename T1 , typename op_type >
const Col< eT > & Col< eT >::operator= ( const mtOp< eT, T1, op_type > &  X  )  [inline, inherited]

EXPERIMENTAL.

Reimplemented from Mat< eT >.

Definition at line 569 of file Col_meat.hpp.

References Col< eT >::operator=().

00570   {
00571   arma_extra_debug_sigprint();
00572   
00573   Mat<eT>::operator=(X);
00574   arma_debug_check( (Mat<eT>::n_cols > 1), "Col(): incompatible dimensions" );
00575   return *this;
00576   }

template<typename eT>
template<typename T1 , typename op_type >
const Col< eT > & Col< eT >::operator*= ( const mtOp< eT, T1, op_type > &  X  )  [inline, inherited]

EXPERIMENTAL.

Reimplemented from Mat< eT >.

Definition at line 584 of file Col_meat.hpp.

References Col< eT >::operator*=().

00585   {
00586   arma_extra_debug_sigprint();
00587   
00588   Mat<eT>::operator*=(X);
00589   
00590   arma_debug_check( (Mat<eT>::n_cols > 1), "Col(): incompatible dimensions" );
00591   
00592   return *this;
00593   }

template<typename eT>
template<typename T1 , typename T2 , typename glue_type >
Col< eT >::Col ( const Glue< T1, T2, glue_type > &  X  )  [inline, inherited]

construct a column vector from Glue, i.e. run the previously delayed operations; the result of the operations must have exactly one column

Definition at line 601 of file Col_meat.hpp.

00602   : Mat<eT>(X)
00603   {
00604   arma_extra_debug_sigprint();
00605   
00606   arma_debug_check( (Mat<eT>::n_cols > 1), "Col(): incompatible dimensions" );
00607   }

template<typename eT>
template<typename T1 , typename T2 , typename glue_type >
const Col< eT > & Col< eT >::operator= ( const Glue< T1, T2, glue_type > &  X  )  [inline, inherited]

construct a column vector from Glue, i.e. run the previously delayed operations; the result of the operations must have exactly one column

Reimplemented from Mat< eT >.

Definition at line 616 of file Col_meat.hpp.

References Col< eT >::operator=().

00617   {
00618   arma_extra_debug_sigprint();
00619   
00620   Mat<eT>::operator=(X);
00621   
00622   arma_debug_check( (Mat<eT>::n_cols > 1), "Col(): incompatible dimensions" );
00623   
00624   return *this;
00625   }

template<typename eT>
template<typename T1 , typename T2 , typename glue_type >
const Col< eT > & Col< eT >::operator*= ( const Glue< T1, T2, glue_type > &  X  )  [inline, inherited]

in-place matrix multiplications, with the right-hand-side operands having delayed operations

Reimplemented from Mat< eT >.

Definition at line 633 of file Col_meat.hpp.

References Col< eT >::operator*=().

00634   {
00635   arma_extra_debug_sigprint();
00636   
00637   Mat<eT>::operator*=(X);
00638   
00639   arma_debug_check( (Mat<eT>::n_cols > 1), "Col(): incompatible dimensions" );
00640   
00641   return *this;
00642   }

template<typename eT>
template<typename T1 , typename T2 , typename eglue_type >
Col< eT >::Col ( const eGlue< T1, T2, eglue_type > &  X  )  [inline, inherited]

Definition at line 649 of file Col_meat.hpp.

00650   : Mat<eT>(X)
00651   {
00652   arma_extra_debug_sigprint();
00653   
00654   arma_debug_check( (Mat<eT>::n_cols > 1), "Col(): incompatible dimensions" );
00655   }

template<typename eT>
template<typename T1 , typename T2 , typename eglue_type >
const Col< eT > & Col< eT >::operator= ( const eGlue< T1, T2, eglue_type > &  X  )  [inline, inherited]

create a matrix from eGlue, i.e. run the previously delayed binary operations

Reimplemented from Mat< eT >.

Definition at line 663 of file Col_meat.hpp.

References Col< eT >::operator=().

00664   {
00665   arma_extra_debug_sigprint();
00666   
00667   Mat<eT>::operator=(X);
00668   
00669   arma_debug_check( (Mat<eT>::n_cols > 1), "Col(): incompatible dimensions" );
00670   
00671   return *this;
00672   }

template<typename eT>
template<typename T1 , typename T2 , typename eglue_type >
const Col< eT > & Col< eT >::operator*= ( const eGlue< T1, T2, eglue_type > &  X  )  [inline, inherited]

Reimplemented from Mat< eT >.

Definition at line 680 of file Col_meat.hpp.

References Col< eT >::operator*=().

00681   {
00682   arma_extra_debug_sigprint();
00683   
00684   Mat<eT>::operator*=(X);
00685   
00686   arma_debug_check( (Mat<eT>::n_cols > 1), "Col(): incompatible dimensions" );
00687   
00688   return *this;
00689   }

template<typename eT>
template<typename T1 , typename T2 , typename glue_type >
Col< eT >::Col ( const mtGlue< eT, T1, T2, glue_type > &  X  )  [inline, inherited]

Definition at line 696 of file Col_meat.hpp.

00697   : Mat<eT>(X)
00698   {
00699   arma_extra_debug_sigprint();
00700   
00701   arma_debug_check( (Mat<eT>::n_cols > 1), "Col(): incompatible dimensions" );
00702   }

template<typename eT>
template<typename T1 , typename T2 , typename glue_type >
const Col< eT > & Col< eT >::operator= ( const mtGlue< eT, T1, T2, glue_type > &  X  )  [inline, inherited]

EXPERIMENTAL: create a matrix from Glue, i.e. run the previously delayed binary operations.

Reimplemented from Mat< eT >.

Definition at line 710 of file Col_meat.hpp.

References Col< eT >::operator=().

00711   {
00712   arma_extra_debug_sigprint();
00713   
00714   Mat<eT>::operator=(X);
00715   
00716   arma_debug_check( (Mat<eT>::n_cols > 1), "Col(): incompatible dimensions" );
00717   
00718   return *this;
00719   }

template<typename eT>
template<typename T1 , typename T2 , typename glue_type >
const Col< eT > & Col< eT >::operator*= ( const mtGlue< eT, T1, T2, glue_type > &  X  )  [inline, inherited]

EXPERIMENTAL: in-place matrix multiplications, with the right-hand-side operands having delayed operations.

Reimplemented from Mat< eT >.

Definition at line 727 of file Col_meat.hpp.

References Col< eT >::operator*=().

00728   {
00729   arma_extra_debug_sigprint();
00730   
00731   Mat<eT>::operator*=(X);
00732   
00733   arma_debug_check( (Mat<eT>::n_cols > 1), "Col(): incompatible dimensions" );
00734   
00735   return *this;
00736   }

template<typename eT >
void Col< eT >::set_size ( const u32  n_elem  )  [inline, inherited]

change the number of rows

Definition at line 744 of file Col_meat.hpp.

Referenced by Col< eT >::copy_size(), op_princomp::direct_princomp(), auxlib::eig_sym(), Col< eT >::set_size(), svd(), and auxlib::svd().

00745   {
00746   arma_extra_debug_sigprint();
00747   
00748   Mat<eT>::set_size(in_n_elem,1);
00749   }

template<typename eT >
void Col< eT >::set_size ( const u32  n_rows,
const u32  n_cols 
) [inline, inherited]

change the number of n_rows (this function re-implements mat::set_size() in order to check the number of columns)

Reimplemented from Mat< eT >.

Definition at line 757 of file Col_meat.hpp.

References min(), and Col< eT >::set_size().

00758   {
00759   arma_extra_debug_sigprint();
00760 
00761   // min() is used in case in_n_cols is zero
00762   Mat<eT>::set_size( in_n_rows, (std::min)( u32(1), in_n_cols ) );
00763   
00764   arma_debug_check( (in_n_cols > 1), "Col::set_size(): incompatible dimensions" );
00765   }

template<typename eT >
template<typename eT2 >
void Col< eT >::copy_size ( const Mat< eT2 > &  m  )  [inline, inherited]

change the number of n_rows (this function re-implements mat::copy_size() in order to check the number of columns)

Definition at line 774 of file Col_meat.hpp.

References min(), Mat< eT >::n_cols, Mat< eT >::n_rows, and Col< eT >::set_size().

00775   {
00776   arma_extra_debug_sigprint();
00777   
00778   // min() is used in case x.n_cols is zero
00779   Mat<eT>::set_size( x.n_rows, (std::min)( u32(1), x.n_cols ) );
00780   
00781   arma_debug_check( (x.n_cols > 1), "Col::copy_size(): incompatible dimensions" );
00782   }

template<typename eT >
void Col< eT >::zeros (  )  [inline, inherited]

Reimplemented from Mat< eT >.

Definition at line 789 of file Col_meat.hpp.

Referenced by op_princomp::direct_princomp(), and Col< eT >::zeros().

00790   {
00791   arma_extra_debug_sigprint();
00792   
00793   Mat<eT>::zeros();
00794   }

template<typename eT >
void Col< eT >::zeros ( const u32  n_elem  )  [inline, inherited]

Definition at line 801 of file Col_meat.hpp.

References Col< eT >::zeros().

00802   {
00803   arma_extra_debug_sigprint();
00804   
00805   Mat<eT>::zeros(in_n_elem, 1);
00806   }

template<typename eT >
void Col< eT >::zeros ( const u32  n_rows,
const u32  n_cols 
) [inline, inherited]

Reimplemented from Mat< eT >.

Definition at line 813 of file Col_meat.hpp.

References min(), and Col< eT >::zeros().

00814   {
00815   arma_extra_debug_sigprint();
00816   
00817   // min() is used in case in_n_cols is zero
00818   Mat<eT>::zeros( in_n_rows, (std::min)( u32(1), in_n_cols ) );
00819   
00820   arma_debug_check( (in_n_cols > 1), "Col::zeros(): incompatible dimensions" );
00821   }

template<typename eT >
void Col< eT >::ones (  )  [inline, inherited]

Reimplemented from Mat< eT >.

Definition at line 828 of file Col_meat.hpp.

Referenced by Col< eT >::ones().

00829   {
00830   arma_extra_debug_sigprint();
00831   
00832   Mat<eT>::ones();
00833   }

template<typename eT >
void Col< eT >::ones ( const u32  n_elem  )  [inline, inherited]

Definition at line 840 of file Col_meat.hpp.

References Col< eT >::ones().

00841   {
00842   arma_extra_debug_sigprint();
00843   
00844   Mat<eT>::ones(in_n_elem, 1);
00845   }

template<typename eT >
void Col< eT >::ones ( const u32  n_rows,
const u32  n_cols 
) [inline, inherited]

Reimplemented from Mat< eT >.

Definition at line 852 of file Col_meat.hpp.

References min(), and Col< eT >::ones().

00853   {
00854   arma_extra_debug_sigprint();
00855   
00856   // min() is used in case in_n_cols is zero
00857   Mat<eT>::ones( in_n_rows, (std::min)( u32(1), in_n_cols ) );
00858   
00859   arma_debug_check( (in_n_cols > 1), "Col::ones(): incompatible dimensions" );
00860   }

template<typename eT >
void Col< eT >::load ( const std::string  name,
const file_type  type = auto_detect,
const bool  print_status = true 
) [inline, inherited]

load a matrix from a file

Reimplemented from Mat< eT >.

Definition at line 867 of file Col_meat.hpp.

Referenced by Col< eT >::load().

00868   {
00869   arma_extra_debug_sigprint();
00870   
00871   Mat<eT>::load(name, type, print_status);
00872   
00873   arma_debug_check( (Mat<eT>::n_cols > 1), "Col(): incompatible dimensions" );
00874   }

template<typename eT >
void Col< eT >::load ( std::istream &  is,
const file_type  type = auto_detect,
const bool  print_status = true 
) [inline, inherited]

load a matrix from a stream

Reimplemented from Mat< eT >.

Definition at line 881 of file Col_meat.hpp.

References Col< eT >::load().

00882   {
00883   arma_extra_debug_sigprint();
00884   
00885   Mat<eT>::load(is, type, print_status);
00886   
00887   arma_debug_check( (Mat<eT>::n_cols > 1), "Col(): incompatible dimensions" );
00888   }

template<typename eT >
void Col< eT >::quiet_load ( const std::string  name,
const file_type  type = auto_detect 
) [inline, inherited]

load a matrix from a file, without printing any error messages

Reimplemented from Mat< eT >.

Definition at line 895 of file Col_meat.hpp.

Referenced by Col< eT >::quiet_load().

00896   {
00897   arma_extra_debug_sigprint();
00898   
00899   Mat<eT>::quiet_load(name, type);
00900   
00901   arma_debug_check( (Mat<eT>::n_cols > 1), "Col(): incompatible dimensions" );
00902   }

template<typename eT >
void Col< eT >::quiet_load ( std::istream &  is,
const file_type  type = auto_detect 
) [inline, inherited]

load a matrix from a stream, without printing any error messages

Reimplemented from Mat< eT >.

Definition at line 909 of file Col_meat.hpp.

References Col< eT >::quiet_load().

00910   {
00911   arma_extra_debug_sigprint();
00912   
00913   Mat<eT>::quiet_load(is, type);
00914   
00915   arma_debug_check( (Mat<eT>::n_cols > 1), "Col(): incompatible dimensions" );
00916   }

template<typename eT >
Col< eT >::row_iterator Col< eT >::begin_row ( const u32  row_num  )  [inline, inherited]

Reimplemented from Mat< eT >.

Definition at line 923 of file Col_meat.hpp.

References Mat< eT >::memptr().

00924   {
00925   arma_extra_debug_sigprint();
00926   
00927   arma_debug_check( (row_num >= Mat<eT>::n_rows), "begin_row(): index out of bounds");
00928   
00929   return Mat<eT>::memptr() + row_num;
00930   }

template<typename eT >
Col< eT >::const_row_iterator Col< eT >::begin_row ( const u32  row_num  )  const [inline, inherited]

Reimplemented from Mat< eT >.

Definition at line 937 of file Col_meat.hpp.

References Mat< eT >::memptr().

00938   {
00939   arma_extra_debug_sigprint();
00940   
00941   arma_debug_check( (row_num >= Mat<eT>::n_rows), "begin_row(): index out of bounds");
00942   
00943   return Mat<eT>::memptr() + row_num;
00944   }

template<typename eT >
Col< eT >::row_iterator Col< eT >::end_row ( const u32  row_num  )  [inline, inherited]

Reimplemented from Mat< eT >.

Definition at line 951 of file Col_meat.hpp.

References Mat< eT >::memptr().

00952   {
00953   arma_extra_debug_sigprint();
00954   
00955   arma_debug_check( (row_num >= Mat<eT>::n_rows), "end_row(): index out of bounds");
00956   
00957   return Mat<eT>::memptr() + row_num + 1;
00958   }

template<typename eT >
Col< eT >::const_row_iterator Col< eT >::end_row ( const u32  row_num  )  const [inline, inherited]

Reimplemented from Mat< eT >.

Definition at line 965 of file Col_meat.hpp.

References Mat< eT >::memptr().

00966   {
00967   arma_extra_debug_sigprint();
00968   
00969   arma_debug_check( (row_num >= Mat<eT>::n_rows), "end_row(): index out of bounds");
00970   
00971   return Mat<eT>::memptr() + row_num + 1;
00972   }