Operator_relational


Functions

template<typename eT , typename T1 , typename T2 >
umat operator== (const Base< eT, T1 > &X, const Base< eT, T2 > &Y)
template<typename eT , typename T1 , typename T2 >
umat operator!= (const Base< eT, T1 > &X, const Base< eT, T2 > &Y)
template<typename eT , typename T1 , typename T2 >
umat operator>= (const Base< eT, T1 > &X, const Base< eT, T2 > &Y)
template<typename eT , typename T1 , typename T2 >
umat operator<= (const Base< eT, T1 > &X, const Base< eT, T2 > &Y)
template<typename eT , typename T1 , typename T2 >
umat operator> (const Base< eT, T1 > &X, const Base< eT, T2 > &Y)
template<typename eT , typename T1 , typename T2 >
umat operator< (const Base< eT, T1 > &X, const Base< eT, T2 > &Y)
template<typename T1 >
umat operator== (const Base< typename T1::elem_type, T1 > &X, const typename T1::elem_type val)
template<typename T1 >
umat operator!= (const Base< typename T1::elem_type, T1 > &X, const typename T1::elem_type val)
template<typename T1 >
umat operator>= (const Base< typename T1::elem_type, T1 > &X, const typename T1::elem_type val)
template<typename T1 >
umat operator<= (const Base< typename T1::elem_type, T1 > &X, const typename T1::elem_type val)
template<typename T1 >
umat operator> (const Base< typename T1::elem_type, T1 > &X, const typename T1::elem_type val)
template<typename T1 >
umat operator< (const Base< typename T1::elem_type, T1 > &X, const typename T1::elem_type val)
template<typename T1 >
umat operator== (const typename T1::elem_type val, const Base< typename T1::elem_type, T1 > &X)
template<typename T1 >
umat operator!= (const typename T1::elem_type val, const Base< typename T1::elem_type, T1 > &X)
template<typename T1 >
umat operator>= (const typename T1::elem_type val, const Base< typename T1::elem_type, T1 > &X)
template<typename T1 >
umat operator<= (const typename T1::elem_type val, const Base< typename T1::elem_type, T1 > &X)
template<typename T1 >
umat operator> (const typename T1::elem_type val, const Base< typename T1::elem_type, T1 > &X)
template<typename T1 >
umat operator< (const typename T1::elem_type val, const Base< typename T1::elem_type, T1 > &X)

Function Documentation

template<typename eT , typename T1 , typename T2 >
umat operator== ( const Base< eT, T1 > &  X,
const Base< eT, T2 > &  Y 
) [inline]

Definition at line 25 of file operator_relational.hpp.

References Base< elem_type, derived >::get_ref(), Mat< eT >::mem, and Mat< eT >::memptr().

Referenced by operator==().

00026   {
00027   arma_extra_debug_sigprint();
00028   
00029   const unwrap<T1> tmp1(X.get_ref());
00030   const unwrap<T2> tmp2(Y.get_ref());
00031   
00032   const Mat<eT>& A = tmp1.M;
00033   const Mat<eT>& B = tmp2.M;
00034     
00035   arma_debug_assert_same_size(A, B, "operator==");
00036   
00037   umat out(A.n_rows, A.n_cols);
00038   
00039   const eT* A_mem = A.mem;
00040   const eT* B_mem = B.mem;
00041   
00042   typedef typename umat::elem_type umat_elem_type;
00043   umat_elem_type* out_mem = out.memptr();
00044   
00045   
00046   for(u32 i=0; i<A.n_elem; ++i)
00047     {
00048     if(A_mem[i] == B_mem[i])
00049       {
00050       out_mem[i] = umat_elem_type(1);
00051       }
00052     else
00053       {
00054       out_mem[i] = umat_elem_type(0);
00055       }
00056     }
00057   
00058   return out;
00059   }

template<typename eT , typename T1 , typename T2 >
umat operator!= ( const Base< eT, T1 > &  X,
const Base< eT, T2 > &  Y 
) [inline]

Definition at line 67 of file operator_relational.hpp.

References Base< elem_type, derived >::get_ref(), Mat< eT >::mem, and Mat< eT >::memptr().

Referenced by operator!=().

