op_misc_meat.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 
00017 //! \addtogroup op_misc
00018 //! @{
00019 
00020 
00021 template<typename T1>
00022 inline
00023 void
00024 op_log::apply(Mat<typename T1::elem_type>& out, const Op<T1,op_log>& in)
00025   {
00026   arma_extra_debug_sigprint();
00027   
00028   typedef typename T1::elem_type eT;
00029   
00030   const unwrap_write<T1> tmp(out, in.m);
00031   const Mat<eT>& A     = tmp.M;
00032   
00033         eT* out_mem = out.memptr();
00034   const eT* A_mem   = A.memptr();
00035   const u32 n_elem  = out.n_elem;
00036   
00037   for(u32 i=0; i<n_elem; ++i)
00038     {
00039     out_mem[i] = std::log(A_mem[i]);
00040     }
00041   }
00042   
00043   
00044 
00045 template<typename T1>
00046 inline
00047 void
00048 op_log::apply(Cube<typename T1::elem_type>& out, const OpCube<T1,op_log>& in)
00049   {
00050   arma_extra_debug_sigprint();
00051   
00052   typedef typename T1::elem_type eT;
00053   
00054   const unwrap_cube_write<T1> tmp(out, in.m);
00055   const Cube<eT>& A         = tmp.M;
00056 
00057         eT* out_mem = out.memptr();
00058   const eT* A_mem   = A.memptr();
00059   const u32 n_elem  = out.n_elem;
00060   
00061   for(u32 i=0; i<n_elem; ++i)
00062     {
00063     out_mem[i] = std::log(A_mem[i]);
00064     }
00065   }
00066   
00067   
00068 
00069 template<typename T1>
00070 inline
00071 void
00072 op_trunc_log::apply(Mat<typename T1::elem_type>& out, const Op<T1,op_trunc_log>& in)
00073   {
00074   arma_extra_debug_sigprint();
00075   
00076   typedef typename T1::elem_type eT;
00077   
00078   const unwrap_write<T1> tmp(out, in.m);
00079   const Mat<eT>& A     = tmp.M;
00080   
00081         eT* out_mem = out.memptr();
00082   const eT* A_mem   = A.memptr();
00083   const u32 n_elem  = out.n_elem;
00084   
00085   for(u32 i=0; i<n_elem; ++i)
00086     {
00087     out_mem[i] = trunc_log(A_mem[i]);
00088     }
00089   }
00090   
00091   
00092 
00093 template<typename T1>
00094 inline
00095 void
00096 op_trunc_log::apply(Cube<typename T1::elem_type>& out, const OpCube<T1,op_trunc_log>& in)
00097   {
00098   arma_extra_debug_sigprint();
00099   
00100   typedef typename T1::elem_type eT;
00101   
00102   const unwrap_cube_write<T1> tmp(out, in.m);
00103   const Cube<eT>& A         = tmp.M;
00104 
00105         eT* out_mem = out.memptr();
00106   const eT* A_mem   = A.memptr();
00107   const u32 n_elem  = out.n_elem;
00108   
00109   for(u32 i=0; i<n_elem; ++i)
00110     {
00111     out_mem[i] = trunc_log(A_mem[i]);
00112     }
00113   }
00114   
00115   
00116 
00117 template<typename T1>
00118 inline
00119 void
00120 op_log10::apply(Mat<typename T1::elem_type>& out, const Op<T1,op_log10>& in)
00121   {
00122   arma_extra_debug_sigprint();
00123   
00124   typedef typename T1::elem_type eT;
00125   
00126   const unwrap_write<T1> tmp(out, in.m);
00127   const Mat<eT>& A     = tmp.M;
00128   
00129         eT* out_mem = out.memptr();
00130   const eT* A_mem   = A.memptr();
00131   const u32 n_elem  = out.n_elem;
00132   
00133   for(u32 i=0; i<n_elem; ++i)
00134     {
00135     out_mem[i] = std::log10(A_mem[i]);
00136     }
00137   }
00138   
00139   
00140 
00141 template<typename T1>
00142 inline
00143 void
00144 op_log10::apply(Cube<typename T1::elem_type>& out, const OpCube<T1,op_log10>& in)
00145   {
00146   arma_extra_debug_sigprint();
00147   
00148   typedef typename T1::elem_type eT;
00149   
00150   const unwrap_cube_write<T1> tmp(out, in.m);
00151   const Cube<eT>& A         = tmp.M;
00152 
00153         eT* out_mem = out.memptr();
00154   const eT* A_mem   = A.memptr();
00155   const u32 n_elem  = out.n_elem;
00156   
00157   for(u32 i=0; i<n_elem; ++i)
00158     {
00159     out_mem[i] = std::log10(A_mem[i]);
00160     }
00161   }
00162 
00163 
00164 
00165 template<typename T1>
00166 inline
00167 void
00168 op_exp::apply(Mat<typename T1::elem_type>& out, const Op<T1,op_exp>& in)
00169   {
00170   arma_extra_debug_sigprint();
00171   
00172   typedef typename T1::elem_type eT;
00173   
00174   const unwrap_write<T1> tmp(out, in.m);
00175   const Mat<eT>& A     = tmp.M;
00176   
00177         eT* out_mem = out.memptr();
00178   const eT* A_mem   = A.memptr();
00179   const u32 n_elem  = out.n_elem;
00180   
00181   for(u32 i=0; i<n_elem; ++i)
00182     {
00183     out_mem[i] = std::exp(A_mem[i]);
00184     }
00185   }
00186   
00187   
00188 
00189 template<typename T1>
00190 inline
00191 void
00192 op_exp::apply(Cube<typename T1::elem_type>& out, const OpCube<T1,op_exp>& in)
00193   {
00194   arma_extra_debug_sigprint();
00195   
00196   typedef typename T1::elem_type eT;
00197   
00198   const unwrap_cube_write<T1> tmp(out, in.m);
00199   const Cube<eT>& A         = tmp.M;
00200 
00201         eT* out_mem = out.memptr();
00202   const eT* A_mem   = A.memptr();
00203   const u32 n_elem  = out.n_elem;
00204   
00205   for(u32 i=0; i<n_elem; ++i)
00206     {
00207     out_mem[i] = std::exp(A_mem[i]);
00208     }
00209   }
00210   
00211   
00212 
00213 template<typename T1>
00214 inline
00215 void
00216 op_trunc_exp::apply(Mat<typename T1::elem_type>& out, const Op<T1,op_trunc_exp>& in)
00217   {
00218   arma_extra_debug_sigprint();
00219   
00220   typedef typename T1::elem_type eT;
00221   
00222   const unwrap_write<T1> tmp(out, in.m);
00223   const Mat<eT>& A     = tmp.M;
00224   
00225         eT* out_mem = out.memptr();
00226   const eT* A_mem   = A.memptr();
00227   const u32 n_elem  = out.n_elem;
00228   
00229   for(u32 i=0; i<n_elem; ++i)
00230     {
00231     out_mem[i] = trunc_exp(A_mem[i]);
00232     }
00233   }
00234 
00235 
00236 
00237 template<typename T1>
00238 inline
00239 void
00240 op_trunc_exp::apply(Cube<typename T1::elem_type>& out, const OpCube<T1,op_trunc_exp>& in)
00241   {
00242   arma_extra_debug_sigprint();
00243   
00244   typedef typename T1::elem_type eT;
00245   
00246   const unwrap_cube_write<T1> tmp(out, in.m);
00247   const Cube<eT>& A         = tmp.M;
00248 
00249         eT* out_mem = out.memptr();
00250   const eT* A_mem   = A.memptr();
00251   const u32 n_elem  = out.n_elem;
00252   
00253   for(u32 i=0; i<n_elem; ++i)
00254     {
00255     out_mem[i] = trunc_exp(A_mem[i]);
00256     }
00257   }
00258 
00259 
00260 
00261 template<typename T1>
00262 inline
00263 void
00264 op_sqrt::apply(Mat<typename T1::elem_type>& out, const Op<T1,op_sqrt>& in)
00265   {
00266   arma_extra_debug_sigprint();
00267   
00268   typedef typename T1::elem_type eT;
00269   
00270   const unwrap_write<T1> tmp(out, in.m);
00271   const Mat<eT>& A     = tmp.M;
00272   
00273         eT* out_mem = out.memptr();
00274   const eT* A_mem   = A.memptr();
00275   const u32 n_elem  = out.n_elem;
00276   
00277   for(u32 i=0; i<n_elem; ++i)
00278     {
00279     out_mem[i] = std::sqrt(A_mem[i]);
00280     }
00281   }
00282 
00283 
00284 
00285 template<typename T1>
00286 inline
00287 void
00288 op_sqrt::apply(Cube<typename T1::elem_type>& out, const OpCube<T1,op_sqrt>& in)
00289   {
00290   arma_extra_debug_sigprint();
00291   
00292   typedef typename T1::elem_type eT;
00293   
00294   const unwrap_cube_write<T1> tmp(out, in.m);
00295   const Cube<eT>& A         = tmp.M;
00296 
00297         eT* out_mem = out.memptr();
00298   const eT* A_mem   = A.memptr();
00299   const u32 n_elem  = out.n_elem;
00300   
00301   for(u32 i=0; i<n_elem; ++i)
00302     {
00303     out_mem[i] = std::sqrt(A_mem[i]);
00304     }
00305   }
00306 
00307 
00308 
00309 template<typename T1>
00310 inline
00311 void
00312 op_square::apply(Mat<typename T1::elem_type>& out, const Op<T1,op_square>& in)
00313   {
00314   arma_extra_debug_sigprint();
00315   
00316   typedef typename T1::elem_type eT;
00317   
00318   const unwrap_write<T1> tmp(out, in.m);
00319   const Mat<eT>& A     = tmp.M;
00320   
00321         eT* out_mem = out.memptr();
00322   const eT* A_mem   = A.memptr();
00323   const u32 n_elem  = out.n_elem;
00324   
00325   for(u32 i=0; i<n_elem; ++i)
00326     {
00327     const eT val = A_mem[i];
00328     out_mem[i] = val*val;
00329     }
00330   }
00331 
00332 
00333 
00334 template<typename T1>
00335 inline
00336 void
00337 op_square::apply(Cube<typename T1::elem_type>& out, const OpCube<T1,op_square>& in)
00338   {
00339   arma_extra_debug_sigprint();
00340   
00341   typedef typename T1::elem_type eT;
00342   
00343   const unwrap_cube_write<T1> tmp(out, in.m);
00344   const Cube<eT>& A         = tmp.M;
00345 
00346         eT* out_mem = out.memptr();
00347   const eT* A_mem   = A.memptr();
00348   const u32 n_elem  = out.n_elem;
00349   
00350   for(u32 i=0; i<n_elem; ++i)
00351     {
00352     const eT val = A_mem[i];
00353     out_mem[i] = val*val;
00354     }
00355   }
00356 
00357 
00358 
00359 template<typename T1, typename T2>
00360 inline
00361 T1 
00362 op_pow::internal_pow(const T1 base, const T2 exponent)
00363   {
00364   return std::pow(base, exponent);
00365   }
00366 
00367 
00368 
00369 template<typename T2>
00370 inline
00371 char
00372 op_pow::internal_pow(const char base, const T2 exponent)
00373   {
00374   typedef char out_type;
00375   return out_type( std::pow(double(base), exponent) );
00376   }
00377 
00378 
00379 
00380 template<typename T2>
00381 inline
00382 unsigned char
00383 op_pow::internal_pow(const unsigned char base, const T2 exponent)
00384   {
00385   typedef unsigned char out_type;
00386   return out_type( std::pow(double(base), exponent) );
00387   }
00388 
00389 
00390 
00391 template<typename T2>
00392 inline
00393 int
00394 op_pow::internal_pow(const int base, const T2 exponent)
00395   {
00396   typedef int out_type;
00397   return out_type( std::pow(double(base), exponent) );
00398   }
00399 
00400 
00401 
00402 template<typename T2>
00403 inline
00404 unsigned int
00405 op_pow::internal_pow(const unsigned int base, const T2 exponent)
00406   {
00407   typedef unsigned int out_type;
00408   return out_type( std::pow(double(base), exponent) );
00409   }
00410 
00411 
00412 
00413 template<typename T1>
00414 inline
00415 void
00416 op_pow::apply(Mat<typename T1::pod_type>& out, const Op<T1,op_pow>& in)
00417   {
00418   arma_extra_debug_sigprint();
00419   
00420   typedef typename T1::elem_type eT;
00421   
00422   const unwrap_write<T1> tmp(out, in.m);
00423   const Mat<eT>& A     = tmp.M;
00424   
00425         eT* out_mem = out.memptr();
00426   const eT* A_mem   = A.memptr();
00427   const u32 n_elem  = out.n_elem;
00428   
00429   for(u32 i=0; i<n_elem; ++i)
00430     {
00431     //out_mem[i] = std::pow(A_mem[i], in.aux);
00432     out_mem[i] = op_pow::internal_pow(A_mem[i], in.aux);
00433     }
00434   
00435   }
00436 
00437 
00438 
00439 template<typename T1>
00440 inline
00441 void
00442 op_pow::apply(Cube<typename T1::pod_type>& out, const OpCube<T1,op_pow>& in)
00443   {
00444   arma_extra_debug_sigprint();
00445   
00446   typedef typename T1::elem_type eT;
00447   
00448   const unwrap_cube_write<T1> tmp(in.m);
00449   const Cube<eT>& A         = tmp.M;
00450   
00451         eT* out_mem = out.memptr();
00452   const eT* A_mem   = A.memptr();
00453   const u32 n_elem  = out.n_elem;
00454   
00455   for(u32 i=0; i<n_elem; ++i)
00456     {
00457     //out_mem[i] = std::pow(A_mem[i], in.aux);
00458     out_mem[i] = op_pow::internal_pow(A_mem[i], in.aux);
00459     }
00460   
00461   }
00462 
00463 
00464 
00465 template<typename T1>
00466 inline
00467 void
00468 op_pow::apply(Mat< std::complex<typename T1::pod_type> >& out, const Op<T1,op_pow>& in)
00469   {
00470   arma_extra_debug_sigprint();
00471   
00472   typedef typename T1::pod_type  T;
00473   typedef std::complex<T>       eT;
00474   
00475   isnt_same_type<eT, typename T1::elem_type>::check();
00476   
00477   const unwrap<T1> tmp(in.m);
00478   
00479   const Mat<eT>& A = tmp.M;
00480   const u32 n_elem = A.n_elem;
00481   
00482   //out.set_size(A.n_rows, A.n_cols);
00483   out.copy_size(A);
00484   
00485   eT* out_ptr = out.memptr();
00486   
00487   
00488   if(in.aux.imag() == T(0))
00489     {
00490     const T in_aux_real = in.aux.real();
00491     
00492     for(u32 i=0; i<n_elem; ++i)
00493       {
00494       out_ptr[i] = std::pow(A.mem[i], in_aux_real);
00495       }
00496     }
00497   else
00498     {
00499     for(u32 i=0; i<n_elem; ++i)
00500       {
00501       out_ptr[i] = std::pow(A.mem[i], in.aux);
00502       }
00503     }
00504   }
00505 
00506 
00507 
00508 template<typename T1>
00509 inline
00510 void
00511 op_pow::apply(Cube< std::complex<typename T1::pod_type> >& out, const OpCube<T1,op_pow>& in)
00512   {
00513   arma_extra_debug_sigprint();
00514   
00515   typedef typename T1::pod_type  T;
00516   typedef std::complex<T>       eT;
00517   
00518   isnt_same_type<eT, typename T1::elem_type>::check();
00519   
00520   const unwrap_cube<T1> tmp(in.m);
00521   
00522   const Cube<eT>& A = tmp.M;
00523   const u32 n_elem  = A.n_elem;
00524   
00525   //out.set_size(A.n_rows, A.n_cols, A.n_slices);
00526   out.copy_size(A);
00527   
00528   eT* out_ptr = out.memptr();
00529   
00530   
00531   if(in.aux.imag() == T(0))
00532     {
00533     const T in_aux_real = in.aux.real();
00534     
00535     for(u32 i=0; i<n_elem; ++i)
00536       {
00537       out_ptr[i] = std::pow(A.mem[i], in_aux_real);
00538       }
00539     }
00540   else
00541     {
00542     for(u32 i=0; i<n_elem; ++i)
00543       {
00544       out_ptr[i] = std::pow(A.mem[i], in.aux);
00545       }
00546     }
00547   }
00548 
00549 
00550 
00551 template<typename T1>
00552 inline
00553 T1 
00554 op_pow_s32::internal_pow(const T1 base, const int exponent)
00555   {
00556   return std::pow(base, exponent);
00557   }
00558 
00559 
00560 
00561 inline
00562 char
00563 op_pow_s32::internal_pow(const char base, const int exponent)
00564   {
00565   typedef char out_type;
00566   return out_type( std::pow(double(base), exponent) );
00567   }
00568 
00569 
00570 
00571 inline
00572 unsigned char
00573 op_pow_s32::internal_pow(const unsigned char base, const int exponent)
00574   {
00575   typedef unsigned char out_type;
00576   return out_type( std::pow(double(base), exponent) );
00577   }
00578 
00579 
00580 
00581 inline
00582 int
00583 op_pow_s32::internal_pow(const int base, const int exponent)
00584   {
00585   typedef int out_type;
00586   return out_type( std::pow(double(base), exponent) );
00587   }
00588 
00589 
00590 
00591 inline
00592 unsigned int
00593 op_pow_s32::internal_pow(const unsigned int base, const int exponent)
00594   {
00595   typedef unsigned int out_type;
00596   return out_type( std::pow(double(base), exponent) );
00597   }
00598 
00599 
00600 
00601 template<typename T1>
00602 inline
00603 void
00604 op_pow_s32::apply(Mat<typename T1::elem_type>& out, const Op<T1,op_pow_s32>& in)
00605   {
00606   arma_extra_debug_sigprint();
00607   
00608   typedef typename T1::elem_type eT;
00609   
00610   const unwrap_write<T1> tmp(out, in.m);
00611   const Mat<eT>& A     = tmp.M;
00612   
00613         eT* out_mem = out.memptr();
00614   const eT* A_mem   = A.memptr();
00615   const u32 n_elem  = out.n_elem;
00616   
00617   const int exponent = (in.aux_u32_b == 0) ? in.aux_u32_a : -in.aux_u32_a;
00618   
00619   for(u32 i=0; i<n_elem; ++i)
00620     {
00621     //out_mem[i] = std::pow(A_mem[i], exponent);  // causes problems with gcc 4.1/4.2 for base that has an integer type
00622     out_mem[i] = op_pow_s32::internal_pow(A_mem[i], exponent);
00623     }
00624   
00625   }
00626 
00627 
00628 
00629 template<typename T1>
00630 inline
00631 void
00632 op_pow_s32::apply(Cube<typename T1::elem_type>& out, const OpCube<T1,op_pow_s32>& in)
00633   {
00634   arma_extra_debug_sigprint();
00635   
00636   typedef typename T1::elem_type eT;
00637   
00638   const unwrap_cube_write<T1> tmp(out, in.m);
00639   const Cube<eT>& A         = tmp.M;
00640   
00641         eT* out_mem = out.memptr();  
00642   const eT* A_mem   = A.memptr();
00643   const u32 n_elem  = out.n_elem;
00644   
00645   const int exponent = (in.aux_u32_b == 0) ? in.aux_u32_a : -in.aux_u32_a;
00646   
00647   for(u32 i=0; i<n_elem; ++i)
00648     {
00649     //out_mem[i] = std::pow(A_mem[i], exponent);  // causes problems with gcc 4.1/4.2 for base that has an integer type
00650     out_mem[i] = op_pow_s32::internal_pow(A_mem[i], exponent);
00651     }
00652   
00653   }
00654 
00655 
00656 
00657 template<typename T1>
00658 inline
00659 void
00660 op_conj::apply(Mat<typename T1::elem_type>& out, const Op<T1,op_conj>& in)
00661   {
00662   arma_extra_debug_sigprint();
00663   
00664   typedef typename T1::elem_type eT;
00665   
00666   const unwrap_write<T1> tmp(out, in.m);
00667   const Mat<eT>& A     = tmp.M;
00668   
00669         eT* out_mem = out.memptr();
00670   const eT* A_mem   = A.memptr();
00671   const u32 n_elem  = out.n_elem;
00672   
00673   for(u32 i=0; i<n_elem; ++i)
00674     {
00675     out_mem[i] = std::conj(A_mem[i]);
00676     }
00677   }
00678 
00679 
00680 
00681 template<typename T1>
00682 inline
00683 void
00684 op_conj::apply(Cube<typename T1::elem_type>& out, const OpCube<T1,op_conj>& in)
00685   {
00686   arma_extra_debug_sigprint();
00687   
00688   typedef typename T1::elem_type eT;
00689   
00690   const unwrap_cube_write<T1> tmp(out, in.m);
00691   const Cube<eT>& A         = tmp.M;
00692 
00693         eT* out_mem = out.memptr();
00694   const eT* A_mem   = A.memptr();
00695   const u32 n_elem  = out.n_elem;
00696   
00697   for(u32 i=0; i<n_elem; ++i)
00698     {
00699     out_mem[i] = std::conj(A_mem[i]);
00700     }
00701   }
00702 
00703 
00704 
00705 //! @}