00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022 template<typename T1, typename T2>
00023 inline
00024 ucube
00025 operator==
00026 (const BaseCube<typename T1::elem_type,T1>& X, const BaseCube<typename T1::elem_type,T2>& Y)
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 }
00055
00056
00057
00058 template<typename T1, typename T2>
00059 inline
00060 ucube
00061 operator!=
00062 (const BaseCube<typename T1::elem_type,T1>& X, const BaseCube<typename T1::elem_type,T2>& Y)
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 }
00091
00092
00093
00094 template<typename T1, typename T2>
00095 inline
00096 ucube
00097 operator>=
00098 (const BaseCube<typename T1::elem_type,T1>& X, const BaseCube<typename T1::elem_type,T2>& Y)
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 }
00127
00128
00129
00130 template<typename T1, typename T2>
00131 inline
00132 ucube
00133 operator<=
00134 (const BaseCube<typename T1::elem_type,T1>& X, const BaseCube<typename T1::elem_type,T2>& Y)
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 }
00163
00164
00165
00166 template<typename T1, typename T2>
00167 inline
00168 ucube
00169 operator>
00170 (const BaseCube<typename T1::elem_type,T1>& X, const BaseCube<typename T1::elem_type,T2>& Y)
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 }
00199
00200
00201
00202 template<typename T1, typename T2>
00203 inline
00204 ucube
00205 operator<
00206 (const BaseCube<typename T1::elem_type,T1>& X, const BaseCube<typename T1::elem_type,T2>& Y)
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 }
00235
00236
00237
00238 template<typename T1>
00239 inline
00240 ucube
00241 operator==
00242 (const BaseCube<typename T1::elem_type,T1>& X, const typename T1::elem_type val)
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 }
00268
00269
00270
00271 template<typename T1>
00272 inline
00273 ucube
00274 operator!=
00275 (const BaseCube<typename T1::elem_type,T1>& X, const typename T1::elem_type val)
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 }
00301
00302
00303
00304 template<typename T1>
00305 inline
00306 ucube
00307 operator>=
00308 (const BaseCube<typename T1::elem_type,T1>& X, const typename T1::elem_type val)
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 }
00334
00335
00336
00337 template<typename T1>
00338 inline
00339 ucube
00340 operator<=
00341 (const BaseCube<typename T1::elem_type,T1>& X, const typename T1::elem_type val)
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 }
00367
00368
00369
00370 template<typename T1>
00371 inline
00372 ucube
00373 operator>
00374 (const BaseCube<typename T1::elem_type,T1>& X, const typename T1::elem_type val)
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 }
00400
00401
00402
00403 template<typename T1>
00404 inline
00405 ucube
00406 operator<
00407 (const BaseCube<typename T1::elem_type,T1>& X, const typename T1::elem_type val)
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 }
00433
00434
00435
00436 template<typename T1>
00437 inline
00438 ucube
00439 operator==
00440 (const typename T1::elem_type val, const BaseCube<typename T1::elem_type,T1>& X)
00441 {
00442 return operator==(X,val);
00443 }
00444
00445
00446
00447 template<typename T1>
00448 inline
00449 ucube
00450 operator!=
00451 (const typename T1::elem_type val, const BaseCube<typename T1::elem_type,T1>& X)
00452 {
00453 return operator!=(X,val);
00454 }
00455
00456
00457
00458 template<typename T1>
00459 inline
00460 ucube
00461 operator>=
00462 (const typename T1::elem_type val, const BaseCube<typename T1::elem_type,T1>& X)
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 }
00488
00489
00490
00491 template<typename T1>
00492 inline
00493 ucube
00494 operator<=
00495 (const typename T1::elem_type val, const BaseCube<typename T1::elem_type,T1>& X)
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 }
00521
00522
00523
00524 template<typename T1>
00525 inline
00526 ucube
00527 operator>
00528 (const typename T1::elem_type val, const BaseCube<typename T1::elem_type,T1>& X)
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 }
00554
00555
00556
00557 template<typename T1>
00558 inline
00559 ucube
00560 operator<
00561 (const typename T1::elem_type val, const BaseCube<typename T1::elem_type,T1>& X)
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 }
00587
00588
00589
00590