00068   {
00069   arma_extra_debug_sigprint();
00070   
00071   const unwrap<T1> tmp1(X.get_ref());
00072   const unwrap<T2> tmp2(Y.get_ref());
00073   
00074   const Mat<eT>& A = tmp1.M;
00075   const Mat<eT>& B = tmp2.M;
00076     
00077   arma_debug_assert_same_size(A, B, "operator!=");
00078   
00079   umat out(A.n_rows, A.n_cols);
00080   
00081   const eT* A_mem = A.mem;
00082   const eT* B_mem = B.mem;
00083   
00084   typedef typename umat::elem_type umat_elem_type;
00085   umat_elem_type* out_mem = out.memptr();
00086   
00087   
00088   for(u32 i=0; i<A.n_elem; ++i)
00089     {
00090     if(A_mem[i] != B_mem[i])
00091       {
00092       out_mem[i] = umat_elem_type(1);
00093       }
00094     else
00095       {
00096       out_mem[i] = umat_elem_type(0);
00097       }
00098     }
00099   
00100   return out;
00101   }

template<typename eT , typename T1 , typename T2 >
umat operator>= ( const Base< eT, T1 > &  X,
const Base< eT, T2 > &  Y 
) [inline]

Definition at line 109 of file operator_relational.hpp.

References Base< elem_type, derived >::get_ref(), Mat< eT >::mem, and Mat< eT >::memptr().

00110   {
00111   arma_extra_debug_sigprint();
00112   
00113   const unwrap<T1> tmp1(X.get_ref());
00114   const unwrap<T2> tmp2(Y.get_ref());
00115   
00116   const Mat<eT>& A = tmp1.M;
00117   const Mat<eT>& B = tmp2.M;
00118     
00119   arma_debug_assert_same_size(A, B, "operator>=");
00120   
00121   umat out(A.n_rows, A.n_cols);
00122   
00123   const eT* A_mem = A.mem;
00124   const eT* B_mem = B.mem;
00125   
00126   typedef typename umat::elem_type umat_elem_type;
00127   umat_elem_type* out_mem = out.memptr();
00128   
00129   
00130   for(u32 i=0; i<A.n_elem; ++i)
00131     {
00132     if(A_mem[i] >= B_mem[i])
00133       {
00134       out_mem[i] = umat_elem_type(1);
00135       }
00136     else
00137       {
00138       out_mem[i] = umat_elem_type(0);
00139       }
00140     }
00141   
00142   return out;
00143   }

template<typename eT , typename T1 , typename T2 >
umat operator<= ( const Base< eT, T1 > &  X,
const Base< eT, T2 > &  Y 
) [inline]

Definition at line 151 of file operator_relational.hpp.

References Base< elem_type, derived >::get_ref(), Mat< eT >::mem, and Mat< eT >::memptr().

00152   {
00153   arma_extra_debug_sigprint();
00154   
00155   const unwrap<T1> tmp1(X.get_ref());
00156   const unwrap<T2> tmp2(Y.get_ref());
00157   
00158   const Mat<eT>& A = tmp1.M;
00159   const Mat<eT>& B = tmp2.M;
00160     
00161   arma_debug_assert_same_size(A, B, "operator<=");
00162   
00163   umat out(A.n_rows, A.n_cols);
00164   
00165   const eT* A_mem = A.mem;
00166   const eT* B_mem = B.mem;
00167   
00168   typedef typename umat::elem_type umat_elem_type;
00169   umat_elem_type* out_mem = out.memptr();
00170   
00171   
00172   for(u32 i=0; i<A.n_elem; ++i)
00173     {
00174     if(A_mem[i] == B_mem[i])
00175       {
00176       out_mem[i] = umat_elem_type(1);
00177       }
00178     else
00179       {
00180       out_mem[i] = umat_elem_type(0);
00181       }
00182     }
00183   
00184   return out;
00185   }

template<typename eT , typename T1 , typename T2 >
umat operator> ( const Base< eT, T1 > &  X,
const Base< eT, T2 > &  Y 
) [inline]

Definition at line 193 of file operator_relational.hpp.

References Base< elem_type, derived >::get_ref(), Mat< eT >::mem, and Mat< eT >::memptr().

00194   {
00195   arma_extra_debug_sigprint();
00196   
00197   const unwrap<T1> tmp1(X.get_ref());
00198   const unwrap<T2> tmp2(Y.get_ref());
00199   
00200   const Mat<eT>& A = tmp1.M;
00201   const Mat<eT>& B = tmp2.M;
00202     
00203   arma_debug_assert_same_size(A, B, "operator>");
00204   
00205   umat out(A.n_rows, A.n_cols);
00206   
00207   const eT* A_mem = A.mem;
00208   const eT* B_mem = B.mem;
00209   
00210   typedef typename umat::elem_type umat_elem_type;
00211   umat_elem_type* out_mem = out.memptr();
00212   
00213   
00214   for(u32 i=0; i<A.n_elem; ++i)
00215     {
00216     if(A_mem[i] > B_mem[i])
00217       {
00218       out_mem[i] = umat_elem_type(1);
00219       }
00220     else
00221       {
00222       out_mem[i] = umat_elem_type(0);
00223       }
00224     }
00225   
00226   return out;
00227   }

