fn_elem.hpp
Go to the documentation of this file.
1 // Copyright (C) 2008-2011 NICTA (www.nicta.com.au)
2 // Copyright (C) 2008-2011 Conrad Sanderson
3 //
4 // This file is part of the Armadillo C++ library.
5 // It is provided without any warranty of fitness
6 // for any purpose. You can redistribute this file
7 // and/or modify it under the terms of the GNU
8 // Lesser General Public License (LGPL) as published
9 // by the Free Software Foundation, either version 3
10 // of the License or (at your option) any later version.
11 // (see http://www.opensource.org/licenses for more info)
12 
13 
16 
17 
18 
19 //
20 // find
21 
22 template<typename eT, typename T1>
23 inline
25 find(const Base<eT,T1>& X, const uword k = 0, const char* direction = "first")
26  {
28 
29  const char sig = direction[0];
30 
32  (
33  (sig != 'f' && sig != 'F' && sig != 'l' && sig != 'L'),
34  "find(): 3rd input argument must be \"first\" or \"last\""
35  );
36 
37  const uword type = (sig == 'f' || sig == 'F') ? 0 : 1;
38 
39  return mtOp<uword, T1, op_find>(X.get_ref(), k, type);
40  }
41 
42 
43 
44 //
45 // real
46 
47 template<typename T1>
49 const T1&
51  {
53 
54  return X.get_ref();
55  }
56 
57 
58 
59 template<typename T1>
61 const T1&
63  {
65 
66  return X.get_ref();
67  }
68 
69 
70 
71 template<typename T1>
72 inline
74 real(const Base<std::complex<typename T1::pod_type>, T1>& X)
75  {
77 
78  return mtOp<typename T1::pod_type, T1, op_real>( X.get_ref() );
79  }
80 
81 
82 
83 template<typename T1>
84 inline
86 real(const BaseCube<std::complex<typename T1::pod_type>, T1>& X)
87  {
89 
91  }
92 
93 
94 
95 //
96 // imag
97 
98 template<typename T1>
99 inline
102  {
104 
105  const Proxy<T1> A(X.get_ref());
106 
107  return Gen<typename T1::pod_type, gen_zeros>(A.get_n_rows(), A.get_n_cols());
108  }
109 
110 
111 
112 template<typename T1>
113 inline
116  {
118 
119  const ProxyCube<T1> A(X.get_ref());
120 
121  return GenCube<typename T1::pod_type, gen_zeros>(A.get_n_rows(), A.get_n_cols(), A.get_n_slices());
122  }
123 
124 
125 
126 template<typename T1>
127 inline
129 imag(const Base<std::complex<typename T1::pod_type>, T1>& X)
130  {
132 
133  return mtOp<typename T1::pod_type, T1, op_imag>( X.get_ref() );
134  }
135 
136 
137 
138 template<typename T1>
139 inline
141 imag(const BaseCube<std::complex<typename T1::pod_type>,T1>& X)
142  {
144 
145  return mtOpCube<typename T1::pod_type, T1, op_imag>( X.get_ref() );
146  }
147 
148 
149 
150 //
151 // log
152 
153 template<typename T1>
155 const eOp<T1, eop_log>
157  {
159 
160  return eOp<T1, eop_log>(A.get_ref());
161  }
162 
163 
164 
165 template<typename T1>
169  {
171 
172  return eOpCube<T1, eop_log>(A.get_ref());
173  }
174 
175 
176 
177 //
178 // log2
179 
180 template<typename T1>
182 const eOp<T1, eop_log2>
184  {
186 
187  return eOp<T1, eop_log2>(A.get_ref());
188  }
189 
190 
191 
192 template<typename T1>
196  {
198 
199  return eOpCube<T1, eop_log2>(A.get_ref());
200  }
201 
202 
203 
204 //
205 // log10
206 
207 template<typename T1>
209 const eOp<T1, eop_log10>
211  {
213 
214  return eOp<T1, eop_log10>(A.get_ref());
215  }
216 
217 
218 
219 template<typename T1>
223  {
225 
226  return eOpCube<T1, eop_log10>(A.get_ref());
227  }
228 
229 
230 
231 //
232 // exp
233 
234 template<typename T1>
236 const eOp<T1, eop_exp>
238  {
240 
241  return eOp<T1, eop_exp>(A.get_ref());
242  }
243 
244 
245 
246 template<typename T1>
250  {
252 
253  return eOpCube<T1, eop_exp>(A.get_ref());
254  }
255 
256 
257 
258 // exp2
259 
260 template<typename T1>
262 const eOp<T1, eop_exp2>
264  {
266 
267  return eOp<T1, eop_exp2>(A.get_ref());
268  }
269 
270 
271 
272 template<typename T1>
276  {
278 
279  return eOpCube<T1, eop_exp2>(A.get_ref());
280  }
281 
282 
283 
284 // exp10
285 
286 template<typename T1>
288 const eOp<T1, eop_exp10>
290  {
292 
293  return eOp<T1, eop_exp10>(A.get_ref());
294  }
295 
296 
297 
298 template<typename T1>
302  {
304 
305  return eOpCube<T1, eop_exp10>(A.get_ref());
306  }
307 
308 
309 
310 //
311 // abs
312 
313 
314 template<typename T1>
316 const eOp<T1, eop_abs>
318  {
320 
321  arma_ignore(junk);
322 
323  return eOp<T1, eop_abs>(X.get_ref());
324  }
325 
326 
327 
328 template<typename T1>
332  {
334 
335  arma_ignore(junk);
336 
337  return eOpCube<T1, eop_abs>(X.get_ref());
338  }
339 
340 
341 
342 template<typename T1>
343 inline
345 abs(const Base<std::complex<typename T1::pod_type>, T1>& X, const typename arma_cx_only<typename T1::elem_type>::result* junk = 0)
346  {
348 
349  arma_ignore(junk);
350 
351  return mtOp<typename T1::pod_type, T1, op_abs>( X.get_ref() );
352  }
353 
354 
355 
356 template<typename T1>
357 inline
359 abs(const BaseCube< std::complex<typename T1::pod_type>,T1>& X, const typename arma_cx_only<typename T1::elem_type>::result* junk = 0)
360  {
362 
363  arma_ignore(junk);
364 
365  return mtOpCube<typename T1::pod_type, T1, op_abs>( X.get_ref() );
366  }
367 
368 
369 
370 //
371 // square
372 
373 template<typename T1>
377  {
379 
380  return eOp<T1, eop_square>(A.get_ref());
381  }
382 
383 
384 
385 template<typename T1>
389  {
391 
392  return eOpCube<T1, eop_square>(A.get_ref());
393  }
394 
395 
396 
397 //
398 // sqrt
399 
400 template<typename T1>
402 const eOp<T1, eop_sqrt>
404  {
406 
407  return eOp<T1, eop_sqrt>(A.get_ref());
408  }
409 
410 
411 
412 template<typename T1>
416  {
418 
419  return eOpCube<T1, eop_sqrt>(A.get_ref());
420  }
421 
422 
423 
424 //
425 // conj
426 
427 template<typename T1>
429 const T1&
431  {
433 
434  return A.get_ref();
435  }
436 
437 
438 
439 template<typename T1>
441 const T1&
443  {
445 
446  return A.get_ref();
447  }
448 
449 
450 
451 template<typename T1>
453 const eOp<T1, eop_conj>
454 conj(const Base<std::complex<typename T1::pod_type>,T1>& A)
455  {
457 
458  return eOp<T1, eop_conj>(A.get_ref());
459  }
460 
461 
462 
463 template<typename T1>
466 conj(const BaseCube<std::complex<typename T1::pod_type>,T1>& A)
467  {
469 
470  return eOpCube<T1, eop_conj>(A.get_ref());
471  }
472 
473 
474 
475 template<typename T1>
477 const T1&
479  {
481 
482  return A.m;
483  }
484 
485 
486 
487 template<typename T1>
489 const T1&
491  {
493 
494  return A.m;
495  }
496 
497 
498 
499 // TODO: this needs a more elaborate template restriction mechanism to work properly,
500 // i.e. an overloaded version of thus function should do nothing if the input type is non-complex
501 //
502 // //! the conjugate of the transpose of a complex matrix is the same as the hermitian transpose
503 // template<typename T1>
504 // arma_inline
505 // const Op<T1, op_htrans>
506 // conj(const Op<T1, op_strans>& A)
507 // {
508 // arma_extra_debug_sigprint();
509 //
510 // return Op<T1, op_htrans>(A.m);
511 // }
512 
513 
514 
515 // pow
516 
517 template<typename T1>
519 const eOp<T1, eop_pow>
520 pow(const Base<typename T1::elem_type,T1>& A, const typename T1::elem_type exponent)
521  {
523 
524  return eOp<T1, eop_pow>(A.get_ref(), exponent);
525  }
526 
527 
528 
529 template<typename T1>
532 pow(const BaseCube<typename T1::elem_type,T1>& A, const typename T1::elem_type exponent)
533  {
535 
536  return eOpCube<T1, eop_pow>(A.get_ref(), exponent);
537  }
538 
539 
540 
541 // pow, specialised handling (non-complex exponent for complex matrices)
542 
543 template<typename T1>
545 const eOp<T1, eop_pow>
546 pow(const Base<typename T1::elem_type,T1>& A, const typename T1::elem_type::value_type exponent)
547  {
549 
550  typedef typename T1::elem_type eT;
551 
552  return eOp<T1, eop_pow>(A.get_ref(), eT(exponent));
553  }
554 
555 
556 
557 template<typename T1>
560 pow(const BaseCube<typename T1::elem_type,T1>& A, const typename T1::elem_type::value_type exponent)
561  {
563 
564  typedef typename T1::elem_type eT;
565 
566  return eOpCube<T1, eop_pow>(A.get_ref(), eT(exponent));
567  }
568 
569 
570 
571 //
572 // floor
573 
574 template<typename T1>
576 const eOp<T1, eop_floor>
578  {
580 
581  return eOp<T1, eop_floor>(A.get_ref());
582  }
583 
584 
585 
586 template<typename T1>
590  {
592 
593  return eOpCube<T1, eop_floor>(A.get_ref());
594  }
595 
596 
597 
598 //
599 // ceil
600 
601 template<typename T1>
603 const eOp<T1, eop_ceil>
605  {
607 
608  return eOp<T1, eop_ceil>(A.get_ref());
609  }
610 
611 
612 
613 template<typename T1>
617  {
619 
620  return eOpCube<T1, eop_ceil>(A.get_ref());
621  }
622 
623 
624 
support class for generator functions (eg. zeros, randu, randn, ...)
arma_inline const eOp< T1, eop_ceil > ceil(const Base< typename T1::elem_type, T1 > &A)
Definition: fn_elem.hpp:604
arma_inline const eOp< T1, eop_exp > exp(const Base< typename T1::elem_type, T1 > &A)
Definition: fn_elem.hpp:237
arma_inline const eOp< T1, eop_log10 > log10(const Base< typename T1::elem_type, T1 > &A)
Definition: fn_elem.hpp:210
arma_inline const derived & get_ref() const
Definition: Base_meat.hpp:22
arma_inline const eOp< T1, eop_sqrt > sqrt(const Base< typename T1::elem_type, T1 > &A)
Definition: fn_elem.hpp:403
arma_inline const eOp< T1, eop_log2 > log2(const Base< typename T1::elem_type, T1 > &A)
Definition: fn_elem.hpp:183
support class for generator functions (eg. zeros, randu, randn, ...)
arma_inline const eOp< T1, eop_exp2 > exp2(const Base< typename T1::elem_type, T1 > &A)
Definition: fn_elem.hpp:263
arma_inline const T1 & conj(const Base< typename T1::pod_type, T1 > &A)
Definition: fn_elem.hpp:430
u32 uword
Definition: typedef.hpp:85
#define arma_debug_check
Definition: debug.hpp:1084
#define arma_ignore(variable)
arma_inline const T1 & real(const Base< typename T1::pod_type, T1 > &X)
Definition: fn_elem.hpp:50
arma_inline const eOp< T1, eop_abs > abs(const Base< typename T1::elem_type, T1 > &X, const typename arma_not_cx< typename T1::elem_type >::result *junk=0)
Definition: fn_elem.hpp:317
#define arma_extra_debug_sigprint
Definition: debug.hpp:1116
arma_inline const eOp< T1, eop_pow > pow(const Base< typename T1::elem_type, T1 > &A, const typename T1::elem_type exponent)
Definition: fn_elem.hpp:520
const mtOp< uword, T1, op_find > find(const Base< eT, T1 > &X, const uword k=0, const char *direction="first")
Definition: fn_elem.hpp:25
Analog of the Base class, intended for cubes.
arma_inline const eOp< T1, eop_exp10 > exp10(const Base< typename T1::elem_type, T1 > &A)
Definition: fn_elem.hpp:289
#define arma_inline
arma_inline const derived & get_ref() const
arma_inline const eOp< T1, eop_log > log(const Base< typename T1::elem_type, T1 > &A)
Definition: fn_elem.hpp:156
const Gen< typename T1::pod_type, gen_zeros > imag(const Base< typename T1::pod_type, T1 > &X)
Definition: fn_elem.hpp:101
arma_inline const eOp< T1, eop_floor > floor(const Base< typename T1::elem_type, T1 > &A)
Definition: fn_elem.hpp:577
arma_inline const eOp< T1, eop_square > square(const Base< typename T1::elem_type, T1 > &A)
Definition: fn_elem.hpp:376


armadillo_matrix
Author(s):
autogenerated on Fri Apr 16 2021 02:31:57