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_div 00017 //! @{ 00018 00019 00020 00021 //! Base / scalar 00022 template<typename T1> 00023 arma_inline 00024 const Op<T1, op_scalar_div_post> 00025 operator/ 00026 (const Base<typename T1::elem_type,T1>& X, const typename T1::elem_type k) 00027 { 00028 arma_extra_debug_sigprint(); 00029 00030 return Op<T1, op_scalar_div_post>(X.get_ref(), k); 00031 } 00032 00033 00034 00035 //! Op<mat,op_ones_full> / scalar 00036 template<typename eT> 00037 arma_inline 00038 Mat<eT> 00039 operator/ 00040 (const Op<Mat<eT>,op_ones_full>& X, const eT k) 00041 { 00042 arma_extra_debug_sigprint(); 00043 00044 Mat<eT> tmp(X.aux_u32_a, X.aux_u32_b); 00045 tmp.fill( eT(1)/k ); 00046 00047 return tmp; 00048 } 00049 00050 00051 00052 //! Op<mat,op_ones_diag> / scalar 00053 template<typename eT> 00054 arma_inline 00055 Mat<eT> 00056 operator/ 00057 (const Op<Mat<eT>,op_ones_diag>& X, const eT k) 00058 { 00059 arma_extra_debug_sigprint(); 00060 00061 Mat<eT> out; 00062 out.zeros(X.aux_u32_a, X.aux_u32_b); 00063 00064 const eT inv_k = eT(1)/k; 00065 00066 for(u32 i=0; i<out.n_rows; ++i) 00067 { 00068 out.at(i,i) = inv_k; 00069 } 00070 00071 return out; 00072 } 00073 00074 00075 00076 //! scalar / Base 00077 template<typename T1> 00078 arma_inline 00079 const Op<T1, op_scalar_div_pre> 00080 operator/ 00081 (const typename T1::elem_type k, const Base<typename T1::elem_type,T1>& X) 00082 { 00083 arma_extra_debug_sigprint(); 00084 00085 return Op<T1, op_scalar_div_pre>(X.get_ref(), k); 00086 } 00087 00088 00089 00090 // 00091 // element-wise division of Base objects with different element types 00092 // 00093 00094 00095 00096 //! Base / Base 00097 template<typename eT1, typename T1, typename eT2, typename T2> 00098 arma_inline 00099 Mat<typename promote_type<eT1,eT2>::result> 00100 operator/ 00101 (const Base<eT1,T1>& X, const Base<eT2,T2>& Y) 00102 { 00103 arma_extra_debug_sigprint(); 00104 00105 promote_type<eT1,eT2>::check(); 00106 00107 const unwrap<T1> tmp1(X.get_ref()); 00108 const unwrap<T2> tmp2(Y.get_ref()); 00109 00110 const Mat<eT1>& A = tmp1.M; 00111 const Mat<eT2>& B = tmp2.M; 00112 00113 Mat< typename promote_type<eT1,eT2>::result > out; 00114 glue_div::apply_mixed(out, A, B); 00115 00116 return out; 00117 } 00118 00119 00120 00121 // 00122 // element-wise division of Base objects with same element types 00123 // 00124 00125 00126 00127 template<typename T1, typename T2> 00128 arma_inline 00129 const Glue<T1, T2, glue_div> 00130 operator/ 00131 (const Base<std::complex<double>,T1>& X, const Base<std::complex<double>,T2>& Y) 00132 { 00133 arma_extra_debug_sigprint(); 00134 00135 return Glue<T1, T2, glue_div>(X.get_ref(), Y.get_ref()); 00136 } 00137 00138 00139 00140 template<typename T1, typename T2> 00141 arma_inline 00142 const Glue<T1, T2, glue_div> 00143 operator/ 00144 (const Base<std::complex<float>,T1>& X, const Base<std::complex<float>,T2>& Y) 00145 { 00146 arma_extra_debug_sigprint(); 00147 00148 return Glue<T1, T2, glue_div>(X.get_ref(), Y.get_ref()); 00149 } 00150 00151 00152 00153 template<typename T1, typename T2> 00154 arma_inline 00155 const Glue<T1, T2, glue_div> 00156 operator/ 00157 (const Base<double,T1>& X, const Base<double,T2>& Y) 00158 { 00159 arma_extra_debug_sigprint(); 00160 00161 return Glue<T1, T2, glue_div>(X.get_ref(), Y.get_ref()); 00162 } 00163 00164 00165 00166 template<typename T1, typename T2> 00167 arma_inline 00168 const Glue<T1, T2, glue_div> 00169 operator/ 00170 (const Base<float,T1>& X, const Base<float,T2>& Y) 00171 { 00172 arma_extra_debug_sigprint(); 00173 00174 return Glue<T1, T2, glue_div>(X.get_ref(), Y.get_ref()); 00175 } 00176 00177 00178 00179 template<typename T1, typename T2> 00180 arma_inline 00181 const Glue<T1, T2, glue_div> 00182 operator/ 00183 (const Base<s32,T1>& X, const Base<s32,T2>& Y) 00184 { 00185 arma_extra_debug_sigprint(); 00186 00187 return Glue<T1, T2, glue_div>(X.get_ref(), Y.get_ref()); 00188 } 00189 00190 00191 00192 template<typename T1, typename T2> 00193 arma_inline 00194 const Glue<T1, T2, glue_div> 00195 operator/ 00196 (const Base<u32,T1>& X, const Base<u32,T2>& Y) 00197 { 00198 arma_extra_debug_sigprint(); 00199 00200 return Glue<T1, T2, glue_div>(X.get_ref(), Y.get_ref()); 00201 } 00202 00203 00204 00205 template<typename T1, typename T2> 00206 arma_inline 00207 const Glue<T1, T2, glue_div> 00208 operator/ 00209 (const Base<s16,T1>& X, const Base<s16,T2>& Y) 00210 { 00211 arma_extra_debug_sigprint(); 00212 00213 return Glue<T1, T2, glue_div>(X.get_ref(), Y.get_ref()); 00214 } 00215 00216 00217 00218 template<typename T1, typename T2> 00219 arma_inline 00220 const Glue<T1, T2, glue_div> 00221 operator/ 00222 (const Base<u16,T1>& X, const Base<u16,T2>& Y) 00223 { 00224 arma_extra_debug_sigprint(); 00225 00226 return Glue<T1, T2, glue_div>(X.get_ref(), Y.get_ref()); 00227 } 00228 00229 00230 00231 template<typename T1, typename T2> 00232 arma_inline 00233 const Glue<T1, T2, glue_div> 00234 operator/ 00235 (const Base<s8,T1>& X, const Base<s8,T2>& Y) 00236 { 00237 arma_extra_debug_sigprint(); 00238 00239 return Glue<T1, T2, glue_div>(X.get_ref(), Y.get_ref()); 00240 } 00241 00242 00243 00244 template<typename T1, typename T2> 00245 arma_inline 00246 const Glue<T1, T2, glue_div> 00247 operator/ 00248 (const Base<u8,T1>& X, const Base<u8,T2>& Y) 00249 { 00250 arma_extra_debug_sigprint(); 00251 00252 return Glue<T1, T2, glue_div>(X.get_ref(), Y.get_ref()); 00253 } 00254 00255 00256 00257 // 00258 // old operators 00259 // 00260 00261 00262 // //! mat / scalar 00263 // template<typename mT> 00264 // arma_inline 00265 // const Op<Mat<mT>, op_scalar_div_post> 00266 // operator/ 00267 // (const Mat<mT>& X, const mT k) 00268 // { 00269 // arma_extra_debug_sigprint(); 00270 // 00271 // return Op<Mat<mT>, op_scalar_div_post>(X, k); 00272 // } 00273 // 00274 // 00275 // 00276 // //! op / scalar 00277 // template<typename T1, typename op_type> 00278 // arma_inline 00279 // const Op< Op<T1,op_type>, op_scalar_div_post> 00280 // operator/ 00281 // (const Op<T1,op_type>& X, const typename T1::elem_type k) 00282 // { 00283 // arma_extra_debug_sigprint(); 00284 // 00285 // return Op< Op<T1,op_type>, op_scalar_div_post>(X, k); 00286 // } 00287 // 00288 // 00289 // 00290 // //! op / scalar, level 2 00291 // template<typename T1> 00292 // arma_inline 00293 // const Op<T1,op_scalar_div_post> 00294 // operator/ 00295 // (const Op<T1,op_scalar_div_post>& X, const typename T1::elem_type k) 00296 // { 00297 // arma_extra_debug_sigprint(); 00298 // 00299 // return Op<T1, op_scalar_div_post>(X.m, X.aux / k); 00300 // } 00301 // 00302 // 00303 // 00304 // //! glue / scalar 00305 // template<typename T1, typename T2, typename glue_type> 00306 // arma_inline 00307 // const Op<Glue<T1,T2,glue_type>, op_scalar_div_post> 00308 // operator/ 00309 // (const Glue<T1,T2,glue_type>& X, const typename T1::elem_type k) 00310 // { 00311 // arma_extra_debug_sigprint(); 00312 // 00313 // return Op<Glue<T1,T2,glue_type>, op_scalar_div_post>(X, k); 00314 // } 00315 // 00316 // 00317 // 00318 // //! Op<mat,op_ones_full> / scalar 00319 // template<typename mT> 00320 // arma_inline 00321 // Mat<mT> 00322 // operator/ 00323 // (const Op<Mat<mT>,op_ones_full>& X, const mT k) 00324 // { 00325 // arma_extra_debug_sigprint(); 00326 // 00327 // Mat<mT> tmp(X.aux_u32_a, X.aux_u32_b); 00328 // tmp.fill( mT(1)/k ); 00329 // 00330 // return tmp; 00331 // } 00332 // 00333 // 00334 // 00335 // //! Op<mat,op_ones_diag> / scalar 00336 // template<typename mT> 00337 // arma_inline 00338 // Mat<mT> 00339 // operator/ 00340 // (const Op<Mat<mT>,op_ones_diag>& X, const mT k) 00341 // { 00342 // arma_extra_debug_sigprint(); 00343 // 00344 // Mat<mT> out; 00345 // out.zeros(X.aux_u32_a, X.aux_u32_b); 00346 // 00347 // const mT inv_k = mT(1)/k; 00348 // 00349 // for(u32 i=0; i<out.n_rows; ++i) 00350 // { 00351 // out.at(i,i) = inv_k; 00352 // } 00353 // 00354 // return out; 00355 // } 00356 // 00357 // 00358 // 00359 // //! scalar / mat 00360 // template<typename mT> 00361 // arma_inline 00362 // const Op<Mat<mT>, op_scalar_div_pre> 00363 // operator/ 00364 // (const mT k, const Mat<mT>& X) 00365 // { 00366 // arma_extra_debug_sigprint(); 00367 // 00368 // return Op<Mat<mT>, op_scalar_div_pre>(X, k); 00369 // } 00370 // 00371 // 00372 // 00373 // //! scalar / op 00374 // template<typename T1, typename op_type> 00375 // arma_inline 00376 // const Op< Op<T1,op_type>, op_scalar_div_pre> 00377 // operator/ 00378 // (const typename T1::elem_type k, const Op<T1,op_type>& X) 00379 // { 00380 // arma_extra_debug_sigprint(); 00381 // 00382 // return Op< Op<T1,op_type>, op_scalar_div_pre>(X, k); 00383 // } 00384 // 00385 // 00386 // 00387 // //! scalar / glue 00388 // template<typename T1, typename T2, typename glue_type> 00389 // arma_inline 00390 // const Op<Glue<T1,T2,glue_type>, op_scalar_div_pre> 00391 // operator/ 00392 // (const typename T1::elem_type k, const Glue<T1,T2,glue_type>& X) 00393 // { 00394 // arma_extra_debug_sigprint(); 00395 // 00396 // return Op<Glue<T1,T2,glue_type>, op_scalar_div_pre>(X, k); 00397 // } 00398 // 00399 // 00400 // 00401 // //! mat / mat 00402 // template<typename mT> 00403 // arma_inline 00404 // const Glue<Mat<mT>, Mat<mT>, glue_div> 00405 // operator/ 00406 // (const Mat<mT>& X, const Mat<mT>& Y) 00407 // { 00408 // arma_extra_debug_sigprint(); 00409 // 00410 // return Glue<Mat<mT>, Mat<mT>, glue_div>(X,Y); 00411 // } 00412 // 00413 // 00414 // 00415 // //! mat / op 00416 // template<typename T1, typename op_type> 00417 // arma_inline 00418 // const Glue<Mat<typename T1::elem_type>, Op<T1,op_type>, glue_div> 00419 // operator/ 00420 // (const Mat<typename T1::elem_type>& X, const Op<T1,op_type>& Y) 00421 // { 00422 // arma_extra_debug_sigprint(); 00423 // 00424 // return Glue<Mat<typename T1::elem_type>, Op<T1,op_type>, glue_div>(X,Y); 00425 // } 00426 // 00427 // 00428 // 00429 // //! mat / glue 00430 // template<typename T1, typename T2, typename glue_type> 00431 // arma_inline 00432 // const Glue<Mat<typename T1::elem_type>, Glue<T1, T2,glue_type>, glue_div> 00433 // operator/ 00434 // (const Mat<typename T1::elem_type>& X, const Glue<T1, T2,glue_type>& Y) 00435 // { 00436 // arma_extra_debug_sigprint(); 00437 // 00438 // return Glue<Mat<typename T1::elem_type>, Glue<T1, T2,glue_type>, glue_div>(X,Y); 00439 // } 00440 // 00441 // 00442 // 00443 // //! op / mat 00444 // template<typename T1, typename op_type> 00445 // arma_inline 00446 // const Glue<Op<T1,op_type>, Mat<typename T1::elem_type>, glue_div> 00447 // operator/ 00448 // (const Op<T1,op_type>& X, const Mat<typename T1::elem_type>& Y) 00449 // { 00450 // arma_extra_debug_sigprint(); 00451 // 00452 // return Glue<Op<T1,op_type>, Mat<typename T1::elem_type>, glue_div>(X,Y); 00453 // } 00454 // 00455 // 00456 // 00457 // //! op / op 00458 // template<typename T1, typename op_type1, typename T2, typename op_type2> 00459 // arma_inline 00460 // const Glue<Op<T1,op_type1>, Op<T2,op_type2>, glue_div> 00461 // operator/ 00462 // (const Op<T1,op_type1>& X, const Op<T2,op_type2>& Y) 00463 // { 00464 // arma_extra_debug_sigprint(); 00465 // 00466 // return Glue<Op<T1,op_type1>, Op<T2,op_type2>, glue_div>(X,Y); 00467 // } 00468 // 00469 // 00470 // 00471 // //! op / glue 00472 // template<typename T1, typename op_type, typename T2, typename T3, typename glue_type> 00473 // arma_inline 00474 // const Glue<Op<T1,op_type>, Glue<T2, T3, glue_type>, glue_div> 00475 // operator/ 00476 // (const Op<T1,op_type>& X, const Glue<T2, T3, glue_type>& Y) 00477 // { 00478 // arma_extra_debug_sigprint(); 00479 // 00480 // return Glue<Op<T1,op_type>, Glue<T2, T3, glue_type>, glue_div>(X,Y); 00481 // } 00482 // 00483 // 00484 // 00485 // //! glue / mat 00486 // template<typename T1, typename T2, typename glue_type> 00487 // arma_inline 00488 // const Glue<Glue<T1, T2,glue_type>, Mat<typename T1::elem_type>, glue_div> 00489 // operator/ 00490 // (const Glue<T1, T2,glue_type>& X, const Mat<typename T1::elem_type>& Y) 00491 // { 00492 // arma_extra_debug_sigprint(); 00493 // 00494 // return Glue<Glue<T1, T2,glue_type>, Mat<typename T1::elem_type>, glue_div>(X,Y); 00495 // } 00496 // 00497 // 00498 // 00499 // //! glue / op 00500 // template<typename T1, typename op_type, typename T2, typename T3, typename glue_type> 00501 // arma_inline 00502 // const Glue<Glue<T2, T3, glue_type>, Op<T1,op_type>, glue_div> 00503 // operator/ 00504 // (const Glue<T2, T3, glue_type>& X, const Op<T1,op_type>& Y) 00505 // { 00506 // arma_extra_debug_sigprint(); 00507 // 00508 // return Glue<Glue<T2, T3, glue_type>, Op<T1,op_type>, glue_div>(X,Y); 00509 // } 00510 // 00511 // 00512 // 00513 // //! glue / glue 00514 // template<typename T1, typename T2, typename glue_type1, typename T3, typename T4, typename glue_type2> 00515 // arma_inline 00516 // const Glue<Glue<T1,T2,glue_type1>, Glue<T3,T4,glue_type2>, glue_div> 00517 // operator/ 00518 // (const Glue<T1,T2,glue_type1>& X, const Glue<T3,T4,glue_type2>& Y) 00519 // { 00520 // arma_extra_debug_sigprint(); 00521 // 00522 // return Glue<Glue<T1,T2,glue_type1>, Glue<T3,T4,glue_type2>, glue_div>(X,Y); 00523 // } 00524 // 00525 // 00526 // 00527 // //! Base / subview 00528 // template<typename T1> 00529 // arma_inline 00530 // const Glue<T1, subview<typename T1::elem_type>, glue_div> 00531 // operator/ 00532 // (const Base<T1>& X, const subview<typename T1::elem_type>& Y) 00533 // { 00534 // arma_extra_debug_sigprint(); 00535 // 00536 // return Glue<T1, subview<typename T1::elem_type>, glue_div>(X.get_ref(),Y); 00537 // } 00538 // 00539 // 00540 // 00541 // //! subview / Base 00542 // template<typename T1> 00543 // arma_inline 00544 // const Glue<subview<typename T1::elem_type>, T1, glue_div> 00545 // operator/ 00546 // (const subview<typename T1::elem_type>& X, const Base<T1>& Y) 00547 // { 00548 // arma_extra_debug_sigprint(); 00549 // 00550 // return Glue<subview<typename T1::elem_type>, T1, glue_div>(X,Y.get_ref()); 00551 // } 00552 // 00553 // 00554 // 00555 // //! Base / diagview 00556 // template<typename T1> 00557 // arma_inline 00558 // const Glue<T1, diagview<typename T1::elem_type>, glue_div> 00559 // operator/ 00560 // (const Base<T1>& X, const diagview<typename T1::elem_type>& Y) 00561 // { 00562 // arma_extra_debug_sigprint(); 00563 // 00564 // return Glue<T1, diagview<typename T1::elem_type>, glue_div>(X.get_ref(),Y); 00565 // } 00566 // 00567 // 00568 // 00569 // //! diagview / Base 00570 // template<typename T1> 00571 // arma_inline 00572 // const Glue<diagview<typename T1::elem_type>, T1, glue_div> 00573 // operator/ 00574 // (const diagview<typename T1::elem_type>& X, const Base<T1>& Y) 00575 // { 00576 // arma_extra_debug_sigprint(); 00577 // 00578 // return Glue<diagview<typename T1::elem_type>, T1, glue_div>(X,Y.get_ref()); 00579 // } 00580 // 00581 // 00582 // 00583 // //! scalar / subview 00584 // template<typename mT> 00585 // arma_inline 00586 // const Op<subview<mT>, op_scalar_div_pre> 00587 // operator/ 00588 // (const mT k, const subview<mT>& X) 00589 // { 00590 // arma_extra_debug_sigprint(); 00591 // 00592 // return Op<subview<mT>, op_scalar_div_pre>(X,k); 00593 // } 00594 // 00595 // 00596 // 00597 // //! scalar / diagview 00598 // template<typename mT> 00599 // arma_inline 00600 // const Op<diagview<mT>, op_scalar_div_pre> 00601 // operator/ 00602 // (const mT k, const diagview<mT>& X) 00603 // { 00604 // arma_extra_debug_sigprint(); 00605 // 00606 // return Op<diagview<mT>, op_scalar_div_pre>(X,k); 00607 // } 00608 // 00609 // 00610 // 00611 // //! subview / scalar 00612 // template<typename mT> 00613 // arma_inline 00614 // const Op<subview<mT>, op_scalar_div_post> 00615 // operator/ 00616 // (const subview<mT>& X, const mT k) 00617 // { 00618 // arma_extra_debug_sigprint(); 00619 // 00620 // return Op<subview<mT>, op_scalar_div_post>(X,k); 00621 // } 00622 // 00623 // 00624 // 00625 // //! diagview / scalar 00626 // template<typename mT> 00627 // arma_inline 00628 // const Op<diagview<mT>, op_scalar_div_post> 00629 // operator/ 00630 // (const diagview<mT>& X, const mT k) 00631 // { 00632 // arma_extra_debug_sigprint(); 00633 // 00634 // return Op<diagview<mT>, op_scalar_div_post>(X,k); 00635 // } 00636 00637 00638 00639 //! @}