op_cx_scalar_meat.hpp

Go to the documentation of this file.
00001 // Copyright (C) 2010 NICTA and the authors listed below
00002 // http://nicta.com.au
00003 // 
00004 // Authors:
00005 // - Conrad Sanderson (conradsand at ieee dot org)
00006 // 
00007 // This file is part of the Armadillo C++ library.
00008 // It is provided without any warranty of fitness
00009 // for any purpose. You can redistribute this file
00010 // and/or modify it under the terms of the GNU
00011 // Lesser General Public License (LGPL) as published
00012 // by the Free Software Foundation, either version 3
00013 // of the License or (at your option) any later version.
00014 // (see http://www.opensource.org/licenses for more info)
00015 
00016 
00017 //! \addtogroup op_cx_scalar
00018 //! @{
00019 
00020 
00021 
00022 template<typename T1>
00023 inline
00024 void
00025 op_cx_scalar_times::apply
00026   (
00027         Mat< typename std::complex<typename T1::pod_type> >& out,
00028   const mtOp<typename std::complex<typename T1::pod_type>, T1, op_cx_scalar_times>& X
00029   )
00030   {
00031   arma_extra_debug_sigprint();
00032   
00033   typedef typename std::complex<typename T1::pod_type> eT;
00034   typedef typename T1::pod_type                         T;
00035   
00036   const Proxy<T1> A(X.m);
00037   
00038   out.set_size(A.n_rows, A.n_cols);
00039   
00040   const u32 n_elem  = A.n_elem;
00041   const eT  k       = X.aux_out_eT;
00042         eT* out_mem = out.memptr();
00043   
00044   for(u32 i=0; i<n_elem; ++i)
00045     {
00046     out_mem[i] = A[i] * k;
00047     }
00048   }
00049 
00050 
00051 
00052 template<typename T1>
00053 inline
00054 void
00055 op_cx_scalar_plus::apply
00056   (
00057         Mat< typename std::complex<typename T1::pod_type> >& out,
00058   const mtOp<typename std::complex<typename T1::pod_type>, T1, op_cx_scalar_plus>& X
00059   )
00060   {
00061   arma_extra_debug_sigprint();
00062   
00063   typedef typename std::complex<typename T1::pod_type> eT;
00064   typedef typename T1::pod_type                         T;
00065   
00066   const Proxy<T1> A(X.m);
00067   
00068   out.set_size(A.n_rows, A.n_cols);
00069   
00070   const u32 n_elem  = A.n_elem;
00071   const eT  k       = X.aux_out_eT;
00072         eT* out_mem = out.memptr();
00073   
00074   for(u32 i=0; i<n_elem; ++i)
00075     {
00076     out_mem[i] = A[i] + k;
00077     }
00078   }
00079 
00080 
00081 
00082 template<typename T1>
00083 inline
00084 void
00085 op_cx_scalar_minus_pre::apply
00086   (
00087         Mat< typename std::complex<typename T1::pod_type> >& out,
00088   const mtOp<typename std::complex<typename T1::pod_type>, T1, op_cx_scalar_minus_pre>& X
00089   )
00090   {
00091   arma_extra_debug_sigprint();
00092   
00093   typedef typename std::complex<typename T1::pod_type> eT;
00094   typedef typename T1::pod_type                         T;
00095   
00096   const Proxy<T1> A(X.m);
00097   
00098   out.set_size(A.n_rows, A.n_cols);
00099   
00100   const u32 n_elem  = A.n_elem;
00101   const eT  k       = X.aux_out_eT;
00102         eT* out_mem = out.memptr();
00103   
00104   for(u32 i=0; i<n_elem; ++i)
00105     {
00106     out_mem[i] = k - A[i];
00107     }
00108   }
00109 
00110 
00111 
00112 template<typename T1>
00113 inline
00114 void
00115 op_cx_scalar_minus_post::apply
00116   (
00117         Mat< typename std::complex<typename T1::pod_type> >& out,
00118   const mtOp<typename std::complex<typename T1::pod_type>, T1, op_cx_scalar_minus_post>& X
00119   )
00120   {
00121   arma_extra_debug_sigprint();
00122   
00123   typedef typename std::complex<typename T1::pod_type> eT;
00124   typedef typename T1::pod_type                         T;
00125   
00126   const Proxy<T1> A(X.m);
00127   
00128   out.set_size(A.n_rows, A.n_cols);
00129   
00130   const u32 n_elem  = A.n_elem;
00131   const eT  k       = X.aux_out_eT;
00132         eT* out_mem = out.memptr();
00133   
00134   for(u32 i=0; i<n_elem; ++i)
00135     {
00136     out_mem[i] = A[i] - k;
00137     }
00138   }
00139 
00140 
00141 
00142 template<typename T1>
00143 inline
00144 void
00145 op_cx_scalar_div_pre::apply
00146   (
00147         Mat< typename std::complex<typename T1::pod_type> >& out,
00148   const mtOp<typename std::complex<typename T1::pod_type>, T1, op_cx_scalar_div_pre>& X
00149   )
00150   {
00151   arma_extra_debug_sigprint();
00152   
00153   typedef typename std::complex<typename T1::pod_type> eT;
00154   typedef typename T1::pod_type                         T;
00155   
00156   const Proxy<T1> A(X.m);
00157   
00158   out.set_size(A.n_rows, A.n_cols);
00159   
00160   const u32 n_elem  = A.n_elem;
00161   const eT  k       = X.aux_out_eT;
00162         eT* out_mem = out.memptr();
00163   
00164   for(u32 i=0; i<n_elem; ++i)
00165     {
00166     out_mem[i] = k / A[i];
00167     }
00168   }
00169 
00170 
00171 
00172 template<typename T1>
00173 inline
00174 void
00175 op_cx_scalar_div_post::apply
00176   (
00177         Mat< typename std::complex<typename T1::pod_type> >& out,
00178   const mtOp<typename std::complex<typename T1::pod_type>, T1, op_cx_scalar_div_post>& X
00179   )
00180   {
00181   arma_extra_debug_sigprint();
00182   
00183   typedef typename std::complex<typename T1::pod_type> eT;
00184   typedef typename T1::pod_type                         T;
00185   
00186   const Proxy<T1> A(X.m);
00187   
00188   out.set_size(A.n_rows, A.n_cols);
00189   
00190   const u32 n_elem  = A.n_elem;
00191   const eT  k       = X.aux_out_eT;
00192         eT* out_mem = out.memptr();
00193   
00194   for(u32 i=0; i<n_elem; ++i)
00195     {
00196     out_mem[i] = A[i] / k;
00197     }
00198   }
00199 
00200 
00201 
00202 //! @}