operator_schur.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_schur
00017 //! @{
00018 
00019 
00020 // operator %, which we define it to do a schur product (element-wise multiplication)
00021 
00022 
00023 //! Base % Base
00024 template<typename T1, typename T2>
00025 arma_inline
00026 const Glue<T1, T2, glue_schur>
00027 operator%
00028 (const Base<typename T1::elem_type,T1>& X, const Base<typename T1::elem_type,T2>& Y)
00029   {
00030   arma_extra_debug_sigprint();
00031   
00032   return Glue<T1, T2, glue_schur>(X.get_ref(), Y.get_ref());
00033   }
00034 
00035 
00036 
00037 //! Base % diagmat
00038 template<typename T1, typename T2>
00039 arma_inline
00040 const Glue<T1, Op<T2,op_diagmat>, glue_schur_diag>
00041 operator%
00042 (const Base<typename T2::elem_type,T1>& X, const Op<T2,op_diagmat>& Y)
00043   {
00044   arma_extra_debug_sigprint();
00045   
00046   return Glue<T1, Op<T2,op_diagmat>, glue_schur_diag>(X.get_ref(), Y);
00047   }
00048 
00049 
00050 
00051 //! diagmat % Base
00052 template<typename T1, typename T2>
00053 arma_inline
00054 const Glue< Op<T1,op_diagmat>, T2, glue_schur_diag>
00055 operator%
00056 (const Op<T1,op_diagmat>& X, const Base<typename T1::elem_type,T2>& Y)
00057   {
00058   arma_extra_debug_sigprint();
00059   
00060   return Glue< Op<T1,op_diagmat>, T2, glue_schur_diag>(X, Y.get_ref());
00061   }
00062 
00063 
00064 
00065 //
00066 // schur product of Base objects with different element types
00067 //
00068 
00069 
00070 
00071 //! Base % Base
00072 template<typename eT1, typename T1, typename eT2, typename T2>
00073 arma_inline
00074 Mat<typename promote_type<eT1,eT2>::result>
00075 operator%
00076 (const Base<eT1,T1>& X, const Base<eT2,T2>& Y)
00077   {
00078   arma_extra_debug_sigprint();
00079   
00080   promote_type<eT1,eT2>::check();
00081   
00082   const unwrap<T1> tmp1(X.get_ref());
00083   const unwrap<T2> tmp2(Y.get_ref());
00084   
00085   const Mat<eT1>& A = tmp1.M;
00086   const Mat<eT2>& B = tmp2.M;
00087   
00088   Mat< typename promote_type<eT1,eT2>::result > out;
00089   glue_schur::apply_mixed(out, A, B);
00090   
00091   return out;
00092   }
00093 
00094 
00095 
00096 //
00097 // schur product of Base objects with same element types
00098 //
00099 
00100 
00101 
00102 template<typename T1, typename T2>
00103 arma_inline
00104 const Glue<T1, T2, glue_schur>
00105 operator%
00106 (const Base<std::complex<double>,T1>& X, const Base<std::complex<double>,T2>& Y)
00107   {
00108   arma_extra_debug_sigprint();
00109   
00110   return Glue<T1, T2, glue_schur>(X.get_ref(), Y.get_ref());
00111   }
00112 
00113 
00114 
00115 template<typename T1, typename T2>
00116 arma_inline
00117 const Glue<T1, T2, glue_schur>
00118 operator%
00119 (const Base<std::complex<float>,T1>& X, const Base<std::complex<float>,T2>& Y)
00120   {
00121   arma_extra_debug_sigprint();
00122   
00123   return Glue<T1, T2, glue_schur>(X.get_ref(), Y.get_ref());
00124   }
00125 
00126 
00127 
00128 template<typename T1, typename T2>
00129 arma_inline
00130 const Glue<T1, T2, glue_schur>
00131 operator%
00132 (const Base<double,T1>& X, const Base<double,T2>& Y)
00133   {
00134   arma_extra_debug_sigprint();
00135   
00136   return Glue<T1, T2, glue_schur>(X.get_ref(), Y.get_ref());
00137   }
00138 
00139 
00140 
00141 template<typename T1, typename T2>
00142 arma_inline
00143 const Glue<T1, T2, glue_schur>
00144 operator%
00145 (const Base<float,T1>& X, const Base<float,T2>& Y)
00146   {
00147   arma_extra_debug_sigprint();
00148   
00149   return Glue<T1, T2, glue_schur>(X.get_ref(), Y.get_ref());
00150   }
00151 
00152 
00153 
00154 template<typename T1, typename T2>
00155 arma_inline
00156 const Glue<T1, T2, glue_schur>
00157 operator%
00158 (const Base<s32,T1>& X, const Base<s32,T2>& Y)
00159   {
00160   arma_extra_debug_sigprint();
00161   
00162   return Glue<T1, T2, glue_schur>(X.get_ref(), Y.get_ref());
00163   }
00164 
00165 
00166 
00167 template<typename T1, typename T2>
00168 arma_inline
00169 const Glue<T1, T2, glue_schur>
00170 operator%
00171 (const Base<u32,T1>& X, const Base<u32,T2>& Y)
00172   {
00173   arma_extra_debug_sigprint();
00174   
00175   return Glue<T1, T2, glue_schur>(X.get_ref(), Y.get_ref());
00176   }
00177 
00178 
00179 
00180 template<typename T1, typename T2>
00181 arma_inline
00182 const Glue<T1, T2, glue_schur>
00183 operator%
00184 (const Base<s16,T1>& X, const Base<s16,T2>& Y)
00185   {
00186   arma_extra_debug_sigprint();
00187   
00188   return Glue<T1, T2, glue_schur>(X.get_ref(), Y.get_ref());
00189   }
00190 
00191 
00192 
00193 template<typename T1, typename T2>
00194 arma_inline
00195 const Glue<T1, T2, glue_schur>
00196 operator%
00197 (const Base<u16,T1>& X, const Base<u16,T2>& Y)
00198   {
00199   arma_extra_debug_sigprint();
00200   
00201   return Glue<T1, T2, glue_schur>(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_schur>
00209 operator%
00210 (const Base<s8,T1>& X, const Base<s8,T2>& Y)
00211   {
00212   arma_extra_debug_sigprint();
00213   
00214   return Glue<T1, T2, glue_schur>(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_schur>
00222 operator%
00223 (const Base<u8,T1>& X, const Base<u8,T2>& Y)
00224   {
00225   arma_extra_debug_sigprint();
00226   
00227   return Glue<T1, T2, glue_schur>(X.get_ref(), Y.get_ref());
00228   }
00229 
00230 
00231 
00232 //
00233 // old operators
00234 //
00235 
00236 
00237 // //! mat % mat
00238 // template<typename mT>
00239 // arma_inline
00240 // const Glue<Mat<mT>, Mat<mT>, glue_schur>
00241 // operator%
00242 // (const Mat<mT>& X, const Mat<mT>& Y)
00243 //   {
00244 //   arma_extra_debug_sigprint();
00245 //   
00246 //   return Glue<Mat<mT>, Mat<mT>, glue_schur>(X,Y);
00247 //   }
00248 // 
00249 // 
00250 // 
00251 // //! mat % diagmat(T1)
00252 // template<typename T1>
00253 // arma_inline
00254 // const Glue<Mat<typename T1::elem_type>, Op<T1,op_diagmat>, glue_schur_diag>
00255 // operator%
00256 // (const Mat<typename T1::elem_type>& X, const Op<T1,op_diagmat>& Y)
00257 //   {
00258 //   arma_extra_debug_sigprint();
00259 //   
00260 //   return Glue<Mat<typename T1::elem_type>, Op<T1,op_diagmat>, glue_schur_diag>(X,Y);
00261 //   }
00262 // 
00263 // 
00264 // 
00265 // //! diagmat(T1) % mat
00266 // template<typename mT, typename T1>
00267 // arma_inline
00268 // const Glue< Op<T1,op_diagmat>, Mat<typename T1::elem_type>, glue_schur_diag>
00269 // operator%
00270 // (const Op<T1,op_diagmat>& X, const Mat<typename T1::elem_type>& Y)
00271 //   {
00272 //   arma_extra_debug_sigprint();
00273 //   
00274 //   return Glue< Op<T1,op_diagmat>, Mat<typename T1::elem_type>, glue_schur_diag>(X,Y);
00275 //   }
00276 // 
00277 // 
00278 // 
00279 // //! diagmat(T1) % diagmat(T2)
00280 // template<typename T1, typename T2>
00281 // arma_inline
00282 // const Glue< Op<T1,op_diagmat>, Op<T2,op_diagmat>, glue_schur_diag>
00283 // operator%
00284 // (const Op<T1,op_diagmat>& X, const Op<T2,op_diagmat>& Y)
00285 //   {
00286 //   arma_extra_debug_sigprint();
00287 //   
00288 //   return Glue< Op<T1,op_diagmat>, Op<T2,op_diagmat>, glue_schur_diag>(X,Y);
00289 //   }
00290 // 
00291 // 
00292 // 
00293 // //! mat % op
00294 // template<typename T1, typename op_type>
00295 // arma_inline
00296 // const Glue<Mat<typename T1::elem_type>, Op<T1,op_type>, glue_schur>
00297 // operator%
00298 // (const Mat<typename T1::elem_type>& X, const Op<T1,op_type>& Y)
00299 //   {
00300 //   arma_extra_debug_sigprint();
00301 //   
00302 //   return Glue<Mat<typename T1::elem_type>, Op<T1,op_type>, glue_schur>(X,Y);
00303 //   }
00304 // 
00305 // 
00306 // 
00307 // //! op % mat
00308 // template<typename T1, typename op_type>
00309 // arma_inline
00310 // const Glue<Op<T1,op_type>, Mat<typename T1::elem_type>, glue_schur>
00311 // operator%
00312 // (const Op<T1,op_type>& X, const Mat<typename T1::elem_type>& Y)
00313 //   {
00314 //   arma_extra_debug_sigprint();
00315 //   
00316 //   return Glue<Op<T1,op_type>, Mat<typename T1::elem_type>, glue_schur>(X,Y);
00317 //   }
00318 // 
00319 // 
00320 // 
00321 // //! op % diagmat(T2)
00322 // template<typename T1, typename op_type, typename T2>
00323 // arma_inline
00324 // const Glue<Op<T1,op_type>, Op<T2,op_diagmat>, glue_schur_diag>
00325 // operator%
00326 // (const Op<T1,op_type>& X, const Op<T2,op_diagmat>& Y)
00327 //   {
00328 //   arma_extra_debug_sigprint();
00329 //   
00330 //   return Glue<Op<T1,op_type>, Op<T2,op_diagmat>, glue_schur_diag>(X,Y);
00331 //   }
00332 // 
00333 // 
00334 // 
00335 // //! op % glue
00336 // template<typename T1, typename op_type, typename T2, typename T3, typename glue_type>
00337 // arma_inline
00338 // const Glue<Op<T1,op_type>, Glue<T2, T3, glue_type>, glue_schur>
00339 // operator%
00340 // (const Op<T1,op_type>& X, const Glue<T2, T3, glue_type>& Y)
00341 //   {
00342 //   arma_extra_debug_sigprint();
00343 //   
00344 //   return Glue<Op<T1,op_type>, Glue<T2, T3, glue_type>, glue_schur>(X,Y);
00345 //   }
00346 // 
00347 // 
00348 // 
00349 // //! glue % op
00350 // template<typename T1, typename op_type, typename T2, typename T3, typename glue_type>
00351 // arma_inline
00352 // const Glue<Glue<T2, T3, glue_type>, Op<T1,op_type>, glue_schur>
00353 // operator%
00354 // (const Glue<T2, T3, glue_type>& X, const Op<T1,op_type>& Y)
00355 //   {
00356 //   arma_extra_debug_sigprint();
00357 //   
00358 //   return Glue<Glue<T2, T3, glue_type>, Op<T1,op_type>, glue_schur>(X,Y);
00359 //   }
00360 // 
00361 // 
00362 // 
00363 // //! mat % glue
00364 // template<typename T1, typename T2, typename glue_type>
00365 // arma_inline
00366 // const Glue<Mat<typename T1::elem_type>, Glue<T1,T2,glue_type>, glue_schur>
00367 // operator%
00368 // (const Mat<typename T1::elem_type>& X, const Glue<T1,T2,glue_type>& Y)
00369 //   {
00370 //   arma_extra_debug_sigprint();
00371 //   
00372 //   return Glue<Mat<typename T1::elem_type>, Glue<T1,T2,glue_type>, glue_schur>(X,Y);
00373 //   }
00374 // 
00375 // 
00376 // 
00377 // //! diagmat(T1) % glue
00378 // template<typename T1, typename T2, typename T3, typename glue_type>
00379 // arma_inline
00380 // const Glue< Op<T1,op_diagmat>, Glue<T2,T3,glue_type>, glue_schur_diag>
00381 // operator%
00382 // (const Op<T1,op_diagmat>& X, const Glue<T2,T3,glue_type>& Y)
00383 //   {
00384 //   arma_extra_debug_sigprint();
00385 //   
00386 //   return Glue< Op<T1,op_diagmat>, Glue<T2,T3,glue_type>, glue_schur_diag>(X,Y);
00387 //   }
00388 // 
00389 // 
00390 // 
00391 // //! glue % mat
00392 // template<typename T1, typename T2, typename glue_type>
00393 // arma_inline
00394 // const Glue<Glue<T1, T2,glue_type>, Mat<typename T1::elem_type>, glue_schur>
00395 // operator%
00396 // (const Glue<T1,T2,glue_type>& X, const Mat<typename T1::elem_type>& Y)
00397 //   {
00398 //   arma_extra_debug_sigprint();
00399 //   
00400 //   return Glue<Glue<T1,T2,glue_type>, Mat<typename T1::elem_type>, glue_schur>(X,Y);
00401 //   }
00402 // 
00403 // 
00404 // 
00405 // //! glue % diagmat(T3)
00406 // template<typename T1, typename T2, typename glue_type, typename T3>
00407 // arma_inline
00408 // const Glue<Glue<T1, T2,glue_type>, Op<T3,op_diagmat>, glue_schur_diag>
00409 // operator%
00410 // (const Glue<T1,T2,glue_type>& X, const Op<T3,op_diagmat>& Y)
00411 //   {
00412 //   arma_extra_debug_sigprint();
00413 //   
00414 //   return Glue<Glue<T1,T2,glue_type>, Op<T3,op_diagmat>, glue_schur_diag>(X,Y);
00415 //   }
00416 // 
00417 // 
00418 // 
00419 // //! op % op
00420 // template<typename T1, typename op_type1, typename T2, typename op_type2>
00421 // arma_inline
00422 // const Glue<Op<T1,op_type1>, Op<T2,op_type2>, glue_schur>
00423 // operator%
00424 // (const Op<T1,op_type1>& X, const Op<T2,op_type2>& Y)
00425 //   {
00426 //   arma_extra_debug_sigprint();
00427 //   
00428 //   return Glue<Op<T1,op_type1>, Op<T2,op_type2>, glue_schur>(X,Y);
00429 //   }
00430 // 
00431 // 
00432 // //! glue % glue
00433 // template<typename T1, typename T2, typename glue_type1, typename T3, typename T4, typename glue_type2>
00434 // arma_inline
00435 // const Glue<Glue<T1,T2,glue_type1>, Glue<T3,T4,glue_type2>, glue_schur>
00436 // operator%
00437 // (const Glue<T1,T2,glue_type1>& X, const Glue<T3,T4,glue_type2>& Y)
00438 //   {
00439 //   arma_extra_debug_sigprint();
00440 //   
00441 //   return Glue<Glue<T1,T2,glue_type1>, Glue<T3,T4,glue_type2>, glue_schur>(X,Y);
00442 //   }
00443 // 
00444 // 
00445 // 
00446 // //! Base % subview
00447 // template<typename T1>
00448 // arma_inline
00449 // const Glue<T1, subview<typename T1::elem_type>, glue_schur>
00450 // operator%
00451 // (const Base<T1>& X, const subview<typename T1::elem_type>& Y)
00452 //   {
00453 //   arma_extra_debug_sigprint();
00454 //   
00455 //   return Glue<T1, subview<typename T1::elem_type>, glue_schur>(X.get_ref(),Y);
00456 //   }
00457 // 
00458 // 
00459 // 
00460 // //! subview % Base
00461 // template<typename T1>
00462 // arma_inline
00463 // const Glue<subview<typename T1::elem_type>, T1, glue_schur>
00464 // operator%
00465 // (const subview<typename T1::elem_type>& X, const Base<T1>& Y)
00466 //   {
00467 //   arma_extra_debug_sigprint();
00468 //   
00469 //   return Glue<subview<typename T1::elem_type>, T1, glue_schur>(X,Y.get_ref());
00470 //   }
00471 // 
00472 // 
00473 // 
00474 // //! Base % diagview
00475 // template<typename T1>
00476 // arma_inline
00477 // const Glue<T1, diagview<typename T1::elem_type>, glue_schur>
00478 // operator%
00479 // (const Base<T1>& X, const diagview<typename T1::elem_type>& Y)
00480 //   {
00481 //   arma_extra_debug_sigprint();
00482 //   
00483 //   return Glue<T1, diagview<typename T1::elem_type>, glue_schur>(X.get_ref(),Y);
00484 //   }
00485 // 
00486 // 
00487 // 
00488 // //! diagview % Base
00489 // template<typename T1>
00490 // arma_inline
00491 // const Glue<diagview<typename T1::elem_type>, T1, glue_schur>
00492 // operator%
00493 // (const diagview<typename T1::elem_type>& X, const Base<T1>& Y)
00494 //   {
00495 //   arma_extra_debug_sigprint();
00496 //   
00497 //   return Glue<diagview<typename T1::elem_type>, T1, glue_schur>(X,Y.get_ref());
00498 //   }
00499 
00500 
00501 
00502 //! @}