Fn_conv_to

Classes

class  conv_to< out_eT >
class  conv_to< Mat< out_eT > >
class  conv_to< Row< out_eT > >
class  conv_to< Col< out_eT > >
class  conv_to< Cube< out_eT > >
class  conv_to< itpp::Mat< out_eT > >
class  conv_to< itpp::Vec< out_eT > >

Functions

template<typename out_eT , typename in_eT >
void copy_complex_elem (out_eT &out, const in_eT &in)
template<typename out_eT , typename in_T >
void copy_complex_elem (out_eT &out, const std::complex< in_T > &in)
template<typename out_T , typename in_T >
void copy_complex_elem (std::complex< out_T > &out, const std::complex< in_T > &in)
static out_eT conv_to::from (const Mat< out_eT > &in)
template<typename in_eT >
static out_eT conv_to::from (const Mat< in_eT > &in)
template<typename in_eT , typename T1 >
static out_eT conv_to::from (const Base< in_eT, T1 > &in)
static out_eT conv_to::from (const Cube< out_eT > &in)
template<typename in_eT >
static out_eT conv_to::from (const Cube< in_eT > &in)
template<typename in_eT , typename T1 >
static out_eT conv_to::from (const BaseCube< in_eT, T1 > &in)
template<typename in_eT >
static Mat< out_eT > conv_to< Mat< out_eT > >::from (const Mat< in_eT > &in)
template<typename in_T >
static Mat< out_eT > conv_to< Mat< out_eT > >::from (const Mat< std::complex< in_T > > &in)
template<typename in_eT , typename T1 >
static Mat< out_eT > conv_to< Mat< out_eT > >::from (const Base< in_eT, T1 > &in)
template<typename in_eT >
static Mat< out_eT > conv_to< Mat< out_eT > >::from (const itpp::Mat< in_eT > &in)
template<typename in_T >
static Mat< out_eT > conv_to< Mat< out_eT > >::from (const itpp::Mat< std::complex< in_T > > &in)
static Row< out_eT > conv_to< Row< out_eT > >::from (const Mat< out_eT > &in)
template<typename in_eT >
static Row< out_eT > conv_to< Row< out_eT > >::from (const Mat< in_eT > &in)
template<typename in_T >
static Row< out_eT > conv_to< Row< out_eT > >::from (const Mat< std::complex< in_T > > &in)
template<typename in_eT , typename T1 >
static Row< out_eT > conv_to< Row< out_eT > >::from (const Base< in_eT, T1 > &in)
template<typename in_eT >
static Row< out_eT > conv_to< Row< out_eT > >::from (const itpp::Vec< in_eT > &in)
template<typename in_T >
static Row< out_eT > conv_to< Row< out_eT > >::from (const itpp::Vec< std::complex< in_T > > &in)
static Col< out_eT > conv_to< Col< out_eT > >::from (const Mat< out_eT > &in)
template<typename in_eT >
static Col< out_eT > conv_to< Col< out_eT > >::from (const Mat< in_eT > &in)
template<typename in_T >
static Col< out_eT > conv_to< Col< out_eT > >::from (const Mat< std::complex< in_T > > &in)
template<typename in_eT , typename T1 >
static Col< out_eT > conv_to< Col< out_eT > >::from (const Base< in_eT, T1 > &in)
template<typename in_eT >
static Col< out_eT > conv_to< Col< out_eT > >::from (const itpp::Vec< in_eT > &in)
template<typename in_T >
static Col< out_eT > conv_to< Col< out_eT > >::from (const itpp::Vec< std::complex< in_T > > &in)
template<typename in_eT >
static Cube< out_eT > conv_to< Cube< out_eT > >::from (const Cube< in_eT > &in)
template<typename in_T >
static Cube< out_eT > conv_to< Cube< out_eT > >::from (const Cube< std::complex< in_T > > &in)
template<typename in_eT , typename T1 >
static Cube< out_eT > conv_to< Cube< out_eT > >::from (const BaseCube< in_eT, T1 > &in)
static itpp::Mat< out_eT > conv_to< itpp::Mat< out_eT > >::from (const Mat< out_eT > &in)
static itpp::Mat< out_eT > conv_to< itpp::Mat< out_eT > >::from (const Col< out_eT > &in)
static itpp::Mat< out_eT > conv_to< itpp::Mat< out_eT > >::from (const Row< out_eT > &in)
template<typename in_eT >
static itpp::Mat< out_eT > conv_to< itpp::Mat< out_eT > >::from (const Mat< in_eT > &in)
template<typename in_eT >
static itpp::Mat< out_eT > conv_to< itpp::Mat< out_eT > >::from (const Col< in_eT > &in)
template<typename in_eT >
static itpp::Mat< out_eT > conv_to< itpp::Mat< out_eT > >::from (const Row< in_eT > &in)
template<typename in_T >
static itpp::Mat< out_eT > conv_to< itpp::Mat< out_eT > >::from (const Mat< std::complex< in_T > > &in)
template<typename in_T >
static itpp::Mat< out_eT > conv_to< itpp::Mat< out_eT > >::from (const Col< std::complex< in_T > > &in)
template<typename in_T >
static itpp::Mat< out_eT > conv_to< itpp::Mat< out_eT > >::from (const Row< std::complex< in_T > > &in)
template<typename in_eT , typename T1 >
static itpp::Mat< out_eT > conv_to< itpp::Mat< out_eT > >::from (const Base< in_eT, T1 > &in)
static itpp::Vec< out_eT > conv_to< itpp::Vec< out_eT > >::from (const Mat< out_eT > &in)
template<typename in_eT >
static itpp::Vec< out_eT > conv_to< itpp::Vec< out_eT > >::from (const Mat< in_eT > &in)
template<typename in_T >
static itpp::Vec< out_eT > conv_to< itpp::Vec< out_eT > >::from (const Mat< std::complex< in_T > > &in)
template<typename in_eT >
static itpp::Vec< out_eT > conv_to< itpp::Vec< out_eT > >::from (const Col< in_eT > &in)
template<typename in_T >
static itpp::Vec< out_eT > conv_to< itpp::Vec< out_eT > >::from (const Col< std::complex< in_T > > &in)
template<typename in_eT >
static itpp::Vec< out_eT > conv_to< itpp::Vec< out_eT > >::from (const Row< in_eT > &in)
template<typename in_T >
static itpp::Vec< out_eT > conv_to< itpp::Vec< out_eT > >::from (const Row< std::complex< in_T > > &in)
template<typename in_eT , typename T1 >
static itpp::Vec< out_eT > conv_to< itpp::Vec< out_eT > >::from (const Base< in_eT, T1 > &in)

