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