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)
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 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
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)
 load a matrix from a file

Function Documentation

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

Definition at line 21 of file Row_meat.hpp.

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

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

Definition at line 31 of file Row_meat.hpp.

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

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

Definition at line 41 of file Row_meat.hpp.

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

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

Definition at line 53 of file Row_meat.hpp.

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

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

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

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

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

Definition at line 81 of file Row_meat.hpp.

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

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

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

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

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

Definition at line 109 of file Row_meat.hpp.

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

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

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

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

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

Definition at line 132 of file Row_meat.hpp.

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

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

Definition at line 145 of file Row_meat.hpp.

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

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

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

Definition at line 159 of file Row_meat.hpp.

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

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

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

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

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

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

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

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

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

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

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

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

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

Definition at line 247 of file Row_meat.hpp.

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

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

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

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

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

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

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

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

Definition at line 291 of file Row_meat.hpp.

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

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

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

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

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

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

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

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

construct a row vector from given a diagview

Definition at line 336 of file Row_meat.hpp.

References access::rw().

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

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

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

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

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

Definition at line 369 of file Row_meat.hpp.

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

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

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

References access::rw().

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

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

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

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

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

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

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

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

Definition at line 435 of file Row_meat.hpp.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Definition at line 529 of file Row_meat.hpp.

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

00530   {
00531   arma_extra_debug_sigprint();
00532   
00533   Mat<eT>::set_size(1,in_n_elem);
00534   }

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

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

00542   {
00543   arma_extra_debug_sigprint();
00544   
00545   // min is used in case in_n_rows is zero
00546   Mat<eT>::set_size( (std::min)( u32(1), in_n_rows), in_n_cols );
00547   
00548   arma_debug_check( (in_n_rows > 1), "Row::set_size(): incompatible dimensions" );
00549   }

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

Definition at line 557 of file Row_meat.hpp.

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

Referenced by unwrap_write< Col< eT > >::unwrap_write(), unwrap_write< Row< eT > >::unwrap_write(), and unwrap_write< Mat< eT > >::unwrap_write().

00558   {
00559   arma_extra_debug_sigprint();
00560   
00561   // min is used in case x.n_rows is zero
00562   Mat<eT>::set_size( (std::min)( u32(1), x.n_rows), x.n_cols );
00563   
00564   arma_debug_check( (x.n_rows > 1), "Row::copy_size(): incompatible dimensions" );
00565   }

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

Reimplemented from Mat< eT >.

Definition at line 572 of file Row_meat.hpp.

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

00573   {
00574   arma_extra_debug_sigprint();
00575   
00576   Mat<eT>::zeros();
00577   }

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

Definition at line 584 of file Row_meat.hpp.

References Row< eT >::zeros().

00585   {
00586   arma_extra_debug_sigprint();
00587   
00588   Mat<eT>::zeros(1, in_n_elem);
00589   }

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

Reimplemented from Mat< eT >.

Definition at line 596 of file Row_meat.hpp.

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

00597   {
00598   arma_extra_debug_sigprint();
00599   
00600   // min is used in case in_n_rows is zero
00601   Mat<eT>::zeros( (std::min)( u32(1), in_n_rows), in_n_cols );
00602   
00603   arma_debug_check( (in_n_rows > 1), "Row<eT>::zeros(): incompatible dimensions" );
00604   }

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

Reimplemented from Mat< eT >.

Definition at line 611 of file Row_meat.hpp.

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

00612   {
00613   arma_extra_debug_sigprint();
00614   
00615   Mat<eT>::ones();
00616   }

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

Definition at line 623 of file Row_meat.hpp.

References Row< eT >::ones().

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

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

Reimplemented from Mat< eT >.

Definition at line 635 of file Row_meat.hpp.

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

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

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

00651   {
00652   arma_extra_debug_sigprint();
00653   
00654   Mat<eT>::load(name,type);
00655   
00656   arma_debug_check( (Mat<eT>::n_rows > 1), "Row(): incompatible dimensions" );
00657   }