Function Documentation

template<typename out_eT , typename in_eT >
void copy_complex_elem ( out_eT &  out,
const in_eT &  in 
) [inline]
template<typename out_eT , typename in_T >
void copy_complex_elem ( out_eT &  out,
const std::complex< in_T > &  in 
) [inline]

Definition at line 39 of file fn_conv_to.hpp.

00040   {
00041   //arma_extra_debug_sigprint();
00042   
00043   out = out_eT( in.real() );
00044   }

template<typename out_T , typename in_T >
void copy_complex_elem ( std::complex< out_T > &  out,
const std::complex< in_T > &  in 
) [inline]

Definition at line 51 of file fn_conv_to.hpp.

00052   {
00053   //arma_extra_debug_sigprint();
00054   
00055   typedef std::complex<out_T> out_eT;
00056   out = out_eT(in);
00057   }

template<typename out_eT >
out_eT conv_to< out_eT >::from ( const Mat< out_eT > &  in  )  [inline, static, inherited]

Definition at line 94 of file fn_conv_to.hpp.

References Mat< eT >::mem, and Mat< eT >::n_elem.

Referenced by conv_to< out_eT >::from().

00095   {
00096   arma_extra_debug_sigprint();
00097   
00098   arma_debug_check( (in.n_elem != 1), "conv_to<>: matrix doesn't have exactly one element" );
00099   
00100   return in.mem[0];
00101   }

template<typename out_eT >
template<typename in_eT >
out_eT conv_to< out_eT >::from ( const Mat< in_eT > &  in  )  [inline, static, inherited]

Definition at line 109 of file fn_conv_to.hpp.

References copy_complex_elem(), Mat< eT >::mem, and Mat< eT >::n_elem.

00110   {
00111   arma_extra_debug_sigprint();
00112   
00113   arma_type_check< is_supported_elem_type<out_eT>::value == false >::apply();
00114   
00115   arma_debug_check( (in.n_elem != 1), "conv_to<>: matrix doesn't have exactly one element" );
00116   
00117   out_eT out;
00118   copy_complex_elem(out, in.mem[0]);
00119   
00120   return out;
00121   }

template<typename out_eT >
template<typename in_eT , typename T1 >
out_eT conv_to< out_eT >::from ( const Base< in_eT, T1 > &  in  )  [inline, static, inherited]

Definition at line 129 of file fn_conv_to.hpp.

References conv_to< out_eT >::from(), and Base< elem_type, derived >::get_ref().

00130   {
00131   arma_extra_debug_sigprint();
00132   
00133   arma_type_check< is_supported_elem_type<out_eT>::value == false >::apply();
00134   
00135   const unwrap<T1> tmp(in.get_ref());
00136 
00137   return conv_to<out_eT>::from( tmp.M );
00138   }

template<typename out_eT >
out_eT conv_to< out_eT >::from ( const Cube< out_eT > &  in  )  [inline, static, inherited]

