operator_minus.hpp

Go to the documentation of this file.
00001 // Copyright (C) 2009 NICTA
00002 // 
00003 // Authors:
00004 // - Conrad Sanderson (conradsand at ieee dot org)
00005 // 
00006 // This file is part of the Armadillo C++ library.
00007 // It is provided without any warranty of fitness
00008 // for any purpose. You can redistribute this file
00009 // and/or modify it under the terms of the GNU
00010 // Lesser General Public License (LGPL) as published
00011 // by the Free Software Foundation, either version 3
00012 // of the License or (at your option) any later version.
00013 // (see http://www.opensource.org/licenses for more info)
00014 
00015 
00016 //! \addtogroup 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 //! @}