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)
 Row::Row (const Mat< eT > &X)
const RowRow::operator= (const Mat< eT > &X)
 construct a matrix from a given matrix
const RowRow::operator*= (const Mat< eT > &X)
 in-place matrix multiplication
 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< typename Row< eT >::pod_type, T1 > &A, const Base< typename Row< eT >::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 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)
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)
 change the matrix (without preserving data) to have the same dimensions as the given matrix
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)
 load a matrix from a file
void Row::load (std::istream &is, const file_type type=auto_detect)
 load a matrix from a stream
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 > &  X  )  [inline, inherited]

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 > &  m  )  [inline, inherited]

construct a matrix from a given matrix

Reimplemented from Mat< eT >.

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 > &  m  )  [inline, inherited]

in-place matrix multiplication

Reimplemented from Mat< eT >.

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< typename Row< eT >::pod_type, T1 > &  A,
const Base< typename Row< eT >::pod_type, T2 > &  B 
) [inline, 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 T2 , typename glue_type >
Row< eT >::Row ( const Glue< T1, T2, glue_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 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 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 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 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 eglue_type >
Row< eT >::Row ( const eGlue< T1, T2, eglue_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 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 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 eglue_type >
const Row< eT > & Row< eT >::operator*= ( const eGlue< T1, T2, eglue_type > &  X  )  [inline, inherited]

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 >
void Row< eT >::set_size ( const u32  N  )  [inline, inherited]

Definition at line 624 of file Row_meat.hpp.

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

00625   {
00626   arma_extra_debug_sigprint();
00627   
00628   Mat<eT>::set_size(1,in_n_elem);
00629   }

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 636 of file Row_meat.hpp.

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

00637   {
00638   arma_extra_debug_sigprint();
00639   
00640   // min is used in case in_n_rows is zero
00641   Mat<eT>::set_size( (std::min)( u32(1), in_n_rows), in_n_cols );
00642   
00643   arma_debug_check( (in_n_rows > 1), "Row::set_size(): incompatible dimensions" );
00644   }

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

change the matrix (without preserving data) to have the same dimensions as the given matrix

Reimplemented from Mat< eT >.

Definition at line 652 of file Row_meat.hpp.

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

00653   {
00654   arma_extra_debug_sigprint();
00655   
00656   // min is used in case x.n_rows is zero
00657   Mat<eT>::set_size( (std::min)( u32(1), x.n_rows), x.n_cols );
00658   
00659   arma_debug_check( (x.n_rows > 1), "Row::copy_size(): incompatible dimensions" );
00660   }

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

Reimplemented from Mat< eT >.

Definition at line 667 of file Row_meat.hpp.

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

00668   {
00669   arma_extra_debug_sigprint();
00670   
00671   Mat<eT>::zeros();
00672   }

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

Definition at line 679 of file Row_meat.hpp.

References Row< eT >::zeros().

00680   {
00681   arma_extra_debug_sigprint();
00682   
00683   Mat<eT>::zeros(1, in_n_elem);
00684   }

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

Reimplemented from Mat< eT >.

Definition at line 691 of file Row_meat.hpp.

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

00692   {
00693   arma_extra_debug_sigprint();
00694   
00695   // min is used in case in_n_rows is zero
00696   Mat<eT>::zeros( (std::min)( u32(1), in_n_rows), in_n_cols );
00697   
00698   arma_debug_check( (in_n_rows > 1), "Row<eT>::zeros(): incompatible dimensions" );
00699   }

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

Reimplemented from Mat< eT >.

Definition at line 706 of file Row_meat.hpp.

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

00707   {
00708   arma_extra_debug_sigprint();
00709   
00710   Mat<eT>::ones();
00711   }

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

Definition at line 718 of file Row_meat.hpp.

References Row< eT >::ones().

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

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

Reimplemented from Mat< eT >.

Definition at line 730 of file Row_meat.hpp.

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

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

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

load a matrix from a file

Reimplemented from Mat< eT >.

Definition at line 745 of file Row_meat.hpp.

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

00746   {
00747   arma_extra_debug_sigprint();
00748   
00749   Mat<eT>::load(name,type);
00750   
00751   arma_debug_check( (Mat<eT>::n_rows > 1), "Row(): incompatible dimensions" );
00752   }

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

load a matrix from a stream

Reimplemented from Mat< eT >.

Definition at line 759 of file Row_meat.hpp.

References Row< eT >::load().

00760   {
00761   arma_extra_debug_sigprint();
00762   
00763   Mat<eT>::load(is, type);
00764   
00765   arma_debug_check( (Mat<eT>::n_rows > 1), "Row(): incompatible dimensions" );
00766   }

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

Reimplemented from Mat< eT >.

Definition at line 773 of file Row_meat.hpp.

References Mat< eT >::memptr().

00774   {
00775   arma_extra_debug_sigprint();
00776   
00777   arma_debug_check( (row_num >= Mat<eT>::n_rows), "begin_row(): index out of bounds");
00778   
00779   return Mat<eT>::memptr();
00780   }

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 787 of file Row_meat.hpp.

References Mat< eT >::memptr().

00788   {
00789   arma_extra_debug_sigprint();
00790   
00791   arma_debug_check( (row_num >= Mat<eT>::n_rows), "begin_row(): index out of bounds");
00792   
00793   return Mat<eT>::memptr();
00794   }

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

Reimplemented from Mat< eT >.

Definition at line 801 of file Row_meat.hpp.

References Mat< eT >::memptr().

00802   {
00803   arma_extra_debug_sigprint();
00804   
00805   arma_debug_check( (row_num >= Mat<eT>::n_rows), "end_row(): index out of bounds");
00806   
00807   return Mat<eT>::memptr() + Mat<eT>::n_cols;
00808   }

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 815 of file Row_meat.hpp.

References Mat< eT >::memptr().

00816   {
00817   arma_extra_debug_sigprint();
00818   
00819   arma_debug_check( (row_num >= Mat<eT>::n_rows), "end_row(): index out of bounds");
00820   
00821   return Mat<eT>::memptr() + Mat<eT>::n_cols;
00822   }