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 char *text)
const RowRow::operator= (const char *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 (const eT *aux_mem, const u32 aux_length)
 construct a row vector from a given auxillary 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 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)
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)
void Row::zeros ()
void Row::zeros (const u32 N)
void Row::zeros (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 char *  text  )  [inline, inherited]

Definition at line 41 of file Row_meat.hpp.

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

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

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

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

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

Definition at line 67 of file Row_meat.hpp.

00068   : Mat<eT>(X)
00069   {
00070   arma_extra_debug_sigprint();
00071   }

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

Definition at line 78 of file Row_meat.hpp.

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

00079   {
00080   arma_extra_debug_sigprint();
00081   
00082   Mat<eT>::operator=(X);
00083   return *this;
00084   }

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

Definition at line 89 of file Row_meat.hpp.

00090   : Mat<eT>(X)
00091   {
00092   arma_extra_debug_sigprint();
00093   
00094   arma_debug_check( (Mat<eT>::n_rows > 1), "Row(): incompatible dimensions" );
00095   }

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

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

00103   {
00104   arma_extra_debug_sigprint();
00105   
00106   Mat<eT>::operator=(X);
00107   arma_debug_check( (Mat<eT>::n_rows > 1), "Row(): incompatible dimensions" );
00108   return *this;
00109   }

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

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

00117   {
00118   arma_extra_debug_sigprint();
00119   
00120   Mat<eT>::operator*=(X);
00121   arma_debug_check( (Mat<eT>::n_rows > 1), "Row(): incompatible dimensions" );
00122   return *this;
00123   }

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

construct a row vector from a given auxillary array

Definition at line 130 of file Row_meat.hpp.

References arma_check(), syslib::copy_elem(), and Row< eT >::set_size().

00131   {
00132   arma_extra_debug_sigprint();
00133   
00134   Mat<eT>::set_size(1, aux_length);
00135   arma_check( (Mat<eT>::n_elem != aux_length), "Row(): don't know how to handle the given array" );
00136 
00137   syslib::copy_elem( Mat<eT>::memptr(), aux_mem, Mat<eT>::n_elem );
00138   }

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

00150   : Mat<eT>(A,B)
00151   {
00152   arma_extra_debug_sigprint();
00153   
00154   arma_debug_check( (Mat<eT>::n_rows > 1), "Row(): incompatible dimensions" );
00155   }

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

Definition at line 161 of file Row_meat.hpp.

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

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

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

00175   {
00176   arma_extra_debug_sigprint();
00177   
00178   Mat<eT>::operator=(X);
00179   arma_debug_check( (Mat<eT>::n_rows > 1), "Row(): incompatible dimensions" );
00180   return *this;
00181   }

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

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

00189   {
00190   arma_extra_debug_sigprint();
00191   
00192   Mat<eT>::operator*=(X);
00193   arma_debug_check( (Mat<eT>::n_rows > 1), "Row(): incompatible dimensions" );
00194   return *this;
00195   }

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

construct a row vector from given a diagview

Definition at line 201 of file Row_meat.hpp.

References access::rw().

00202   : Mat<eT>(X)
00203   {
00204   arma_extra_debug_sigprint();
00205   
00206   std::swap( access::rw(Mat<eT>::n_rows), access::rw(Mat<eT>::n_cols) );
00207   arma_debug_check( (Mat<eT>::n_rows > 1), "Row(): incompatible dimensions" );
00208   }

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

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

00217   {
00218   arma_extra_debug_sigprint();
00219   
00220   Mat<eT>::operator=(X);
00221   
00222   //std::swap( access::rw(Mat<eT>::n_rows), access::rw(Mat<eT>::n_cols) );
00223   arma_debug_check( (Mat<eT>::n_rows > 1), "Row(): incompatible dimensions" );
00224   
00225   return *this;
00226   }

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

Definition at line 233 of file Row_meat.hpp.

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

00234   {
00235   arma_extra_debug_sigprint();
00236   
00237   Mat<eT>::operator*=(X);
00238   
00239   arma_debug_check( (Mat<eT>::n_rows > 1), "Row(): incompatible dimensions" );
00240   
00241   return *this;
00242   }

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

Definition at line 249 of file Row_meat.hpp.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Definition at line 335 of file Row_meat.hpp.

Referenced by op_randn::apply(), op_rand::apply(), op_ones_full::apply(), Row< eT >::Row(), and Row< eT >::set_size().

00336   {
00337   arma_extra_debug_sigprint();
00338   
00339   Mat<eT>::set_size(1,in_n_elem);
00340   }

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

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

00348   {
00349   arma_extra_debug_sigprint();
00350   
00351   Mat<eT>::set_size( (std::min)( u32(1), in_n_rows), in_n_cols );
00352   
00353   arma_debug_check( (in_n_rows > 1), "Row::set_size(): incompatible dimensions" );
00354   }

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

Reimplemented from Mat< eT >.

Definition at line 361 of file Row_meat.hpp.

Referenced by op_zeros::apply(), and Row< eT >::zeros().

00362   {
00363   arma_extra_debug_sigprint();
00364   
00365   Mat<eT>::zeros();
00366   }

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

Definition at line 373 of file Row_meat.hpp.

References Row< eT >::zeros().

00374   {
00375   arma_extra_debug_sigprint();
00376   
00377   Mat<eT>::zeros(1,in_n_elem);
00378   }

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

Reimplemented from Mat< eT >.

Definition at line 385 of file Row_meat.hpp.

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

00386   {
00387   arma_extra_debug_sigprint();
00388   
00389   Mat<eT>::zeros( (std::min)( u32(1), in_n_rows), in_n_cols );
00390   arma_debug_check( (in_n_rows > 1), "Row<eT>::zeros(): incompatible dimensions" );
00391   }

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

00399   {
00400   arma_extra_debug_sigprint();
00401   
00402   Mat<eT>::load(name,type);
00403   arma_debug_check( (Mat<eT>::n_rows > 1), "Row(): incompatible dimensions" );
00404   }