fn_conv_to.hpp

Go to the documentation of this file.
00001 // Copyright (C) 2009 NICTA
00002 // 
00003 // Authors:
00004 // - Conrad Sanderson (conradsand at ieee dot org)
00005 // 
00006 // This file is part of the Armadillo C++ library.
00007 // It is provided without any warranty of fitness
00008 // for any purpose. You can redistribute this file
00009 // and/or modify it under the terms of the GNU
00010 // Lesser General Public License (LGPL) as published
00011 // by the Free Software Foundation, either version 3
00012 // of the License or (at your option) any later version.
00013 // (see http://www.opensource.org/licenses for more info)
00014 
00015 
00016 //! \addtogroup fn_conv_to
00017 //! @{
00018 
00019 
00020 //
00021 //
00022 // conversions between various mat types
00023 
00024 template<typename out_eT, typename in_eT>
00025 inline
00026 void
00027 copy_complex_elem(out_eT& out, const in_eT& in)
00028   {
00029   //arma_extra_debug_sigprint();
00030   
00031   out = out_eT(in);
00032   }
00033 
00034 
00035 
00036 template<typename out_eT, typename in_T>
00037 inline
00038 void
00039 copy_complex_elem(out_eT& out, const std::complex<in_T>& in)
00040   {
00041   //arma_extra_debug_sigprint();
00042   
00043   out = out_eT( in.real() );
00044   }
00045 
00046 
00047 
00048 template<typename out_T, typename in_T>
00049 inline
00050 void
00051 copy_complex_elem(std::complex<out_T>& out, const std::complex<in_T>& in)
00052   {
00053   //arma_extra_debug_sigprint();
00054   
00055   typedef std::complex<out_T> out_eT;
00056   out = out_eT(in);
00057   }
00058 
00059 
00060 
00061 //
00062 // scalar family
00063 
00064 
00065 template<typename out_eT>
00066 class conv_to
00067   {
00068   public:
00069   
00070   inline static out_eT from(const Mat< out_eT >& in);
00071 
00072   template<typename in_eT>
00073   inline static out_eT from(const Mat< in_eT >& in);
00074 
00075   template<typename in_eT, typename T1>
00076   inline static out_eT from(const Base<in_eT,T1>& in);
00077 
00078   //
00079 
00080   inline static out_eT from(const Cube< out_eT >& in);
00081 
00082   template<typename in_eT>
00083   inline static out_eT from(const Cube< in_eT >& in);
00084 
00085   template<typename in_eT, typename T1>
00086   inline static out_eT from(const BaseCube<in_eT,T1>& in);
00087   };
00088 
00089 
00090 
00091 template<typename out_eT>
00092 inline
00093 out_eT
00094 conv_to<out_eT>::from(const Mat<out_eT>& in)
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   }
00102 
00103 
00104 
00105 template<typename out_eT>
00106 template<typename in_eT>
00107 inline
00108 out_eT
00109 conv_to<out_eT>::from(const Mat<in_eT>& in)
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   }
00122 
00123 
00124 
00125 template<typename out_eT>
00126 template<typename in_eT, typename T1>
00127 inline
00128 out_eT
00129 conv_to<out_eT>::from(const Base<in_eT,T1>& in)
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   }
00139 
00140 
00141 
00142 template<typename out_eT>
00143 inline
00144 out_eT
00145 conv_to<out_eT>::from(const Cube<out_eT>& in)
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   }
00153 
00154 
00155 
00156 template<typename out_eT>
00157 template<typename in_eT>
00158 inline
00159 out_eT
00160 conv_to<out_eT>::from(const Cube<in_eT>& in)
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   }
00173 
00174 
00175 
00176 template<typename out_eT>
00177 template<typename in_eT, typename T1>
00178 inline
00179 out_eT
00180 conv_to<out_eT>::from(const BaseCube<in_eT,T1>& in)
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   }
00190 
00191 
00192 
00193 //
00194 //
00195 // Mat family
00196 
00197 template<typename out_eT>
00198 class conv_to< Mat<out_eT> >
00199   {
00200   public:
00201   
00202   template<typename in_eT>
00203   inline static Mat<out_eT> from(const Mat< in_eT >& in);
00204   
00205   template<typename in_T>
00206   inline static Mat<out_eT> from(const Mat< std::complex<in_T> >& in);
00207   
00208   template<typename in_eT, typename T1>
00209   inline static Mat<out_eT> from(const Base<in_eT,T1>& in);
00210   
00211   
00212   
00213 //   template<typename in_eT>
00214 //   inline static Mat<out_eT> from(const std::vector< in_eT >& in);
00215 //   
00216 //   template<typename in_eT>
00217 //   inline static Mat<out_eT> from(const std::vector< std::complex<in_eT> >& in);
00218   
00219   
00220   template<typename in_eT>
00221   inline static Mat<out_eT> from(const itpp::Mat< in_eT >& in);
00222   
00223   template<typename in_T>
00224   inline static Mat<out_eT> from(const itpp::Mat< std::complex<in_T> >& in);
00225   };
00226 
00227 
00228 
00229 template<typename out_eT>
00230 template<typename in_eT>
00231 inline
00232 Mat<out_eT>
00233 conv_to< Mat<out_eT> >::from(const Mat<in_eT>& in)
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   }
00249 
00250 
00251 
00252 template<typename out_eT>
00253 template<typename in_T>
00254 inline
00255 Mat<out_eT>
00256 conv_to< Mat<out_eT> >::from(const Mat< std::complex<in_T> >& in)
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   }
00274 
00275 
00276 
00277 template<typename out_eT>
00278 template<typename in_eT, typename T1>
00279 inline
00280 Mat<out_eT>
00281 conv_to< Mat<out_eT> >::from(const Base<in_eT,T1>& in)
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   }
00289 
00290 
00291 
00292 template<typename out_eT>
00293 template<typename in_eT>
00294 inline
00295 Mat<out_eT>
00296 conv_to< Mat<out_eT> >::from(const itpp::Mat<in_eT>& in)
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   }
00312 
00313 
00314 
00315 template<typename out_eT>
00316 template<typename in_T>
00317 inline
00318 Mat<out_eT>
00319 conv_to< Mat<out_eT> >::from(const itpp::Mat< std::complex<in_T> >& in)
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   }
00337 
00338 
00339 
00340 //
00341 //
00342 // Row family
00343 
00344 template<typename out_eT>
00345 class conv_to< Row<out_eT> >
00346   {
00347   public:
00348   
00349   inline static Row<out_eT> from(const Mat< out_eT >& in);
00350   
00351   template<typename in_eT>
00352   inline static Row<out_eT> from(const Mat< in_eT >& in);
00353   
00354   template<typename in_T>  
00355   inline static Row<out_eT> from(const Mat< std::complex<in_T> >& in);
00356   
00357   template<typename in_eT, typename T1>
00358   inline static Row<out_eT> from(const Base<in_eT,T1>& in);
00359   
00360   
00361   
00362   template<typename in_eT>
00363   inline static Row<out_eT> from(const itpp::Vec< in_eT >& in);
00364   
00365   template<typename in_T>  
00366   inline static Row<out_eT> from(const itpp::Vec< std::complex<in_T> >& in);
00367   
00368   //inline static Row<out_eT> from(const Col< out_eT >& in);
00369   //template<typename in_eT> inline static Row<out_eT> from(const Col< in_eT >& in);
00370   //template<typename in_T>  inline static Row<out_eT> from(const Col< std::complex<in_T> >& in);
00371   
00372   };
00373 
00374 
00375 
00376 template<typename out_eT>
00377 inline
00378 Row<out_eT>
00379 conv_to< Row<out_eT> >::from(const Mat<out_eT>& in)
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   }
00391 
00392 
00393 
00394 template<typename out_eT>
00395 template<typename in_eT>
00396 inline
00397 Row<out_eT>
00398 conv_to< Row<out_eT> >::from(const Mat<in_eT>& in)
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   }
00415 
00416 
00417 
00418 template<typename out_eT>
00419 template<typename in_T>
00420 inline
00421 Row<out_eT>
00422 conv_to< Row<out_eT> >::from(const Mat< std::complex<in_T> >& in)
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   }
00441 
00442 
00443 
00444 template<typename out_eT>
00445 template<typename in_eT, typename T1>
00446 inline
00447 Row<out_eT>
00448 conv_to< Row<out_eT> >::from(const Base<in_eT,T1>& in)
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   }
00456 
00457 
00458 
00459 template<typename out_eT>
00460 template<typename in_eT>
00461 inline
00462 Row<out_eT>
00463 conv_to< Row<out_eT> >::from(const itpp::Vec<in_eT>& in)
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   }
00479 
00480 
00481 
00482 template<typename out_eT>
00483 template<typename in_T>
00484 inline
00485 Row<out_eT>
00486 conv_to< Row<out_eT> >::from(const itpp::Vec< std::complex<in_T> >& in)
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   }
00504 
00505 
00506 
00507 // template<typename out_eT>
00508 // inline
00509 // Row<out_eT>
00510 // conv_to< Row<out_eT> >::from(const Col<out_eT>& in)
00511 //   {
00512 //   arma_extra_debug_sigprint();
00513 //   
00514 //   return trans(in);
00515 //   }
00516 // 
00517 // 
00518 // 
00519 // template<typename out_eT>
00520 // template<typename in_eT>
00521 // inline
00522 // Row<out_eT>
00523 // conv_to< Row<out_eT> >::from(const Col<in_eT>& in)
00524 //   {
00525 //   arma_extra_debug_sigprint();
00526 //   
00527 //   Row<out_eT> out(in.n_rows);
00528 //   
00529 //   const in_eT*  in_mem = in.mem;
00530 //   out_eT*      out_mem = out.memptr();
00531 //   
00532 //   for(u32 i=0; i<out.n_elem; ++i)
00533 //     {
00534 //     out_mem[i] = out_eT( in_mem[i] );
00535 //     }
00536 //   
00537 //   return out;
00538 //   }
00539 // 
00540 // 
00541 // 
00542 // template<typename out_eT>
00543 // template<typename in_T>
00544 // inline
00545 // Row<out_eT>
00546 // conv_to< Row<out_eT> >::from(const Col< std::complex<in_T> >& in)
00547 //   {
00548 //   arma_extra_debug_sigprint();
00549 //   
00550 //   typedef std::complex<in_T> in_eT; 
00551 //   
00552 //   Row<out_eT> out(in.n_rows);
00553 //   
00554 //   const in_eT*  in_mem = in.mem;
00555 //   out_eT*      out_mem = out.memptr();
00556 //   
00557 //   for(u32 i=0; i<out.n_elem; ++i)
00558 //     {
00559 //     copy_complex_elem(out_mem[i], in_mem[i]);
00560 //     }
00561 //   
00562 //   return out;
00563 //   }
00564 
00565 
00566 
00567 //
00568 //
00569 // Col family
00570 
00571 template<typename out_eT>
00572 class conv_to< Col<out_eT> >
00573   {
00574   public:
00575   
00576   inline static Col<out_eT> from(const Mat< out_eT >& in);
00577   
00578   template<typename in_eT>
00579   inline static Col<out_eT> from(const Mat< in_eT >& in);
00580   
00581   template<typename in_T>
00582   inline static Col<out_eT> from(const Mat< std::complex<in_T> >& in);
00583   
00584   template<typename in_eT, typename T1>
00585   inline static Col<out_eT> from(const Base<in_eT,T1>& in);
00586   
00587   
00588   
00589   template<typename in_eT>
00590   inline static Col<out_eT> from(const itpp::Vec< in_eT >& in);
00591   
00592   template<typename in_T>
00593   inline static Col<out_eT> from(const itpp::Vec< std::complex<in_T> >& in);
00594 
00595 //   inline static Col<out_eT> from(const Row< out_eT >& in);
00596 //   template<typename in_eT> inline static Col<out_eT> from(const Row< in_eT >& in);
00597 //   template<typename in_T>  inline static Col<out_eT> from(const Row< std::complex<in_T> >& in);
00598   
00599   };
00600 
00601 
00602 
00603 template<typename out_eT>
00604 inline
00605 Col<out_eT>
00606 conv_to< Col<out_eT> >::from(const Mat<out_eT>& in)
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   }
00617 
00618 
00619 
00620 template<typename out_eT>
00621 template<typename in_eT>
00622 inline
00623 Col<out_eT>
00624 conv_to< Col<out_eT> >::from(const Mat<in_eT>& in)
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   }
00641 
00642 
00643 
00644 template<typename out_eT>
00645 template<typename in_T>
00646 inline
00647 Col<out_eT>
00648 conv_to< Col<out_eT> >::from(const Mat< std::complex<in_T> >& in)
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   }
00667 
00668 
00669 
00670 template<typename out_eT>
00671 template<typename in_eT, typename T1>
00672 inline
00673 Col<out_eT>
00674 conv_to< Col<out_eT> >::from(const Base<in_eT,T1>& in)
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   }
00682 
00683 
00684 
00685 template<typename out_eT>
00686 template<typename in_eT>
00687 inline
00688 Col<out_eT>
00689 conv_to< Col<out_eT> >::from(const itpp::Vec<in_eT>& in)
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   }
00705 
00706 
00707 
00708 template<typename out_eT>
00709 template<typename in_T>
00710 inline
00711 Col<out_eT>
00712 conv_to< Col<out_eT> >::from(const itpp::Vec< std::complex<in_T> >& in)
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   }
00730 
00731 
00732 
00733 // template<typename out_eT>
00734 // inline
00735 // Col<out_eT>
00736 // conv_to< Col<out_eT> >::from(const Row<out_eT>& in)
00737 //   {
00738 //   arma_extra_debug_sigprint();
00739 //   
00740 //   return trans(in);
00741 //   }
00742 // 
00743 // 
00744 // 
00745 // template<typename out_eT>
00746 // template<typename in_eT>
00747 // inline
00748 // Col<out_eT>
00749 // conv_to< Col<out_eT> >::from(const Row<in_eT>& in)
00750 //   {
00751 //   arma_extra_debug_sigprint();
00752 //   
00753 //   Col<out_eT> out(in.n_cols);
00754 //   
00755 //   const in_eT*  in_mem = in.mem;
00756 //   out_eT*      out_mem = out.memptr();
00757 //   
00758 //   for(u32 i=0; i<out.n_elem; ++i)
00759 //     {
00760 //     out_mem[i] = out_eT( in_mem[i] );
00761 //     }
00762 //   
00763 //   return out;
00764 //   }
00765 // 
00766 // 
00767 // 
00768 // template<typename out_eT>
00769 // template<typename in_T>
00770 // inline
00771 // Col<out_eT>
00772 // conv_to< Col<out_eT> >::from(const Row< std::complex<in_T> >& in)
00773 //   {
00774 //   arma_extra_debug_sigprint();
00775 //   
00776 //   typedef std::complex<in_T> in_eT; 
00777 //   
00778 //   Col<out_eT> out(in.n_cols);
00779 //   
00780 //   const in_eT*  in_mem = in.mem;
00781 //   out_eT*      out_mem = out.memptr();
00782 //   
00783 //   for(u32 i=0; i<out.n_elem; ++i)
00784 //     {
00785 //     copy_complex_elem(out_mem[i], in_mem[i]);
00786 //     }
00787 //   
00788 //   return out;
00789 //   }
00790 
00791 
00792 
00793 //
00794 //
00795 // Cube family
00796 
00797 template<typename out_eT>
00798 class conv_to< Cube<out_eT> >
00799   {
00800   public:
00801   
00802   template<typename in_eT>
00803   inline static Cube<out_eT> from(const Cube< in_eT >& in);
00804   
00805   template<typename in_T>
00806   inline static Cube<out_eT> from(const Cube< std::complex<in_T> >& in);
00807   
00808   template<typename in_eT, typename T1>
00809   inline static Cube<out_eT> from(const BaseCube<in_eT,T1>& in);
00810   };
00811 
00812 
00813 
00814 template<typename out_eT>
00815 template<typename in_eT>
00816 inline
00817 Cube<out_eT>
00818 conv_to< Cube<out_eT> >::from(const Cube<in_eT>& in)
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   }
00834 
00835 
00836 
00837 template<typename out_eT>
00838 template<typename in_T>
00839 inline
00840 Cube<out_eT>
00841 conv_to< Cube<out_eT> >::from(const Cube< std::complex<in_T> >& in)
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   }
00859 
00860 
00861 
00862 template<typename out_eT>
00863 template<typename in_eT, typename T1>
00864 inline
00865 Cube<out_eT>
00866 conv_to< Cube<out_eT> >::from(const BaseCube<in_eT,T1>& in)
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   }
00874 
00875 
00876 
00877 //
00878 //
00879 // itpp::Mat family
00880 
00881 
00882 
00883 template<typename out_eT>
00884 class conv_to< itpp::Mat<out_eT> >
00885   {
00886   public:
00887   
00888   inline static itpp::Mat<out_eT> from(const Mat< out_eT >& in);
00889   
00890   inline static itpp::Mat<out_eT> from(const Col< out_eT >& in);
00891   
00892   inline static itpp::Mat<out_eT> from(const Row< out_eT >& in);
00893 
00894   
00895   
00896   template<typename in_eT>
00897   inline static itpp::Mat<out_eT> from(const Mat< in_eT >& in);
00898   
00899   template<typename in_eT>
00900   inline static itpp::Mat<out_eT> from(const Col< in_eT >& in);
00901   
00902   template<typename in_eT>
00903   inline static itpp::Mat<out_eT> from(const Row< in_eT >& in);
00904   
00905   
00906   template<typename in_T>
00907   inline static itpp::Mat<out_eT> from(const Mat< std::complex<in_T> >& in);
00908   
00909   template<typename in_T>
00910   inline static itpp::Mat<out_eT> from(const Col< std::complex<in_T> >& in);
00911   
00912   template<typename in_T>
00913   inline static itpp::Mat<out_eT> from(const Row< std::complex<in_T> >& in);
00914   
00915   
00916   
00917   template<typename in_eT, typename T1>
00918   inline static itpp::Mat<out_eT> from(const Base<in_eT,T1>& in);
00919   
00920   };
00921 
00922 
00923 
00924 template<typename out_eT>
00925 inline
00926 itpp::Mat<out_eT>
00927 conv_to< itpp::Mat<out_eT> >::from(const Mat<out_eT>& in)
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   }
00937 
00938 
00939 
00940 template<typename out_eT>
00941 inline
00942 itpp::Mat<out_eT>
00943 conv_to< itpp::Mat<out_eT> >::from(const Col<out_eT>& in)
00944   {
00945   arma_extra_debug_sigprint();
00946   
00947   return conv_to< itpp::Mat<out_eT> >::from( reinterpret_cast<const Mat<out_eT>& >(in) );
00948   }
00949 
00950 
00951 
00952 template<typename out_eT>
00953 inline
00954 itpp::Mat<out_eT>
00955 conv_to< itpp::Mat<out_eT> >::from(const Row<out_eT>& in)
00956   {
00957   arma_extra_debug_sigprint();
00958   
00959   return conv_to< itpp::Mat<out_eT> >::from( reinterpret_cast<const Mat<out_eT>& >(in) );
00960   }
00961 
00962 
00963 
00964 template<typename out_eT>
00965 template<typename in_eT>
00966 inline
00967 itpp::Mat<out_eT>
00968 conv_to< itpp::Mat<out_eT> >::from(const Mat<in_eT>& in)
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   }
00984 
00985 
00986 
00987 template<typename out_eT>
00988 template<typename in_eT>
00989 inline
00990 itpp::Mat<out_eT>
00991 conv_to< itpp::Mat<out_eT> >::from(const Col<in_eT>& in)
00992   {
00993   arma_extra_debug_sigprint();
00994   
00995   return conv_to< itpp::Mat<out_eT> >::from( reinterpret_cast<const Mat<in_eT>& >(in) );
00996   }
00997 
00998 
00999 
01000 template<typename out_eT>
01001 template<typename in_eT>
01002 inline
01003 itpp::Mat<out_eT>
01004 conv_to< itpp::Mat<out_eT> >::from(const Row<in_eT>& in)
01005   {
01006   arma_extra_debug_sigprint();
01007   
01008   return conv_to< itpp::Mat<out_eT> >::from( reinterpret_cast<const Mat<in_eT>& >(in) );
01009   }
01010 
01011 
01012 
01013 template<typename out_eT>
01014 template<typename in_T>
01015 inline
01016 itpp::Mat<out_eT>
01017 conv_to< itpp::Mat<out_eT> >::from(const Mat< std::complex<in_T> >& in)
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   }
01035 
01036 
01037 
01038 template<typename out_eT>
01039 template<typename in_T>
01040 inline
01041 itpp::Mat<out_eT>
01042 conv_to< itpp::Mat<out_eT> >::from(const Col< std::complex<in_T> >& in)
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   }
01048 
01049 
01050 
01051 template<typename out_eT>
01052 template<typename in_T>
01053 inline
01054 itpp::Mat<out_eT>
01055 conv_to< itpp::Mat<out_eT> >::from(const Row< std::complex<in_T> >& in)
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   }
01061 
01062 
01063 
01064 template<typename out_eT>
01065 template<typename in_eT, typename T1>
01066 inline
01067 itpp::Mat<out_eT>
01068 conv_to< itpp::Mat<out_eT> >::from(const Base<in_eT,T1>& in)
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   }
01076 
01077 
01078 
01079 //
01080 //
01081 // itpp::Vec family
01082 
01083 template<typename out_eT>
01084 class conv_to< itpp::Vec<out_eT> >
01085   {
01086   public:
01087   
01088   inline static itpp::Vec<out_eT> from(const Mat< out_eT >& in);
01089   
01090   template<typename in_eT>
01091   inline static itpp::Vec<out_eT> from(const Mat< in_eT >& in);
01092   
01093   template<typename in_T>  
01094   inline static itpp::Vec<out_eT> from(const Mat< std::complex<in_T> >& in);
01095   
01096   
01097   
01098   template<typename in_eT>
01099   inline static itpp::Vec<out_eT> from(const Col< in_eT >& in);
01100   
01101   template<typename in_eT>
01102   inline static itpp::Vec<out_eT> from(const Row< in_eT >& in);
01103   
01104   
01105   
01106   template<typename in_T>  
01107   inline static itpp::Vec<out_eT> from(const Col< std::complex<in_T> >& in);
01108   
01109   template<typename in_T>  
01110   inline static itpp::Vec<out_eT> from(const Row< std::complex<in_T> >& in);
01111   
01112   
01113   
01114   template<typename in_eT, typename T1>
01115   inline static itpp::Vec<out_eT> from(const Base<in_eT,T1>& in);
01116   };
01117 
01118 
01119 
01120 template<typename out_eT>
01121 inline
01122 itpp::Vec<out_eT>
01123 conv_to< itpp::Vec<out_eT> >::from(const Mat<out_eT>& in)
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   }
01135 
01136 
01137 
01138 template<typename out_eT>
01139 template<typename in_eT>
01140 inline
01141 itpp::Vec<out_eT>
01142 conv_to< itpp::Vec<out_eT> >::from(const Mat<in_eT>& in)
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   }
01159 
01160 
01161 
01162 template<typename out_eT>
01163 template<typename in_T>
01164 inline
01165 itpp::Vec<out_eT>
01166 conv_to< itpp::Vec<out_eT> >::from(const Mat< std::complex<in_T> >& in)
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   }
01186 
01187 
01188 
01189 template<typename out_eT>
01190 template<typename in_eT>
01191 inline
01192 itpp::Vec<out_eT>
01193 conv_to< itpp::Vec<out_eT> >::from(const Col<in_eT>& in)
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   }
01209 
01210 
01211 
01212 template<typename out_eT>
01213 template<typename in_T>
01214 inline
01215 itpp::Vec<out_eT>
01216 conv_to< itpp::Vec<out_eT> >::from(const Col< std::complex<in_T> >& in)
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   }
01234 
01235 
01236 
01237 template<typename out_eT>
01238 template<typename in_eT>
01239 inline
01240 itpp::Vec<out_eT>
01241 conv_to< itpp::Vec<out_eT> >::from(const Row<in_eT>& in)
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   }
01257 
01258 
01259 
01260 template<typename out_eT>
01261 template<typename in_T>
01262 inline
01263 itpp::Vec<out_eT>
01264 conv_to< itpp::Vec<out_eT> >::from(const Row< std::complex<in_T> >& in)
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   }
01282 
01283 
01284 
01285 template<typename out_eT>
01286 template<typename in_eT, typename T1>
01287 inline
01288 itpp::Vec<out_eT>
01289 conv_to< itpp::Vec<out_eT> >::from(const Base<in_eT,T1>& in)
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   }
01297 
01298 
01299 //! @}