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 //! @}