Definition at line 145 of file fn_conv_to.hpp.

References Cube< eT >::mem, and Cube< eT >::n_elem.

00146   {
00147   arma_extra_debug_sigprint();
00148   
00149   arma_debug_check( (in.n_elem != 1), "conv_to<>: cube doesn't have exactly one element" );
00150   
00151   return in.mem[0];
00152   }

template<typename out_eT >
template<typename in_eT >
out_eT conv_to< out_eT >::from ( const Cube< in_eT > &  in  )  [inline, static, inherited]

Definition at line 160 of file fn_conv_to.hpp.

References copy_complex_elem(), Cube< eT >::mem, and Cube< eT >::n_elem.

00161   {
00162   arma_extra_debug_sigprint();
00163   
00164   arma_type_check< is_supported_elem_type<out_eT>::value == false >::apply();
00165   
00166   arma_debug_check( (in.n_elem != 1), "conv_to<>: cube doesn't have exactly one element" );
00167   
00168   out_eT out;
00169   copy_complex_elem(out, in.mem[0]);
00170   
00171   return out;
00172   }

template<typename out_eT >
template<typename in_eT , typename T1 >
out_eT conv_to< out_eT >::from ( const BaseCube< in_eT, T1 > &  in  )  [inline, static, inherited]

Definition at line 180 of file fn_conv_to.hpp.

References conv_to< out_eT >::from(), and BaseCube< elem_type, derived >::get_ref().

00181   {
00182   arma_extra_debug_sigprint();
00183   
00184   arma_type_check< is_supported_elem_type<out_eT>::value == false >::apply();
00185   
00186   const unwrap_cube<T1> tmp(in.get_ref());
00187 
00188   return conv_to<out_eT>::from( tmp.M );
00189   }

template<typename out_eT >
template<typename in_eT >
Mat< out_eT > conv_to< Mat< out_eT > >::from ( const Mat< in_eT > &  in  )  [inline, static, inherited]

Definition at line 233 of file fn_conv_to.hpp.

References Mat< eT >::memptr(), and Mat< eT >::n_elem.

00234   {
00235   arma_extra_debug_sigprint();
00236   
00237   Mat<out_eT> out(in.n_rows, in.n_cols);
00238   
00239   const in_eT*  in_mem = in.mem;
00240   out_eT*      out_mem = out.memptr();
00241   
00242   for(u32 i=0; i<out.n_elem; ++i)
00243     {
00244     out_mem[i] = out_eT( in_mem[i] );
00245     }
00246   
00247   return out;
00248   }

template<typename out_eT >
template<typename in_T >
Mat< out_eT > conv_to< Mat< out_eT > >::from ( const Mat< std::complex< in_T > > &  in  )  [inline, static, inherited]

Definition at line 256 of file fn_conv_to.hpp.

References copy_complex_elem(), Mat< eT >::memptr(), and Mat< eT >::n_elem.

00257   {
00258   arma_extra_debug_sigprint();
00259   
00260   typedef std::complex<in_T> in_eT; 
00261   
00262   Mat<out_eT> out(in.n_rows, in.n_cols);
00263   
00264   const in_eT*  in_mem = in.mem;
00265   out_eT*      out_mem = out.memptr();
00266   
00267   for(u32 i=0; i<out.n_elem; ++i)
00268     {
00269     copy_complex_elem(out_mem[i], in_mem[i]);
00270     }
00271   
00272   return out;
00273   }

template<typename out_eT >
template<typename in_eT , typename T1 >
Mat< out_eT > conv_to< Mat< out_eT > >::from ( const Base< in_eT, T1 > &  in  )  [inline, static, inherited]

Definition at line 281 of file fn_conv_to.hpp.

00282   {
00283   arma_extra_debug_sigprint();
00284   
00285   const unwrap<T1> tmp(in.get_ref());
00286 
00287   return conv_to< Mat<out_eT> >::from( tmp.M );
00288   }

template<typename out_eT >
template<typename in_eT >
Mat< out_eT > conv_to< Mat< out_eT > >::from ( const itpp::Mat< in_eT > &  in  )  [inline, static, inherited]

Definition at line 296 of file fn_conv_to.hpp.

00297   {
00298   arma_extra_debug_sigprint();
00299   
00300   Mat<out_eT> out(in.rows(), in.cols());
00301   
00302   const in_eT*  in_mem = in._data();
00303   out_eT*      out_mem = out.memptr();
00304   
00305   for(u32 i=0; i<out.n_elem; ++i)
00306     {
00307     out_mem[i] = out_eT( in_mem[i] );
00308     }
00309   
00310   return out;
00311   }

template<typename out_eT >
template<typename in_T >
Mat< out_eT > conv_to< Mat< out_eT > >::from ( const itpp::Mat< std::complex< in_T > > &  in  )  [inline, static, inherited]

