Operator_cube_relational

Functions

template<typename T1 , typename T2 >
ucube operator== (const BaseCube< typename T1::elem_type, T1 > &X, const BaseCube< typename T1::elem_type, T2 > &Y)
template<typename T1 , typename T2 >
ucube operator!= (const BaseCube< typename T1::elem_type, T1 > &X, const BaseCube< typename T1::elem_type, T2 > &Y)
template<typename T1 , typename T2 >
ucube operator>= (const BaseCube< typename T1::elem_type, T1 > &X, const BaseCube< typename T1::elem_type, T2 > &Y)
template<typename T1 , typename T2 >
ucube operator<= (const BaseCube< typename T1::elem_type, T1 > &X, const BaseCube< typename T1::elem_type, T2 > &Y)
template<typename T1 , typename T2 >
ucube operator> (const BaseCube< typename T1::elem_type, T1 > &X, const BaseCube< typename T1::elem_type, T2 > &Y)
template<typename T1 , typename T2 >
ucube operator< (const BaseCube< typename T1::elem_type, T1 > &X, const BaseCube< typename T1::elem_type, T2 > &Y)
template<typename T1 >
ucube operator== (const BaseCube< typename T1::elem_type, T1 > &X, const typename T1::elem_type val)
template<typename T1 >
ucube operator!= (const BaseCube< typename T1::elem_type, T1 > &X, const typename T1::elem_type val)
template<typename T1 >
ucube operator>= (const BaseCube< typename T1::elem_type, T1 > &X, const typename T1::elem_type val)
template<typename T1 >
ucube operator<= (const BaseCube< typename T1::elem_type, T1 > &X, const typename T1::elem_type val)
template<typename T1 >
ucube operator> (const BaseCube< typename T1::elem_type, T1 > &X, const typename T1::elem_type val)
template<typename T1 >
ucube operator< (const BaseCube< typename T1::elem_type, T1 > &X, const typename T1::elem_type val)
template<typename T1 >
ucube operator== (const typename T1::elem_type val, const BaseCube< typename T1::elem_type, T1 > &X)
template<typename T1 >
ucube operator!= (const typename T1::elem_type val, const BaseCube< typename T1::elem_type, T1 > &X)
template<typename T1 >
ucube operator>= (const typename T1::elem_type val, const BaseCube< typename T1::elem_type, T1 > &X)
template<typename T1 >
ucube operator<= (const typename T1::elem_type val, const BaseCube< typename T1::elem_type, T1 > &X)
template<typename T1 >
ucube operator> (const typename T1::elem_type val, const BaseCube< typename T1::elem_type, T1 > &X)
template<typename T1 >
ucube operator< (const typename T1::elem_type val, const BaseCube< typename T1::elem_type, T1 > &X)

Function Documentation

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

Definition at line 26 of file operator_cube_relational.hpp.

References BaseCube< elem_type, derived >::get_ref(), and Cube< eT >::memptr().

Referenced by operator==().

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   }

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

Definition at line 62 of file operator_cube_relational.hpp.

References BaseCube< elem_type, derived >::get_ref(), and Cube< eT >::memptr().

Referenced by operator!=().

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   }

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

Definition at line 98 of file operator_cube_relational.hpp.

References BaseCube< elem_type, derived >::get_ref(), and Cube< eT >::memptr().

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   }

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

Definition at line 134 of file operator_cube_relational.hpp.

References BaseCube< elem_type, derived >::get_ref(), and Cube< eT >::memptr().

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   }

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

Definition at line 170 of file operator_cube_relational.hpp.

References BaseCube< elem_type, derived >::get_ref(), and Cube< eT >::memptr().

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   }

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

Definition at line 206 of file operator_cube_relational.hpp.

References BaseCube< elem_type, derived >::get_ref(), and Cube< eT >::memptr().

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   }

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

Definition at line 242 of file operator_cube_relational.hpp.

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

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   }

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

Definition at line 275 of file operator_cube_relational.hpp.

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

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   }

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

Definition at line 308 of file operator_cube_relational.hpp.

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

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   }

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

Definition at line 341 of file operator_cube_relational.hpp.

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

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   }

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

Definition at line 374 of file operator_cube_relational.hpp.

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

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   }

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

Definition at line 407 of file operator_cube_relational.hpp.

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

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   }

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

Definition at line 440 of file operator_cube_relational.hpp.

References operator==().

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

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

Definition at line 451 of file operator_cube_relational.hpp.

References operator!=().

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

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

Definition at line 462 of file operator_cube_relational.hpp.

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

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   }

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

Definition at line 495 of file operator_cube_relational.hpp.

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

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   }

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

Definition at line 528 of file operator_cube_relational.hpp.

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

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   }

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

Definition at line 561 of file operator_cube_relational.hpp.

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

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   }