00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
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
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
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
00055
00056 typedef std::complex<out_T> out_eT;
00057 out = out_eT(in);
00058 }
00059
00060
00061
00062
00063
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
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
00215
00216
00217
00218
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
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
00370
00371
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
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
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
00597
00598
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
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
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
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
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