Definition at line 319 of file fn_conv_to.hpp.

References copy_complex_elem().

00320   {
00321   arma_extra_debug_sigprint();
00322   
00323   typedef std::complex<in_T> in_eT; 
00324   
00325   Mat<out_eT> out(in.rows(), in.cols());
00326   
00327   const in_eT*  in_mem = in._data();
00328   out_eT*      out_mem = out.memptr();
00329   
00330   for(u32 i=0; i<out.n_elem; ++i)
00331     {
00332     copy_complex_elem(out_mem[i], in_mem[i]);
00333     }
00334   
00335   return out;
00336   }

template<typename out_eT >
Row< out_eT > conv_to< Row< out_eT > >::from ( const Mat< out_eT > &  in  )  [inline, static, inherited]

Definition at line 379 of file fn_conv_to.hpp.

References syslib::copy_elem(), Mat< eT >::memptr(), and Mat< eT >::n_elem.

00380   {
00381   arma_extra_debug_sigprint();
00382   
00383   arma_debug_check( (in.n_rows > 1), "conv_to<>: given matrix has more than one row");
00384   Row<out_eT> out(in.n_cols);
00385   
00386   syslib::copy_elem(out.memptr(), in.mem, out.n_elem);
00387   
00388   
00389   return out;
00390   }

template<typename out_eT >
template<typename in_eT >
Row< out_eT > conv_to< Row< out_eT > >::from ( const Mat< in_eT > &  in  )  [inline, static, inherited]

Definition at line 398 of file fn_conv_to.hpp.

References Mat< eT >::memptr(), and Mat< eT >::n_elem.

00399   {
00400   arma_extra_debug_sigprint();
00401   
00402   arma_debug_check( (in.n_rows > 1), "conv_to<>: given matrix has more than one row");
00403   Row<out_eT> out(in.n_cols);
00404   
00405   const in_eT*  in_mem = in.mem;
00406   out_eT*      out_mem = out.memptr();
00407   
00408   for(u32 i=0; i<out.n_elem; ++i)
00409     {
00410     out_mem[i] = out_eT( in_mem[i] );
00411     }
00412   
00413   return out;
00414   }

template<typename out_eT >
template<typename in_T >
Row< out_eT > conv_to< Row< out_eT > >::from ( const Mat< std::complex< in_T > > &  in  )  [inline, static, inherited]

Definition at line 422 of file fn_conv_to.hpp.

References copy_complex_elem(), Mat< eT >::memptr(), and Mat< eT >::n_elem.

00423   {
00424   arma_extra_debug_sigprint();
00425   
00426   typedef std::complex<in_T> in_eT; 
00427   
00428   arma_debug_check( (in.n_rows > 1), "conv_to<>: given matrix has more than one row");
00429   Row<out_eT> out(in.n_cols);
00430   
00431   const in_eT*  in_mem = in.mem;
00432   out_eT*      out_mem = out.memptr();
00433   
00434   for(u32 i=0; i<out.n_elem; ++i)
00435     {
00436     copy_complex_elem(out_mem[i], in_mem[i]);
00437     }
00438   
00439   return out;
00440   }

template<typename out_eT >
template<typename in_eT , typename T1 >
Row< out_eT > conv_to< Row< out_eT > >::from ( const Base< in_eT, T1 > &  in  )  [inline, static, inherited]

Definition at line 448 of file fn_conv_to.hpp.

00449   {
00450   arma_extra_debug_sigprint();
00451 
00452   const unwrap<T1> tmp(in.get_ref());
00453   
00454   return conv_to< Row<out_eT> >::from( tmp.M );
00455   }

template<typename out_eT >
template<typename in_eT >
Row< out_eT > conv_to< Row< out_eT > >::from ( const itpp::Vec< in_eT > &  in  )  [inline, static, inherited]

Definition at line 463 of file fn_conv_to.hpp.

00464   {
00465   arma_extra_debug_sigprint();
00466   
00467   Row<out_eT> out(in.length());
00468   
00469   const in_eT*  in_mem = in._data();
00470   out_eT*      out_mem = out.memptr();
00471   
00472   for(u32 i=0; i<out.n_elem; ++i)
00473     {
00474     out_mem[i] = out_eT( in_mem[i] );
00475     }
00476   
00477   return out;
00478   }

template<typename out_eT >
template<typename in_T >
Row< out_eT > conv_to< Row< out_eT > >::from ( const itpp::Vec< std::complex< in_T > > &  in  )  [inline, static, inherited]

Definition at line 486 of file fn_conv_to.hpp.

References copy_complex_elem().

00487   {
00488   arma_extra_debug_sigprint();
00489   
00490   typedef std::complex<in_T> in_eT; 
00491   
00492   Row<out_eT> out(in.length());
00493   
00494   const in_eT*  in_mem = in._data();
00495   out_eT*      out_mem = out.memptr();
00496   
00497   for(u32 i=0; i<out.n_elem; ++i)
00498     {
00499     copy_complex_elem(out_mem[i], in_mem[i]);
00500     }
00501   
00502   return out;
00503   }

template<typename out_eT >
Col< out_eT > conv_to< Col< out_eT > >::from ( const Mat< out_eT > &  in  )  [inline, static, inherited]

Definition at line 606 of file fn_conv_to.hpp.

References syslib::copy_elem(), Mat< eT >::memptr(), and Mat< eT >::n_elem.

00607   {
00608   arma_extra_debug_sigprint();
00609   
00610   arma_debug_check( (in.n_cols > 1), "conv_to<>: given matrix has more than one column");
00611   Col<out_eT> out(in.n_rows);
00612   
00613   syslib::copy_elem(out.memptr(), in.mem, out.n_elem);
00614   
00615   return out;
00616   }

template<typename out_eT >
template<typename in_eT >
Col< out_eT > conv_to< Col< out_eT > >::from ( const Mat< in_eT > &  in  )  [inline, static, inherited]

Definition at line 624 of file fn_conv_to.hpp.

References Mat< eT >::memptr(), and Mat< eT >::n_elem.

00625   {
00626   arma_extra_debug_sigprint();
00627   
00628   arma_debug_check( (in.n_cols > 1), "conv_to<>: given matrix has more than one column");
00629   Col<out_eT> out(in.n_rows);
00630   
00631   const in_eT*  in_mem = in.mem;
00632   out_eT*      out_mem = out.memptr();
00633   
00634   for(u32 i=0; i<out.n_elem; ++i)
00635     {
00636     out_mem[i] = out_eT( in_mem[i] );
00637     }
00638   
00639   return out;
00640   }

template<typename out_eT >
template<typename in_T >
Col< out_eT > conv_to< Col< out_eT > >::from ( const Mat< std::complex< in_T > > &  in  )  [inline, static, inherited]

Definition at line 648 of file fn_conv_to.hpp.

References copy_complex_elem(), Mat< eT >::memptr(), and Mat< eT >::n_elem.

00649   {
00650   arma_extra_debug_sigprint();
00651   
00652   typedef std::complex<in_T> in_eT; 
00653   
00654   arma_debug_check( (in.n_cols > 1), "conv_to<>: given matrix has more than one column");
00655   Col<out_eT> out(in.n_rows);
00656   
00657   const in_eT*  in_mem = in.mem;
00658   out_eT*      out_mem = out.memptr();
00659   
00660   for(u32 i=0; i<out.n_elem; ++i)
00661     {
00662     copy_complex_elem(out_mem[i], in_mem[i]);
00663     }
00664   
00665   return out;
00666   }

template<typename out_eT >
template<typename in_eT , typename T1 >
Col< out_eT > conv_to< Col< out_eT > >::from ( const Base< in_eT, T1 > &  in  )  [inline, static, inherited]

Definition at line 674 of file fn_conv_to.hpp.

00675   {
00676   arma_extra_debug_sigprint();
00677   
00678   const unwrap<T1> tmp(in.get_ref());
00679   
00680   return conv_to< Col<out_eT> >::from( tmp.M );
00681   }

template<typename out_eT >
template<typename in_eT >
Col< out_eT > conv_to< Col< out_eT > >::from ( const itpp::Vec< in_eT > &  in  )  [inline, static, inherited]

Definition at line 689 of file fn_conv_to.hpp.

00690   {
00691   arma_extra_debug_sigprint();
00692   
00693   Col<out_eT> out(in.length());
00694   
00695   const in_eT*  in_mem = in._data();
00696   out_eT*      out_mem = out.memptr();
00697   
00698   for(u32 i=0; i<out.n_elem; ++i)
00699     {
00700     out_mem[i] = out_eT( in_mem[i] );
00701     }
00702   
00703   return out;
00704   }

template<typename out_eT >
template<typename in_T >
Col< out_eT > conv_to< Col< out_eT > >::from ( const itpp::Vec< std::complex< in_T > > &  in  )  [inline, static, inherited]

Definition at line 712 of file fn_conv_to.hpp.

References copy_complex_elem().

00713   {
00714   arma_extra_debug_sigprint();
00715   
00716   typedef std::complex<in_T> in_eT; 
00717   
00718   Col<out_eT> out(in.length());
00719   
00720   const in_eT*  in_mem = in._data();
00721   out_eT*      out_mem = out.memptr();
00722   
00723   for(u32 i=0; i<out.n_elem; ++i)
00724     {
00725     copy_complex_elem(out_mem[i], in_mem[i]);
00726     }
00727   
00728   return out;
00729   }

