fn_conv_to.hpp

Go to the documentation of this file.
00001 // Copyright (C) 2010 NICTA and the authors listed below
00002 // http://nicta.com.au
00003 // 
00004 // Authors:
00005 // - Conrad Sanderson (conradsand at ieee dot org)
00006 // 
00007 // This file is part of the Armadillo C++ library.
00008 // It is provided without any warranty of fitness
00009 // for any purpose. You can redistribute this file
00010 // and/or modify it under the terms of the GNU
00011 // Lesser General Public License (LGPL) as published
00012 // by the Free Software Foundation, either version 3
00013 // of the License or (at your option) any later version.
00014 // (see http://www.opensource.org/licenses for more info)
00015 
00016 
00017 //! \addtogroup fn_conv_to
00018 //! @{
00019 
00020 
00021 //
00022 //
00023 // conversions between various mat types
00024 
00025 template<typename out_eT, typename in_eT>
00026 arma_inline
00027 void
00028 copy_complex_elem(out_eT& out, const in_eT& in)
00029   {
00030   //arma_extra_debug_sigprint();
00031   
00032   out = out_eT(in);
00033   }
00034 
00035 
00036 
00037 template<typename out_eT, typename in_T>
00038 arma_inline
00039 void
00040 copy_complex_elem(out_eT& out, const std::complex<in_T>& in)
00041   {
00042   //arma_extra_debug_sigprint();
00043   
00044   out = out_eT( in.real() );
00045   }
00046 
00047 
00048 
00049 template<typename out_T, typename in_T>
00050 arma_inline
00051 void
00052 copy_complex_elem(std::complex<out_T>& out, const std::complex<in_T>& in)
00053   {
00054   //arma_extra_debug_sigprint();
00055   
00056   typedef std::complex<out_T> out_eT;
00057   out = out_eT(in);
00058   }
00059 
00060 
00061 
00062 //
00063 // scalar family
00064 
00065 
00066 template<typename out_eT>
00067 class conv_to
00068   {
00069   public:
00070   
00071   inline static out_eT from(const Mat< out_eT >& in);
00072 
00073   template<typename in_eT>
00074   inline static out_eT from(const Mat< in_eT >& in);
00075 
00076   template<typename in_eT, typename T1>
00077   inline static out_eT from(const Base<in_eT,T1>& in);
00078 
00079   //
00080 
00081   inline static out_eT from(const Cube< out_eT >& in);
00082 
00083   template<typename in_eT>
00084   inline static out_eT from(const Cube< in_eT >& in);
00085 
00086   template<typename in_eT, typename T1>
00087   inline static out_eT from(const BaseCube<in_eT,T1>& in);
00088   };
00089 
00090 
00091 
00092 template<typename out_eT>
00093 inline
00094 out_eT
00095 conv_to<out_eT>::from(const Mat<out_eT>& in)
00096   {
00097   arma_extra_debug_sigprint();
00098   
00099   arma_debug_check( (in.n_elem != 1), "conv_to<>: matrix doesn't have exactly one element" );
00100   
00101   return in.mem[0];
00102   }
00103 
00104 
00105 
00106 template<typename out_eT>
00107 template<typename in_eT>
00108 inline
00109 out_eT
00110 conv_to<out_eT>::from(const Mat<in_eT>& in)
00111   {
00112   arma_extra_debug_sigprint();
00113   
00114   arma_type_check< is_supported_elem_type<out_eT>::value == false >::apply();
00115   
00116   arma_debug_check( (in.n_elem != 1), "conv_to<>: matrix doesn't have exactly one element" );
00117   
00118   out_eT out;
00119   copy_complex_elem(out, in.mem[0]);
00120   
00121   return out;
00122   }
00123 
00124 
00125 
00126 template<typename out_eT>
00127 template<typename in_eT, typename T1>
00128 inline
00129 out_eT
00130 conv_to<out_eT>::from(const Base<in_eT,T1>& in)
00131   {
00132   arma_extra_debug_sigprint();
00133   
00134   arma_type_check< is_supported_elem_type<out_eT>::value == false >::apply();
00135   
00136   const unwrap<T1> tmp(in.get_ref());
00137 
00138   return conv_to<out_eT>::from( tmp.M );
00139   }
00140 
00141 
00142 
00143 template<typename out_eT>
00144 inline
00145 out_eT
00146 conv_to<out_eT>::from(const Cube<out_eT>& in)
00147   {
00148   arma_extra_debug_sigprint();
00149   
00150   arma_debug_check( (in.n_elem != 1), "conv_to<>: cube doesn't have exactly one element" );
00151   
00152   return in.mem[0];
00153   }
00154 
00155 
00156 
00157 template<typename out_eT>
00158 template<typename in_eT>
00159 inline
00160 out_eT
00161 conv_to<out_eT>::from(const Cube<in_eT>& in)
00162   {
00163   arma_extra_debug_sigprint();
00164   
00165   arma_type_check< is_supported_elem_type<out_eT>::value == false >::apply();
00166   
00167   arma_debug_check( (in.n_elem != 1), "conv_to<>: cube doesn't have exactly one element" );
00168   
00169   out_eT out;
00170   copy_complex_elem(out, in.mem[0]);
00171   
00172   return out;
00173   }
00174 
00175 
00176 
00177 template<typename out_eT>
00178 template<typename in_eT, typename T1>
00179 inline
00180 out_eT
00181 conv_to<out_eT>::from(const BaseCube<in_eT,T1>& in)
00182   {
00183   arma_extra_debug_sigprint();
00184   
00185   arma_type_check< is_supported_elem_type<out_eT>::value == false >::apply();
00186   
00187   const unwrap_cube<T1> tmp(in.get_ref());
00188 
00189   return conv_to<out_eT>::from( tmp.M );
00190   }
00191 
00192 
00193 
00194 //
00195 //
00196 // Mat family
00197 
00198 template<typename out_eT>
00199 class conv_to< Mat<out_eT> >
00200   {
00201   public:
00202   
00203   template<typename in_eT>
00204   inline static Mat<out_eT> from(const Mat< in_eT >& in);
00205   
00206   template<typename in_T>
00207   inline static Mat<out_eT> from(const Mat< std::complex<in_T> >& in);
00208   
00209   template<typename in_eT, typename T1>
00210   inline static Mat<out_eT> from(const Base<in_eT,T1>& in);
00211   
00212   
00213   
00214 //   template<typename in_eT>
00215 //   inline static Mat<out_eT> from(const std::vector< in_eT >& in);
00216 //   
00217 //   template<typename in_eT>
00218 //   inline static Mat<out_eT> from(const std::vector< std::complex<in_eT> >& in);
00219   
00220   
00221   template<typename in_eT>
00222   inline static Mat<out_eT> from(const itpp::Mat< in_eT >& in);
00223   
00224   template<typename in_T>
00225   inline static Mat<out_eT> from(const itpp::Mat< std::complex<in_T> >& in);
00226   };
00227 
00228 
00229 
00230 template<typename out_eT>
00231 template<typename in_eT>
00232 inline
00233 Mat<out_eT>
00234 conv_to< Mat<out_eT> >::from(const Mat<in_eT>& in)
00235   {
00236   arma_extra_debug_sigprint();
00237   
00238   Mat<out_eT> out(in.n_rows, in.n_cols);
00239   
00240   const in_eT*  in_mem = in.mem;
00241   out_eT*      out_mem = out.memptr();
00242   
00243   for(u32 i=0; i<out.n_elem; ++i)
00244     {
00245     out_mem[i] = out_eT( in_mem[i] );
00246     }
00247   
00248   return out;
00249   }
00250 
00251 
00252 
00253 template<typename out_eT>
00254 template<typename in_T>
00255 inline
00256 Mat<out_eT>
00257 conv_to< Mat<out_eT> >::from(const Mat< std::complex<in_T> >& in)
00258   {
00259   arma_extra_debug_sigprint();
00260   
00261   typedef std::complex<in_T> in_eT; 
00262   
00263   Mat<out_eT> out(in.n_rows, in.n_cols);
00264   
00265   const in_eT*  in_mem = in.mem;
00266   out_eT*      out_mem = out.memptr();
00267   
00268   for(u32 i=0; i<out.n_elem; ++i)
00269     {
00270     copy_complex_elem(out_mem[i], in_mem[i]);
00271     }
00272   
00273   return out;
00274   }
00275 
00276 
00277 
00278 template<typename out_eT>
00279 template<typename in_eT, typename T1>
00280 inline
00281 Mat<out_eT>
00282 conv_to< Mat<out_eT> >::from(const Base<in_eT,T1>& in)
00283   {
00284   arma_extra_debug_sigprint();
00285   
00286   const unwrap<T1> tmp(in.get_ref());
00287 
00288   return conv_to< Mat<out_eT> >::from( tmp.M );
00289   }
00290 
00291 
00292 
00293 template<typename out_eT>
00294 template<typename in_eT>
00295 inline
00296 Mat<out_eT>
00297 conv_to< Mat<out_eT> >::from(const itpp::Mat<in_eT>& in)
00298   {
00299   arma_extra_debug_sigprint();
00300   
00301   Mat<out_eT> out(in.rows(), in.cols());
00302   
00303   const in_eT*  in_mem = in._data();
00304   out_eT*      out_mem = out.memptr();
00305   
00306   for(u32 i=0; i<out.n_elem; ++i)
00307     {
00308     out_mem[i] = out_eT( in_mem[i] );
00309     }
00310   
00311   return out;
00312   }
00313 
00314 
00315 
00316 template<typename out_eT>
00317 template<typename in_T>
00318 inline
00319 Mat<out_eT>
00320 conv_to< Mat<out_eT> >::from(const itpp::Mat< std::complex<in_T> >& in)
00321   {
00322   arma_extra_debug_sigprint();
00323   
00324   typedef std::complex<in_T> in_eT; 
00325   
00326   Mat<out_eT> out(in.rows(), in.cols());
00327   
00328   const in_eT*  in_mem = in._data();
00329   out_eT*      out_mem = out.memptr();
00330   
00331   for(u32 i=0; i<out.n_elem; ++i)
00332     {
00333     copy_complex_elem(out_mem[i], in_mem[i]);
00334     }
00335   
00336   return out;
00337   }
00338 
00339 
00340 
00341 //
00342 //
00343 // Row family
00344 
00345 template<typename out_eT>
00346 class conv_to< Row<out_eT> >
00347   {
00348   public:
00349   
00350   inline static Row<out_eT> from(const Mat< out_eT >& in);
00351   
00352   template<typename in_eT>
00353   inline static Row<out_eT> from(const Mat< in_eT >& in);
00354   
00355   template<typename in_T>  
00356   inline static Row<out_eT> from(const Mat< std::complex<in_T> >& in);
00357   
00358   template<typename in_eT, typename T1>
00359   inline static Row<out_eT> from(const Base<in_eT,T1>& in);
00360   
00361   
00362   
00363   template<typename in_eT>
00364   inline static Row<out_eT> from(const itpp::Vec< in_eT >& in);
00365   
00366   template<typename in_T>  
00367   inline static Row<out_eT> from(const itpp::Vec< std::complex<in_T> >& in);
00368   
00369   //inline static Row<out_eT> from(const Col< out_eT >& in);
00370   //template<typename in_eT> inline static Row<out_eT> from(const Col< in_eT >& in);
00371   //template<typename in_T>  inline static Row<out_eT> from(const Col< std::complex<in_T> >& in);
00372   
00373   };
00374 
00375 
00376 
00377 template<typename out_eT>
00378 inline
00379 Row<out_eT>
00380 conv_to< Row<out_eT> >::from(const Mat<out_eT>& in)
00381   {
00382   arma_extra_debug_sigprint();
00383   
00384   arma_debug_check( (in.n_rows > 1), "conv_to<>: given matrix has more than one row");
00385   Row<out_eT> out(in.n_cols);
00386   
00387   syslib::copy_elem(out.memptr(), in.mem, out.n_elem);
00388   
00389   
00390   return out;
00391   }
00392 
00393 
00394 
00395 template<typename out_eT>
00396 template<typename in_eT>
00397 inline
00398 Row<out_eT>
00399 conv_to< Row<out_eT> >::from(const Mat<in_eT>& in)
00400   {
00401   arma_extra_debug_sigprint();
00402   
00403   arma_debug_check( (in.n_rows > 1), "conv_to<>: given matrix has more than one row");
00404   Row<out_eT> out(in.n_cols);
00405   
00406   const in_eT*  in_mem = in.mem;
00407   out_eT*      out_mem = out.memptr();
00408   
00409   for(u32 i=0; i<out.n_elem; ++i)
00410     {
00411     out_mem[i] = out_eT( in_mem[i] );
00412     }
00413   
00414   return out;
00415   }
00416 
00417 
00418 
00419 template<typename out_eT>
00420 template<typename in_T>
00421 inline
00422 Row<out_eT>
00423 conv_to< Row<out_eT> >::from(const Mat< std::complex<in_T> >& in)
00424   {
00425   arma_extra_debug_sigprint();
00426   
00427   typedef std::complex<in_T> in_eT; 
00428   
00429   arma_debug_check( (in.n_rows > 1), "conv_to<>: given matrix has more than one row");
00430   Row<out_eT> out(in.n_cols);
00431   
00432   const in_eT*  in_mem = in.mem;
00433   out_eT*      out_mem = out.memptr();
00434   
00435   for(u32 i=0; i<out.n_elem; ++i)
00436     {
00437     copy_complex_elem(out_mem[i], in_mem[i]);
00438     }
00439   
00440   return out;
00441   }
00442 
00443 
00444 
00445 template<typename out_eT>
00446 template<typename in_eT, typename T1>
00447 inline
00448 Row<out_eT>
00449 conv_to< Row<out_eT> >::from(const Base<in_eT,T1>& in)
00450   {
00451   arma_extra_debug_sigprint();
00452 
00453   const unwrap<T1> tmp(in.get_ref());
00454   
00455   return conv_to< Row<out_eT> >::from( tmp.M );
00456   }
00457 
00458 
00459 
00460 template<typename out_eT>
00461 template<typename in_eT>
00462 inline
00463 Row<out_eT>
00464 conv_to< Row<out_eT> >::from(const itpp::Vec<in_eT>& in)
00465   {
00466   arma_extra_debug_sigprint();
00467   
00468   Row<out_eT> out(in.length());
00469   
00470   const in_eT*  in_mem = in._data();
00471   out_eT*      out_mem = out.memptr();
00472   
00473   for(u32 i=0; i<out.n_elem; ++i)
00474     {
00475     out_mem[i] = out_eT( in_mem[i] );
00476     }
00477   
00478   return out;
00479   }
00480 
00481 
00482 
00483 template<typename out_eT>
00484 template<typename in_T>
00485 inline
00486 Row<out_eT>
00487 conv_to< Row<out_eT> >::from(const itpp::Vec< std::complex<in_T> >& in)
00488   {
00489   arma_extra_debug_sigprint();
00490   
00491   typedef std::complex<in_T> in_eT; 
00492   
00493   Row<out_eT> out(in.length());
00494   
00495   const in_eT*  in_mem = in._data();
00496   out_eT*      out_mem = out.memptr();
00497   
00498   for(u32 i=0; i<out.n_elem; ++i)
00499     {
00500     copy_complex_elem(out_mem[i], in_mem[i]);
00501     }
00502   
00503   return out;
00504   }
00505 
00506 
00507 
00508 // template<typename out_eT>
00509 // inline
00510 // Row<out_eT>
00511 // conv_to< Row<out_eT> >::from(const Col<out_eT>& in)
00512 //   {
00513 //   arma_extra_debug_sigprint();
00514 //   
00515 //   return trans(in);
00516 //   }
00517 // 
00518 // 
00519 // 
00520 // template<typename out_eT>
00521 // template<typename in_eT>
00522 // inline
00523 // Row<out_eT>
00524 // conv_to< Row<out_eT> >::from(const Col<in_eT>& in)
00525 //   {
00526 //   arma_extra_debug_sigprint();
00527 //   
00528 //   Row<out_eT> out(in.n_rows);
00529 //   
00530 //   const in_eT*  in_mem = in.mem;
00531 //   out_eT*      out_mem = out.memptr();
00532 //   
00533 //   for(u32 i=0; i<out.n_elem; ++i)
00534 //     {
00535 //     out_mem[i] = out_eT( in_mem[i] );
00536 //     }
00537 //   
00538 //   return out;
00539 //   }
00540 // 
00541 // 
00542 // 
00543 // template<typename out_eT>
00544 // template<typename in_T>
00545 // inline
00546 // Row<out_eT>
00547 // conv_to< Row<out_eT> >::from(const Col< std::complex<in_T> >& in)
00548 //   {
00549 //   arma_extra_debug_sigprint();
00550 //   
00551 //   typedef std::complex<in_T> in_eT; 
00552 //   
00553 //   Row<out_eT> out(in.n_rows);
00554 //   
00555 //   const in_eT*  in_mem = in.mem;
00556 //   out_eT*      out_mem = out.memptr();
00557 //   
00558 //   for(u32 i=0; i<out.n_elem; ++i)
00559 //     {
00560 //     copy_complex_elem(out_mem[i], in_mem[i]);
00561 //     }
00562 //   
00563 //   return out;
00564 //   }
00565 
00566 
00567 
00568 //
00569 //
00570 // Col family
00571 
00572 template<typename out_eT>
00573 class conv_to< Col<out_eT> >
00574   {
00575   public:
00576   
00577   inline static Col<out_eT> from(const Mat< out_eT >& in);
00578   
00579   template<typename in_eT>
00580   inline static Col<out_eT> from(const Mat< in_eT >& in);
00581   
00582   template<typename in_T>
00583   inline static Col<out_eT> from(const Mat< std::complex<in_T> >& in);
00584   
00585   template<typename in_eT, typename T1>
00586   inline static Col<out_eT> from(const Base<in_eT,T1>& in);
00587   
00588   
00589   
00590   template<typename in_eT>
00591   inline static Col<out_eT> from(const itpp::Vec< in_eT >& in);
00592   
00593   template<typename in_T>
00594   inline static Col<out_eT> from(const itpp::Vec< std::complex<in_T> >& in);
00595 
00596 //   inline static Col<out_eT> from(const Row< out_eT >& in);
00597 //   template<typename in_eT> inline static Col<out_eT> from(const Row< in_eT >& in);
00598 //   template<typename in_T>  inline static Col<out_eT> from(const Row< std::complex<in_T> >& in);
00599   
00600   };
00601 
00602 
00603 
00604 template<typename out_eT>
00605 inline
00606 Col<out_eT>
00607 conv_to< Col<out_eT> >::from(const Mat<out_eT>& in)
00608   {
00609   arma_extra_debug_sigprint();
00610   
00611   arma_debug_check( (in.n_cols > 1), "conv_to<>: given matrix has more than one column");
00612   Col<out_eT> out(in.n_rows);
00613   
00614   syslib::copy_elem(out.memptr(), in.mem, out.n_elem);
00615   
00616   return out;
00617   }
00618 
00619 
00620 
00621 template<typename out_eT>
00622 template<typename in_eT>
00623 inline
00624 Col<out_eT>
00625 conv_to< Col<out_eT> >::from(const Mat<in_eT>& in)
00626   {
00627   arma_extra_debug_sigprint();
00628   
00629   arma_debug_check( (in.n_cols > 1), "conv_to<>: given matrix has more than one column");
00630   Col<out_eT> out(in.n_rows);
00631   
00632   const in_eT*  in_mem = in.mem;
00633   out_eT*      out_mem = out.memptr();
00634   
00635   for(u32 i=0; i<out.n_elem; ++i)
00636     {
00637     out_mem[i] = out_eT( in_mem[i] );
00638     }
00639   
00640   return out;
00641   }
00642 
00643 
00644 
00645 template<typename out_eT>
00646 template<typename in_T>
00647 inline
00648 Col<out_eT>
00649 conv_to< Col<out_eT> >::from(const Mat< std::complex<in_T> >& in)
00650   {
00651   arma_extra_debug_sigprint();
00652   
00653   typedef std::complex<in_T> in_eT; 
00654   
00655   arma_debug_check( (in.n_cols > 1), "conv_to<>: given matrix has more than one column");
00656   Col<out_eT> out(in.n_rows);
00657   
00658   const in_eT*  in_mem = in.mem;
00659   out_eT*      out_mem = out.memptr();
00660   
00661   for(u32 i=0; i<out.n_elem; ++i)
00662     {
00663     copy_complex_elem(out_mem[i], in_mem[i]);
00664     }
00665   
00666   return out;
00667   }
00668 
00669 
00670 
00671 template<typename out_eT>
00672 template<typename in_eT, typename T1>
00673 inline
00674 Col<out_eT>
00675 conv_to< Col<out_eT> >::from(const Base<in_eT,T1>& in)
00676   {
00677   arma_extra_debug_sigprint();
00678   
00679   const unwrap<T1> tmp(in.get_ref());
00680   
00681   return conv_to< Col<out_eT> >::from( tmp.M );
00682   }
00683 
00684 
00685 
00686 template<typename out_eT>
00687 template<typename in_eT>
00688 inline
00689 Col<out_eT>
00690 conv_to< Col<out_eT> >::from(const itpp::Vec<in_eT>& in)
00691   {
00692   arma_extra_debug_sigprint();
00693   
00694   Col<out_eT> out(in.length());
00695   
00696   const in_eT*  in_mem = in._data();
00697   out_eT*      out_mem = out.memptr();
00698   
00699   for(u32 i=0; i<out.n_elem; ++i)
00700     {
00701     out_mem[i] = out_eT( in_mem[i] );
00702     }
00703   
00704   return out;
00705   }
00706 
00707 
00708 
00709 template<typename out_eT>
00710 template<typename in_T>
00711 inline
00712 Col<out_eT>
00713 conv_to< Col<out_eT> >::from(const itpp::Vec< std::complex<in_T> >& in)
00714   {
00715   arma_extra_debug_sigprint();
00716   
00717   typedef std::complex<in_T> in_eT; 
00718   
00719   Col<out_eT> out(in.length());
00720   
00721   const in_eT*  in_mem = in._data();
00722   out_eT*      out_mem = out.memptr();
00723   
00724   for(u32 i=0; i<out.n_elem; ++i)
00725     {
00726     copy_complex_elem(out_mem[i], in_mem[i]);
00727     }
00728   
00729   return out;
00730   }
00731 
00732 
00733 
00734 // template<typename out_eT>
00735 // inline
00736 // Col<out_eT>
00737 // conv_to< Col<out_eT> >::from(const Row<out_eT>& in)
00738 //   {
00739 //   arma_extra_debug_sigprint();
00740 //   
00741 //   return trans(in);
00742 //   }
00743 // 
00744 // 
00745 // 
00746 // template<typename out_eT>
00747 // template<typename in_eT>
00748 // inline
00749 // Col<out_eT>
00750 // conv_to< Col<out_eT> >::from(const Row<in_eT>& in)
00751 //   {
00752 //   arma_extra_debug_sigprint();
00753 //   
00754 //   Col<out_eT> out(in.n_cols);
00755 //   
00756 //   const in_eT*  in_mem = in.mem;
00757 //   out_eT*      out_mem = out.memptr();
00758 //   
00759 //   for(u32 i=0; i<out.n_elem; ++i)
00760 //     {
00761 //     out_mem[i] = out_eT( in_mem[i] );
00762 //     }
00763 //   
00764 //   return out;
00765 //   }
00766 // 
00767 // 
00768 // 
00769 // template<typename out_eT>
00770 // template<typename in_T>
00771 // inline
00772 // Col<out_eT>
00773 // conv_to< Col<out_eT> >::from(const Row< std::complex<in_T> >& in)
00774 //   {
00775 //   arma_extra_debug_sigprint();
00776 //   
00777 //   typedef std::complex<in_T> in_eT; 
00778 //   
00779 //   Col<out_eT> out(in.n_cols);
00780 //   
00781 //   const in_eT*  in_mem = in.mem;
00782 //   out_eT*      out_mem = out.memptr();
00783 //   
00784 //   for(u32 i=0; i<out.n_elem; ++i)
00785 //     {
00786 //     copy_complex_elem(out_mem[i], in_mem[i]);
00787 //     }
00788 //   
00789 //   return out;
00790 //   }
00791 
00792 
00793 
00794 //
00795 //
00796 // Cube family
00797 
00798 template<typename out_eT>
00799 class conv_to< Cube<out_eT> >
00800   {
00801   public:
00802   
00803   template<typename in_eT>
00804   inline static Cube<out_eT> from(const Cube< in_eT >& in);
00805   
00806   template<typename in_T>
00807   inline static Cube<out_eT> from(const Cube< std::complex<in_T> >& in);
00808   
00809   template<typename in_eT, typename T1>
00810   inline static Cube<out_eT> from(const BaseCube<in_eT,T1>& in);
00811   };
00812 
00813 
00814 
00815 template<typename out_eT>
00816 template<typename in_eT>
00817 inline
00818 Cube<out_eT>
00819 conv_to< Cube<out_eT> >::from(const Cube<in_eT>& in)
00820   {
00821   arma_extra_debug_sigprint();
00822   
00823   Cube<out_eT> out(in.n_rows, in.n_cols, in.n_slices);
00824   
00825   const in_eT*  in_mem = in.mem;
00826   out_eT*      out_mem = out.memptr();
00827   
00828   for(u32 i=0; i<out.n_elem; ++i)
00829     {
00830     out_mem[i] = out_eT( in_mem[i] );
00831     }
00832   
00833   return out;
00834   }
00835 
00836 
00837 
00838 template<typename out_eT>
00839 template<typename in_T>
00840 inline
00841 Cube<out_eT>
00842 conv_to< Cube<out_eT> >::from(const Cube< std::complex<in_T> >& in)
00843   {
00844   arma_extra_debug_sigprint();
00845   
00846   typedef std::complex<in_T> in_eT; 
00847   
00848   Cube<out_eT> out(in.n_rows, in.n_cols, in.n_slices);
00849   
00850   const in_eT*  in_mem = in.mem;
00851   out_eT*      out_mem = out.memptr();
00852   
00853   for(u32 i=0; i<out.n_elem; ++i)
00854     {
00855     copy_complex_elem(out_mem[i], in_mem[i]);
00856     }
00857   
00858   return out;
00859   }
00860 
00861 
00862 
00863 template<typename out_eT>
00864 template<typename in_eT, typename T1>
00865 inline
00866 Cube<out_eT>
00867 conv_to< Cube<out_eT> >::from(const BaseCube<in_eT,T1>& in)
00868   {
00869   arma_extra_debug_sigprint();
00870   
00871   const unwrap_cube<T1> tmp(in.get_ref());
00872 
00873   return conv_to< Mat<out_eT> >::from( tmp.M );
00874   }
00875 
00876 
00877 
00878 //
00879 //
00880 // itpp::Mat family
00881 
00882 
00883 
00884 template<typename out_eT>
00885 class conv_to< itpp::Mat<out_eT> >
00886   {
00887   public:
00888   
00889   inline static itpp::Mat<out_eT> from(const Mat< out_eT >& in);
00890   
00891   inline static itpp::Mat<out_eT> from(const Col< out_eT >& in);
00892   
00893   inline static itpp::Mat<out_eT> from(const Row< out_eT >& in);
00894 
00895   
00896   
00897   template<typename in_eT>
00898   inline static itpp::Mat<out_eT> from(const Mat< in_eT >& in);
00899   
00900   template<typename in_eT>
00901   inline static itpp::Mat<out_eT> from(const Col< in_eT >& in);
00902   
00903   template<typename in_eT>
00904   inline static itpp::Mat<out_eT> from(const Row< in_eT >& in);
00905   
00906   
00907   template<typename in_T>
00908   inline static itpp::Mat<out_eT> from(const Mat< std::complex<in_T> >& in);
00909   
00910   template<typename in_T>
00911   inline static itpp::Mat<out_eT> from(const Col< std::complex<in_T> >& in);
00912   
00913   template<typename in_T>
00914   inline static itpp::Mat<out_eT> from(const Row< std::complex<in_T> >& in);
00915   
00916   
00917   
00918   template<typename in_eT, typename T1>
00919   inline static itpp::Mat<out_eT> from(const Base<in_eT,T1>& in);
00920   
00921   };
00922 
00923 
00924 
00925 template<typename out_eT>
00926 inline
00927 itpp::Mat<out_eT>
00928 conv_to< itpp::Mat<out_eT> >::from(const Mat<out_eT>& in)
00929   {
00930   arma_extra_debug_sigprint();
00931   
00932   itpp::Mat<out_eT> out(in.n_rows, in.n_cols);
00933   
00934   syslib::copy_elem(out._data(), in.mem, in.n_elem);
00935   
00936   return out;
00937   }
00938 
00939 
00940 
00941 template<typename out_eT>
00942 inline
00943 itpp::Mat<out_eT>
00944 conv_to< itpp::Mat<out_eT> >::from(const Col<out_eT>& in)
00945   {
00946   arma_extra_debug_sigprint();
00947   
00948   return conv_to< itpp::Mat<out_eT> >::from( reinterpret_cast<const Mat<out_eT>& >(in) );
00949   }
00950 
00951 
00952 
00953 template<typename out_eT>
00954 inline
00955 itpp::Mat<out_eT>
00956 conv_to< itpp::Mat<out_eT> >::from(const Row<out_eT>& in)
00957   {
00958   arma_extra_debug_sigprint();
00959   
00960   return conv_to< itpp::Mat<out_eT> >::from( reinterpret_cast<const Mat<out_eT>& >(in) );
00961   }
00962 
00963 
00964 
00965 template<typename out_eT>
00966 template<typename in_eT>
00967 inline
00968 itpp::Mat<out_eT>
00969 conv_to< itpp::Mat<out_eT> >::from(const Mat<in_eT>& in)
00970   {
00971   arma_extra_debug_sigprint();
00972   
00973   itpp::Mat<out_eT> out(in.n_rows, in.n_cols);
00974   
00975   const in_eT* in_mem = in.memptr();
00976   out_eT*     out_mem = out._data();
00977   
00978   for(u32 i=0; i<in.n_elem; ++i)
00979     {
00980     out_mem[i] = out_eT( in_mem[i] );
00981     }
00982   
00983   return out;
00984   }
00985 
00986 
00987 
00988 template<typename out_eT>
00989 template<typename in_eT>
00990 inline
00991 itpp::Mat<out_eT>
00992 conv_to< itpp::Mat<out_eT> >::from(const Col<in_eT>& in)
00993   {
00994   arma_extra_debug_sigprint();
00995   
00996   return conv_to< itpp::Mat<out_eT> >::from( reinterpret_cast<const Mat<in_eT>& >(in) );
00997   }
00998 
00999 
01000 
01001 template<typename out_eT>
01002 template<typename in_eT>
01003 inline
01004 itpp::Mat<out_eT>
01005 conv_to< itpp::Mat<out_eT> >::from(const Row<in_eT>& in)
01006   {
01007   arma_extra_debug_sigprint();
01008   
01009   return conv_to< itpp::Mat<out_eT> >::from( reinterpret_cast<const Mat<in_eT>& >(in) );
01010   }
01011 
01012 
01013 
01014 template<typename out_eT>
01015 template<typename in_T>
01016 inline
01017 itpp::Mat<out_eT>
01018 conv_to< itpp::Mat<out_eT> >::from(const Mat< std::complex<in_T> >& in)
01019   {
01020   arma_extra_debug_sigprint();
01021   
01022   typedef std::complex<in_T> in_eT; 
01023   
01024   itpp::Mat<out_eT> out(in.n_rows, in.n_cols);
01025   
01026   const in_eT* in_mem = in.memptr();
01027   out_eT*     out_mem = out._data();
01028   
01029   for(u32 i=0; i<in.n_elem; ++i)
01030     {
01031     copy_complex_elem(out_mem[i], in_mem[i]);
01032     }
01033   
01034   return out;
01035   }
01036 
01037 
01038 
01039 template<typename out_eT>
01040 template<typename in_T>
01041 inline
01042 itpp::Mat<out_eT>
01043 conv_to< itpp::Mat<out_eT> >::from(const Col< std::complex<in_T> >& in)
01044   {
01045   arma_extra_debug_sigprint();
01046   
01047   return conv_to< itpp::Mat<out_eT> >::from( reinterpret_cast<const Mat< std::complex<in_T> >& >(in) );
01048   }
01049 
01050 
01051 
01052 template<typename out_eT>
01053 template<typename in_T>
01054 inline
01055 itpp::Mat<out_eT>
01056 conv_to< itpp::Mat<out_eT> >::from(const Row< std::complex<in_T> >& in)
01057   {
01058   arma_extra_debug_sigprint();
01059   
01060   return conv_to< itpp::Mat<out_eT> >::from( reinterpret_cast<const Mat< std::complex<in_T> >& >(in) );
01061   }
01062 
01063 
01064 
01065 template<typename out_eT>
01066 template<typename in_eT, typename T1>
01067 inline
01068 itpp::Mat<out_eT>
01069 conv_to< itpp::Mat<out_eT> >::from(const Base<in_eT,T1>& in)
01070   {
01071   arma_extra_debug_sigprint();
01072   
01073   const unwrap<T1> tmp(in.get_ref());
01074 
01075   return conv_to< itpp::Mat<out_eT> >::from( tmp.M );
01076   }
01077 
01078 
01079 
01080 //
01081 //
01082 // itpp::Vec family
01083 
01084 template<typename out_eT>
01085 class conv_to< itpp::Vec<out_eT> >
01086   {
01087   public:
01088   
01089   inline static itpp::Vec<out_eT> from(const Mat< out_eT >& in);
01090   
01091   template<typename in_eT>
01092   inline static itpp::Vec<out_eT> from(const Mat< in_eT >& in);
01093   
01094   template<typename in_T>  
01095   inline static itpp::Vec<out_eT> from(const Mat< std::complex<in_T> >& in);
01096   
01097   
01098   
01099   template<typename in_eT>
01100   inline static itpp::Vec<out_eT> from(const Col< in_eT >& in);
01101   
01102   template<typename in_eT>
01103   inline static itpp::Vec<out_eT> from(const Row< in_eT >& in);
01104   
01105   
01106   
01107   template<typename in_T>  
01108   inline static itpp::Vec<out_eT> from(const Col< std::complex<in_T> >& in);
01109   
01110   template<typename in_T>  
01111   inline static itpp::Vec<out_eT> from(const Row< std::complex<in_T> >& in);
01112   
01113   
01114   
01115   template<typename in_eT, typename T1>
01116   inline static itpp::Vec<out_eT> from(const Base<in_eT,T1>& in);
01117   };
01118 
01119 
01120 
01121 template<typename out_eT>
01122 inline
01123 itpp::Vec<out_eT>
01124 conv_to< itpp::Vec<out_eT> >::from(const Mat<out_eT>& in)
01125   {
01126   arma_extra_debug_sigprint();
01127   
01128   arma_debug_check( ( (in.n_cols != 1) && (in.n_rows != 1) ), "conv_to<>: given matrix can't be interpreted as a vector");
01129   
01130   itpp::Vec<out_eT> out(in.n_elem);
01131   
01132   syslib::copy_elem(out._data(), in.mem, in.n_elem);
01133   
01134   return out;
01135   }
01136 
01137 
01138 
01139 template<typename out_eT>
01140 template<typename in_eT>
01141 inline
01142 itpp::Vec<out_eT>
01143 conv_to< itpp::Vec<out_eT> >::from(const Mat<in_eT>& in)
01144   {
01145   arma_extra_debug_sigprint();
01146   
01147   arma_debug_check( ( (in.n_cols != 1) && (in.n_rows != 1) ), "conv_to<>: given matrix can't be interpreted as a vector");
01148   itpp::Vec<out_eT> out(in.n_elem);
01149   
01150   const in_eT*  in_mem = in.memptr();
01151   out_eT*      out_mem = out._data();
01152   
01153   for(u32 i=0; i<in.n_elem; ++i)
01154     {
01155     out_mem[i] = out_eT( in_mem[i] );
01156     }
01157   
01158   return out;
01159   }
01160 
01161 
01162 
01163 template<typename out_eT>
01164 template<typename in_T>
01165 inline
01166 itpp::Vec<out_eT>
01167 conv_to< itpp::Vec<out_eT> >::from(const Mat< std::complex<in_T> >& in)
01168   {
01169   arma_extra_debug_sigprint();
01170   
01171   typedef std::complex<in_T> in_eT; 
01172   
01173   arma_debug_check( ( (in.n_cols != 1) && (in.n_rows != 1) ), "conv_to<>: given matrix can't be interpreted as a vector");
01174   
01175   itpp::Vec<out_eT> out(in.n_elem);
01176   
01177   const in_eT*  in_mem = in.memptr();
01178   out_eT*      out_mem = out._data();
01179   
01180   for(u32 i=0; i<in.n_elem; ++i)
01181     {
01182     copy_complex_elem(out_mem[i], in_mem[i]);
01183     }
01184   
01185   return out;
01186   }
01187 
01188 
01189 
01190 template<typename out_eT>
01191 template<typename in_eT>
01192 inline
01193 itpp::Vec<out_eT>
01194 conv_to< itpp::Vec<out_eT> >::from(const Col<in_eT>& in)
01195   {
01196   arma_extra_debug_sigprint();
01197   
01198   itpp::Vec<out_eT> out(in.n_elem);
01199   
01200   const in_eT*  in_mem = in.memptr();
01201   out_eT*      out_mem = out._data();
01202   
01203   for(u32 i=0; i<in.n_elem; ++i)
01204     {
01205     out_mem[i] = out_eT( in_mem[i] );
01206     }
01207   
01208   return out;
01209   }
01210 
01211 
01212 
01213 template<typename out_eT>
01214 template<typename in_T>
01215 inline
01216 itpp::Vec<out_eT>
01217 conv_to< itpp::Vec<out_eT> >::from(const Col< std::complex<in_T> >& in)
01218   {
01219   arma_extra_debug_sigprint();
01220   
01221   typedef std::complex<in_T> in_eT; 
01222   
01223   itpp::Vec<out_eT> out(in.n_elem);
01224   
01225   const in_eT*  in_mem = in.memptr();
01226   out_eT*      out_mem = out._data();
01227   
01228   for(u32 i=0; i<in.n_elem; ++i)
01229     {
01230     copy_complex_elem(out_mem[i], in_mem[i]);
01231     }
01232   
01233   return out;
01234   }
01235 
01236 
01237 
01238 template<typename out_eT>
01239 template<typename in_eT>
01240 inline
01241 itpp::Vec<out_eT>
01242 conv_to< itpp::Vec<out_eT> >::from(const Row<in_eT>& in)
01243   {
01244   arma_extra_debug_sigprint();
01245   
01246   itpp::Vec<out_eT> out(in.n_elem);
01247   
01248   const in_eT*  in_mem = in.memptr();
01249   out_eT*      out_mem = out._data();
01250   
01251   for(u32 i=0; i<in.n_elem; ++i)
01252     {
01253     out_mem[i] = out_eT( in_mem[i] );
01254     }
01255   
01256   return out;
01257   }
01258 
01259 
01260 
01261 template<typename out_eT>
01262 template<typename in_T>
01263 inline
01264 itpp::Vec<out_eT>
01265 conv_to< itpp::Vec<out_eT> >::from(const Row< std::complex<in_T> >& in)
01266   {
01267   arma_extra_debug_sigprint();
01268   
01269   typedef std::complex<in_T> in_eT; 
01270   
01271   itpp::Vec<out_eT> out(in.n_elem);
01272   
01273   const in_eT*  in_mem = in.memptr();
01274   out_eT*      out_mem = out._data();
01275   
01276   for(u32 i=0; i<in.n_elem; ++i)
01277     {
01278     copy_complex_elem(out_mem[i], in_mem[i]);
01279     }
01280   
01281   return out;
01282   }
01283 
01284 
01285 
01286 template<typename out_eT>
01287 template<typename in_eT, typename T1>
01288 inline
01289 itpp::Vec<out_eT>
01290 conv_to< itpp::Vec<out_eT> >::from(const Base<in_eT,T1>& in)
01291   {
01292   arma_extra_debug_sigprint();
01293   
01294   const unwrap<T1> tmp(in.get_ref());
01295 
01296   return conv_to< itpp::Vec<out_eT> >::from( tmp.M );
01297   }
01298 
01299 
01300 //! @}