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) |
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }