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