op_relational_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_relational
00018 //! @{
00019 
00020 
00021 
00022 template<typename T1>
00023 inline
00024 void
00025 op_rel_lt_pre::apply(Mat<u32>& out, const mtOp<u32, T1, op_rel_lt_pre>& X)
00026   {
00027   arma_extra_debug_sigprint();
00028   
00029   typedef typename T1::elem_type eT;
00030   
00031   const Proxy<T1> A(X.m);
00032   
00033   out.set_size(A.n_rows, A.n_cols);
00034   
00035   const u32  n_elem  = A.n_elem;
00036   const eT   val     = X.aux;
00037         u32* out_mem = out.memptr();
00038    
00039   for(u32 i=0; i<n_elem; ++i)
00040     {
00041     out_mem[i] = (val < A[i]) ? u32(1) : u32(0);
00042     }
00043   }
00044 
00045 
00046 
00047 template<typename T1>
00048 inline
00049 void
00050 op_rel_lt_post::apply(Mat<u32>& out, const mtOp<u32, T1, op_rel_lt_post>& X)
00051   {
00052   arma_extra_debug_sigprint();
00053   
00054   typedef typename T1::elem_type eT;
00055   
00056   const Proxy<T1> A(X.m);
00057   
00058   out.set_size(A.n_rows, A.n_cols);
00059   
00060   const u32  n_elem  = A.n_elem;
00061   const eT   val     = X.aux;
00062         u32* out_mem = out.memptr();
00063    
00064   for(u32 i=0; i<n_elem; ++i)
00065     {
00066     out_mem[i] = (A[i] < val) ? u32(1) : u32(0);
00067     }
00068   }
00069 
00070 
00071 
00072 template<typename T1>
00073 inline
00074 void
00075 op_rel_gt_pre::apply(Mat<u32>& out, const mtOp<u32, T1, op_rel_gt_pre>& X)
00076   {
00077   arma_extra_debug_sigprint();
00078   
00079   typedef typename T1::elem_type eT;
00080   
00081   const Proxy<T1> A(X.m);
00082   
00083   out.set_size(A.n_rows, A.n_cols);
00084   
00085   const u32  n_elem  = A.n_elem;
00086   const eT   val     = X.aux;
00087         u32* out_mem = out.memptr();
00088    
00089   for(u32 i=0; i<n_elem; ++i)
00090     {
00091     out_mem[i] = (val > A[i]) ? u32(1) : u32(0);
00092     }
00093   }
00094 
00095 
00096 
00097 template<typename T1>
00098 inline
00099 void
00100 op_rel_gt_post::apply(Mat<u32>& out, const mtOp<u32, T1, op_rel_gt_post>& X)
00101   {
00102   arma_extra_debug_sigprint();
00103   
00104   typedef typename T1::elem_type eT;
00105   
00106   const Proxy<T1> A(X.m);
00107   
00108   out.set_size(A.n_rows, A.n_cols);
00109   
00110   const u32  n_elem  = A.n_elem;
00111   const eT   val     = X.aux;
00112         u32* out_mem = out.memptr();
00113    
00114   for(u32 i=0; i<n_elem; ++i)
00115     {
00116     out_mem[i] = (A[i] > val) ? u32(1) : u32(0);
00117     }
00118   }
00119 
00120 
00121 
00122 template<typename T1>
00123 inline
00124 void
00125 op_rel_lteq_pre::apply(Mat<u32>& out, const mtOp<u32, T1, op_rel_lteq_pre>& X)
00126   {
00127   arma_extra_debug_sigprint();
00128   
00129   typedef typename T1::elem_type eT;
00130   
00131   const Proxy<T1> A(X.m);
00132   
00133   out.set_size(A.n_rows, A.n_cols);
00134   
00135   const u32  n_elem  = A.n_elem;
00136   const eT   val     = X.aux;
00137         u32* out_mem = out.memptr();
00138    
00139   for(u32 i=0; i<n_elem; ++i)
00140     {
00141     out_mem[i] = (val <= A[i]) ? u32(1) : u32(0);
00142     }
00143   }
00144 
00145 
00146 
00147 template<typename T1>
00148 inline
00149 void
00150 op_rel_lteq_post::apply(Mat<u32>& out, const mtOp<u32, T1, op_rel_lteq_post>& X)
00151   {
00152   arma_extra_debug_sigprint();
00153   
00154   typedef typename T1::elem_type eT;
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   val     = X.aux;
00162         u32* out_mem = out.memptr();
00163    
00164   for(u32 i=0; i<n_elem; ++i)
00165     {
00166     out_mem[i] = (A[i] <= val) ? u32(1) : u32(0);
00167     }
00168   }
00169 
00170 
00171 
00172 template<typename T1>
00173 inline
00174 void
00175 op_rel_gteq_pre::apply(Mat<u32>& out, const mtOp<u32, T1, op_rel_gteq_pre>& X)
00176   {
00177   arma_extra_debug_sigprint();
00178   
00179   typedef typename T1::elem_type eT;
00180   
00181   const Proxy<T1> A(X.m);
00182   
00183   out.set_size(A.n_rows, A.n_cols);
00184   
00185   const u32  n_elem  = A.n_elem;
00186   const eT   val     = X.aux;
00187         u32* out_mem = out.memptr();
00188    
00189   for(u32 i=0; i<n_elem; ++i)
00190     {
00191     out_mem[i] = (val >= A[i]) ? u32(1) : u32(0);
00192     }
00193   }
00194 
00195 
00196 
00197 template<typename T1>
00198 inline
00199 void
00200 op_rel_gteq_post::apply(Mat<u32>& out, const mtOp<u32, T1, op_rel_gteq_post>& X)
00201   {
00202   arma_extra_debug_sigprint();
00203   
00204   typedef typename T1::elem_type eT;
00205   
00206   const Proxy<T1> A(X.m);
00207   
00208   out.set_size(A.n_rows, A.n_cols);
00209   
00210   const u32  n_elem  = A.n_elem;
00211   const eT   val     = X.aux;
00212         u32* out_mem = out.memptr();
00213    
00214   for(u32 i=0; i<n_elem; ++i)
00215     {
00216     out_mem[i] = (A[i] >= val) ? u32(1) : u32(0);
00217     }
00218   }
00219 
00220 
00221 
00222 template<typename T1>
00223 inline
00224 void
00225 op_rel_eq::apply(Mat<u32>& out, const mtOp<u32, T1, op_rel_eq>& X)
00226   {
00227   arma_extra_debug_sigprint();
00228   
00229   typedef typename T1::elem_type eT;
00230   
00231   const Proxy<T1> A(X.m);
00232   
00233   out.set_size(A.n_rows, A.n_cols);
00234   
00235   const u32  n_elem  = A.n_elem;
00236   const eT   val     = X.aux;
00237         u32* out_mem = out.memptr();
00238    
00239   for(u32 i=0; i<n_elem; ++i)
00240     {
00241     out_mem[i] = (A[i] == val) ? u32(1) : u32(0);
00242     }
00243   }
00244 
00245 
00246 
00247 template<typename T1>
00248 inline
00249 void
00250 op_rel_noteq::apply(Mat<u32>& out, const mtOp<u32, T1, op_rel_noteq>& X)
00251   {
00252   arma_extra_debug_sigprint();
00253   
00254   typedef typename T1::elem_type eT;
00255   
00256   const Proxy<T1> A(X.m);
00257   
00258   out.set_size(A.n_rows, A.n_cols);
00259   
00260   const u32  n_elem  = A.n_elem;
00261   const eT   val     = X.aux;
00262         u32* out_mem = out.memptr();
00263    
00264   for(u32 i=0; i<n_elem; ++i)
00265     {
00266     out_mem[i] = (A[i] != val) ? u32(1) : u32(0);
00267     }
00268   }
00269 
00270 
00271 
00272 //! @}