Row

Classes

class  Row< eT >
 Class for row vectors (matrices with only one row). More...

Functions

 Row::Row ()
 Row::Row (const u32 N)
 Row::Row (const u32 in_rows, const u32 in_cols)
 Row::Row (const char *text)
const RowRow::operator= (const char *text)
 create the matrix from a textual description
 Row::Row (const std::string &text)
const RowRow::operator= (const std::string &text)
 create the matrix from a textual description
 Row::Row (const Row &X)
const RowRow::operator= (const Row &X)
 construct a matrix from a given matrix
 Row::Row (const Mat< eT > &X)
const RowRow::operator= (const Mat< eT > &X)
const RowRow::operator*= (const Mat< eT > &X)
 Row::Row (eT *aux_mem, const u32 aux_n_rows, const u32 aux_n_cols, const bool copy_aux_mem=true)
 construct a row vector from a given auxiliary array
 Row::Row (const eT *aux_mem, const u32 aux_n_rows, const u32 aux_n_cols)
 construct a row vector from a given auxiliary array
 Row::Row (eT *aux_mem, const u32 aux_length, const bool copy_aux_mem=true)
 construct a row vector from a given auxiliary array
 Row::Row (const eT *aux_mem, const u32 aux_length)
 construct a row vector from a given auxiliary array
template<typename T1 , typename T2 >
 Row::Row (const Base< pod_type, T1 > &A, const Base< pod_type, T2 > &B)
 Row::Row (const subview< eT > &X)
const RowRow::operator= (const subview< eT > &X)
 construct a matrix from subview (e.g. construct a matrix from a delayed submatrix operation)
const RowRow::operator*= (const subview< eT > &X)
 in-place matrix mutiplication (using a submatrix on the right-hand-side)
 Row::Row (const subview_cube< eT > &X)
const RowRow::operator= (const subview_cube< eT > &X)
 construct a matrix from a subview_cube instance
const RowRow::operator*= (const subview_cube< eT > &X)
 in-place matrix mutiplication (using a single-slice subcube on the right-hand-side)
 Row::Row (const diagview< eT > &X)
 construct a row vector from given a diagview
const RowRow::operator= (const diagview< eT > &X)
 construct a row vector from given a diagview
const RowRow::operator*= (const diagview< eT > &X)
 in-place matrix mutiplication (using a diagview on the right-hand-side)
arma_inline eT & Row::col (const u32 col_num)
 creation of subview (column vector)
arma_inline eT Row::col (const u32 col_num) const
 creation of subview (column vector)
arma_inline subview_row< eT > Row::cols (const u32 in_col1, const u32 in_col2)
 creation of subview (submatrix comprised of specified column vectors)
arma_inline const subview_row< eT > Row::cols (const u32 in_col1, const u32 in_col2) const
 creation of subview (submatrix comprised of specified column vectors)
template<typename T1 , typename op_type >
 Row::Row (const Op< T1, op_type > &X)
