fn_elem.hpp
Go to the documentation of this file.
00001 // Copyright (C) 2008-2011 NICTA (www.nicta.com.au)
00002 // Copyright (C) 2008-2011 Conrad Sanderson
00003 // 
00004 // This file is part of the Armadillo C++ library.
00005 // It is provided without any warranty of fitness
00006 // for any purpose. You can redistribute this file
00007 // and/or modify it under the terms of the GNU
00008 // Lesser General Public License (LGPL) as published
00009 // by the Free Software Foundation, either version 3
00010 // of the License or (at your option) any later version.
00011 // (see http://www.opensource.org/licenses for more info)
00012 
00013 
00016 
00017 
00018 
00019 //
00020 // find
00021 
00022 template<typename eT, typename T1>
00023 inline
00024 const mtOp<uword, T1, op_find>
00025 find(const Base<eT,T1>& X, const uword k = 0, const char* direction = "first")
00026   {
00027   arma_extra_debug_sigprint();
00028   
00029   const char sig = direction[0];
00030   
00031   arma_debug_check
00032     (
00033     (sig != 'f' && sig != 'F' && sig != 'l' && sig != 'L'),
00034     "find(): 3rd input argument must be \"first\" or \"last\""
00035     );
00036   
00037   const uword type = (sig == 'f' || sig == 'F') ? 0 : 1;
00038   
00039   return mtOp<uword, T1, op_find>(X.get_ref(), k, type);
00040   }
00041 
00042 
00043 
00044 //
00045 // real
00046 
00047 template<typename T1>
00048 arma_inline
00049 const T1&
00050 real(const Base<typename T1::pod_type, T1>& X)
00051   {
00052   arma_extra_debug_sigprint();
00053   
00054   return X.get_ref();
00055   }
00056 
00057 
00058 
00059 template<typename T1>
00060 arma_inline
00061 const T1&
00062 real(const BaseCube<typename T1::pod_type, T1>& X)
00063   {
00064   arma_extra_debug_sigprint();
00065   
00066   return X.get_ref();
00067   }
00068 
00069 
00070 
00071 template<typename T1>
00072 inline
00073 const mtOp<typename T1::pod_type, T1, op_real>
00074 real(const Base<std::complex<typename T1::pod_type>, T1>& X)
00075   {
00076   arma_extra_debug_sigprint();
00077   
00078   return mtOp<typename T1::pod_type, T1, op_real>( X.get_ref() );
00079   }
00080 
00081 
00082 
00083 template<typename T1>
00084 inline
00085 const mtOpCube<typename T1::pod_type, T1, op_real>
00086 real(const BaseCube<std::complex<typename T1::pod_type>, T1>& X)
00087   {
00088   arma_extra_debug_sigprint();
00089   
00090   return mtOpCube<typename T1::pod_type, T1, op_real>( X.get_ref() );
00091   }
00092 
00093 
00094 
00095 //
00096 // imag
00097 
00098 template<typename T1>
00099 inline
00100 const Gen<typename T1::pod_type, gen_zeros>
00101 imag(const Base<typename T1::pod_type,T1>& X)
00102   {
00103   arma_extra_debug_sigprint();
00104   
00105   const Proxy<T1> A(X.get_ref());
00106   
00107   return Gen<typename T1::pod_type, gen_zeros>(A.get_n_rows(), A.get_n_cols());
00108   }
00109 
00110 
00111 
00112 template<typename T1>
00113 inline
00114 const GenCube<typename T1::pod_type, gen_zeros>
00115 imag(const BaseCube<typename T1::pod_type,T1>& X)
00116   {
00117   arma_extra_debug_sigprint();
00118   
00119   const ProxyCube<T1> A(X.get_ref());
00120   
00121   return GenCube<typename T1::pod_type, gen_zeros>(A.get_n_rows(), A.get_n_cols(), A.get_n_slices());
00122   }
00123 
00124 
00125 
00126 template<typename T1>
00127 inline
00128 const mtOp<typename T1::pod_type, T1, op_imag>
00129 imag(const Base<std::complex<typename T1::pod_type>, T1>& X)
00130   {
00131   arma_extra_debug_sigprint();
00132   
00133   return mtOp<typename T1::pod_type, T1, op_imag>( X.get_ref() );
00134   }
00135 
00136 
00137 
00138 template<typename T1>
00139 inline
00140 const mtOpCube<typename T1::pod_type, T1, op_imag>
00141 imag(const BaseCube<std::complex<typename T1::pod_type>,T1>& X)
00142   {
00143   arma_extra_debug_sigprint();
00144   
00145   return mtOpCube<typename T1::pod_type, T1, op_imag>( X.get_ref() );
00146   }
00147 
00148 
00149 
00150 //
00151 // log
00152 
00153 template<typename T1>
00154 arma_inline
00155 const eOp<T1, eop_log>
00156 log(const Base<typename T1::elem_type,T1>& A)
00157   {
00158   arma_extra_debug_sigprint();
00159   
00160   return eOp<T1, eop_log>(A.get_ref());
00161   }
00162 
00163 
00164 
00165 template<typename T1>
00166 arma_inline
00167 const eOpCube<T1, eop_log>
00168 log(const BaseCube<typename T1::elem_type,T1>& A)
00169   {
00170   arma_extra_debug_sigprint();
00171   
00172   return eOpCube<T1, eop_log>(A.get_ref());
00173   }
00174 
00175 
00176 
00177 //
00178 // log2
00179 
00180 template<typename T1>
00181 arma_inline
00182 const eOp<T1, eop_log2>
00183 log2(const Base<typename T1::elem_type,T1>& A)
00184   {
00185   arma_extra_debug_sigprint();
00186   
00187   return eOp<T1, eop_log2>(A.get_ref());
00188   }
00189 
00190 
00191 
00192 template<typename T1>
00193 arma_inline
00194 const eOpCube<T1, eop_log2>
00195 log2(const BaseCube<typename T1::elem_type,T1>& A)
00196   {
00197   arma_extra_debug_sigprint();
00198   
00199   return eOpCube<T1, eop_log2>(A.get_ref());
00200   }
00201 
00202 
00203 
00204 //
00205 // log10
00206 
00207 template<typename T1>
00208 arma_inline
00209 const eOp<T1, eop_log10>
00210 log10(const Base<typename T1::elem_type,T1>& A)
00211   {
00212   arma_extra_debug_sigprint();
00213   
00214   return eOp<T1, eop_log10>(A.get_ref());
00215   }
00216 
00217 
00218 
00219 template<typename T1>
00220 arma_inline
00221 const eOpCube<T1, eop_log10>
00222 log10(const BaseCube<typename T1::elem_type,T1>& A)
00223   {
00224   arma_extra_debug_sigprint();
00225   
00226   return eOpCube<T1, eop_log10>(A.get_ref());
00227   }
00228 
00229 
00230 
00231 //
00232 // exp
00233 
00234 template<typename T1>
00235 arma_inline
00236 const eOp<T1, eop_exp>
00237 exp(const Base<typename T1::elem_type,T1>& A)
00238   {
00239   arma_extra_debug_sigprint();
00240   
00241   return eOp<T1, eop_exp>(A.get_ref());
00242   }
00243 
00244 
00245 
00246 template<typename T1>
00247 arma_inline
00248 const eOpCube<T1, eop_exp>
00249 exp(const BaseCube<typename T1::elem_type,T1>& A)
00250   {
00251   arma_extra_debug_sigprint();
00252   
00253   return eOpCube<T1, eop_exp>(A.get_ref());
00254   }
00255 
00256 
00257 
00258 // exp2
00259 
00260 template<typename T1>
00261 arma_inline
00262 const eOp<T1, eop_exp2>
00263 exp2(const Base<typename T1::elem_type,T1>& A)
00264   {
00265   arma_extra_debug_sigprint();
00266   
00267   return eOp<T1, eop_exp2>(A.get_ref());
00268   }
00269 
00270 
00271 
00272 template<typename T1>
00273 arma_inline
00274 const eOpCube<T1, eop_exp2>
00275 exp2(const BaseCube<typename T1::elem_type,T1>& A)
00276   {
00277   arma_extra_debug_sigprint();
00278   
00279   return eOpCube<T1, eop_exp2>(A.get_ref());
00280   }
00281 
00282 
00283 
00284 // exp10
00285 
00286 template<typename T1>
00287 arma_inline
00288 const eOp<T1, eop_exp10>
00289 exp10(const Base<typename T1::elem_type,T1>& A)
00290   {
00291   arma_extra_debug_sigprint();
00292   
00293   return eOp<T1, eop_exp10>(A.get_ref());
00294   }
00295 
00296 
00297 
00298 template<typename T1>
00299 arma_inline
00300 const eOpCube<T1, eop_exp10>
00301 exp10(const BaseCube<typename T1::elem_type,T1>& A)
00302   {
00303   arma_extra_debug_sigprint();
00304   
00305   return eOpCube<T1, eop_exp10>(A.get_ref());
00306   }
00307 
00308 
00309 
00310 //
00311 // abs
00312 
00313 
00314 template<typename T1>
00315 arma_inline
00316 const eOp<T1, eop_abs>
00317 abs(const Base<typename T1::elem_type,T1>& X, const typename arma_not_cx<typename T1::elem_type>::result* junk = 0)
00318   {
00319   arma_extra_debug_sigprint();
00320   
00321   arma_ignore(junk);
00322   
00323   return eOp<T1, eop_abs>(X.get_ref());
00324   }
00325 
00326 
00327 
00328 template<typename T1>
00329 arma_inline
00330 const eOpCube<T1, eop_abs>
00331 abs(const BaseCube<typename T1::elem_type,T1>& X, const typename arma_not_cx<typename T1::elem_type>::result* junk = 0)
00332   {
00333   arma_extra_debug_sigprint();
00334   
00335   arma_ignore(junk);
00336   
00337   return eOpCube<T1, eop_abs>(X.get_ref());
00338   }
00339 
00340 
00341 
00342 template<typename T1>
00343 inline
00344 const mtOp<typename T1::pod_type, T1, op_abs>
00345 abs(const Base<std::complex<typename T1::pod_type>, T1>& X, const typename arma_cx_only<typename T1::elem_type>::result* junk = 0)
00346   {
00347   arma_extra_debug_sigprint();
00348   
00349   arma_ignore(junk);
00350   
00351   return mtOp<typename T1::pod_type, T1, op_abs>( X.get_ref() );
00352   }
00353 
00354 
00355 
00356 template<typename T1>
00357 inline
00358 const mtOpCube<typename T1::pod_type, T1, op_abs>
00359 abs(const BaseCube< std::complex<typename T1::pod_type>,T1>& X, const typename arma_cx_only<typename T1::elem_type>::result* junk = 0)
00360   {
00361   arma_extra_debug_sigprint();
00362   
00363   arma_ignore(junk);
00364   
00365   return mtOpCube<typename T1::pod_type, T1, op_abs>( X.get_ref() );
00366   }
00367 
00368 
00369 
00370 //
00371 // square
00372 
00373 template<typename T1>
00374 arma_inline
00375 const eOp<T1, eop_square>
00376 square(const Base<typename T1::elem_type,T1>& A)
00377   {
00378   arma_extra_debug_sigprint();
00379   
00380   return eOp<T1, eop_square>(A.get_ref());
00381   }
00382 
00383 
00384 
00385 template<typename T1>
00386 arma_inline
00387 const eOpCube<T1, eop_square>
00388 square(const BaseCube<typename T1::elem_type,T1>& A)
00389   {
00390   arma_extra_debug_sigprint();
00391   
00392   return eOpCube<T1, eop_square>(A.get_ref());
00393   }
00394 
00395 
00396 
00397 //
00398 // sqrt
00399 
00400 template<typename T1>
00401 arma_inline
00402 const eOp<T1, eop_sqrt>
00403 sqrt(const Base<typename T1::elem_type,T1>& A)
00404   {
00405   arma_extra_debug_sigprint();
00406   
00407   return eOp<T1, eop_sqrt>(A.get_ref());
00408   }
00409 
00410 
00411 
00412 template<typename T1>
00413 arma_inline
00414 const eOpCube<T1, eop_sqrt>
00415 sqrt(const BaseCube<typename T1::elem_type,T1>& A)
00416   {
00417   arma_extra_debug_sigprint();
00418   
00419   return eOpCube<T1, eop_sqrt>(A.get_ref());
00420   }
00421 
00422 
00423 
00424 //
00425 // conj
00426 
00427 template<typename T1>
00428 arma_inline
00429 const T1&
00430 conj(const Base<typename T1::pod_type,T1>& A)
00431   {
00432   arma_extra_debug_sigprint();
00433 
00434   return A.get_ref();
00435   }
00436 
00437 
00438 
00439 template<typename T1>
00440 arma_inline
00441 const T1&
00442 conj(const BaseCube<typename T1::pod_type,T1>& A)
00443   {
00444   arma_extra_debug_sigprint();
00445 
00446   return A.get_ref();
00447   }
00448 
00449 
00450 
00451 template<typename T1>
00452 arma_inline
00453 const eOp<T1, eop_conj>
00454 conj(const Base<std::complex<typename T1::pod_type>,T1>& A)
00455   {
00456   arma_extra_debug_sigprint();
00457 
00458   return eOp<T1, eop_conj>(A.get_ref());
00459   }
00460 
00461 
00462 
00463 template<typename T1>
00464 arma_inline
00465 const eOpCube<T1, eop_conj>
00466 conj(const BaseCube<std::complex<typename T1::pod_type>,T1>& A)
00467   {
00468   arma_extra_debug_sigprint();
00469 
00470   return eOpCube<T1, eop_conj>(A.get_ref());
00471   }
00472 
00473 
00474 
00475 template<typename T1>
00476 arma_inline
00477 const T1&
00478 conj(const eOp<T1, eop_conj>& A)
00479   {
00480   arma_extra_debug_sigprint();
00481   
00482   return A.m;
00483   }
00484 
00485 
00486 
00487 template<typename T1>
00488 arma_inline
00489 const T1&
00490 conj(const eOpCube<T1, eop_conj>& A)
00491   {
00492   arma_extra_debug_sigprint();
00493   
00494   return A.m;
00495   }
00496 
00497 
00498 
00499 // TODO: this needs a more elaborate template restriction mechanism to work properly,
00500 //       i.e. an overloaded version of thus function should do nothing if the input type is non-complex
00501 // 
00502 // //! the conjugate of the transpose of a complex matrix is the same as the hermitian transpose
00503 // template<typename T1>
00504 // arma_inline
00505 // const Op<T1, op_htrans>
00506 // conj(const Op<T1, op_strans>& A)
00507 //   {
00508 //   arma_extra_debug_sigprint();
00509 //   
00510 //   return Op<T1, op_htrans>(A.m);
00511 //   }
00512 
00513 
00514 
00515 // pow
00516 
00517 template<typename T1>
00518 arma_inline
00519 const eOp<T1, eop_pow>
00520 pow(const Base<typename T1::elem_type,T1>& A, const typename T1::elem_type exponent)
00521   {
00522   arma_extra_debug_sigprint();
00523   
00524   return eOp<T1, eop_pow>(A.get_ref(), exponent);
00525   }
00526 
00527 
00528 
00529 template<typename T1>
00530 arma_inline
00531 const eOpCube<T1, eop_pow>
00532 pow(const BaseCube<typename T1::elem_type,T1>& A, const typename T1::elem_type exponent)
00533   {
00534   arma_extra_debug_sigprint();
00535   
00536   return eOpCube<T1, eop_pow>(A.get_ref(), exponent);
00537   }
00538 
00539 
00540 
00541 // pow, specialised handling (non-complex exponent for complex matrices)
00542 
00543 template<typename T1>
00544 arma_inline
00545 const eOp<T1, eop_pow>
00546 pow(const Base<typename T1::elem_type,T1>& A, const typename T1::elem_type::value_type exponent)
00547   {
00548   arma_extra_debug_sigprint();
00549   
00550   typedef typename T1::elem_type eT;
00551   
00552   return eOp<T1, eop_pow>(A.get_ref(), eT(exponent));
00553   }
00554 
00555 
00556 
00557 template<typename T1>
00558 arma_inline
00559 const eOpCube<T1, eop_pow>
00560 pow(const BaseCube<typename T1::elem_type,T1>& A, const typename T1::elem_type::value_type exponent)
00561   {
00562   arma_extra_debug_sigprint();
00563   
00564   typedef typename T1::elem_type eT;
00565   
00566   return eOpCube<T1, eop_pow>(A.get_ref(), eT(exponent));
00567   }
00568 
00569 
00570 
00571 //
00572 // floor
00573 
00574 template<typename T1>
00575 arma_inline
00576 const eOp<T1, eop_floor>
00577 floor(const Base<typename T1::elem_type,T1>& A)
00578   {
00579   arma_extra_debug_sigprint();
00580   
00581   return eOp<T1, eop_floor>(A.get_ref());
00582   }
00583 
00584 
00585 
00586 template<typename T1>
00587 arma_inline
00588 const eOpCube<T1, eop_floor>
00589 floor(const BaseCube<typename T1::elem_type,T1>& A)
00590   {
00591   arma_extra_debug_sigprint();
00592   
00593   return eOpCube<T1, eop_floor>(A.get_ref());
00594   }
00595 
00596 
00597 
00598 //
00599 // ceil
00600 
00601 template<typename T1>
00602 arma_inline
00603 const eOp<T1, eop_ceil>
00604 ceil(const Base<typename T1::elem_type,T1>& A)
00605   {
00606   arma_extra_debug_sigprint();
00607   
00608   return eOp<T1, eop_ceil>(A.get_ref());
00609   }
00610 
00611 
00612 
00613 template<typename T1>
00614 arma_inline
00615 const eOpCube<T1, eop_ceil>
00616 ceil(const BaseCube<typename T1::elem_type,T1>& A)
00617   {
00618   arma_extra_debug_sigprint();
00619   
00620   return eOpCube<T1, eop_ceil>(A.get_ref());
00621   }
00622 
00623 
00624 


armadillo_matrix
Author(s): Conrad Sanderson - NICTA (www.nicta.com.au), (Wrapper by Sjoerd van den Dries)
autogenerated on Tue Jan 7 2014 11:42:03