template<typename eT , typename T1 , typename T2 >
umat operator< ( const Base< eT, T1 > &  X,
const Base< eT, T2 > &  Y 
) [inline]

Definition at line 235 of file operator_relational.hpp.

References Base< elem_type, derived >::get_ref(), Mat< eT >::mem, and Mat< eT >::memptr().

00236   {
00237   arma_extra_debug_sigprint();
00238   
00239   const unwrap<T1> tmp1(X.get_ref());
00240   const unwrap<T2> tmp2(Y.get_ref());
00241   
00242   const Mat<eT>& A = tmp1.M;
00243   const Mat<eT>& B = tmp2.M;
00244     
00245   arma_debug_assert_same_size(A, B, "operator<");
00246   
00247   umat out(A.n_rows, A.n_cols);
00248   
00249   const eT* A_mem = A.mem;
00250   const eT* B_mem = B.mem;
00251   
00252   typedef typename umat::elem_type umat_elem_type;
00253   umat_elem_type* out_mem = out.memptr();
00254   
00255   
00256   for(u32 i=0; i<A.n_elem; ++i)
00257     {
00258     if(A_mem[i] < B_mem[i])
00259       {
00260       out_mem[i] = umat_elem_type(1);
00261       }
00262     else
00263       {
00264       out_mem[i] = umat_elem_type(0);
00265       }
00266     }
00267   
00268   return out;
00269   }

template<typename T1 >
umat operator== ( const Base< typename T1::elem_type, T1 > &  X,
const typename T1::elem_type  val 
) [inline]

Definition at line 277 of file operator_relational.hpp.

References Base< elem_type, derived >::get_ref(), and Mat< eT >::memptr().

00278   {
00279   arma_extra_debug_sigprint();
00280   
00281   typedef typename T1::elem_type eT;
00282   
00283   const unwrap<T1> tmp1(X.get_ref());
00284   const Mat<eT>& A = tmp1.M;
00285   
00286   umat out(A.n_rows, A.n_cols);
00287   
00288   const eT* A_mem = A.mem;
00289   
00290   typedef typename umat::elem_type umat_elem_type;
00291   umat_elem_type* out_mem = out.memptr();
00292   
00293   for(u32 i=0; i<A.n_elem; ++i)
00294     {
00295     if(A_mem[i] == val)
00296       {
00297       out_mem[i] = umat_elem_type(1);
00298       }
00299     else
00300       {
00301       out_mem[i] = umat_elem_type(0);
00302       }
00303     }
00304   
00305   return out;
00306   }

template<typename T1 >
umat operator!= ( const Base< typename T1::elem_type, T1 > &  X,
const typename T1::elem_type  val 
) [inline]

Definition at line 314 of file operator_relational.hpp.

References Base< elem_type, derived >::get_ref(), and Mat< eT >::memptr().

00315   {
00316   arma_extra_debug_sigprint();
00317   
00318   typedef typename T1::elem_type eT;
00319   
00320   const unwrap<T1> tmp1(X.get_ref());
00321   const Mat<eT>& A = tmp1.M;
00322     
00323   umat out(A.n_rows, A.n_cols);
00324   
00325   const eT* A_mem = A.mem;
00326   
00327   typedef typename umat::elem_type umat_elem_type;
00328   umat_elem_type* out_mem = out.memptr();
00329   
00330   for(u32 i=0; i<A.n_elem; ++i)
00331     {
00332     if(A_mem[i] != val)
00333       {
00334       out_mem[i] = umat_elem_type(1);
00335       }
00336     else
00337       {
00338       out_mem[i] = umat_elem_type(0);
00339       }
00340     }
00341   
00342   return out;
00343   }

template<typename T1 >
umat operator>= ( const Base< typename T1::elem_type, T1 > &  X,
const typename T1::elem_type  val 
) [inline]

Definition at line 351 of file operator_relational.hpp.

References Base< elem_type, derived >::get_ref(), and Mat< eT >::memptr().

