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 operator_minus 00017 //! @{ 00018 00019 00020 00021 //! unary - 00022 template<typename T1> 00023 arma_inline 00024 const Op<T1, op_neg> 00025 operator- 00026 (const Base<typename T1::elem_type,T1>& X) 00027 { 00028 arma_extra_debug_sigprint(); 00029 00030 return Op<T1,op_neg>(X.get_ref()); 00031 } 00032 00033 00034 00035 //! cancellation of two consecutive negations: -(-T1) 00036 template<typename T1> 00037 arma_inline 00038 const T1& 00039 operator- 00040 (const Op<T1, op_neg>& X) 00041 { 00042 arma_extra_debug_sigprint(); 00043 00044 return X.m; 00045 } 00046 00047 00048 00049 //! Base - scalar 00050 template<typename T1> 00051 arma_inline 00052 const Op<T1, op_scalar_minus_post> 00053 operator- 00054 (const Base<typename T1::elem_type,T1>& X, const typename T1::elem_type k) 00055 { 00056 arma_extra_debug_sigprint(); 00057 00058 return Op<T1, op_scalar_minus_post>(X.get_ref(), k); 00059 } 00060 00061 00062 00063 //! scalar - Base 00064 template<typename T1> 00065 arma_inline 00066 const Op<T1, op_scalar_minus_pre> 00067 operator- 00068 (const typename T1::elem_type k, const Base<typename T1::elem_type,T1>& X) 00069 { 00070 arma_extra_debug_sigprint(); 00071 00072 return Op<T1, op_scalar_minus_pre>(X.get_ref(), k); 00073 } 00074 00075 00076 00077 //! Base - - Base = Base + Base 00078 template<typename T1, typename T2> 00079 arma_inline 00080 const Glue<T1, T2, glue_plus> 00081 operator- 00082 ( 00083 const Base<typename T1::elem_type, T1 >& X, 00084 const Base<typename T1::elem_type, Op<T2,op_neg> >& Y 00085 ) 00086 { 00087 arma_extra_debug_sigprint(); 00088 00089 const T1& A = X.get_ref(); 00090 const T2& B = (Y.get_ref()).m; 00091 00092 return Glue<T1, T2, glue_plus>(A,B); 00093 } 00094 00095 00096 00097 //! Base - diagmat 00098 template<typename T1, typename T2> 00099 arma_inline 00100 const Glue<T1, Op<T2,op_diagmat>, glue_minus_diag> 00101 operator- 00102 (const Base<typename T2::elem_type,T1>& X, const Op<T2,op_diagmat>& Y) 00103 { 00104 arma_extra_debug_sigprint(); 00105 00106 return Glue<T1, Op<T1,op_diagmat>, glue_minus_diag>(X.get_ref(), Y); 00107 } 00108 00109 00110 00111 //! diagmat - Base 00112 template<typename T1, typename T2> 00113 arma_inline 00114 const Glue< Op<T1,op_diagmat>, T2, glue_minus_diag> 00115 operator- 00116 (const Op<T1,op_diagmat>& X, const Base<typename T1::elem_type,T2>& Y) 00117 { 00118 arma_extra_debug_sigprint(); 00119 00120 return Glue< Op<T1,op_diagmat>, T2, glue_minus_diag>(X, Y.get_ref()); 00121 } 00122 00123 00124 00125 //! Base - Op<T2,op_neg> = Base + T2 00126 template<typename T1, typename T2> 00127 arma_inline 00128 const Glue<T1, T2, glue_plus> 00129 operator- 00130 (const Base<typename T2::elem_type,T1>& X, const Op<T2, op_neg>& Y) 00131 { 00132 arma_extra_debug_sigprint(); 00133 00134 return Glue<T1, T2, glue_plus>(X.get_ref(), Y.m); 00135 } 00136 00137 00138 00139 //! diagmat - Op<T2,op_neg> = diagmat + T2 00140 template<typename T1, typename T2> 00141 arma_inline 00142 const Glue< Op<T1,op_diagmat>, T2, glue_plus_diag> 00143 operator- 00144 ( 00145 const Base<typename T1::elem_type, Op<T1,op_diagmat> >& X, 00146 const Base<typename T1::elem_type, Op<T2,op_neg > >& Y 00147 ) 00148 { 00149 arma_extra_debug_sigprint(); 00150 00151 return Glue< Op<T1,op_diagmat>, T2, glue_plus_diag>(X.get_ref(), (Y.get_ref()).m); 00152 } 00153 00154 00155 00156 // 00157 // subtraction of Base objects with different element types 00158 // 00159 00160 00161 00162 //! Base - Base 00163 template<typename eT1, typename T1, typename eT2, typename T2> 00164 arma_inline 00165 Mat<typename promote_type<eT1,eT2>::result> 00166 operator- 00167 (const Base<eT1,T1>& X, const Base<eT2,T2>& Y) 00168 { 00169 arma_extra_debug_sigprint(); 00170 00171 promote_type<eT1,eT2>::check(); 00172 00173 const unwrap<T1> tmp1(X.get_ref()); 00174 const unwrap<T2> tmp2(Y.get_ref()); 00175 00176 const Mat<eT1>& A = tmp1.M; 00177 const Mat<eT2>& B = tmp2.M; 00178 00179 Mat< typename promote_type<eT1,eT2>::result > out; 00180 glue_minus::apply_mixed(out, A, B); 00181 00182 return out; 00183 } 00184 00185 00186 00187 // 00188 // subtraction of Base objects with same element types 00189 // 00190 00191 00192 00193 template<typename T1, typename T2> 00194 arma_inline 00195 const Glue<T1, T2, glue_minus> 00196 operator- 00197 (const Base<std::complex<double>,T1>& X, const Base<std::complex<double>,T2>& Y) 00198 { 00199 arma_extra_debug_sigprint(); 00200 00201 return Glue<T1, T2, glue_minus>(X.get_ref(), Y.get_ref()); 00202 } 00203 00204 00205 00206 template<typename T1, typename T2> 00207 arma_inline 00208 const Glue<T1, T2, glue_minus> 00209 operator- 00210 (const Base<std::complex<float>,T1>& X, const Base<std::complex<float>,T2>& Y) 00211 { 00212 arma_extra_debug_sigprint(); 00213 00214 return Glue<T1, T2, glue_minus>(X.get_ref(), Y.get_ref()); 00215 } 00216 00217 00218 00219 template<typename T1, typename T2> 00220 arma_inline 00221 const Glue<T1, T2, glue_minus> 00222 operator- 00223 (const Base<double,T1>& X, const Base<double,T2>& Y) 00224 { 00225 arma_extra_debug_sigprint(); 00226 00227 return Glue<T1, T2, glue_minus>(X.get_ref(), Y.get_ref()); 00228 } 00229 00230 00231 00232 template<typename T1, typename T2> 00233 arma_inline 00234 const Glue<T1, T2, glue_minus> 00235 operator- 00236 (const Base<float,T1>& X, const Base<float,T2>& Y) 00237 { 00238 arma_extra_debug_sigprint(); 00239 00240 return Glue<T1, T2, glue_minus>(X.get_ref(), Y.get_ref()); 00241 } 00242 00243 00244 00245 template<typename T1, typename T2> 00246 arma_inline 00247 const Glue<T1, T2, glue_minus> 00248 operator- 00249 (const Base<s32,T1>& X, const Base<s32,T2>& Y) 00250 { 00251 arma_extra_debug_sigprint(); 00252 00253 return Glue<T1, T2, glue_minus>(X.get_ref(), Y.get_ref()); 00254 } 00255 00256 00257 00258 template<typename T1, typename T2> 00259 arma_inline 00260 const Glue<T1, T2, glue_minus> 00261 operator- 00262 (const Base<u32,T1>& X, const Base<u32,T2>& Y) 00263 { 00264 arma_extra_debug_sigprint(); 00265 00266 return Glue<T1, T2, glue_minus>(X.get_ref(), Y.get_ref()); 00267 } 00268 00269 00270 00271 template<typename T1, typename T2> 00272 arma_inline 00273 const Glue<T1, T2, glue_minus> 00274 operator- 00275 (const Base<s16,T1>& X, const Base<s16,T2>& Y) 00276 { 00277 arma_extra_debug_sigprint(); 00278 00279 return Glue<T1, T2, glue_minus>(X.get_ref(), Y.get_ref()); 00280 } 00281 00282 00283 00284 template<typename T1, typename T2> 00285 arma_inline 00286 const Glue<T1, T2, glue_minus> 00287 operator- 00288 (const Base<u16,T1>& X, const Base<u16,T2>& Y) 00289 { 00290 arma_extra_debug_sigprint(); 00291 00292 return Glue<T1, T2, glue_minus>(X.get_ref(), Y.get_ref()); 00293 } 00294 00295 00296 00297 template<typename T1, typename T2> 00298 arma_inline 00299 const Glue<T1, T2, glue_minus> 00300 operator- 00301 (const Base<s8,T1>& X, const Base<s8,T2>& Y) 00302 { 00303 arma_extra_debug_sigprint(); 00304 00305 return Glue<T1, T2, glue_minus>(X.get_ref(), Y.get_ref()); 00306 } 00307 00308 00309 00310 template<typename T1, typename T2> 00311 arma_inline 00312 const Glue<T1, T2, glue_minus> 00313 operator- 00314 (const Base<u8,T1>& X, const Base<u8,T2>& Y) 00315 { 00316 arma_extra_debug_sigprint(); 00317 00318 return Glue<T1, T2, glue_minus>(X.get_ref(), Y.get_ref()); 00319 } 00320 00321 00322 00323 // 00324 // old operators 00325 // 00326 00327 00328 // //! unary - 00329 // template<typename mT> 00330 // arma_inline 00331 // const Op<Mat<mT>, op_neg> 00332 // operator- 00333 // (const Mat<mT>& X) 00334 // { 00335 // arma_extra_debug_sigprint(); 00336 // 00337 // return Op<Mat<mT>,op_neg>(X); 00338 // } 00339 // 00340 // 00341 // 00342 // //! unary - 00343 // template<typename T1, typename op_type> 00344 // arma_inline 00345 // const Op< Op<T1, op_type>, op_neg > 00346 // operator- 00347 // (const Op<T1, op_type>& X) 00348 // { 00349 // arma_extra_debug_sigprint(); 00350 // 00351 // return Op<Op<T1, op_type>,op_neg>(X); 00352 // } 00353 // 00354 // 00355 // 00356 // //! cancellation of two consecutive negations: -(-T1) 00357 // template<typename T1> 00358 // arma_inline 00359 // const T1& 00360 // operator- 00361 // (const Op<T1, op_neg>& X) 00362 // { 00363 // arma_extra_debug_sigprint(); 00364 // 00365 // return X.m; 00366 // } 00367 // 00368 // 00369 // 00370 // //! -(Glue<T1,T2,glue_type>) 00371 // template<typename T1, typename T2, typename glue_type> 00372 // arma_inline 00373 // const Op< Glue<T1,T2,glue_type>, op_neg > 00374 // operator- 00375 // (const Glue<T1,T2,glue_type>& X) 00376 // { 00377 // arma_extra_debug_sigprint(); 00378 // 00379 // return Op< Glue<T1,T2,glue_type>,op_neg >(X); 00380 // } 00381 // 00382 // 00383 // 00384 // //! mat - scalar 00385 // template<typename mT> 00386 // arma_inline 00387 // const Op<Mat<mT>, op_scalar_minus_post> 00388 // operator- 00389 // (const Mat<mT>& X, const mT k) 00390 // { 00391 // arma_extra_debug_sigprint(); 00392 // 00393 // return Op<Mat<mT>, op_scalar_minus_post>(X,k); 00394 // } 00395 // 00396 // 00397 // 00398 // //! op - scalar 00399 // template<typename T1, typename op_type> 00400 // arma_inline 00401 // const Op<Op<T1,op_type>, op_scalar_minus_post> 00402 // operator- 00403 // (const Op<T1,op_type>& X, const typename T1::elem_type k) 00404 // { 00405 // arma_extra_debug_sigprint(); 00406 // 00407 // return Op<Op<T1,op_type>, op_scalar_minus_post>(X,k); 00408 // } 00409 // 00410 // 00411 // 00412 // //! op - scalar, level 2 00413 // template<typename T1> 00414 // arma_inline 00415 // const Op<T1, op_scalar_minus_post> 00416 // operator- 00417 // (const Op<T1,op_scalar_plus>& X, const typename T1::elem_type k) 00418 // { 00419 // arma_extra_debug_sigprint(); 00420 // 00421 // return Op<T1,op_scalar_minus_post>(X.m, X.aux - k); 00422 // } 00423 // 00424 // 00425 // 00426 // //! glue - scalar 00427 // template<typename T1, typename T2, typename glue_type> 00428 // arma_inline 00429 // const Op<Glue<T1,T2,glue_type>, op_scalar_minus_post> 00430 // operator- 00431 // (const Glue<T1,T2,glue_type>& X, const typename T1::elem_type k) 00432 // { 00433 // arma_extra_debug_sigprint(); 00434 // 00435 // return Op<Glue<T1,T2,glue_type>, op_scalar_minus_post>(X,k); 00436 // } 00437 // 00438 // 00439 // 00440 // //! scalar - mat 00441 // template<typename mT> 00442 // arma_inline 00443 // const Op<Mat<mT>, op_scalar_minus_pre> 00444 // operator- 00445 // (const mT k, const Mat<mT>& X) 00446 // { 00447 // arma_extra_debug_sigprint(); 00448 // 00449 // return Op<Mat<mT>, op_scalar_minus_pre>(X,k); 00450 // } 00451 // 00452 // 00453 // 00454 // //! scalar - op 00455 // template<typename T1, typename op_type> 00456 // arma_inline 00457 // const Op<Op<T1,op_type>, op_scalar_minus_pre> 00458 // operator- 00459 // (const typename T1::elem_type k, const Op<T1,op_type>& X) 00460 // { 00461 // arma_extra_debug_sigprint(); 00462 // 00463 // return Op<Op<T1,op_type>, op_scalar_minus_pre>(X,k); 00464 // } 00465 // 00466 // 00467 // 00468 // //! scalar - glue 00469 // template<typename T1, typename T2, typename glue_type> 00470 // arma_inline 00471 // const Op<Glue<T1,T2,glue_type>, op_scalar_minus_pre> 00472 // operator- 00473 // (const typename T1::elem_type k, const Glue<T1,T2,glue_type>& X) 00474 // { 00475 // arma_extra_debug_sigprint(); 00476 // 00477 // return Op<Glue<T1,T2,glue_type>, op_scalar_minus_pre>(X,k); 00478 // } 00479 // 00480 // 00481 // 00482 // //! mat - mat 00483 // template<typename mT> 00484 // arma_inline 00485 // const Glue<Mat<mT>, Mat<mT>, glue_minus> 00486 // operator- 00487 // (const Mat<mT>& X, const Mat<mT>& Y) 00488 // { 00489 // arma_extra_debug_sigprint(); 00490 // 00491 // return Glue<Mat<mT>, Mat<mT>, glue_minus>(X,Y); 00492 // } 00493 // 00494 // 00495 // 00496 // //! mat - diagmat(T1) 00497 // template<typename T1> 00498 // arma_inline 00499 // const Glue<Mat<typename T1::elem_type>, Op<T1,op_diagmat>, glue_minus_diag> 00500 // operator- 00501 // (const Mat<typename T1::elem_type>& X, const Op<T1,op_diagmat>& Y) 00502 // { 00503 // arma_extra_debug_sigprint(); 00504 // 00505 // return Glue<Mat<typename T1::elem_type>, Op<T1,op_diagmat>, glue_minus_diag>(X,Y); 00506 // } 00507 // 00508 // 00509 // 00510 // //! diagmat(T1) - mat 00511 // template<typename T1> 00512 // arma_inline 00513 // const Glue< Op<T1,op_diagmat>, Mat<typename T1::elem_type>, glue_minus_diag> 00514 // operator- 00515 // (const Op<T1,op_diagmat>& X, const Mat<typename T1::elem_type>& Y) 00516 // { 00517 // arma_extra_debug_sigprint(); 00518 // 00519 // return Glue< Op<T1,op_diagmat>, Mat<typename T1::elem_type>, glue_minus_diag>(X,Y); 00520 // } 00521 // 00522 // 00523 // 00524 // //! diagmat(T1) - diagmat(T2) 00525 // template<typename T1, typename T2> 00526 // arma_inline 00527 // const Glue< Op<T1,op_diagmat>, Op<T2,op_diagmat>, glue_minus_diag> 00528 // operator- 00529 // (const Op<T1,op_diagmat>& X, const Op<T2,op_diagmat>& Y) 00530 // { 00531 // arma_extra_debug_sigprint(); 00532 // 00533 // return Glue< Op<T1,op_diagmat>, Op<T2,op_diagmat>, glue_minus_diag>(X,Y); 00534 // } 00535 // 00536 // 00537 // 00538 // //! mat - op 00539 // template<typename T1, typename op_type> 00540 // arma_inline 00541 // const Glue<Mat<typename T1::elem_type>, Op<T1,op_type>, glue_minus> 00542 // operator- 00543 // (const Mat<typename T1::elem_type>& X, const Op<T1,op_type>& Y) 00544 // { 00545 // arma_extra_debug_sigprint(); 00546 // 00547 // return Glue<Mat<typename T1::elem_type>, Op<T1,op_type>, glue_minus>(X,Y); 00548 // } 00549 // 00550 // 00551 // 00552 // //! diagmat(T1) - op 00553 // template<typename T1, typename T2, typename op_type> 00554 // arma_inline 00555 // const Glue< Op<T1,op_diagmat>, Op<T2,op_type>, glue_minus_diag> 00556 // operator- 00557 // (const Op<T1,op_diagmat>& X, const Op<T2,op_type>& Y) 00558 // { 00559 // arma_extra_debug_sigprint(); 00560 // 00561 // return Glue< Op<T1,op_diagmat>, Op<T2,op_type>, glue_minus_diag>(X,Y); 00562 // } 00563 // 00564 // 00565 // 00566 // //! op - mat 00567 // template<typename T1, typename op_type> 00568 // arma_inline 00569 // const Glue<Op<T1,op_type>, Mat<typename T1::elem_type>, glue_minus> 00570 // operator- 00571 // (const Op<T1,op_type>& X, const Mat<typename T1::elem_type>& Y) 00572 // { 00573 // arma_extra_debug_sigprint(); 00574 // 00575 // return Glue<Op<T1,op_type>, Mat<typename T1::elem_type>, glue_minus>(X,Y); 00576 // } 00577 // 00578 // 00579 // 00580 // //! op - diagmat(T2) 00581 // template<typename T1, typename op_type, typename T2> 00582 // arma_inline 00583 // const Glue<Op<T1,op_type>, Op<T2,op_diagmat>, glue_minus_diag> 00584 // operator- 00585 // (const Op<T1,op_type>& X, const Op<T2,op_diagmat>& Y) 00586 // { 00587 // arma_extra_debug_sigprint(); 00588 // 00589 // return Glue<Op<T1,op_type>, Op<T2,op_diagmat>, glue_minus_diag>(X,Y); 00590 // } 00591 // 00592 // 00593 // 00594 // //! op - glue 00595 // template<typename T1, typename op_type, typename T2, typename T3, typename glue_type> 00596 // arma_inline 00597 // const Glue<Op<T1,op_type>, Glue<T2, T3, glue_type>, glue_minus> 00598 // operator- 00599 // (const Op<T1,op_type>& X, const Glue<T2, T3, glue_type>& Y) 00600 // { 00601 // arma_extra_debug_sigprint(); 00602 // 00603 // return Glue<Op<T1,op_type>, Glue<T2, T3, glue_type>, glue_minus>(X,Y); 00604 // } 00605 // 00606 // 00607 // 00608 // //! glue - op 00609 // template<typename T1, typename op_type, typename T2, typename T3, typename glue_type> 00610 // arma_inline 00611 // const Glue<Glue<T2, T3, glue_type>, Op<T1,op_type>, glue_minus> 00612 // operator- 00613 // (const Glue<T2, T3, glue_type>& X, const Op<T1,op_type>& Y) 00614 // { 00615 // arma_extra_debug_sigprint(); 00616 // 00617 // return Glue<Glue<T2, T3, glue_type>, Op<T1,op_type>, glue_minus>(X,Y); 00618 // } 00619 // 00620 // 00621 // 00622 // //! mat - glue 00623 // template<typename T1, typename T2, typename glue_type> 00624 // arma_inline 00625 // const Glue<Mat<typename T1::elem_type>, Glue<T1, T2,glue_type>, glue_minus> 00626 // operator- 00627 // (const Mat<typename T1::elem_type>& X, const Glue<T1, T2,glue_type>& Y) 00628 // { 00629 // arma_extra_debug_sigprint(); 00630 // 00631 // return Glue<Mat<typename T1::elem_type>, Glue<T1, T2,glue_type>, glue_minus>(X,Y); 00632 // } 00633 // 00634 // 00635 // 00636 // //! diagmat(T1) - glue 00637 // template<typename T1, typename T2, typename T3, typename glue_type> 00638 // arma_inline 00639 // const Glue<Op<T1,op_diagmat>, Glue<T2,T3,glue_type>, glue_minus_diag> 00640 // operator- 00641 // (const Op<T1,op_diagmat>& X, const Glue<T2,T3,glue_type>& Y) 00642 // { 00643 // arma_extra_debug_sigprint(); 00644 // 00645 // return Glue<Op<T1,op_diagmat>, Glue<T2,T3,glue_type>, glue_minus_diag>(X,Y); 00646 // } 00647 // 00648 // 00649 // 00650 // //! glue - mat 00651 // template<typename T1, typename T2, typename glue_type> 00652 // arma_inline 00653 // const Glue< Glue<T1,T2,glue_type>, Mat<typename T1::elem_type>, glue_minus> 00654 // operator- 00655 // (const Glue<T1,T2,glue_type>& X, const Mat<typename T1::elem_type>& Y) 00656 // { 00657 // arma_extra_debug_sigprint(); 00658 // 00659 // return Glue< Glue<T1,T2,glue_type>, Mat<typename T1::elem_type>, glue_minus>(X,Y); 00660 // } 00661 // 00662 // 00663 // 00664 // //! glue - diagmat(T1) 00665 // template<typename T1, typename T2, typename glue_type, typename T3> 00666 // arma_inline 00667 // const Glue< Glue<T1,T2,glue_type>, Op<T3,op_diagmat>, glue_minus_diag> 00668 // operator- 00669 // (const Glue<T1,T2,glue_type>& X, const Op<T3,op_diagmat>& Y) 00670 // { 00671 // arma_extra_debug_sigprint(); 00672 // 00673 // return Glue< Glue<T1,T2,glue_type>, Op<T3,op_diagmat>, glue_minus_diag>(X,Y); 00674 // } 00675 // 00676 // 00677 // 00678 // //! op - op 00679 // template<typename T1, typename op_type1, typename T2, typename op_type2> 00680 // arma_inline 00681 // const Glue<Op<T1,op_type1>, Op<T2,op_type2>, glue_minus> 00682 // operator- 00683 // (const Op<T1,op_type1>& X, const Op<T2,op_type2>& Y) 00684 // { 00685 // arma_extra_debug_sigprint(); 00686 // 00687 // return Glue<Op<T1,op_type1>, Op<T2,op_type2>, glue_minus>(X,Y); 00688 // } 00689 // 00690 // 00691 // 00692 // //! glue - glue 00693 // template<typename T1, typename T2, typename glue_type1, typename T3, typename T4, typename glue_type2> 00694 // arma_inline 00695 // const Glue<Glue<T1,T2,glue_type1>, Glue<T3,T4,glue_type2>, glue_minus> 00696 // operator- 00697 // (const Glue<T1,T2,glue_type1>& X, const Glue<T3,T4,glue_type2>& Y) 00698 // { 00699 // arma_extra_debug_sigprint(); 00700 // 00701 // return Glue<Glue<T1,T2,glue_type1>, Glue<T3,T4,glue_type2>, glue_minus>(X,Y); 00702 // } 00703 // 00704 // 00705 // 00706 // //! mat - Op<T2,op_neg> = mat + T2 00707 // template<typename T2> 00708 // arma_inline 00709 // const Glue<Mat<typename T2::elem_type>, T2, glue_plus> 00710 // operator- 00711 // (const Mat<typename T2::elem_type>& X, const Op<T2, op_neg>& Y) 00712 // { 00713 // arma_extra_debug_sigprint(); 00714 // 00715 // return Glue<Mat<typename T2::elem_type>, T2, glue_plus>(X,Y.m); 00716 // } 00717 // 00718 // 00719 // 00720 // //! diagmat - Op<T2,op_neg> = diagmat + T2 00721 // template<typename T1, typename T2> 00722 // arma_inline 00723 // const Glue< Op<T1,op_diagmat>, T2, glue_plus_diag> 00724 // operator- 00725 // (const Op<T1,op_diagmat>& X, const Op<T2, op_neg>& Y) 00726 // { 00727 // arma_extra_debug_sigprint(); 00728 // 00729 // return Glue< Op<T1,op_diagmat>, T2, glue_plus_diag>(X,Y.m); 00730 // } 00731 // 00732 // 00733 // 00734 // //! op - Op<T2,op_neg> = op + T2 00735 // template<typename T1, typename op_type, typename T2> 00736 // arma_inline 00737 // const Glue<Op<T1, op_type>, T2, glue_plus> 00738 // operator- 00739 // (const Op<T1, op_type>& X, const Op<T2, op_neg>& Y) 00740 // { 00741 // arma_extra_debug_sigprint(); 00742 // 00743 // return Glue< Op<T1, op_type>, T2, glue_plus>(X,Y.m); 00744 // } 00745 // 00746 // 00747 // 00748 // //! glue - Op<T3,op_neg> = glue + T3 00749 // template<typename T1, typename T2, typename glue_type, typename T3> 00750 // arma_inline 00751 // const Glue<Glue<T1,T2,glue_type>, T3, glue_plus> 00752 // operator- 00753 // (const Glue<T1,T2,glue_type>& X, const Op<T3, op_neg>& Y) 00754 // { 00755 // arma_extra_debug_sigprint(); 00756 // 00757 // return Glue< Glue<T1,T2,glue_type>, T3, glue_plus>(X,Y.m); 00758 // } 00759 // 00760 // 00761 // 00762 // //! Base - subview 00763 // template<typename T1> 00764 // arma_inline 00765 // const Glue<T1, subview<typename T1::elem_type>, glue_minus> 00766 // operator- 00767 // (const Base<T1>& X, const subview<typename T1::elem_type>& Y) 00768 // { 00769 // arma_extra_debug_sigprint(); 00770 // 00771 // return Glue<T1, subview<typename T1::elem_type>, glue_minus>(X.get_ref(),Y); 00772 // } 00773 // 00774 // 00775 // 00776 // //! subview - Base 00777 // template<typename T1> 00778 // arma_inline 00779 // const Glue<subview<typename T1::elem_type>, T1, glue_minus> 00780 // operator- 00781 // (const subview<typename T1::elem_type>& X, const Base<T1>& Y) 00782 // { 00783 // arma_extra_debug_sigprint(); 00784 // 00785 // return Glue<subview<typename T1::elem_type>, T1, glue_minus>(X,Y.get_ref()); 00786 // } 00787 // 00788 // 00789 // 00790 // //! Base - diagview 00791 // template<typename T1> 00792 // arma_inline 00793 // const Glue<T1, diagview<typename T1::elem_type>, glue_minus> 00794 // operator- 00795 // (const Base<T1>& X, const diagview<typename T1::elem_type>& Y) 00796 // { 00797 // arma_extra_debug_sigprint(); 00798 // 00799 // return Glue<T1, diagview<typename T1::elem_type>, glue_minus>(X.get_ref(),Y); 00800 // } 00801 // 00802 // 00803 // 00804 // //! diagview - Base 00805 // template<typename T1> 00806 // arma_inline 00807 // const Glue<diagview<typename T1::elem_type>, T1, glue_minus> 00808 // operator- 00809 // (const diagview<typename T1::elem_type>& X, const Base<T1>& Y) 00810 // { 00811 // arma_extra_debug_sigprint(); 00812 // 00813 // return Glue<diagview<typename T1::elem_type>, T1, glue_minus>(X,Y.get_ref()); 00814 // } 00815 // 00816 // 00817 // 00818 // //! scalar - subview 00819 // template<typename mT> 00820 // arma_inline 00821 // const Op<subview<mT>, op_scalar_minus_pre> 00822 // operator- 00823 // (const mT k, const subview<mT>& X) 00824 // { 00825 // arma_extra_debug_sigprint(); 00826 // 00827 // return Op<subview<mT>, op_scalar_minus_pre>(X,k); 00828 // } 00829 // 00830 // 00831 // 00832 // //! scalar - diagview 00833 // template<typename mT> 00834 // arma_inline 00835 // const Op<diagview<mT>, op_scalar_minus_pre> 00836 // operator- 00837 // (const mT k, const diagview<mT>& X) 00838 // { 00839 // arma_extra_debug_sigprint(); 00840 // 00841 // return Op<diagview<mT>, op_scalar_minus_pre>(X,k); 00842 // } 00843 // 00844 // 00845 // 00846 // //! subview - scalar 00847 // template<typename mT> 00848 // arma_inline 00849 // const Op<subview<mT>, op_scalar_minus_post> 00850 // operator- 00851 // (const subview<mT>& X, const mT k) 00852 // { 00853 // arma_extra_debug_sigprint(); 00854 // 00855 // return Op<subview<mT>, op_scalar_minus_post>(X,k); 00856 // } 00857 // 00858 // 00859 // 00860 // //! diagview - scalar 00861 // template<typename mT> 00862 // arma_inline 00863 // const Op<diagview<mT>, op_scalar_minus_post> 00864 // operator- 00865 // (const diagview<mT>& X, const mT k) 00866 // { 00867 // arma_extra_debug_sigprint(); 00868 // 00869 // return Op<diagview<mT>, op_scalar_minus_post>(X,k); 00870 // } 00871 00872 00873 00874 //! @}