template<typename out_eT >
template<typename in_eT >
Cube< out_eT > conv_to< Cube< out_eT > >::from ( const Cube< in_eT > &  in  )  [inline, static, inherited]

Definition at line 818 of file fn_conv_to.hpp.

References Cube< eT >::memptr(), and Cube< eT >::n_elem.

00819   {
00820   arma_extra_debug_sigprint();
00821   
00822   Cube<out_eT> out(in.n_rows, in.n_cols, in.n_slices);
00823   
00824   const in_eT*  in_mem = in.mem;
00825   out_eT*      out_mem = out.memptr();
00826   
00827   for(u32 i=0; i<out.n_elem; ++i)
00828     {
00829     out_mem[i] = out_eT( in_mem[i] );
00830     }
00831   
00832   return out;
00833   }

template<typename out_eT >
template<typename in_T >
Cube< out_eT > conv_to< Cube< out_eT > >::from ( const Cube< std::complex< in_T > > &  in  )  [inline, static, inherited]

Definition at line 841 of file fn_conv_to.hpp.

References copy_complex_elem(), Cube< eT >::memptr(), and Cube< eT >::n_elem.

00842   {
00843   arma_extra_debug_sigprint();
00844   
00845   typedef std::complex<in_T> in_eT; 
00846   
00847   Cube<out_eT> out(in.n_rows, in.n_cols, in.n_slices);
00848   
00849   const in_eT*  in_mem = in.mem;
00850   out_eT*      out_mem = out.memptr();
00851   
00852   for(u32 i=0; i<out.n_elem; ++i)
00853     {
00854     copy_complex_elem(out_mem[i], in_mem[i]);
00855     }
00856   
00857   return out;
00858   }

template<typename out_eT >
template<typename in_eT , typename T1 >
Cube< out_eT > conv_to< Cube< out_eT > >::from ( const BaseCube< in_eT, T1 > &  in  )  [inline, static, inherited]

Definition at line 866 of file fn_conv_to.hpp.

00867   {
00868   arma_extra_debug_sigprint();
00869   
00870   const unwrap_cube<T1> tmp(in.get_ref());
00871 
00872   return conv_to< Mat<out_eT> >::from( tmp.M );
00873   }

template<typename out_eT >
itpp::Mat< out_eT > conv_to< itpp::Mat< out_eT > >::from ( const Mat< out_eT > &  in  )  [inline, static, inherited]

Definition at line 927 of file fn_conv_to.hpp.

References itpp::Mat< eT >::_data(), and syslib::copy_elem().

00928   {
00929   arma_extra_debug_sigprint();
00930   
00931   itpp::Mat<out_eT> out(in.n_rows, in.n_cols);
00932   
00933   syslib::copy_elem(out._data(), in.mem, in.n_elem);
00934   
00935   return out;
00936   }

template<typename out_eT >
itpp::Mat< out_eT > conv_to< itpp::Mat< out_eT > >::from ( const Col< out_eT > &  in  )  [inline, static, inherited]

Definition at line 943 of file fn_conv_to.hpp.

00944   {
00945   arma_extra_debug_sigprint();
00946   
00947   return conv_to< itpp::Mat<out_eT> >::from( reinterpret_cast<const Mat<out_eT>& >(in) );
00948   }

template<typename out_eT >
itpp::Mat< out_eT > conv_to< itpp::Mat< out_eT > >::from ( const Row< out_eT > &  in  )  [inline, static, inherited]

Definition at line 955 of file fn_conv_to.hpp.

00956   {
00957   arma_extra_debug_sigprint();
00958   
00959   return conv_to< itpp::Mat<out_eT> >::from( reinterpret_cast<const Mat<out_eT>& >(in) );
00960   }

template<typename out_eT >
template<typename in_eT >
itpp::Mat< out_eT > conv_to< itpp::Mat< out_eT > >::from ( const Mat< in_eT > &  in  )  [inline, static, inherited]

Definition at line 968 of file fn_conv_to.hpp.

References itpp::Mat< eT >::_data().

00969   {
00970   arma_extra_debug_sigprint();
00971   
00972   itpp::Mat<out_eT> out(in.n_rows, in.n_cols);
00973   
00974   const in_eT* in_mem = in.memptr();
00975   out_eT*     out_mem = out._data();
00976   
00977   for(u32 i=0; i<in.n_elem; ++i)
00978     {
00979     out_mem[i] = out_eT( in_mem[i] );
00980     }
00981   
00982   return out;
00983   }

template<typename out_eT >
template<typename in_eT >
itpp::Mat< out_eT > conv_to< itpp::Mat< out_eT > >::from ( const Col< in_eT > &  in  )  [inline, static, inherited]

Definition at line 991 of file fn_conv_to.hpp.

