00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
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
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
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
00054
00055 typedef std::complex<out_T> out_eT;
00056 out = out_eT(in);
00057 }
00058
00059
00060
00061
00062
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
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
00214
00215
00216
00217
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
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
00369
00370
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
00508
00509
00510
00511
00512
00513
00514
00515
00516
00517
00518
00519
00520
00521
00522
00523
00524
00525
00526
00527
00528
00529
00530
00531
00532
00533
00534
00535
00536
00537
00538
00539
00540
00541
00542
00543
00544
00545
00546
00547
00548
00549
00550
00551
00552
00553
00554
00555
00556
00557
00558
00559
00560
00561
00562
00563
00564
00565
00566
00567
00568
00569
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
00596
00597
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
00734
00735
00736
00737
00738
00739
00740
00741
00742
00743
00744
00745
00746
00747
00748
00749
00750
00751
00752
00753
00754
00755
00756
00757
00758
00759
00760
00761
00762
00763
00764
00765
00766
00767
00768
00769
00770
00771
00772
00773
00774
00775
00776
00777
00778
00779
00780
00781
00782
00783
00784
00785
00786
00787
00788
00789
00790
00791
00792
00793
00794
00795
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
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
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