00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021 template<typename T1>
00022 inline
00023 void
00024 op_log::apply(Mat<typename T1::elem_type>& out, const Op<T1,op_log>& in)
00025 {
00026 arma_extra_debug_sigprint();
00027
00028 typedef typename T1::elem_type eT;
00029
00030 const unwrap_write<T1> tmp(out, in.m);
00031 const Mat<eT>& A = tmp.M;
00032
00033 eT* out_mem = out.memptr();
00034 const eT* A_mem = A.memptr();
00035 const u32 n_elem = out.n_elem;
00036
00037 for(u32 i=0; i<n_elem; ++i)
00038 {
00039 out_mem[i] = std::log(A_mem[i]);
00040 }
00041 }
00042
00043
00044
00045 template<typename T1>
00046 inline
00047 void
00048 op_log::apply(Cube<typename T1::elem_type>& out, const OpCube<T1,op_log>& in)
00049 {
00050 arma_extra_debug_sigprint();
00051
00052 typedef typename T1::elem_type eT;
00053
00054 const unwrap_cube_write<T1> tmp(out, in.m);
00055 const Cube<eT>& A = tmp.M;
00056
00057 eT* out_mem = out.memptr();
00058 const eT* A_mem = A.memptr();
00059 const u32 n_elem = out.n_elem;
00060
00061 for(u32 i=0; i<n_elem; ++i)
00062 {
00063 out_mem[i] = std::log(A_mem[i]);
00064 }
00065 }
00066
00067
00068
00069 template<typename T1>
00070 inline
00071 void
00072 op_trunc_log::apply(Mat<typename T1::elem_type>& out, const Op<T1,op_trunc_log>& in)
00073 {
00074 arma_extra_debug_sigprint();
00075
00076 typedef typename T1::elem_type eT;
00077
00078 const unwrap_write<T1> tmp(out, in.m);
00079 const Mat<eT>& A = tmp.M;
00080
00081 eT* out_mem = out.memptr();
00082 const eT* A_mem = A.memptr();
00083 const u32 n_elem = out.n_elem;
00084
00085 for(u32 i=0; i<n_elem; ++i)
00086 {
00087 out_mem[i] = trunc_log(A_mem[i]);
00088 }
00089 }
00090
00091
00092
00093 template<typename T1>
00094 inline
00095 void
00096 op_trunc_log::apply(Cube<typename T1::elem_type>& out, const OpCube<T1,op_trunc_log>& in)
00097 {
00098 arma_extra_debug_sigprint();
00099
00100 typedef typename T1::elem_type eT;
00101
00102 const unwrap_cube_write<T1> tmp(out, in.m);
00103 const Cube<eT>& A = tmp.M;
00104
00105 eT* out_mem = out.memptr();
00106 const eT* A_mem = A.memptr();
00107 const u32 n_elem = out.n_elem;
00108
00109 for(u32 i=0; i<n_elem; ++i)
00110 {
00111 out_mem[i] = trunc_log(A_mem[i]);
00112 }
00113 }
00114
00115
00116
00117 template<typename T1>
00118 inline
00119 void
00120 op_log10::apply(Mat<typename T1::elem_type>& out, const Op<T1,op_log10>& in)
00121 {
00122 arma_extra_debug_sigprint();
00123
00124 typedef typename T1::elem_type eT;
00125
00126 const unwrap_write<T1> tmp(out, in.m);
00127 const Mat<eT>& A = tmp.M;
00128
00129 eT* out_mem = out.memptr();
00130 const eT* A_mem = A.memptr();
00131 const u32 n_elem = out.n_elem;
00132
00133 for(u32 i=0; i<n_elem; ++i)
00134 {
00135 out_mem[i] = std::log10(A_mem[i]);
00136 }
00137 }
00138
00139
00140
00141 template<typename T1>
00142 inline
00143 void
00144 op_log10::apply(Cube<typename T1::elem_type>& out, const OpCube<T1,op_log10>& in)
00145 {
00146 arma_extra_debug_sigprint();
00147
00148 typedef typename T1::elem_type eT;
00149
00150 const unwrap_cube_write<T1> tmp(out, in.m);
00151 const Cube<eT>& A = tmp.M;
00152
00153 eT* out_mem = out.memptr();
00154 const eT* A_mem = A.memptr();
00155 const u32 n_elem = out.n_elem;
00156
00157 for(u32 i=0; i<n_elem; ++i)
00158 {
00159 out_mem[i] = std::log10(A_mem[i]);
00160 }
00161 }
00162
00163
00164
00165 template<typename T1>
00166 inline
00167 void
00168 op_exp::apply(Mat<typename T1::elem_type>& out, const Op<T1,op_exp>& in)
00169 {
00170 arma_extra_debug_sigprint();
00171
00172 typedef typename T1::elem_type eT;
00173
00174 const unwrap_write<T1> tmp(out, in.m);
00175 const Mat<eT>& A = tmp.M;
00176
00177 eT* out_mem = out.memptr();
00178 const eT* A_mem = A.memptr();
00179 const u32 n_elem = out.n_elem;
00180
00181 for(u32 i=0; i<n_elem; ++i)
00182 {
00183 out_mem[i] = std::exp(A_mem[i]);
00184 }
00185 }
00186
00187
00188
00189 template<typename T1>
00190 inline
00191 void
00192 op_exp::apply(Cube<typename T1::elem_type>& out, const OpCube<T1,op_exp>& in)
00193 {
00194 arma_extra_debug_sigprint();
00195
00196 typedef typename T1::elem_type eT;
00197
00198 const unwrap_cube_write<T1> tmp(out, in.m);
00199 const Cube<eT>& A = tmp.M;
00200
00201 eT* out_mem = out.memptr();
00202 const eT* A_mem = A.memptr();
00203 const u32 n_elem = out.n_elem;
00204
00205 for(u32 i=0; i<n_elem; ++i)
00206 {
00207 out_mem[i] = std::exp(A_mem[i]);
00208 }
00209 }
00210
00211
00212
00213 template<typename T1>
00214 inline
00215 void
00216 op_trunc_exp::apply(Mat<typename T1::elem_type>& out, const Op<T1,op_trunc_exp>& in)
00217 {
00218 arma_extra_debug_sigprint();
00219
00220 typedef typename T1::elem_type eT;
00221
00222 const unwrap_write<T1> tmp(out, in.m);
00223 const Mat<eT>& A = tmp.M;
00224
00225 eT* out_mem = out.memptr();
00226 const eT* A_mem = A.memptr();
00227 const u32 n_elem = out.n_elem;
00228
00229 for(u32 i=0; i<n_elem; ++i)
00230 {
00231 out_mem[i] = trunc_exp(A_mem[i]);
00232 }
00233 }
00234
00235
00236
00237 template<typename T1>
00238 inline
00239 void
00240 op_trunc_exp::apply(Cube<typename T1::elem_type>& out, const OpCube<T1,op_trunc_exp>& in)
00241 {
00242 arma_extra_debug_sigprint();
00243
00244 typedef typename T1::elem_type eT;
00245
00246 const unwrap_cube_write<T1> tmp(out, in.m);
00247 const Cube<eT>& A = tmp.M;
00248
00249 eT* out_mem = out.memptr();
00250 const eT* A_mem = A.memptr();
00251 const u32 n_elem = out.n_elem;
00252
00253 for(u32 i=0; i<n_elem; ++i)
00254 {
00255 out_mem[i] = trunc_exp(A_mem[i]);
00256 }
00257 }
00258
00259
00260
00261 template<typename T1>
00262 inline
00263 void
00264 op_sqrt::apply(Mat<typename T1::elem_type>& out, const Op<T1,op_sqrt>& in)
00265 {
00266 arma_extra_debug_sigprint();
00267
00268 typedef typename T1::elem_type eT;
00269
00270 const unwrap_write<T1> tmp(out, in.m);
00271 const Mat<eT>& A = tmp.M;
00272
00273 eT* out_mem = out.memptr();
00274 const eT* A_mem = A.memptr();
00275 const u32 n_elem = out.n_elem;
00276
00277 for(u32 i=0; i<n_elem; ++i)
00278 {
00279 out_mem[i] = std::sqrt(A_mem[i]);
00280 }
00281 }
00282
00283
00284
00285 template<typename T1>
00286 inline
00287 void
00288 op_sqrt::apply(Cube<typename T1::elem_type>& out, const OpCube<T1,op_sqrt>& in)
00289 {
00290 arma_extra_debug_sigprint();
00291
00292 typedef typename T1::elem_type eT;
00293
00294 const unwrap_cube_write<T1> tmp(out, in.m);
00295 const Cube<eT>& A = tmp.M;
00296
00297 eT* out_mem = out.memptr();
00298 const eT* A_mem = A.memptr();
00299 const u32 n_elem = out.n_elem;
00300
00301 for(u32 i=0; i<n_elem; ++i)
00302 {
00303 out_mem[i] = std::sqrt(A_mem[i]);
00304 }
00305 }
00306
00307
00308
00309 template<typename T1>
00310 inline
00311 void
00312 op_square::apply(Mat<typename T1::elem_type>& out, const Op<T1,op_square>& in)
00313 {
00314 arma_extra_debug_sigprint();
00315
00316 typedef typename T1::elem_type eT;
00317
00318 const unwrap_write<T1> tmp(out, in.m);
00319 const Mat<eT>& A = tmp.M;
00320
00321 eT* out_mem = out.memptr();
00322 const eT* A_mem = A.memptr();
00323 const u32 n_elem = out.n_elem;
00324
00325 for(u32 i=0; i<n_elem; ++i)
00326 {
00327 const eT val = A_mem[i];
00328 out_mem[i] = val*val;
00329 }
00330 }
00331
00332
00333
00334 template<typename T1>
00335 inline
00336 void
00337 op_square::apply(Cube<typename T1::elem_type>& out, const OpCube<T1,op_square>& in)
00338 {
00339 arma_extra_debug_sigprint();
00340
00341 typedef typename T1::elem_type eT;
00342
00343 const unwrap_cube_write<T1> tmp(out, in.m);
00344 const Cube<eT>& A = tmp.M;
00345
00346 eT* out_mem = out.memptr();
00347 const eT* A_mem = A.memptr();
00348 const u32 n_elem = out.n_elem;
00349
00350 for(u32 i=0; i<n_elem; ++i)
00351 {
00352 const eT val = A_mem[i];
00353 out_mem[i] = val*val;
00354 }
00355 }
00356
00357
00358
00359 template<typename T1, typename T2>
00360 inline
00361 T1
00362 op_pow::internal_pow(const T1 base, const T2 exponent)
00363 {
00364 return std::pow(base, exponent);
00365 }
00366
00367
00368
00369 template<typename T2>
00370 inline
00371 char
00372 op_pow::internal_pow(const char base, const T2 exponent)
00373 {
00374 typedef char out_type;
00375 return out_type( std::pow(double(base), exponent) );
00376 }
00377
00378
00379
00380 template<typename T2>
00381 inline
00382 unsigned char
00383 op_pow::internal_pow(const unsigned char base, const T2 exponent)
00384 {
00385 typedef unsigned char out_type;
00386 return out_type( std::pow(double(base), exponent) );
00387 }
00388
00389
00390
00391 template<typename T2>
00392 inline
00393 int
00394 op_pow::internal_pow(const int base, const T2 exponent)
00395 {
00396 typedef int out_type;
00397 return out_type( std::pow(double(base), exponent) );
00398 }
00399
00400
00401
00402 template<typename T2>
00403 inline
00404 unsigned int
00405 op_pow::internal_pow(const unsigned int base, const T2 exponent)
00406 {
00407 typedef unsigned int out_type;
00408 return out_type( std::pow(double(base), exponent) );
00409 }
00410
00411
00412
00413 template<typename T1>
00414 inline
00415 void
00416 op_pow::apply(Mat<typename T1::pod_type>& out, const Op<T1,op_pow>& in)
00417 {
00418 arma_extra_debug_sigprint();
00419
00420 typedef typename T1::elem_type eT;
00421
00422 const unwrap_write<T1> tmp(out, in.m);
00423 const Mat<eT>& A = tmp.M;
00424
00425 eT* out_mem = out.memptr();
00426 const eT* A_mem = A.memptr();
00427 const u32 n_elem = out.n_elem;
00428
00429 for(u32 i=0; i<n_elem; ++i)
00430 {
00431
00432 out_mem[i] = op_pow::internal_pow(A_mem[i], in.aux);
00433 }
00434
00435 }
00436
00437
00438
00439 template<typename T1>
00440 inline
00441 void
00442 op_pow::apply(Cube<typename T1::pod_type>& out, const OpCube<T1,op_pow>& in)
00443 {
00444 arma_extra_debug_sigprint();
00445
00446 typedef typename T1::elem_type eT;
00447
00448 const unwrap_cube_write<T1> tmp(in.m);
00449 const Cube<eT>& A = tmp.M;
00450
00451 eT* out_mem = out.memptr();
00452 const eT* A_mem = A.memptr();
00453 const u32 n_elem = out.n_elem;
00454
00455 for(u32 i=0; i<n_elem; ++i)
00456 {
00457
00458 out_mem[i] = op_pow::internal_pow(A_mem[i], in.aux);
00459 }
00460
00461 }
00462
00463
00464
00465 template<typename T1>
00466 inline
00467 void
00468 op_pow::apply(Mat< std::complex<typename T1::pod_type> >& out, const Op<T1,op_pow>& in)
00469 {
00470 arma_extra_debug_sigprint();
00471
00472 typedef typename T1::pod_type T;
00473 typedef std::complex<T> eT;
00474
00475 isnt_same_type<eT, typename T1::elem_type>::check();
00476
00477 const unwrap<T1> tmp(in.m);
00478
00479 const Mat<eT>& A = tmp.M;
00480 const u32 n_elem = A.n_elem;
00481
00482
00483 out.copy_size(A);
00484
00485 eT* out_ptr = out.memptr();
00486
00487
00488 if(in.aux.imag() == T(0))
00489 {
00490 const T in_aux_real = in.aux.real();
00491
00492 for(u32 i=0; i<n_elem; ++i)
00493 {
00494 out_ptr[i] = std::pow(A.mem[i], in_aux_real);
00495 }
00496 }
00497 else
00498 {
00499 for(u32 i=0; i<n_elem; ++i)
00500 {
00501 out_ptr[i] = std::pow(A.mem[i], in.aux);
00502 }
00503 }
00504 }
00505
00506
00507
00508 template<typename T1>
00509 inline
00510 void
00511 op_pow::apply(Cube< std::complex<typename T1::pod_type> >& out, const OpCube<T1,op_pow>& in)
00512 {
00513 arma_extra_debug_sigprint();
00514
00515 typedef typename T1::pod_type T;
00516 typedef std::complex<T> eT;
00517
00518 isnt_same_type<eT, typename T1::elem_type>::check();
00519
00520 const unwrap_cube<T1> tmp(in.m);
00521
00522 const Cube<eT>& A = tmp.M;
00523 const u32 n_elem = A.n_elem;
00524
00525
00526 out.copy_size(A);
00527
00528 eT* out_ptr = out.memptr();
00529
00530
00531 if(in.aux.imag() == T(0))
00532 {
00533 const T in_aux_real = in.aux.real();
00534
00535 for(u32 i=0; i<n_elem; ++i)
00536 {
00537 out_ptr[i] = std::pow(A.mem[i], in_aux_real);
00538 }
00539 }
00540 else
00541 {
00542 for(u32 i=0; i<n_elem; ++i)
00543 {
00544 out_ptr[i] = std::pow(A.mem[i], in.aux);
00545 }
00546 }
00547 }
00548
00549
00550
00551 template<typename T1>
00552 inline
00553 T1
00554 op_pow_s32::internal_pow(const T1 base, const int exponent)
00555 {
00556 return std::pow(base, exponent);
00557 }
00558
00559
00560
00561 inline
00562 char
00563 op_pow_s32::internal_pow(const char base, const int exponent)
00564 {
00565 typedef char out_type;
00566 return out_type( std::pow(double(base), exponent) );
00567 }
00568
00569
00570
00571 inline
00572 unsigned char
00573 op_pow_s32::internal_pow(const unsigned char base, const int exponent)
00574 {
00575 typedef unsigned char out_type;
00576 return out_type( std::pow(double(base), exponent) );
00577 }
00578
00579
00580
00581 inline
00582 int
00583 op_pow_s32::internal_pow(const int base, const int exponent)
00584 {
00585 typedef int out_type;
00586 return out_type( std::pow(double(base), exponent) );
00587 }
00588
00589
00590
00591 inline
00592 unsigned int
00593 op_pow_s32::internal_pow(const unsigned int base, const int exponent)
00594 {
00595 typedef unsigned int out_type;
00596 return out_type( std::pow(double(base), exponent) );
00597 }
00598
00599
00600
00601 template<typename T1>
00602 inline
00603 void
00604 op_pow_s32::apply(Mat<typename T1::elem_type>& out, const Op<T1,op_pow_s32>& in)
00605 {
00606 arma_extra_debug_sigprint();
00607
00608 typedef typename T1::elem_type eT;
00609
00610 const unwrap_write<T1> tmp(out, in.m);
00611 const Mat<eT>& A = tmp.M;
00612
00613 eT* out_mem = out.memptr();
00614 const eT* A_mem = A.memptr();
00615 const u32 n_elem = out.n_elem;
00616
00617 const int exponent = (in.aux_u32_b == 0) ? in.aux_u32_a : -in.aux_u32_a;
00618
00619 for(u32 i=0; i<n_elem; ++i)
00620 {
00621
00622 out_mem[i] = op_pow_s32::internal_pow(A_mem[i], exponent);
00623 }
00624
00625 }
00626
00627
00628
00629 template<typename T1>
00630 inline
00631 void
00632 op_pow_s32::apply(Cube<typename T1::elem_type>& out, const OpCube<T1,op_pow_s32>& in)
00633 {
00634 arma_extra_debug_sigprint();
00635
00636 typedef typename T1::elem_type eT;
00637
00638 const unwrap_cube_write<T1> tmp(out, in.m);
00639 const Cube<eT>& A = tmp.M;
00640
00641 eT* out_mem = out.memptr();
00642 const eT* A_mem = A.memptr();
00643 const u32 n_elem = out.n_elem;
00644
00645 const int exponent = (in.aux_u32_b == 0) ? in.aux_u32_a : -in.aux_u32_a;
00646
00647 for(u32 i=0; i<n_elem; ++i)
00648 {
00649
00650 out_mem[i] = op_pow_s32::internal_pow(A_mem[i], exponent);
00651 }
00652
00653 }
00654
00655
00656
00657 template<typename T1>
00658 inline
00659 void
00660 op_conj::apply(Mat<typename T1::elem_type>& out, const Op<T1,op_conj>& in)
00661 {
00662 arma_extra_debug_sigprint();
00663
00664 typedef typename T1::elem_type eT;
00665
00666 const unwrap_write<T1> tmp(out, in.m);
00667 const Mat<eT>& A = tmp.M;
00668
00669 eT* out_mem = out.memptr();
00670 const eT* A_mem = A.memptr();
00671 const u32 n_elem = out.n_elem;
00672
00673 for(u32 i=0; i<n_elem; ++i)
00674 {
00675 out_mem[i] = std::conj(A_mem[i]);
00676 }
00677 }
00678
00679
00680
00681 template<typename T1>
00682 inline
00683 void
00684 op_conj::apply(Cube<typename T1::elem_type>& out, const OpCube<T1,op_conj>& in)
00685 {
00686 arma_extra_debug_sigprint();
00687
00688 typedef typename T1::elem_type eT;
00689
00690 const unwrap_cube_write<T1> tmp(out, in.m);
00691 const Cube<eT>& A = tmp.M;
00692
00693 eT* out_mem = out.memptr();
00694 const eT* A_mem = A.memptr();
00695 const u32 n_elem = out.n_elem;
00696
00697 for(u32 i=0; i<n_elem; ++i)
00698 {
00699 out_mem[i] = std::conj(A_mem[i]);
00700 }
00701 }
00702
00703
00704
00705