00992   {
00993   arma_extra_debug_sigprint();
00994   
00995   return conv_to< itpp::Mat<out_eT> >::from( reinterpret_cast<const Mat<in_eT>& >(in) );
00996   }

template<typename out_eT >
template<typename in_eT >
itpp::Mat< out_eT > conv_to< itpp::Mat< out_eT > >::from ( const Row< in_eT > &  in  )  [inline, static, inherited]

Definition at line 1004 of file fn_conv_to.hpp.

01005   {
01006   arma_extra_debug_sigprint();
01007   
01008   return conv_to< itpp::Mat<out_eT> >::from( reinterpret_cast<const Mat<in_eT>& >(in) );
01009   }

template<typename out_eT >
template<typename in_T >
itpp::Mat< out_eT > conv_to< itpp::Mat< out_eT > >::from ( const Mat< std::complex< in_T > > &  in  )  [inline, static, inherited]

Definition at line 1017 of file fn_conv_to.hpp.

References itpp::Mat< eT >::_data(), and copy_complex_elem().

01018   {
01019   arma_extra_debug_sigprint();
01020   
01021   typedef std::complex<in_T> in_eT; 
01022   
01023   itpp::Mat<out_eT> out(in.n_rows, in.n_cols);
01024   
01025   const in_eT* in_mem = in.memptr();
01026   out_eT*     out_mem = out._data();
01027   
01028   for(u32 i=0; i<in.n_elem; ++i)
01029     {
01030     copy_complex_elem(out_mem[i], in_mem[i]);
01031     }
01032   
01033   return out;
01034   }

template<typename out_eT >
template<typename in_T >
itpp::Mat< out_eT > conv_to< itpp::Mat< out_eT > >::from ( const Col< std::complex< in_T > > &  in  )  [inline, static, inherited]

Definition at line 1042 of file fn_conv_to.hpp.

01043   {
01044   arma_extra_debug_sigprint();
01045   
01046   return conv_to< itpp::Mat<out_eT> >::from( reinterpret_cast<const Mat< std::complex<in_T> >& >(in) );
01047   }

template<typename out_eT >
template<typename in_T >
itpp::Mat< out_eT > conv_to< itpp::Mat< out_eT > >::from ( const Row< std::complex< in_T > > &  in  )  [inline, static, inherited]

Definition at line 1055 of file fn_conv_to.hpp.

01056   {
01057   arma_extra_debug_sigprint();
01058   
01059   return conv_to< itpp::Mat<out_eT> >::from( reinterpret_cast<const Mat< std::complex<in_T> >& >(in) );
01060   }

template<typename out_eT >
template<typename in_eT , typename T1 >
itpp::Mat< out_eT > conv_to< itpp::Mat< out_eT > >::from ( const Base< in_eT, T1 > &  in  )  [inline, static, inherited]

Definition at line 1068 of file fn_conv_to.hpp.

01069   {
01070   arma_extra_debug_sigprint();
01071   
01072   const unwrap<T1> tmp(in.get_ref());
01073 
01074   return conv_to< itpp::Mat<out_eT> >::from( tmp.M );
01075   }

template<typename out_eT >
itpp::Vec< out_eT > conv_to< itpp::Vec< out_eT > >::from ( const Mat< out_eT > &  in  )  [inline, static, inherited]

Definition at line 1123 of file fn_conv_to.hpp.

References itpp::Vec< eT >::_data(), and syslib::copy_elem().

01124   {
01125   arma_extra_debug_sigprint();
01126   
01127   arma_debug_check( ( (in.n_cols != 1) && (in.n_rows != 1) ), "conv_to<>: given matrix can't be interpreted as a vector");
01128   
01129   itpp::Vec<out_eT> out(in.n_elem);
01130   
01131   syslib::copy_elem(out._data(), in.mem, in.n_elem);
01132   
01133   return out;
01134   }

template<typename out_eT >
template<typename in_eT >
itpp::Vec< out_eT > conv_to< itpp::Vec< out_eT > >::from ( const Mat< in_eT > &  in  )  [inline, static, inherited]

Definition at line 1142 of file fn_conv_to.hpp.

References itpp::Vec< eT >::_data().

01143   {
01144   arma_extra_debug_sigprint();
01145   
01146   arma_debug_check( ( (in.n_cols != 1) && (in.n_rows != 1) ), "conv_to<>: given matrix can't be interpreted as a vector");
01147   itpp::Vec<out_eT> out(in.n_elem);
01148   
01149   const in_eT*  in_mem = in.memptr();
01150   out_eT*      out_mem = out._data();
01151   
01152   for(u32 i=0; i<in.n_elem; ++i)
01153     {
01154     out_mem[i] = out_eT( in_mem[i] );
01155     }
01156   
01157   return out;
01158   }