00352   {
00353   arma_extra_debug_sigprint();
00354   
00355   typedef typename T1::elem_type eT;
00356   
00357   const unwrap<T1> tmp1(X.get_ref());
00358   const Mat<eT>& A = tmp1.M;
00359     
00360   umat out(A.n_rows, A.n_cols);
00361   
00362   const eT* A_mem = A.mem;
00363   
00364   typedef typename umat::elem_type umat_elem_type;
00365   umat_elem_type* out_mem = out.memptr();
00366   
00367   for(u32 i=0; i<A.n_elem; ++i)
00368     {
00369     if(A_mem[i] >= val)
00370       {
00371       out_mem[i] = umat_elem_type(1);
00372       }
00373     else
00374       {
00375       out_mem[i] = umat_elem_type(0);
00376       }
00377     }
00378   
00379   return out;
00380   }

template<typename T1 >
umat operator<= ( const Base< typename T1::elem_type, T1 > &  X,
const typename T1::elem_type  val 
) [inline]

Definition at line 388 of file operator_relational.hpp.

References Base< elem_type, derived >::get_ref(), and Mat< eT >::memptr().

00389   {
00390   arma_extra_debug_sigprint();
00391   
00392   typedef typename T1::elem_type eT;
00393   
00394   const unwrap<T1> tmp1(X.get_ref());
00395   const Mat<eT>& A = tmp1.M;
00396     
00397   umat out(A.n_rows, A.n_cols);
00398   
00399   const eT* A_mem = A.mem;
00400   
00401   typedef typename umat::elem_type umat_elem_type;
00402   umat_elem_type* out_mem = out.memptr();
00403   
00404   for(u32 i=0; i<A.n_elem; ++i)
00405     {
00406     if(A_mem[i] <= val)
00407       {
00408       out_mem[i] = umat_elem_type(1);
00409       }
00410     else
00411       {
00412       out_mem[i] = umat_elem_type(0);
00413       }
00414     }
00415   
00416   return out;
00417   }

template<typename T1 >
umat operator> ( const Base< typename T1::elem_type, T1 > &  X,
const typename T1::elem_type  val 
) [inline]

Definition at line 425 of file operator_relational.hpp.

References Base< elem_type, derived >::get_ref(), and Mat< eT >::memptr().

00426   {
00427   arma_extra_debug_sigprint();
00428   
00429   typedef typename T1::elem_type eT;
00430   
00431   const unwrap<T1> tmp1(X.get_ref());
00432   const Mat<eT>& A = tmp1.M;
00433     
00434   umat out(A.n_rows, A.n_cols);
00435   
00436   const eT* A_mem = A.mem;
00437   
00438   typedef typename umat::elem_type umat_elem_type;
00439   umat_elem_type* out_mem = out.memptr();
00440   
00441   for(u32 i=0; i<A.n_elem; ++i)
00442     {
00443     if(A_mem[i] > val)
00444       {
00445       out_mem[i] = umat_elem_type(1);
00446       }
00447     else
00448       {
00449       out_mem[i] = umat_elem_type(0);
00450       }
00451     }
00452   
00453   return out;
00454   }

template<typename T1 >
umat operator< ( const Base< typename T1::elem_type, T1 > &  X,
const typename T1::elem_type  val 
) [inline]

Definition at line 462 of file operator_relational.hpp.

References Base< elem_type, derived >::get_ref(), and Mat< eT >::memptr().

00463   {
00464   arma_extra_debug_sigprint();
00465   
00466   typedef typename T1::elem_type eT;
00467   
00468   const unwrap<T1> tmp1(X.get_ref());
00469   const Mat<eT>& A = tmp1.M;
00470     
00471   umat out(A.n_rows, A.n_cols);
00472   
00473   const eT* A_mem = A.mem;
00474   
00475   typedef typename umat::elem_type umat_elem_type;
00476   umat_elem_type* out_mem = out.memptr();
00477   
00478   for(u32 i=0; i<A.n_elem; ++i)
00479     {
00480     if(A_mem[i] < val)
00481       {
00482       out_mem[i] = umat_elem_type(1);
00483       }
00484     else
00485       {
00486       out_mem[i] = umat_elem_type(0);
00487       }
00488     }
00489   
00490   return out;
00491   }

template<typename T1 >
umat operator== ( const typename T1::elem_type  val,
const Base< typename T1::elem_type, T1 > &  X 
) [inline]

Definition at line 499 of file operator_relational.hpp.

References operator==().

00500   {
00501   return operator==(X,val);
00502   }

template<typename T1 >
umat operator!= ( const typename T1::elem_type  val,
const Base< typename T1::elem_type, T1 > &  X 
) [inline]

Definition at line 510 of file operator_relational.hpp.

References operator!=().

00511   {
00512   return operator!=(X,val);
00513   }

