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