Operator_relational

Functions

template<typename T1 , typename T2 >
umat operator== (const Base< typename T1::elem_type, T1 > &X, const Base< typename T1::elem_type, T2 > &Y)
template<typename T1 , typename T2 >
umat operator!= (const Base< typename T1::elem_type, T1 > &X, const Base< typename T1::elem_type, T2 > &Y)
template<typename T1 , typename T2 >
umat operator>= (const Base< typename T1::elem_type, T1 > &X, const Base< typename T1::elem_type, T2 > &Y)
template<typename T1 , typename T2 >
umat operator<= (const Base< typename T1::elem_type, T1 > &X, const Base< typename T1::elem_type, T2 > &Y)
template<typename T1 , typename T2 >
umat operator> (const Base< typename T1::elem_type, T1 > &X, const Base< typename T1::elem_type, T2 > &Y)
template<typename T1 , typename T2 >
umat operator< (const Base< typename T1::elem_type, T1 > &X, const Base< typename T1::elem_type, 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 T1 , typename T2 >
umat operator== ( const Base< typename T1::elem_type, T1 > &  X,
const Base< typename T1::elem_type, T2 > &  Y 
) [inline]

Definition at line 26 of file operator_relational.hpp.

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

00027   {
00028   arma_extra_debug_sigprint();
00029   
00030   typedef typename umat::elem_type umat_eT;
00031 
00032   const Proxy<T1> A(X.get_ref());
00033   const Proxy<T2> B(Y.get_ref());
00034   
00035   arma_debug_assert_same_size(A, B, "operator==");
00036   
00037   umat out(A.n_rows, A.n_cols);
00038   
00039   umat_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] = umat_eT(1);
00046       }
00047     else
00048       {
00049       out_mem[i] = umat_eT(0);
00050       }
00051     }
00052   
00053   return out;
00054   }

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

Definition at line 62 of file operator_relational.hpp.

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

00063   {
00064   arma_extra_debug_sigprint();
00065   
00066   typedef typename umat::elem_type umat_eT;
00067 
00068   const Proxy<T1> A(X.get_ref());
00069   const Proxy<T2> B(Y.get_ref());
00070     
00071   arma_debug_assert_same_size(A, B, "operator!=");
00072   
00073   umat out(A.n_rows, A.n_cols);
00074   
00075   umat_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] = umat_eT(1);
00082       }
00083     else
00084       {
00085       out_mem[i] = umat_eT(0);
00086       }
00087     }
00088   
00089   return out;
00090   }

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

Definition at line 98 of file operator_relational.hpp.

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

00099   {
00100   arma_extra_debug_sigprint();
00101   
00102   typedef typename umat::elem_type umat_eT;
00103 
00104   const Proxy<T1> A(X.get_ref());
00105   const Proxy<T2> B(Y.get_ref());
00106     
00107   arma_debug_assert_same_size(A, B, "operator>=");
00108   
00109   umat out(A.n_rows, A.n_cols);
00110   
00111   umat_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] = umat_eT(1);
00118       }
00119     else
00120       {
00121       out_mem[i] = umat_eT(0);
00122       }
00123     }
00124   
00125   return out;
00126   }

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

Definition at line 134 of file operator_relational.hpp.

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

00135   {
00136   arma_extra_debug_sigprint();
00137   
00138   typedef typename umat::elem_type umat_eT;
00139 
00140   const Proxy<T1> A(X.get_ref());
00141   const Proxy<T2> B(Y.get_ref());
00142     
00143   arma_debug_assert_same_size(A, B, "operator<=");
00144   
00145   umat out(A.n_rows, A.n_cols);
00146   
00147   umat_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] = umat_eT(1);
00154       }
00155     else
00156       {
00157       out_mem[i] = umat_eT(0);
00158       }
00159     }
00160   
00161   return out;
00162   }

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

Definition at line 170 of file operator_relational.hpp.

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

00171   {
00172   arma_extra_debug_sigprint();
00173   
00174   typedef typename umat::elem_type umat_eT;
00175 
00176   const Proxy<T1> A(X.get_ref());
00177   const Proxy<T2> B(Y.get_ref());
00178     
00179   arma_debug_assert_same_size(A, B, "operator>");
00180   
00181   umat out(A.n_rows, A.n_cols);
00182   
00183   umat_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] = umat_eT(1);
00190       }
00191     else
00192       {
00193       out_mem[i] = umat_eT(0);
00194       }
00195     }
00196   
00197   return out;
00198   }

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

Definition at line 206 of file operator_relational.hpp.

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

00207   {
00208   arma_extra_debug_sigprint();
00209   
00210   typedef typename umat::elem_type umat_eT;
00211 
00212   const Proxy<T1> A(X.get_ref());
00213   const Proxy<T2> B(Y.get_ref());
00214     
00215   arma_debug_assert_same_size(A, B, "operator<");
00216   
00217   umat out(A.n_rows, A.n_cols);
00218   
00219   umat_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] = umat_eT(1);
00226       }
00227     else
00228       {
00229       out_mem[i] = umat_eT(0);
00230       }
00231     }
00232   
00233   return out;
00234   }

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

Definition at line 242 of file operator_relational.hpp.

References Base< elem_type, derived >::get_ref().

00243   {
00244   arma_extra_debug_sigprint();
00245   
00246   typedef typename umat::elem_type umat_eT;
00247   
00248   const Proxy<T1> A(X.get_ref());
00249 
00250   umat out(A.n_rows, A.n_cols);
00251   
00252   umat_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] = umat_eT(1);
00259       }
00260     else
00261       {
00262       out_mem[i] = umat_eT(0);
00263       }
00264     }
00265   
00266   return out;
00267   }

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

Definition at line 275 of file operator_relational.hpp.

References Base< elem_type, derived >::get_ref().

00276   {
00277   arma_extra_debug_sigprint();
00278   
00279   typedef typename umat::elem_type umat_eT;
00280 
00281   const Proxy<T1> A(X.get_ref());
00282 
00283   umat out(A.n_rows, A.n_cols);
00284   
00285   umat_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] = umat_eT(1);
00292       }
00293     else
00294       {
00295       out_mem[i] = umat_eT(0);
00296       }
00297     }
00298   
00299   return out;
00300   }

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

Definition at line 308 of file operator_relational.hpp.

References Base< elem_type, derived >::get_ref().

00309   {
00310   arma_extra_debug_sigprint();
00311   
00312   typedef typename umat::elem_type umat_eT;
00313   
00314   const Proxy<T1> A(X.get_ref());
00315 
00316   umat out(A.n_rows, A.n_cols);
00317   
00318   umat_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] = umat_eT(1);
00325       }
00326     else
00327       {
00328       out_mem[i] = umat_eT(0);
00329       }
00330     }
00331   
00332   return out;
00333   }

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

Definition at line 341 of file operator_relational.hpp.

References Base< elem_type, derived >::get_ref().

00342   {
00343   arma_extra_debug_sigprint();
00344   
00345   typedef typename umat::elem_type umat_eT;
00346   
00347   const Proxy<T1> A(X.get_ref());
00348 
00349   umat out(A.n_rows, A.n_cols);
00350   
00351   umat_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] = umat_eT(1);
00358       }
00359     else
00360       {
00361       out_mem[i] = umat_eT(0);
00362       }
00363     }
00364   
00365   return out;
00366   }

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

Definition at line 374 of file operator_relational.hpp.

References Base< elem_type, derived >::get_ref().

00375   {
00376   arma_extra_debug_sigprint();
00377   
00378   typedef typename umat::elem_type umat_eT;
00379   
00380   const Proxy<T1> A(X.get_ref());
00381 
00382   umat out(A.n_rows, A.n_cols);
00383   
00384   umat_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] = umat_eT(1);
00391       }
00392     else
00393       {
00394       out_mem[i] = umat_eT(0);
00395       }
00396     }
00397   
00398   return out;
00399   }

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

Definition at line 407 of file operator_relational.hpp.

References Base< elem_type, derived >::get_ref().

00408   {
00409   arma_extra_debug_sigprint();
00410   
00411   typedef typename umat::elem_type umat_eT;
00412   
00413   const Proxy<T1> A(X.get_ref());
00414 
00415   umat out(A.n_rows, A.n_cols);
00416   
00417   umat_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] = umat_eT(1);
00424       }
00425     else
00426       {
00427       out_mem[i] = umat_eT(0);
00428       }
00429     }
00430   
00431   return out;
00432   }

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

Definition at line 440 of file operator_relational.hpp.

References operator==().

00441   {
00442   return operator==(X,val);
00443   }

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

Definition at line 451 of file operator_relational.hpp.

References operator!=().

00452   {
00453   return operator!=(X,val);
00454   }

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

Definition at line 462 of file operator_relational.hpp.

References Base< elem_type, derived >::get_ref().

00463   {
00464   arma_extra_debug_sigprint();
00465   
00466   typedef typename umat::elem_type umat_eT;
00467   
00468   const Proxy<T1> A(X.get_ref());
00469 
00470   umat out(A.n_rows, A.n_cols);
00471   
00472   umat_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] = umat_eT(1);
00479       }
00480     else
00481       {
00482       out_mem[i] = umat_eT(0);
00483       }
00484     }
00485   
00486   return out;
00487   }

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

Definition at line 495 of file operator_relational.hpp.

References Base< elem_type, derived >::get_ref().

00496   {
00497   arma_extra_debug_sigprint();
00498   
00499   typedef typename umat::elem_type umat_eT;
00500   
00501   const Proxy<T1> A(X.get_ref());
00502 
00503   umat out(A.n_rows, A.n_cols);
00504   
00505   umat_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] = umat_eT(1);
00512       }
00513     else
00514       {
00515       out_mem[i] = umat_eT(0);
00516       }
00517     }
00518   
00519   return out;
00520   }

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

Definition at line 528 of file operator_relational.hpp.

References Base< elem_type, derived >::get_ref().

00529   {
00530   arma_extra_debug_sigprint();
00531   
00532   typedef typename umat::elem_type umat_eT;
00533   
00534   const Proxy<T1> A(X.get_ref());
00535 
00536   umat out(A.n_rows, A.n_cols);
00537   
00538   umat_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] = umat_eT(1);
00545       }
00546     else
00547       {
00548       out_mem[i] = umat_eT(0);
00549       }
00550     }
00551   
00552   return out;
00553   }

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

Definition at line 561 of file operator_relational.hpp.

References Base< elem_type, derived >::get_ref().

00562   {
00563   arma_extra_debug_sigprint();
00564   
00565   typedef typename umat::elem_type umat_eT;
00566   
00567   const Proxy<T1> A(X.get_ref());
00568 
00569   umat out(A.n_rows, A.n_cols);
00570   
00571   umat_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] = umat_eT(1);
00578       }
00579     else
00580       {
00581       out_mem[i] = umat_eT(0);
00582       }
00583     }
00584   
00585   return out;
00586   }