template<typename T1 , typename op_type >
const RowRow::operator= (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 RowRow::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 >
 Row::Row (const eOp< T1, eop_type > &X)
template<typename T1 , typename eop_type >
const RowRow::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 RowRow::operator*= (const eOp< T1, eop_type > &X)
template<typename T1 , typename op_type >
 Row::Row (const mtOp< eT, T1, op_type > &X)
template<typename T1 , typename op_type >
const RowRow::operator= (const mtOp< eT, T1, op_type > &X)
 EXPERIMENTAL.
template<typename T1 , typename op_type >
const RowRow::operator*= (const mtOp< eT, T1, op_type > &X)
 EXPERIMENTAL.
template<typename T1 , typename T2 , typename glue_type >
 Row::Row (const Glue< T1, T2, glue_type > &X)
template<typename T1 , typename T2 , typename glue_type >
const RowRow::operator= (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 RowRow::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 >
 Row::Row (const eGlue< T1, T2, eglue_type > &X)
template<typename T1 , typename T2 , typename eglue_type >
const RowRow::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 RowRow::operator*= (const eGlue< T1, T2, eglue_type > &X)
template<typename T1 , typename T2 , typename glue_type >
 Row::Row (const mtGlue< eT, T1, T2, glue_type > &X)
template<typename T1 , typename T2 , typename glue_type >
const RowRow::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 RowRow::operator*= (const mtGlue< eT, T1, T2, glue_type > &X)
 EXPERIMENTAL: in-place matrix multiplications, with the right-hand-side operands having delayed operations.
void Row::set_size (const u32 N)
void Row::set_size (const u32 n_rows, const u32 n_cols)
 change the matrix to have user specified dimensions (data is not preserved)
template<typename eT2 >
void Row::copy_size (const Mat< eT2 > &m)
void Row::zeros ()
void Row::zeros (const u32 N)
void Row::zeros (const u32 n_rows, const u32 n_cols)
void Row::ones ()
void Row::ones (const u32 N)
void Row::ones (const u32 n_rows, const u32 n_cols)
void Row::load (const std::string name, const file_type type=auto_detect, const bool print_status=true)
 load a matrix from a file
void Row::load (std::istream &is, const file_type type=auto_detect, const bool print_status=true)
 load a matrix from a stream
void Row::quiet_load (const std::string name, const file_type type=auto_detect)
 load a matrix from a file, without printing any error messages
void Row::quiet_load (std::istream &is, const file_type type=auto_detect)
 load a matrix from a stream, without printing any error messages
row_iterator Row::begin_row (const u32 row_num)
const_row_iterator Row::begin_row (const u32 row_num) const
row_iterator Row::end_row (const u32 row_num)
const_row_iterator Row::end_row (const u32 row_num) const

Function Documentation

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

Definition at line 22 of file Row_meat.hpp.

00023   : Mat<eT>()
00024   {
00025   arma_extra_debug_sigprint();
00026   }

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

Definition at line 32 of file Row_meat.hpp.

00033   : Mat<eT>(1,in_n_elem)
00034   {
00035   arma_extra_debug_sigprint();
00036   }

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

Definition at line 42 of file Row_meat.hpp.

00043   : Mat<eT>(in_n_rows, in_n_cols)
00044   {
00045   arma_extra_debug_sigprint();
00046   
00047   arma_debug_check( (Mat<eT>::n_rows > 1), "Row(): incompatible dimensions" );
00048   }

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

Definition at line 54 of file Row_meat.hpp.

00055   : Mat<eT>(text)
00056   {
00057   arma_extra_debug_sigprint();
00058   
00059   arma_debug_check( (Mat<eT>::n_rows > 1), "Row(): incompatible dimensions" );
00060   }

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

create the matrix from a textual description

Reimplemented from Mat< eT >.

Definition at line 67 of file Row_meat.hpp.

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

00068   {
00069   arma_extra_debug_sigprint();
00070   
00071   Mat<eT>::operator=(text);
00072   
00073   arma_debug_check( (Mat<eT>::n_rows > 1), "Row(): incompatible dimensions" );
00074   
00075   return *this;
00076   }

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

Definition at line 82 of file Row_meat.hpp.

00083   : Mat<eT>(text)
00084   {
00085   arma_extra_debug_sigprint();
00086   
00087   arma_debug_check( (Mat<eT>::n_rows > 1), "Row(): incompatible dimensions" );
00088   }

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

create the matrix from a textual description

Reimplemented from Mat< eT >.

Definition at line 95 of file Row_meat.hpp.

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

00096   {
00097   arma_extra_debug_sigprint();
00098   
00099   Mat<eT>::operator=(text);
00100   
00101   arma_debug_check( (Mat<eT>::n_rows > 1), "Row(): incompatible dimensions" );
00102   
00103   return *this;
00104   }

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

Definition at line 110 of file Row_meat.hpp.

00111   : Mat<eT>(X)
00112   {
00113   arma_extra_debug_sigprint();
00114   }

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

construct a matrix from a given matrix

Reimplemented from Mat< eT >.

Definition at line 121 of file Row_meat.hpp.

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

00122   {
00123   arma_extra_debug_sigprint();
00124   
00125   Mat<eT>::operator=(X);
00126   return *this;
00127   }

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

Definition at line 133 of file Row_meat.hpp.

00134   : Mat<eT>(X)
00135   {
00136   arma_extra_debug_sigprint();
00137   
00138   arma_debug_check( (Mat<eT>::n_rows > 1), "Row(): incompatible dimensions" );
00139   }

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

Definition at line 146 of file Row_meat.hpp.

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

00147   {
00148   arma_extra_debug_sigprint();
00149   
00150   Mat<eT>::operator=(X);
00151   arma_debug_check( (Mat<eT>::n_rows > 1), "Row(): incompatible dimensions" );
00152   return *this;
00153   }

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

Definition at line 160 of file Row_meat.hpp.

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

00161   {
00162   arma_extra_debug_sigprint();
00163   
00164   Mat<eT>::operator*=(X);
00165   arma_debug_check( (Mat<eT>::n_rows > 1), "Row(): incompatible dimensions" );
00166   return *this;
00167   }

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

construct a row vector from a given auxiliary array

Definition at line 174 of file Row_meat.hpp.

00175   : Mat<eT>(aux_mem, aux_n_rows, aux_n_cols, copy_aux_mem)
00176   {
00177   arma_extra_debug_sigprint();
00178   
00179   arma_debug_check( (Mat<eT>::n_rows > 1), "Row(): incompatible dimensions" );
00180   }

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

construct a row vector from a given auxiliary array

Definition at line 187 of file Row_meat.hpp.

00188   : Mat<eT>(aux_mem, aux_n_rows, aux_n_cols)
00189   {
00190   arma_extra_debug_sigprint();
00191   
00192   arma_debug_check( (Mat<eT>::n_rows > 1), "Row(): incompatible dimensions" );
00193   }

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

construct a row vector from a given auxiliary array

Definition at line 200 of file Row_meat.hpp.

00201   : Mat<eT>(aux_mem, 1, aux_length, copy_aux_mem)
00202   {
00203   arma_extra_debug_sigprint();
00204   
00205 //   Mat<eT>::set_size(1, aux_length);
00206 //   arma_check( (Mat<eT>::n_elem != aux_length), "Row(): don't know how to handle the given array" );
00207 // 
00208 //   syslib::copy_elem( Mat<eT>::memptr(), aux_mem, Mat<eT>::n_elem );
00209   }

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

construct a row vector from a given auxiliary array

Definition at line 216 of file Row_meat.hpp.

00217   : Mat<eT>(aux_mem, 1, aux_length)
00218   {
00219   arma_extra_debug_sigprint();
00220   
00221 //   Mat<eT>::set_size(1, aux_length);
00222 //   arma_check( (Mat<eT>::n_elem != aux_length), "Row(): don't know how to handle the given array" );
00223 // 
00224 //   syslib::copy_elem( Mat<eT>::memptr(), aux_mem, Mat<eT>::n_elem );
00225   }

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

Definition at line 233 of file Row_meat.hpp.

00237   : Mat<eT>(A,B)
00238   {
00239   arma_extra_debug_sigprint();
00240   
00241   arma_debug_check( (Mat<eT>::n_rows > 1), "Row(): incompatible dimensions" );
00242   }

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

Definition at line 248 of file Row_meat.hpp.

00249   : Mat<eT>(X)
00250   {
00251   arma_extra_debug_sigprint();
00252   
00253   arma_debug_check( (Mat<eT>::n_rows > 1), "Row(): incompatible dimensions" );
00254   }

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

construct a matrix from subview (e.g. construct a matrix from a delayed submatrix operation)

Reimplemented from Mat< eT >.

Definition at line 261 of file Row_meat.hpp.

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

00262   {
00263   arma_extra_debug_sigprint();
00264   
00265   Mat<eT>::operator=(X);
00266   
00267   arma_debug_check( (Mat<eT>::n_rows > 1), "Row(): incompatible dimensions" );
00268   
00269   return *this;
00270   }

template<typename eT>
const Row< eT > & Row< 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 277 of file Row_meat.hpp.

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

00278   {
00279   arma_extra_debug_sigprint();
00280   
00281   Mat<eT>::operator*=(X);
00282   
00283   arma_debug_check( (Mat<eT>::n_rows > 1), "Row(): incompatible dimensions" );
00284   
00285   return *this;
00286   }

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

Definition at line 292 of file Row_meat.hpp.

00293   : Mat<eT>(X)
00294   {
00295   arma_extra_debug_sigprint();
00296   
00297   arma_debug_check( (Mat<eT>::n_rows > 1), "Row(): incompatible dimensions" );
00298   }

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

construct a matrix from a subview_cube instance

Reimplemented from Mat< eT >.

Definition at line 305 of file Row_meat.hpp.

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

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

template<typename eT>
const Row< eT > & Row< 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 321 of file Row_meat.hpp.

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

00322   {
00323   arma_extra_debug_sigprint();
00324   
00325   Mat<eT>::operator*=(X);
00326   
00327   arma_debug_check( (Mat<eT>::n_rows > 1), "Row(): incompatible dimensions" );
00328   
00329   return *this;
00330   }

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

construct a row vector from given a diagview

Definition at line 337 of file Row_meat.hpp.

References access::rw().

00338   : Mat<eT>(X)
00339   {
00340   arma_extra_debug_sigprint();
00341   
00342   std::swap( access::rw(Mat<eT>::n_rows), access::rw(Mat<eT>::n_cols) );
00343   
00344   arma_debug_check( (Mat<eT>::n_rows > 1), "Row(): incompatible dimensions" );
00345   }

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

construct a row vector from given a diagview

Reimplemented from Mat< eT >.

Definition at line 353 of file Row_meat.hpp.

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

00354   {
00355   arma_extra_debug_sigprint();
00356   
00357   Mat<eT>::operator=(X);
00358   
00359   //std::swap( access::rw(Mat<eT>::n_rows), access::rw(Mat<eT>::n_cols) );
00360   arma_debug_check( (Mat<eT>::n_rows > 1), "Row(): incompatible dimensions" );
00361   
00362   return *this;
00363   }

template<typename eT>
const Row< eT > & Row< 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 370 of file Row_meat.hpp.

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

00371   {
00372   arma_extra_debug_sigprint();
00373   
00374   Mat<eT>::operator*=(X);
00375   
00376   arma_debug_check( (Mat<eT>::n_rows > 1), "Row(): incompatible dimensions" );
00377   
00378   return *this;
00379   }

template<typename eT >
arma_inline eT & Row< eT >::col ( const u32  col_num  )  [inline, inherited]

creation of subview (column vector)

Reimplemented from Mat< eT >.

Definition at line 386 of file Row_meat.hpp.

References access::rw().

00387   {
00388   arma_debug_check( (col_num >= Mat<eT>::n_cols), "Row::col(): out of bounds" );
00389   
00390   return access::rw(Mat<eT>::mem[col_num]);
00391   }

template<typename eT >
arma_inline eT Row< eT >::col ( const u32  col_num  )  const [inline, inherited]

creation of subview (column vector)

Reimplemented from Mat< eT >.

Definition at line 398 of file Row_meat.hpp.

00400   {
00401   arma_debug_check( (col_num >= Mat<eT>::n_cols), "Row::col(): out of bounds" );
00402   
00403   return Mat<eT>::mem[col_num];
00404   }

template<typename eT >
arma_inline subview_row< eT > Row< eT >::cols ( const u32  in_col1,
const u32  in_col2 
) [inline, inherited]

creation of subview (submatrix comprised of specified column vectors)

Reimplemented from Mat< eT >.

Definition at line 411 of file Row_meat.hpp.

00412   {
00413   arma_debug_check( ( (in_col1 > in_col2) || (in_col2 >= Mat<eT>::n_cols) ), "Row::cols(): indices out of bounds or incorrectly used");
00414   
00415   return subview_row<eT>(*this, 0, in_col1, in_col2);
00416   }

template<typename eT >
arma_inline const subview_row< eT > Row< eT >::cols ( const u32  in_col1,
const u32  in_col2 
) const [inline, inherited]

creation of subview (submatrix comprised of specified column vectors)

Reimplemented from Mat< eT >.

Definition at line 423 of file Row_meat.hpp.

00425   {
00426   arma_debug_check( ( (in_col1 > in_col2) || (in_col2 >= Mat<eT>::n_cols) ), "Row::cols(): indices out of bounds or incorrectly used");
00427   
00428   return subview_row<eT>(*this, 0, in_col1, in_col2);
00429   }

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

Definition at line 436 of file Row_meat.hpp.

00437   : Mat<eT>(X)
00438   {
00439   arma_extra_debug_sigprint();
00440   
00441   arma_debug_check( (Mat<eT>::n_rows > 1), "Row(): incompatible dimensions" );
00442   }

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

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

Reimplemented from Mat< eT >.

Definition at line 450 of file Row_meat.hpp.

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

00451   {
00452   arma_extra_debug_sigprint();
00453   
00454   Mat<eT>::operator=(X);
00455   
00456   arma_debug_check( (Mat<eT>::n_rows > 1), "Row(): incompatible dimensions" );
00457   
00458   return *this;
00459   }

template<typename eT >
template<typename T1 , typename op_type >
const Row< eT > & Row< 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 467 of file Row_meat.hpp.

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

00468   {
00469   arma_extra_debug_sigprint();
00470   
00471   Mat<eT>::operator*=(X);
00472   
00473   arma_debug_check( (Mat<eT>::n_rows > 1), "Row(): incompatible dimensions" );
00474   
00475   return *this;
00476   }

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

Definition at line 483 of file Row_meat.hpp.

00484   : Mat<eT>(X)
00485   {
00486   arma_extra_debug_sigprint();
00487   
00488   arma_debug_check( (Mat<eT>::n_rows > 1), "Row(): incompatible dimensions" );
00489   }

template<typename eT >
template<typename T1 , typename eop_type >
const Row< eT > & Row< 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 497 of file Row_meat.hpp.

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

00498   {
00499   arma_extra_debug_sigprint();
00500   
00501   Mat<eT>::operator=(X);
00502   
00503   arma_debug_check( (Mat<eT>::n_rows > 1), "Row(): incompatible dimensions" );
00504   
00505   return *this;
00506   }

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

Reimplemented from Mat< eT >.

Definition at line 514 of file Row_meat.hpp.

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

00515   {
00516   arma_extra_debug_sigprint();
00517   
00518   Mat<eT>::operator*=(X);
00519   
00520   arma_debug_check( (Mat<eT>::n_rows > 1), "Row(): incompatible dimensions" );
00521   
00522   return *this;
00523   }

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

Definition at line 530 of file Row_meat.hpp.

00531   : Mat<eT>(X)
00532   {
00533   arma_extra_debug_sigprint();
00534   
00535   arma_debug_check( (Mat<eT>::n_rows > 1), "Row(): incompatible dimensions" );
00536   }

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

EXPERIMENTAL.

Reimplemented from Mat< eT >.

Definition at line 544 of file Row_meat.hpp.

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

00545   {
00546   arma_extra_debug_sigprint();
00547   
00548   Mat<eT>::operator=(X);
00549   
00550   arma_debug_check( (Mat<eT>::n_rows > 1), "Row(): incompatible dimensions" );
00551   
00552   return *this;
00553   }

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

EXPERIMENTAL.

Reimplemented from Mat< eT >.

Definition at line 561 of file Row_meat.hpp.

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

00562   {
00563   arma_extra_debug_sigprint();
00564   
00565   Mat<eT>::operator*=(X);
00566   
00567   arma_debug_check( (Mat<eT>::n_rows > 1), "Row(): incompatible dimensions" );
00568   
00569   return *this;
00570   }

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

Definition at line 577 of file Row_meat.hpp.

00578   : Mat<eT>(X)
00579   {
00580   arma_extra_debug_sigprint();
00581   
00582   arma_debug_check( (Mat<eT>::n_rows > 1), "Row(): incompatible dimensions" );
00583   }

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

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

Reimplemented from Mat< eT >.

Definition at line 591 of file Row_meat.hpp.

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

00592   {
00593   arma_extra_debug_sigprint();
00594   
00595   Mat<eT>::operator=(X);
00596   
00597   arma_debug_check( (Mat<eT>::n_rows > 1), "Row(): incompatible dimensions" );
00598   
00599   return *this;
00600   }

template<typename eT>
template<typename T1 , typename T2 , typename glue_type >
const Row< eT > & Row< 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 608 of file Row_meat.hpp.

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

00609   {
00610   arma_extra_debug_sigprint();
00611   
00612   Mat<eT>::operator*=(X);
00613   
00614   arma_debug_check( (Mat<eT>::n_rows > 1), "Row(): incompatible dimensions" );
00615   
00616   return *this;
00617   }

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

Definition at line 624 of file Row_meat.hpp.

00625   : Mat<eT>(X)
00626   {
00627   arma_extra_debug_sigprint();
00628   
00629   arma_debug_check( (Mat<eT>::n_rows > 1), "Row(): incompatible dimensions" );
00630   }

template<typename eT>
template<typename T1 , typename T2 , typename eglue_type >
const Row< eT > & Row< 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 638 of file Row_meat.hpp.

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

00639   {
00640   arma_extra_debug_sigprint();
00641   
00642   Mat<eT>::operator=(X);
00643   
00644   arma_debug_check( (Mat<eT>::n_rows > 1), "Row(): incompatible dimensions" );
00645   
00646   return *this;
00647   }

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

Reimplemented from Mat< eT >.

Definition at line 655 of file Row_meat.hpp.

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

00656   {
00657   arma_extra_debug_sigprint();
00658   
00659   Mat<eT>::operator*=(X);
00660   
00661   arma_debug_check( (Mat<eT>::n_rows > 1), "Row(): incompatible dimensions" );
00662   
00663   return *this;
00664   }

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

Definition at line 671 of file Row_meat.hpp.

00672   : Mat<eT>(X)
00673   {
00674   arma_extra_debug_sigprint();
00675   
00676   arma_debug_check( (Mat<eT>::n_rows > 1), "Row(): incompatible dimensions" );
00677   }

template<typename eT>
template<typename T1 , typename T2 , typename glue_type >
const Row< eT > & Row< 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 685 of file Row_meat.hpp.

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

00686   {
00687   arma_extra_debug_sigprint();
00688   
00689   Mat<eT>::operator=(X);
00690   
00691   arma_debug_check( (Mat<eT>::n_rows > 1), "Row(): incompatible dimensions" );
00692   
00693   return *this;
00694   }

template<typename eT>
template<typename T1 , typename T2 , typename glue_type >
const Row< eT > & Row< 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 702 of file Row_meat.hpp.

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

00703   {
00704   arma_extra_debug_sigprint();
00705   
00706   Mat<eT>::operator*=(X);
00707   
00708   arma_debug_check( (Mat<eT>::n_rows > 1), "Row(): incompatible dimensions" );
00709   
00710   return *this;
00711   }

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

Definition at line 718 of file Row_meat.hpp.

Referenced by Row< eT >::copy_size(), and Row< eT >::set_size().

00719   {
00720   arma_extra_debug_sigprint();
00721   
00722   Mat<eT>::set_size(1,in_n_elem);
00723   }

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

change the matrix to have user specified dimensions (data is not preserved)

Reimplemented from Mat< eT >.

Definition at line 730 of file Row_meat.hpp.

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

00731   {
00732   arma_extra_debug_sigprint();
00733   
00734   // min is used in case in_n_rows is zero
00735   Mat<eT>::set_size( (std::min)( u32(1), in_n_rows), in_n_cols );
00736   
00737   arma_debug_check( (in_n_rows > 1), "Row::set_size(): incompatible dimensions" );
00738   }

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

Definition at line 746 of file Row_meat.hpp.

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

00747   {
00748   arma_extra_debug_sigprint();
00749   
00750   // min is used in case x.n_rows is zero
00751   Mat<eT>::set_size( (std::min)( u32(1), x.n_rows), x.n_cols );
00752   
00753   arma_debug_check( (x.n_rows > 1), "Row::copy_size(): incompatible dimensions" );
00754   }

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

Reimplemented from Mat< eT >.

Definition at line 761 of file Row_meat.hpp.

Referenced by Row< eT >::zeros().

00762   {
00763   arma_extra_debug_sigprint();
00764   
00765   Mat<eT>::zeros();
00766   }

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

Definition at line 773 of file Row_meat.hpp.

References Row< eT >::zeros().

00774   {
00775   arma_extra_debug_sigprint();
00776   
00777   Mat<eT>::zeros(1, in_n_elem);
00778   }

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

Reimplemented from Mat< eT >.

Definition at line 785 of file Row_meat.hpp.

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

00786   {
00787   arma_extra_debug_sigprint();
00788   
00789   // min is used in case in_n_rows is zero
00790   Mat<eT>::zeros( (std::min)( u32(1), in_n_rows), in_n_cols );
00791   
00792   arma_debug_check( (in_n_rows > 1), "Row<eT>::zeros(): incompatible dimensions" );
00793   }

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

Reimplemented from Mat< eT >.

Definition at line 800 of file Row_meat.hpp.

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

00801   {
00802   arma_extra_debug_sigprint();
00803   
00804   Mat<eT>::ones();
00805   }

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

Definition at line 812 of file Row_meat.hpp.

References Row< eT >::ones().

00813   {
00814   arma_extra_debug_sigprint();
00815   
00816   Mat<eT>::ones(1, in_n_elem);
00817   }

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

Reimplemented from Mat< eT >.

Definition at line 824 of file Row_meat.hpp.

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

00825   {
00826   arma_extra_debug_sigprint();
00827   
00828   // min is used in case in_n_rows is zero
00829   Mat<eT>::ones( (std::min)( u32(1), in_n_rows), in_n_cols );
00830   
00831   arma_debug_check( (in_n_rows > 1), "Row<eT>::ones(): incompatible dimensions" );
00832   }

template<typename eT >
void Row< 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 839 of file Row_meat.hpp.

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

00840   {
00841   arma_extra_debug_sigprint();
00842   
00843   Mat<eT>::load(name, type, print_status);
00844   
00845   arma_debug_check( (Mat<eT>::n_rows > 1), "Row(): incompatible dimensions" );
00846   }

template<typename eT >
void Row< 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 853 of file Row_meat.hpp.

References Row< eT >::load().

00854   {
00855   arma_extra_debug_sigprint();
00856   
00857   Mat<eT>::load(is, type, print_status);
00858   
00859   arma_debug_check( (Mat<eT>::n_rows > 1), "Row(): incompatible dimensions" );
00860   }

template<typename eT >
void Row< 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 867 of file Row_meat.hpp.

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

00868   {
00869   arma_extra_debug_sigprint();
00870   
00871   Mat<eT>::quiet_load(name, type);
00872   
00873   arma_debug_check( (Mat<eT>::n_rows > 1), "Row(): incompatible dimensions" );
00874   }

template<typename eT >
void Row< 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 881 of file Row_meat.hpp.

References Row< eT >::quiet_load().

00882   {
00883   arma_extra_debug_sigprint();
00884   
00885   Mat<eT>::quiet_load(is, type);
00886   
00887   arma_debug_check( (Mat<eT>::n_rows > 1), "Row(): incompatible dimensions" );
00888   }

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

Reimplemented from Mat< eT >.

Definition at line 895 of file Row_meat.hpp.

References Mat< eT >::memptr().

00896   {
00897   arma_extra_debug_sigprint();
00898   
00899   arma_debug_check( (row_num >= Mat<eT>::n_rows), "begin_row(): index out of bounds");
00900   
00901   return Mat<eT>::memptr();
00902   }

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

Reimplemented from Mat< eT >.

Definition at line 909 of file Row_meat.hpp.

References Mat< eT >::memptr().

00910   {
00911   arma_extra_debug_sigprint();
00912   
00913   arma_debug_check( (row_num >= Mat<eT>::n_rows), "begin_row(): index out of bounds");
00914   
00915   return Mat<eT>::memptr();
00916   }

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

Reimplemented from Mat< eT >.

Definition at line 923 of file Row_meat.hpp.

References Mat< eT >::memptr().

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

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

Reimplemented from Mat< eT >.

Definition at line 937 of file Row_meat.hpp.

References Mat< eT >::memptr().

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