00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00016
00017
00018
00019 template<typename T1>
00020 class unwrap
00021 {
00022 public:
00023
00024 typedef typename T1::elem_type eT;
00025
00026 inline unwrap(const T1& A)
00027 : M(A)
00028 {
00029 arma_extra_debug_sigprint();
00030 }
00031
00032 const Mat<eT> M;
00033 };
00034
00035
00036
00037 template<typename eT>
00038 class unwrap< Mat<eT> >
00039 {
00040 public:
00041
00042 inline unwrap(const Mat<eT>& A)
00043 : M(A)
00044 {
00045 arma_extra_debug_sigprint();
00046 }
00047
00048 const Mat<eT>& M;
00049 };
00050
00051
00052
00053 template<typename eT>
00054 class unwrap< Row<eT> >
00055 {
00056 public:
00057
00058 inline unwrap(const Row<eT>& A)
00059 : M(A)
00060 {
00061 arma_extra_debug_sigprint();
00062 }
00063
00064 const Row<eT>& M;
00065 };
00066
00067
00068
00069 template<typename eT>
00070 class unwrap< Col<eT> >
00071 {
00072 public:
00073
00074 inline unwrap(const Col<eT>& A)
00075 : M(A)
00076 {
00077 arma_extra_debug_sigprint();
00078 }
00079
00080 const Col<eT>& M;
00081 };
00082
00083
00084
00085 template<typename out_eT, typename T1, typename T2, typename glue_type>
00086 class unwrap< mtGlue<out_eT, T1, T2, glue_type> >
00087 {
00088 public:
00089
00090 inline unwrap(const mtGlue<out_eT, T1, T2, glue_type>& A)
00091 : M(A)
00092 {
00093 arma_extra_debug_sigprint();
00094 }
00095
00096 const Mat<out_eT> M;
00097 };
00098
00099
00100 template<typename out_eT, typename T1, typename op_type>
00101 class unwrap< mtOp<out_eT, T1, op_type> >
00102 {
00103 public:
00104
00105 inline unwrap(const mtOp<out_eT, T1, op_type>& A)
00106 : M(A)
00107 {
00108 arma_extra_debug_sigprint();
00109 }
00110
00111 const Mat<out_eT> M;
00112 };
00113
00114
00115
00116
00117
00118
00119
00120
00121 template<typename T1>
00122 class unwrap_check
00123 {
00124 public:
00125
00126 typedef typename T1::elem_type eT;
00127
00128 inline
00129 unwrap_check(const T1& A, const Mat<eT>& B)
00130 : M(A)
00131 {
00132 arma_extra_debug_sigprint();
00133 arma_ignore(B);
00134 }
00135
00136 inline
00137 ~unwrap_check()
00138 {
00139 arma_extra_debug_sigprint();
00140 }
00141
00142 const Mat<eT> M;
00143 };
00144
00145
00146
00147 template<typename eT>
00148 class unwrap_check< Mat<eT> >
00149 {
00150 public:
00151
00152 inline
00153 unwrap_check(const Mat<eT>& A, const Mat<eT>& B)
00154 : M_local( (&A == &B) ? new Mat<eT>(A) : 0 )
00155 , M ( (&A == &B) ? (*M_local) : A )
00156 {
00157 arma_extra_debug_sigprint();
00158 }
00159
00160
00161 inline
00162 ~unwrap_check()
00163 {
00164 arma_extra_debug_sigprint();
00165
00166 if(M_local)
00167 {
00168 delete M_local;
00169 }
00170 }
00171
00172
00173
00174 const Mat<eT>* M_local;
00175 const Mat<eT>& M;
00176 };
00177
00178
00179
00180 template<typename eT>
00181 class unwrap_check< Row<eT> >
00182 {
00183 public:
00184
00185 inline
00186 unwrap_check(const Row<eT>& A, const Mat<eT>& B)
00187 : M_local( (&A == reinterpret_cast<const Row<eT>*>(&B)) ? new Row<eT>(A) : 0 )
00188 , M ( (&A == reinterpret_cast<const Row<eT>*>(&B)) ? (*M_local) : A )
00189 {
00190 arma_extra_debug_sigprint();
00191 }
00192
00193
00194 inline
00195 ~unwrap_check()
00196 {
00197 arma_extra_debug_sigprint();
00198
00199 if(M_local)
00200 {
00201 delete M_local;
00202 }
00203 }
00204
00205
00206
00207 const Row<eT>* M_local;
00208 const Row<eT>& M;
00209 };
00210
00211
00212
00213 template<typename eT>
00214 class unwrap_check< Col<eT> >
00215 {
00216 public:
00217
00218 inline
00219 unwrap_check(const Col<eT>& A, const Mat<eT>& B)
00220 : M_local( (&A == reinterpret_cast<const Col<eT>*>(&B)) ? new Col<eT>(A) : 0 )
00221 , M ( (&A == reinterpret_cast<const Col<eT>*>(&B)) ? (*M_local) : A )
00222 {
00223 arma_extra_debug_sigprint();
00224 }
00225
00226
00227 inline
00228 ~unwrap_check()
00229 {
00230 arma_extra_debug_sigprint();
00231
00232 if(M_local)
00233 {
00234 delete M_local;
00235 }
00236 }
00237
00238
00239
00240 const Col<eT>* M_local;
00241 const Col<eT>& M;
00242
00243 };
00244
00245
00246
00247
00248
00249
00250
00251
00252
00253 template<typename T1>
00254 class unwrap_check_mixed
00255 {
00256 public:
00257
00258 typedef typename T1::elem_type eT1;
00259
00260 template<typename eT2>
00261 inline
00262 unwrap_check_mixed(const T1& A, const Mat<eT2>& B)
00263 : M(A)
00264 {
00265 arma_extra_debug_sigprint();
00266 arma_ignore(B);
00267 }
00268
00269 inline
00270 ~unwrap_check_mixed()
00271 {
00272 arma_extra_debug_sigprint();
00273 }
00274
00275 const Mat<eT1> M;
00276 };
00277
00278
00279
00280 template<typename eT1>
00281 class unwrap_check_mixed< Mat<eT1> >
00282 {
00283 public:
00284
00285 template<typename eT2>
00286 inline
00287 unwrap_check_mixed(const Mat<eT1>& A, const Mat<eT2>& B)
00288 : M_local( (void_ptr(&A) == void_ptr(&B)) ? new Mat<eT1>(A) : 0 )
00289 , M ( (void_ptr(&A) == void_ptr(&B)) ? (*M_local) : A )
00290 {
00291 arma_extra_debug_sigprint();
00292 }
00293
00294
00295 inline
00296 ~unwrap_check_mixed()
00297 {
00298 arma_extra_debug_sigprint();
00299
00300 if(M_local)
00301 {
00302 delete M_local;
00303 }
00304 }
00305
00306
00307
00308 const Mat<eT1>* M_local;
00309 const Mat<eT1>& M;
00310 };
00311
00312
00313
00314 template<typename eT1>
00315 class unwrap_check_mixed< Row<eT1> >
00316 {
00317 public:
00318
00319 template<typename eT2>
00320 inline
00321 unwrap_check_mixed(const Row<eT1>& A, const Mat<eT2>& B)
00322 : M_local( (void_ptr(&A) == void_ptr(&B)) ? new Row<eT1>(A) : 0 )
00323 , M ( (void_ptr(&A) == void_ptr(&B)) ? (*M_local) : A )
00324 {
00325 arma_extra_debug_sigprint();
00326 }
00327
00328
00329 inline
00330 ~unwrap_check_mixed()
00331 {
00332 arma_extra_debug_sigprint();
00333
00334 if(M_local)
00335 {
00336 delete M_local;
00337 }
00338 }
00339
00340
00341
00342 const Row<eT1>* M_local;
00343 const Row<eT1>& M;
00344 };
00345
00346
00347
00348 template<typename eT1>
00349 class unwrap_check_mixed< Col<eT1> >
00350 {
00351 public:
00352
00353 template<typename eT2>
00354 inline
00355 unwrap_check_mixed(const Col<eT1>& A, const Mat<eT2>& B)
00356 : M_local( (void_ptr(&A) == void_ptr(&B)) ? new Col<eT1>(A) : 0 )
00357 , M ( (void_ptr(&A) == void_ptr(&B)) ? (*M_local) : A )
00358 {
00359 arma_extra_debug_sigprint();
00360 }
00361
00362
00363 inline
00364 ~unwrap_check_mixed()
00365 {
00366 arma_extra_debug_sigprint();
00367
00368 if(M_local)
00369 {
00370 delete M_local;
00371 }
00372 }
00373
00374
00375
00376 const Col<eT1>* M_local;
00377 const Col<eT1>& M;
00378 };
00379
00380
00381
00382
00383
00384
00385
00386 template<typename T1>
00387 class partial_unwrap
00388 {
00389 public:
00390
00391 typedef typename T1::elem_type eT;
00392
00393 inline partial_unwrap(const T1& A)
00394 : M(A)
00395 {
00396 arma_extra_debug_sigprint();
00397 }
00398
00399
00400 inline
00401 ~partial_unwrap()
00402 {
00403 arma_extra_debug_sigprint();
00404 }
00405
00406
00407 inline eT get_val() const { return eT(1); }
00408
00409
00410 static const bool do_trans = false;
00411 static const bool do_times = false;
00412
00413 const Mat<eT> M;
00414 };
00415
00416
00417
00418 template<typename eT>
00419 class partial_unwrap< Mat<eT> >
00420 {
00421 public:
00422
00423 inline
00424 partial_unwrap(const Mat<eT>& A)
00425 : M(A)
00426 {
00427 arma_extra_debug_sigprint();
00428 }
00429
00430
00431 inline
00432 ~partial_unwrap()
00433 {
00434 arma_extra_debug_sigprint();
00435 }
00436
00437
00438 inline eT get_val() const { return eT(1); }
00439
00440
00441 static const bool do_trans = false;
00442 static const bool do_times = false;
00443
00444 const Mat<eT>& M;
00445 };
00446
00447
00448
00449 template<typename eT>
00450 class partial_unwrap< Row<eT> >
00451 {
00452 public:
00453
00454 inline
00455 partial_unwrap(const Row<eT>& A)
00456 : M(A)
00457 {
00458 arma_extra_debug_sigprint();
00459 }
00460
00461
00462 inline
00463 ~partial_unwrap()
00464 {
00465 arma_extra_debug_sigprint();
00466 }
00467
00468
00469 inline eT get_val() const { return eT(1); }
00470
00471
00472 static const bool do_trans = false;
00473 static const bool do_times = false;
00474
00475 const Mat<eT>& M;
00476 };
00477
00478
00479
00480 template<typename eT>
00481 class partial_unwrap< Col<eT> >
00482 {
00483 public:
00484
00485 inline
00486 partial_unwrap(const Col<eT>& A)
00487 : M(A)
00488 {
00489 arma_extra_debug_sigprint();
00490 }
00491
00492
00493 inline
00494 ~partial_unwrap()
00495 {
00496 arma_extra_debug_sigprint();
00497 }
00498
00499
00500 inline eT get_val() const { return eT(1); }
00501
00502
00503 static const bool do_trans = false;
00504 static const bool do_times = false;
00505
00506 const Mat<eT>& M;
00507 };
00508
00509
00510
00511 template<typename T1>
00512 class partial_unwrap< Op<T1, op_htrans> >
00513 {
00514 public:
00515
00516 typedef typename T1::elem_type eT;
00517
00518 inline
00519 partial_unwrap(const Op<T1,op_htrans>& A)
00520 : M(A.m)
00521 {
00522 arma_extra_debug_sigprint();
00523 }
00524
00525 inline
00526 ~partial_unwrap()
00527 {
00528 arma_extra_debug_sigprint();
00529 }
00530
00531
00532 inline eT get_val() const { return eT(1); }
00533
00534
00535 static const bool do_trans = true;
00536 static const bool do_times = false;
00537
00538 const Mat<eT> M;
00539 };
00540
00541
00542
00543 template<typename eT>
00544 class partial_unwrap< Op< Mat<eT>, op_htrans> >
00545 {
00546 public:
00547
00548 inline
00549 partial_unwrap(const Op< Mat<eT>, op_htrans>& A)
00550 : M(A.m)
00551 {
00552 arma_extra_debug_sigprint();
00553 }
00554
00555
00556 inline
00557 ~partial_unwrap()
00558 {
00559 arma_extra_debug_sigprint();
00560 }
00561
00562
00563 inline eT get_val() const { return eT(1); }
00564
00565
00566 static const bool do_trans = true;
00567 static const bool do_times = false;
00568
00569 const Mat<eT>& M;
00570 };
00571
00572
00573
00574 template<typename eT>
00575 class partial_unwrap< Op< Row<eT>, op_htrans> >
00576 {
00577 public:
00578
00579 inline
00580 partial_unwrap(const Op< Row<eT>, op_htrans>& A)
00581 : M(A.m)
00582 {
00583 arma_extra_debug_sigprint();
00584 }
00585
00586 inline
00587 ~partial_unwrap()
00588 {
00589 arma_extra_debug_sigprint();
00590 }
00591
00592
00593 inline eT get_val() const { return eT(1); }
00594
00595
00596 static const bool do_trans = true;
00597 static const bool do_times = false;
00598
00599 const Mat<eT>& M;
00600 };
00601
00602
00603
00604 template<typename eT>
00605 class partial_unwrap< Op< Col<eT>, op_htrans> >
00606 {
00607 public:
00608
00609 inline
00610 partial_unwrap(const Op< Col<eT>, op_htrans>& A)
00611 : M(A.m)
00612 {
00613 arma_extra_debug_sigprint();
00614 }
00615
00616 inline
00617 ~partial_unwrap()
00618 {
00619 arma_extra_debug_sigprint();
00620 }
00621
00622
00623 inline eT get_val() const { return eT(1); }
00624
00625
00626 static const bool do_trans = true;
00627 static const bool do_times = false;
00628
00629 const Mat<eT>& M;
00630 };
00631
00632
00633
00634 template<typename T1>
00635 class partial_unwrap< Op<T1, op_htrans2> >
00636 {
00637 public:
00638
00639 typedef typename T1::elem_type eT;
00640
00641 inline
00642 partial_unwrap(const Op<T1,op_htrans2>& A)
00643 : val(A.aux)
00644 , M (A.m)
00645 {
00646 arma_extra_debug_sigprint();
00647 }
00648
00649 inline
00650 ~partial_unwrap()
00651 {
00652 arma_extra_debug_sigprint();
00653 }
00654
00655
00656 inline eT get_val() const { return val; }
00657
00658
00659 static const bool do_trans = true;
00660 static const bool do_times = true;
00661
00662 const eT val;
00663 const Mat<eT> M;
00664 };
00665
00666
00667
00668 template<typename eT>
00669 class partial_unwrap< Op< Mat<eT>, op_htrans2> >
00670 {
00671 public:
00672
00673 inline
00674 partial_unwrap(const Op< Mat<eT>, op_htrans2>& A)
00675 : val(A.aux)
00676 , M (A.m)
00677 {
00678 arma_extra_debug_sigprint();
00679 }
00680
00681 inline
00682 ~partial_unwrap()
00683 {
00684 arma_extra_debug_sigprint();
00685 }
00686
00687
00688 inline eT get_val() const { return val; }
00689
00690
00691 static const bool do_trans = true;
00692 static const bool do_times = true;
00693
00694 const eT val;
00695 const Mat<eT>& M;
00696 };
00697
00698
00699
00700 template<typename eT>
00701 class partial_unwrap< Op< Row<eT>, op_htrans2> >
00702 {
00703 public:
00704
00705 inline
00706 partial_unwrap(const Op< Row<eT>, op_htrans2>& A)
00707 : val(A.aux)
00708 , M (A.m)
00709 {
00710 arma_extra_debug_sigprint();
00711 }
00712
00713 inline
00714 ~partial_unwrap()
00715 {
00716 arma_extra_debug_sigprint();
00717 }
00718
00719
00720 inline eT get_val() const { return val; }
00721
00722
00723 static const bool do_trans = true;
00724 static const bool do_times = true;
00725
00726 const eT val;
00727 const Mat<eT>& M;
00728 };
00729
00730
00731
00732 template<typename eT>
00733 class partial_unwrap< Op< Col<eT>, op_htrans2> >
00734 {
00735 public:
00736
00737 inline
00738 partial_unwrap(const Op< Col<eT>, op_htrans2>& A)
00739 : val(A.aux)
00740 , M (A.m)
00741 {
00742 arma_extra_debug_sigprint();
00743 }
00744
00745 inline
00746 ~partial_unwrap()
00747 {
00748 arma_extra_debug_sigprint();
00749 }
00750
00751
00752 inline eT get_val() const { return val; }
00753
00754
00755 static const bool do_trans = true;
00756 static const bool do_times = true;
00757
00758 const eT val;
00759 const Mat<eT>& M;
00760 };
00761
00762
00763
00764 template<typename T1>
00765 class partial_unwrap< eOp<T1, eop_scalar_times> >
00766 {
00767 public:
00768
00769 typedef typename T1::elem_type eT;
00770
00771 inline
00772 partial_unwrap(const eOp<T1,eop_scalar_times>& A)
00773 : val(A.aux)
00774 , M (A.P.Q)
00775 {
00776 arma_extra_debug_sigprint();
00777 }
00778
00779 inline
00780 ~partial_unwrap()
00781 {
00782 arma_extra_debug_sigprint();
00783 }
00784
00785
00786 inline eT get_val() const { return val; }
00787
00788
00789 static const bool do_trans = false;
00790 static const bool do_times = true;
00791
00792 const eT val;
00793 const Mat<eT> M;
00794 };
00795
00796
00797
00798 template<typename eT>
00799 class partial_unwrap< eOp<Mat<eT>, eop_scalar_times> >
00800 {
00801 public:
00802
00803 inline
00804 partial_unwrap(const eOp<Mat<eT>,eop_scalar_times>& A)
00805 : val(A.aux)
00806 , M (A.P.Q)
00807 {
00808 arma_extra_debug_sigprint();
00809 }
00810
00811 inline
00812 ~partial_unwrap()
00813 {
00814 arma_extra_debug_sigprint();
00815 }
00816
00817
00818 inline eT get_val() const { return val; }
00819
00820
00821 static const bool do_trans = false;
00822 static const bool do_times = true;
00823
00824 const eT val;
00825 const Mat<eT>& M;
00826 };
00827
00828
00829
00830 template<typename eT>
00831 class partial_unwrap< eOp<Row<eT>, eop_scalar_times> >
00832 {
00833 public:
00834
00835 inline
00836 partial_unwrap(const eOp<Row<eT>,eop_scalar_times>& A)
00837 : val(A.aux)
00838 , M (A.P.Q)
00839 {
00840 arma_extra_debug_sigprint();
00841 }
00842
00843 inline
00844 ~partial_unwrap()
00845 {
00846 arma_extra_debug_sigprint();
00847 }
00848
00849
00850 inline eT get_val() const { return val; }
00851
00852
00853 static const bool do_trans = false;
00854 static const bool do_times = true;
00855
00856 const eT val;
00857 const Mat<eT>& M;
00858 };
00859
00860
00861
00862 template<typename eT>
00863 class partial_unwrap< eOp<Col<eT>, eop_scalar_times> >
00864 {
00865 public:
00866
00867 inline
00868 partial_unwrap(const eOp<Col<eT>,eop_scalar_times>& A)
00869 : val(A.aux)
00870 , M (A.P.Q)
00871 {
00872 arma_extra_debug_sigprint();
00873 }
00874
00875 inline
00876 ~partial_unwrap()
00877 {
00878 arma_extra_debug_sigprint();
00879 }
00880
00881
00882 inline eT get_val() const { return val; }
00883
00884
00885 static const bool do_trans = false;
00886 static const bool do_times = true;
00887
00888 const eT val;
00889 const Mat<eT>& M;
00890 };
00891
00892
00893
00894
00895
00896
00897
00898 template<typename T1>
00899 class partial_unwrap_check
00900 {
00901 public:
00902
00903 typedef typename T1::elem_type eT;
00904
00905 inline partial_unwrap_check(const T1& A, const Mat<eT>& B)
00906 : M(A)
00907 {
00908 arma_extra_debug_sigprint();
00909 arma_ignore(B);
00910 }
00911
00912
00913 inline
00914 ~partial_unwrap_check()
00915 {
00916 arma_extra_debug_sigprint();
00917 }
00918
00919
00920 inline eT get_val() const { return eT(1); }
00921
00922
00923 static const bool do_trans = false;
00924 static const bool do_times = false;
00925
00926 const Mat<eT> M;
00927 };
00928
00929
00930
00931 template<typename eT>
00932 class partial_unwrap_check< Mat<eT> >
00933 {
00934 public:
00935
00936 inline
00937 partial_unwrap_check(const Mat<eT>& A, const Mat<eT>& B)
00938 : M_local ( (&A == &B) ? new Mat<eT>(A) : 0 )
00939 , M ( (&A == &B) ? (*M_local) : A )
00940 {
00941 arma_extra_debug_sigprint();
00942 }
00943
00944
00945 inline
00946 ~partial_unwrap_check()
00947 {
00948 arma_extra_debug_sigprint();
00949
00950 if(M_local)
00951 {
00952 delete M_local;
00953 }
00954 }
00955
00956
00957 inline eT get_val() const { return eT(1); }
00958
00959
00960 static const bool do_trans = false;
00961 static const bool do_times = false;
00962
00963
00964 const Mat<eT>* M_local;
00965 const Mat<eT>& M;
00966 };
00967
00968
00969
00970 template<typename eT>
00971 class partial_unwrap_check< Row<eT> >
00972 {
00973 public:
00974
00975 inline
00976 partial_unwrap_check(const Row<eT>& A, const Mat<eT>& B)
00977 : M_local ( (&A == &B) ? new Mat<eT>(A) : 0 )
00978 , M ( (&A == &B) ? (*M_local) : A )
00979 {
00980 arma_extra_debug_sigprint();
00981 }
00982
00983
00984 inline
00985 ~partial_unwrap_check()
00986 {
00987 arma_extra_debug_sigprint();
00988
00989 if(M_local)
00990 {
00991 delete M_local;
00992 }
00993 }
00994
00995
00996 inline eT get_val() const { return eT(1); }
00997
00998
00999 static const bool do_trans = false;
01000 static const bool do_times = false;
01001
01002
01003 const Mat<eT>* M_local;
01004 const Mat<eT>& M;
01005 };
01006
01007
01008
01009 template<typename eT>
01010 class partial_unwrap_check< Col<eT> >
01011 {
01012 public:
01013
01014 inline
01015 partial_unwrap_check(const Col<eT>& A, const Mat<eT>& B)
01016 : M_local ( (&A == &B) ? new Mat<eT>(A) : 0 )
01017 , M ( (&A == &B) ? (*M_local) : A )
01018 {
01019 arma_extra_debug_sigprint();
01020 }
01021
01022
01023 inline
01024 ~partial_unwrap_check()
01025 {
01026 arma_extra_debug_sigprint();
01027
01028 if(M_local)
01029 {
01030 delete M_local;
01031 }
01032 }
01033
01034
01035 inline eT get_val() const { return eT(1); }
01036
01037
01038 static const bool do_trans = false;
01039 static const bool do_times = false;
01040
01041
01042 const Mat<eT>* M_local;
01043 const Mat<eT>& M;
01044 };
01045
01046
01047
01048 template<typename T1>
01049 class partial_unwrap_check< Op<T1, op_htrans> >
01050 {
01051 public:
01052
01053 typedef typename T1::elem_type eT;
01054
01055 inline
01056 partial_unwrap_check(const Op<T1,op_htrans>& A, const Mat<eT>& B)
01057 : M(A.m)
01058 {
01059 arma_extra_debug_sigprint();
01060 arma_ignore(B);
01061 }
01062
01063 inline
01064 ~partial_unwrap_check()
01065 {
01066 arma_extra_debug_sigprint();
01067 }
01068
01069
01070 inline eT get_val() const { return eT(1); }
01071
01072
01073 static const bool do_trans = true;
01074 static const bool do_times = false;
01075
01076 const Mat<eT> M;
01077 };
01078
01079
01080
01081 template<typename eT>
01082 class partial_unwrap_check< Op< Mat<eT>, op_htrans> >
01083 {
01084 public:
01085
01086 inline
01087 partial_unwrap_check(const Op< Mat<eT>, op_htrans>& A, const Mat<eT>& B)
01088 : M_local ( (&A.m == &B) ? new Mat<eT>(A.m) : 0 )
01089 , M ( (&A.m == &B) ? (*M_local) : A.m )
01090 {
01091 arma_extra_debug_sigprint();
01092 }
01093
01094 inline
01095 ~partial_unwrap_check()
01096 {
01097 arma_extra_debug_sigprint();
01098
01099 if(M_local)
01100 {
01101 delete M_local;
01102 }
01103 }
01104
01105
01106 inline eT get_val() const { return eT(1); }
01107
01108
01109 static const bool do_trans = true;
01110 static const bool do_times = false;
01111
01112
01113 const Mat<eT>* M_local;
01114 const Mat<eT>& M;
01115 };
01116
01117
01118
01119 template<typename eT>
01120 class partial_unwrap_check< Op< Row<eT>, op_htrans> >
01121 {
01122 public:
01123
01124 inline
01125 partial_unwrap_check(const Op< Row<eT>, op_htrans>& A, const Mat<eT>& B)
01126 : M_local ( (&A.m == &B) ? new Mat<eT>(A.m) : 0 )
01127 , M ( (&A.m == &B) ? (*M_local) : A.m )
01128 {
01129 arma_extra_debug_sigprint();
01130 }
01131
01132 inline
01133 ~partial_unwrap_check()
01134 {
01135 arma_extra_debug_sigprint();
01136
01137 if(M_local)
01138 {
01139 delete M_local;
01140 }
01141 }
01142
01143
01144 inline eT get_val() const { return eT(1); }
01145
01146
01147 static const bool do_trans = true;
01148 static const bool do_times = false;
01149
01150
01151 const Mat<eT>* M_local;
01152 const Mat<eT>& M;
01153 };
01154
01155
01156
01157 template<typename eT>
01158 class partial_unwrap_check< Op< Col<eT>, op_htrans> >
01159 {
01160 public:
01161
01162 inline
01163 partial_unwrap_check(const Op< Col<eT>, op_htrans>& A, const Mat<eT>& B)
01164 : M_local ( (&A.m == &B) ? new Mat<eT>(A.m) : 0 )
01165 , M ( (&A.m == &B) ? (*M_local) : A.m )
01166 {
01167 arma_extra_debug_sigprint();
01168 }
01169
01170 inline
01171 ~partial_unwrap_check()
01172 {
01173 arma_extra_debug_sigprint();
01174
01175 if(M_local)
01176 {
01177 delete M_local;
01178 }
01179 }
01180
01181
01182 inline eT get_val() const { return eT(1); }
01183
01184
01185 static const bool do_trans = true;
01186 static const bool do_times = false;
01187
01188
01189 const Mat<eT>* M_local;
01190 const Mat<eT>& M;
01191 };
01192
01193
01194
01195 template<typename T1>
01196 class partial_unwrap_check< Op<T1, op_htrans2> >
01197 {
01198 public:
01199
01200 typedef typename T1::elem_type eT;
01201
01202 inline
01203 partial_unwrap_check(const Op<T1,op_htrans2>& A, const Mat<eT>& B)
01204 : val(A.aux)
01205 , M (A.m)
01206 {
01207 arma_extra_debug_sigprint();
01208 }
01209
01210 inline
01211 ~partial_unwrap_check()
01212 {
01213 arma_extra_debug_sigprint();
01214 }
01215
01216
01217 inline eT get_val() const { return val; }
01218
01219
01220 static const bool do_trans = true;
01221 static const bool do_times = true;
01222
01223 const eT val;
01224 const Mat<eT> M;
01225 };
01226
01227
01228
01229 template<typename eT>
01230 class partial_unwrap_check< Op< Mat<eT>, op_htrans2> >
01231 {
01232 public:
01233
01234 inline
01235 partial_unwrap_check(const Op< Mat<eT>, op_htrans2>& A, const Mat<eT>& B)
01236 : val (A.aux)
01237 , M_local ( (&A.m == &B) ? new Mat<eT>(A.m) : 0 )
01238 , M ( (&A.m == &B) ? (*M_local) : A.m )
01239 {
01240 arma_extra_debug_sigprint();
01241 }
01242
01243 inline
01244 ~partial_unwrap_check()
01245 {
01246 arma_extra_debug_sigprint();
01247
01248 if(M_local)
01249 {
01250 delete M_local;
01251 }
01252 }
01253
01254
01255 inline eT get_val() const { return val; }
01256
01257
01258 static const bool do_trans = true;
01259 static const bool do_times = true;
01260
01261
01262 const eT val;
01263 const Mat<eT>* M_local;
01264 const Mat<eT>& M;
01265 };
01266
01267
01268
01269 template<typename eT>
01270 class partial_unwrap_check< Op< Row<eT>, op_htrans2> >
01271 {
01272 public:
01273
01274 inline
01275 partial_unwrap_check(const Op< Row<eT>, op_htrans2>& A, const Mat<eT>& B)
01276 : val (A.aux)
01277 , M_local ( (&A.m == &B) ? new Mat<eT>(A.m) : 0 )
01278 , M ( (&A.m == &B) ? (*M_local) : A.m )
01279 {
01280 arma_extra_debug_sigprint();
01281 }
01282
01283 inline
01284 ~partial_unwrap_check()
01285 {
01286 arma_extra_debug_sigprint();
01287
01288 if(M_local)
01289 {
01290 delete M_local;
01291 }
01292 }
01293
01294
01295 inline eT get_val() const { return val; }
01296
01297
01298 static const bool do_trans = true;
01299 static const bool do_times = true;
01300
01301
01302 const eT val;
01303 const Mat<eT>* M_local;
01304 const Mat<eT>& M;
01305 };
01306
01307
01308
01309 template<typename eT>
01310 class partial_unwrap_check< Op< Col<eT>, op_htrans2> >
01311 {
01312 public:
01313
01314 inline
01315 partial_unwrap_check(const Op< Mat<eT>, op_htrans2>& A, const Mat<eT>& B)
01316 : val (A.aux)
01317 , M_local ( (&A.m == &B) ? new Mat<eT>(A.m) : 0 )
01318 , M ( (&A.m == &B) ? (*M_local) : A.m )
01319 {
01320 arma_extra_debug_sigprint();
01321 }
01322
01323 inline
01324 ~partial_unwrap_check()
01325 {
01326 arma_extra_debug_sigprint();
01327
01328 if(M_local)
01329 {
01330 delete M_local;
01331 }
01332 }
01333
01334
01335 inline eT get_val() const { return val; }
01336
01337
01338 static const bool do_trans = true;
01339 static const bool do_times = true;
01340
01341
01342 const eT val;
01343 const Mat<eT>* M_local;
01344 const Mat<eT>& M;
01345 };
01346
01347
01348
01349 template<typename T1>
01350 class partial_unwrap_check< eOp<T1, eop_scalar_times> >
01351 {
01352 public:
01353
01354 typedef typename T1::elem_type eT;
01355
01356 inline
01357 partial_unwrap_check(const eOp<T1,eop_scalar_times>& A, const Mat<eT>& B)
01358 : val(A.aux)
01359 , M (A.P.Q)
01360 {
01361 arma_extra_debug_sigprint();
01362 arma_ignore(B);
01363 }
01364
01365 inline
01366 ~partial_unwrap_check()
01367 {
01368 arma_extra_debug_sigprint();
01369 }
01370
01371
01372 inline eT get_val() const { return val; }
01373
01374
01375 static const bool do_trans = false;
01376 static const bool do_times = true;
01377
01378 const eT val;
01379 const Mat<eT> M;
01380 };
01381
01382
01383
01384 template<typename eT>
01385 class partial_unwrap_check< eOp<Mat<eT>, eop_scalar_times> >
01386 {
01387 public:
01388
01389 inline
01390 partial_unwrap_check(const eOp<Mat<eT>,eop_scalar_times>& A, const Mat<eT>& B)
01391 : val(A.aux)
01392 , M (A.P.Q)
01393 {
01394 arma_extra_debug_sigprint();
01395 arma_ignore(B);
01396 }
01397
01398 inline
01399 ~partial_unwrap_check()
01400 {
01401 arma_extra_debug_sigprint();
01402 }
01403
01404
01405 inline eT get_val() const { return val; }
01406
01407
01408 static const bool do_trans = false;
01409 static const bool do_times = true;
01410
01411 const eT val;
01412 const Mat<eT>& M;
01413 };
01414
01415
01416
01417 template<typename eT>
01418 class partial_unwrap_check< eOp<Row<eT>, eop_scalar_times> >
01419 {
01420 public:
01421
01422 inline
01423 partial_unwrap_check(const eOp<Row<eT>,eop_scalar_times>& A, const Mat<eT>& B)
01424 : val(A.aux)
01425 , M (A.P.Q)
01426 {
01427 arma_extra_debug_sigprint();
01428 arma_ignore(B);
01429 }
01430
01431 inline
01432 ~partial_unwrap_check()
01433 {
01434 arma_extra_debug_sigprint();
01435 }
01436
01437
01438 inline eT get_val() const { return val; }
01439
01440
01441 static const bool do_trans = false;
01442 static const bool do_times = true;
01443
01444 const eT val;
01445 const Mat<eT>& M;
01446 };
01447
01448
01449
01450 template<typename eT>
01451 class partial_unwrap_check< eOp<Col<eT>, eop_scalar_times> >
01452 {
01453 public:
01454
01455 inline
01456 partial_unwrap_check(const eOp<Col<eT>,eop_scalar_times>& A, const Mat<eT>& B)
01457 : val(A.aux)
01458 , M (A.P.Q)
01459 {
01460 arma_extra_debug_sigprint();
01461 arma_ignore(B);
01462 }
01463
01464 inline
01465 ~partial_unwrap_check()
01466 {
01467 arma_extra_debug_sigprint();
01468 }
01469
01470
01471 inline eT get_val() const { return val; }
01472
01473
01474 static const bool do_trans = false;
01475 static const bool do_times = true;
01476
01477 const eT val;
01478 const Mat<eT>& M;
01479 };
01480
01481
01482