template<typename out_eT >
template<typename in_T >
itpp::Vec< out_eT > conv_to< itpp::Vec< out_eT > >::from ( const Mat< std::complex< in_T > > &  in  )  [inline, static, inherited]

Definition at line 1166 of file fn_conv_to.hpp.

References itpp::Vec< eT >::_data(), and copy_complex_elem().

01167   {
01168   arma_extra_debug_sigprint();
01169   
01170   typedef std::complex<in_T> in_eT; 
01171   
01172   arma_debug_check( ( (in.n_cols != 1) && (in.n_rows != 1) ), "conv_to<>: given matrix can't be interpreted as a vector");
01173   
01174   itpp::Vec<out_eT> out(in.n_elem);
01175   
01176   const in_eT*  in_mem = in.memptr();
01177   out_eT*      out_mem = out._data();
01178   
01179   for(u32 i=0; i<in.n_elem; ++i)
01180     {
01181     copy_complex_elem(out_mem[i], in_mem[i]);
01182     }
01183   
01184   return out;
01185   }

template<typename out_eT >
template<typename in_eT >
itpp::Vec< out_eT > conv_to< itpp::Vec< out_eT > >::from ( const Col< in_eT > &  in  )  [inline, static, inherited]

Definition at line 1193 of file fn_conv_to.hpp.

References itpp::Vec< eT >::_data().

01194   {
01195   arma_extra_debug_sigprint();
01196   
01197   itpp::Vec<out_eT> out(in.n_elem);
01198   
01199   const in_eT*  in_mem = in.memptr();
01200   out_eT*      out_mem = out._data();
01201   
01202   for(u32 i=0; i<in.n_elem; ++i)
01203     {
01204     out_mem[i] = out_eT( in_mem[i] );
01205     }
01206   
01207   return out;
01208   }

template<typename out_eT >
template<typename in_T >
itpp::Vec< out_eT > conv_to< itpp::Vec< out_eT > >::from ( const Col< std::complex< in_T > > &  in  )  [inline, static, inherited]

Definition at line 1216 of file fn_conv_to.hpp.

References itpp::Vec< eT >::_data(), and copy_complex_elem().

01217   {
01218   arma_extra_debug_sigprint();
01219   
01220   typedef std::complex<in_T> in_eT; 
01221   
01222   itpp::Vec<out_eT> out(in.n_elem);
01223   
01224   const in_eT*  in_mem = in.memptr();
01225   out_eT*      out_mem = out._data();
01226   
01227   for(u32 i=0; i<in.n_elem; ++i)
01228     {
01229     copy_complex_elem(out_mem[i], in_mem[i]);
01230     }
01231   
01232   return out;
01233   }

template<typename out_eT >
template<typename in_eT >
itpp::Vec< out_eT > conv_to< itpp::Vec< out_eT > >::from ( const Row< in_eT > &  in  )  [inline, static, inherited]

Definition at line 1241 of file fn_conv_to.hpp.

References itpp::Vec< eT >::_data().

01242   {
01243   arma_extra_debug_sigprint();
01244   
01245   itpp::Vec<out_eT> out(in.n_elem);
01246   
01247   const in_eT*  in_mem = in.memptr();
01248   out_eT*      out_mem = out._data();
01249   
01250   for(u32 i=0; i<in.n_elem; ++i)
01251     {
01252     out_mem[i] = out_eT( in_mem[i] );
01253     }
01254   
01255   return out;
01256   }

template<typename out_eT >
template<typename in_T >
itpp::Vec< out_eT > conv_to< itpp::Vec< out_eT > >::from ( const Row< std::complex< in_T > > &  in  )  [inline, static, inherited]

Definition at line 1264 of file fn_conv_to.hpp.

References itpp::Vec< eT >::_data(), and copy_complex_elem().

01265   {
01266   arma_extra_debug_sigprint();
01267   
01268   typedef std::complex<in_T> in_eT; 
01269   
01270   itpp::Vec<out_eT> out(in.n_elem);
01271   
01272   const in_eT*  in_mem = in.memptr();
01273   out_eT*      out_mem = out._data();
01274   
01275   for(u32 i=0; i<in.n_elem; ++i)
01276     {
01277     copy_complex_elem(out_mem[i], in_mem[i]);
01278     }
01279   
01280   return out;
01281   }

template<typename out_eT >
template<typename in_eT , typename T1 >
itpp::Vec< out_eT > conv_to< itpp::Vec< out_eT > >::from ( const Base< in_eT, T1 > &  in  )  [inline, static, inherited]

Definition at line 1289 of file fn_conv_to.hpp.

01290   {
01291   arma_extra_debug_sigprint();
01292   
01293   const unwrap<T1> tmp(in.get_ref());
01294 
01295   return conv_to< itpp::Vec<out_eT> >::from( tmp.M );
01296   }