template<typename T1 >
umat operator>= ( const typename T1::elem_type  val,
const Base< typename T1::elem_type, T1 > &  X 
) [inline]

Definition at line 521 of file operator_relational.hpp.

References Base< elem_type, derived >::get_ref(), and Mat< eT >::memptr().

00522   {
00523   arma_extra_debug_sigprint();
00524   
00525   typedef typename T1::elem_type eT;
00526   
00527   const unwrap<T1> tmp1(X.get_ref());
00528   const Mat<eT>& A = tmp1.M;
00529     
00530   umat out(A.n_rows, A.n_cols);
00531   
00532   const eT* A_mem = A.mem;
00533   
00534   typedef typename umat::elem_type umat_elem_type;
00535   umat_elem_type* out_mem = out.memptr();
00536   
00537   for(u32 i=0; i<A.n_elem; ++i)
00538     {
00539     if(val >= A_mem[i])
00540       {
00541       out_mem[i] = umat_elem_type(1);
00542       }
00543     else
00544       {
00545       out_mem[i] = umat_elem_type(0);
00546       }
00547     }
00548   
00549   return out;
00550   }

template<typename T1 >
umat operator<= ( const typename T1::elem_type  val,
const Base< typename T1::elem_type, T1 > &  X 
) [inline]

Definition at line 558 of file operator_relational.hpp.

References Base< elem_type, derived >::get_ref(), and Mat< eT >::memptr().

00559   {
00560   arma_extra_debug_sigprint();
00561   
00562   typedef typename T1::elem_type eT;
00563   
00564   const unwrap<T1> tmp1(X.get_ref());
00565   const Mat<eT>& A = tmp1.M;
00566     
00567   umat out(A.n_rows, A.n_cols);
00568   
00569   const eT* A_mem = A.mem;
00570   
00571   typedef typename umat::elem_type umat_elem_type;
00572   umat_elem_type* out_mem = out.memptr();
00573   
00574   for(u32 i=0; i<A.n_elem; ++i)
00575     {
00576     if(val <= A_mem[i])
00577       {
00578       out_mem[i] = umat_elem_type(1);
00579       }
00580     else
00581       {
00582       out_mem[i] = umat_elem_type(0);
00583       }
00584     }
00585   
00586   return out;
00587   }

template<typename T1 >
umat operator> ( const typename T1::elem_type  val,
const Base< typename T1::elem_type, T1 > &  X 
) [inline]

Definition at line 595 of file operator_relational.hpp.

References Base< elem_type, derived >::get_ref(), and Mat< eT >::memptr().

00596   {
00597   arma_extra_debug_sigprint();
00598   
00599   typedef typename T1::elem_type eT;
00600   
00601   const unwrap<T1> tmp1(X.get_ref());
00602   const Mat<eT>& A = tmp1.M;
00603     
00604   umat out(A.n_rows, A.n_cols);
00605   
00606   const eT* A_mem = A.mem;
00607   
00608   typedef typename umat::elem_type umat_elem_type;
00609   umat_elem_type* out_mem = out.memptr();
00610   
00611   for(u32 i=0; i<A.n_elem; ++i)
00612     {
00613     if(val > A_mem[i])
00614       {
00615       out_mem[i] = umat_elem_type(1);
00616       }
00617     else
00618       {
00619       out_mem[i] = umat_elem_type(0);
00620       }
00621     }
00622   
00623   return out;
00624   }

template<typename T1 >
umat operator< ( const typename T1::elem_type  val,
const Base< typename T1::elem_type, T1 > &  X 
) [inline]

Definition at line 632 of file operator_relational.hpp.

References Base< elem_type, derived >::get_ref(), and Mat< eT >::memptr().

00633   {
00634   arma_extra_debug_sigprint();
00635   
00636   typedef typename T1::elem_type eT;
00637   
00638   const unwrap<T1> tmp1(X.get_ref());
00639   const Mat<eT>& A = tmp1.M;
00640   
00641   umat out(A.n_rows, A.n_cols);
00642   
00643   const eT* A_mem = A.mem;
00644   
00645   typedef typename umat::elem_type umat_elem_type;
00646   umat_elem_type* out_mem = out.memptr();
00647   
00648   for(u32 i=0; i<A.n_elem; ++i)
00649     {
00650     if(val < A_mem[i])
00651       {
00652       out_mem[i] = umat_elem_type(1);
00653       }
00654     else
00655       {
00656       out_mem[i] = umat_elem_type(0);
00657       }
00658     }
00659   
00660   return out;
00661   }