libstdc++
valarray_before.h
Go to the documentation of this file.
1 // The template and inlines for the -*- C++ -*- internal _Meta class.
2 
3 // Copyright (C) 1997-2025 Free Software Foundation, Inc.
4 //
5 // This file is part of the GNU ISO C++ Library. This library is free
6 // software; you can redistribute it and/or modify it under the
7 // terms of the GNU General Public License as published by the
8 // Free Software Foundation; either version 3, or (at your option)
9 // any later version.
10 
11 // This library is distributed in the hope that it will be useful,
12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 // GNU General Public License for more details.
15 
16 // Under Section 7 of GPL version 3, you are granted additional
17 // permissions described in the GCC Runtime Library Exception, version
18 // 3.1, as published by the Free Software Foundation.
19 
20 // You should have received a copy of the GNU General Public License and
21 // a copy of the GCC Runtime Library Exception along with this program;
22 // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
23 // <http://www.gnu.org/licenses/>.
24 
25 /** @file bits/valarray_before.h
26  * This is an internal header file, included by other library headers.
27  * Do not attempt to use it directly. @headername{valarray}
28  */
29 
30 // Written by Gabriel Dos Reis <Gabriel.Dos-Reis@cmla.ens-cachan.fr>
31 
32 #ifndef _VALARRAY_BEFORE_H
33 #define _VALARRAY_BEFORE_H 1
34 
35 #ifdef _GLIBCXX_SYSHDR
36 #pragma GCC system_header
37 #endif
38 
39 #include <bits/slice_array.h>
40 
41 namespace std _GLIBCXX_VISIBILITY(default)
42 {
43 _GLIBCXX_BEGIN_NAMESPACE_VERSION
44 
45  //
46  // Implementing a loosened valarray return value is tricky.
47  // First we need to meet 26.3.1/3: we should not add more than
48  // two levels of template nesting. Therefore we resort to template
49  // template to "flatten" loosened return value types.
50  // At some point we use partial specialization to remove one level
51  // template nesting due to _Expr<>
52  //
53 
54  // This class is NOT defined. It doesn't need to.
55  template<typename _Tp1, typename _Tp2> class _Constant;
56 
57  // Implementations of unary functions applied to valarray<>s.
58  // I use hard-coded object functions here instead of a generic
59  // approach like pointers to function:
60  // 1) correctness: some functions take references, others values.
61  // we can't deduce the correct type afterwards.
62  // 2) efficiency -- object functions can be easily inlined
63  // 3) be Koenig-lookup-friendly
64 
65  struct _Abs
66  {
67  template<typename _Tp>
68  _Tp operator()(const _Tp& __t) const
69  { return abs(__t); }
70  };
71 
72  struct _Cos
73  {
74  template<typename _Tp>
75  _Tp operator()(const _Tp& __t) const
76  { return cos(__t); }
77  };
78 
79  struct _Acos
80  {
81  template<typename _Tp>
82  _Tp operator()(const _Tp& __t) const
83  { return acos(__t); }
84  };
85 
86  struct _Cosh
87  {
88  template<typename _Tp>
89  _Tp operator()(const _Tp& __t) const
90  { return cosh(__t); }
91  };
92 
93  struct _Sin
94  {
95  template<typename _Tp>
96  _Tp operator()(const _Tp& __t) const
97  { return sin(__t); }
98  };
99 
100  struct _Asin
101  {
102  template<typename _Tp>
103  _Tp operator()(const _Tp& __t) const
104  { return asin(__t); }
105  };
106 
107  struct _Sinh
108  {
109  template<typename _Tp>
110  _Tp operator()(const _Tp& __t) const
111  { return sinh(__t); }
112  };
113 
114  struct _Tan
115  {
116  template<typename _Tp>
117  _Tp operator()(const _Tp& __t) const
118  { return tan(__t); }
119  };
120 
121  struct _Atan
122  {
123  template<typename _Tp>
124  _Tp operator()(const _Tp& __t) const
125  { return atan(__t); }
126  };
127 
128  struct _Tanh
129  {
130  template<typename _Tp>
131  _Tp operator()(const _Tp& __t) const
132  { return tanh(__t); }
133  };
134 
135  struct _Exp
136  {
137  template<typename _Tp>
138  _Tp operator()(const _Tp& __t) const
139  { return exp(__t); }
140  };
141 
142  struct _Log
143  {
144  template<typename _Tp>
145  _Tp operator()(const _Tp& __t) const
146  { return log(__t); }
147  };
148 
149  struct _Log10
150  {
151  template<typename _Tp>
152  _Tp operator()(const _Tp& __t) const
153  { return log10(__t); }
154  };
155 
156  struct _Sqrt
157  {
158  template<typename _Tp>
159  _Tp operator()(const _Tp& __t) const
160  { return sqrt(__t); }
161  };
162 
163  // In the past, we used to tailor operator applications semantics
164  // to the specialization of standard function objects (i.e. plus<>, etc.)
165  // That is incorrect. Therefore we provide our own surrogates.
166 
167  struct __unary_plus
168  {
169  template<typename _Tp>
170  _Tp operator()(const _Tp& __t) const
171  { return +__t; }
172  };
173 
174  struct __negate
175  {
176  template<typename _Tp>
177  _Tp operator()(const _Tp& __t) const
178  { return -__t; }
179  };
180 
181  struct __bitwise_not
182  {
183  template<typename _Tp>
184  _Tp operator()(const _Tp& __t) const
185  { return ~__t; }
186  };
187 
188  struct __plus
189  {
190  template<typename _Tp>
191  _Tp operator()(const _Tp& __x, const _Tp& __y) const
192  { return __x + __y; }
193  };
194 
195  struct __minus
196  {
197  template<typename _Tp>
198  _Tp operator()(const _Tp& __x, const _Tp& __y) const
199  { return __x - __y; }
200  };
201 
202  struct __multiplies
203  {
204  template<typename _Tp>
205  _Tp operator()(const _Tp& __x, const _Tp& __y) const
206  { return __x * __y; }
207  };
208 
209  struct __divides
210  {
211  template<typename _Tp>
212  _Tp operator()(const _Tp& __x, const _Tp& __y) const
213  { return __x / __y; }
214  };
215 
216  struct __modulus
217  {
218  template<typename _Tp>
219  _Tp operator()(const _Tp& __x, const _Tp& __y) const
220  { return __x % __y; }
221  };
222 
223  struct __bitwise_xor
224  {
225  template<typename _Tp>
226  _Tp operator()(const _Tp& __x, const _Tp& __y) const
227  { return __x ^ __y; }
228  };
229 
230  struct __bitwise_and
231  {
232  template<typename _Tp>
233  _Tp operator()(const _Tp& __x, const _Tp& __y) const
234  { return __x & __y; }
235  };
236 
237  struct __bitwise_or
238  {
239  template<typename _Tp>
240  _Tp operator()(const _Tp& __x, const _Tp& __y) const
241  { return __x | __y; }
242  };
243 
244  struct __shift_left
245  {
246  template<typename _Tp>
247  _Tp operator()(const _Tp& __x, const _Tp& __y) const
248  { return __x << __y; }
249  };
250 
251  struct __shift_right
252  {
253  template<typename _Tp>
254  _Tp operator()(const _Tp& __x, const _Tp& __y) const
255  { return __x >> __y; }
256  };
257 
258  struct __logical_and
259  {
260  template<typename _Tp>
261  bool operator()(const _Tp& __x, const _Tp& __y) const
262  { return __x && __y; }
263  };
264 
265  struct __logical_or
266  {
267  template<typename _Tp>
268  bool operator()(const _Tp& __x, const _Tp& __y) const
269  { return __x || __y; }
270  };
271 
272  struct __logical_not
273  {
274  template<typename _Tp>
275  bool operator()(const _Tp& __x) const
276  { return !__x; }
277  };
278 
279  struct __equal_to
280  {
281  template<typename _Tp>
282  bool operator()(const _Tp& __x, const _Tp& __y) const
283  { return __x == __y; }
284  };
285 
286  struct __not_equal_to
287  {
288  template<typename _Tp>
289  bool operator()(const _Tp& __x, const _Tp& __y) const
290  { return __x != __y; }
291  };
292 
293  struct __less
294  {
295  template<typename _Tp>
296  bool operator()(const _Tp& __x, const _Tp& __y) const
297  { return __x < __y; }
298  };
299 
300  struct __greater
301  {
302  template<typename _Tp>
303  bool operator()(const _Tp& __x, const _Tp& __y) const
304  { return __x > __y; }
305  };
306 
307  struct __less_equal
308  {
309  template<typename _Tp>
310  bool operator()(const _Tp& __x, const _Tp& __y) const
311  { return __x <= __y; }
312  };
313 
314  struct __greater_equal
315  {
316  template<typename _Tp>
317  bool operator()(const _Tp& __x, const _Tp& __y) const
318  { return __x >= __y; }
319  };
320 
321  // The few binary functions we miss.
322  struct _Atan2
323  {
324  template<typename _Tp>
325  _Tp operator()(const _Tp& __x, const _Tp& __y) const
326  { return atan2(__x, __y); }
327  };
328 
329  struct _Pow
330  {
331  template<typename _Tp>
332  _Tp operator()(const _Tp& __x, const _Tp& __y) const
333  { return pow(__x, __y); }
334  };
335 
336  template<typename _Tp, bool _IsValidValarrayValue = !__is_abstract(_Tp)>
337  struct __fun_with_valarray
338  {
339  typedef _Tp result_type;
340  };
341 
342  template<typename _Tp>
343  struct __fun_with_valarray<_Tp, false>
344  {
345  // No result type defined for invalid value types.
346  };
347 
348  // We need these bits in order to recover the return type of
349  // some functions/operators now that we're no longer using
350  // function templates.
351  template<typename, typename _Tp>
352  struct __fun : __fun_with_valarray<_Tp>
353  {
354  };
355 
356  // several specializations for relational operators.
357  template<typename _Tp>
358  struct __fun<__logical_not, _Tp>
359  {
360  typedef bool result_type;
361  };
362 
363  template<typename _Tp>
364  struct __fun<__logical_and, _Tp>
365  {
366  typedef bool result_type;
367  };
368 
369  template<typename _Tp>
370  struct __fun<__logical_or, _Tp>
371  {
372  typedef bool result_type;
373  };
374 
375  template<typename _Tp>
376  struct __fun<__less, _Tp>
377  {
378  typedef bool result_type;
379  };
380 
381  template<typename _Tp>
382  struct __fun<__greater, _Tp>
383  {
384  typedef bool result_type;
385  };
386 
387  template<typename _Tp>
388  struct __fun<__less_equal, _Tp>
389  {
390  typedef bool result_type;
391  };
392 
393  template<typename _Tp>
394  struct __fun<__greater_equal, _Tp>
395  {
396  typedef bool result_type;
397  };
398 
399  template<typename _Tp>
400  struct __fun<__equal_to, _Tp>
401  {
402  typedef bool result_type;
403  };
404 
405  template<typename _Tp>
406  struct __fun<__not_equal_to, _Tp>
407  {
408  typedef bool result_type;
409  };
410 
411 namespace __detail
412 {
413  // Closure types already have reference semantics and are often short-lived,
414  // so store them by value to avoid (some cases of) dangling references to
415  // out-of-scope temporaries.
416  template<typename _Tp>
417  struct _ValArrayRef
418  { typedef const _Tp __type; };
419 
420  // Use real references for std::valarray objects.
421  template<typename _Tp>
422  struct _ValArrayRef< valarray<_Tp> >
423  { typedef const valarray<_Tp>& __type; };
424 
425  //
426  // Apply function taking a value/const reference closure
427  //
428 
429  template<typename _Dom, typename _Arg>
430  class _FunBase
431  {
432  public:
433  typedef typename _Dom::value_type value_type;
434 
435  _FunBase(const _Dom& __e, value_type __f(_Arg))
436  : _M_expr(__e), _M_func(__f) {}
437 
438  value_type operator[](size_t __i) const
439  { return _M_func (_M_expr[__i]); }
440 
441  size_t size() const { return _M_expr.size ();}
442 
443  private:
444  typename _ValArrayRef<_Dom>::__type _M_expr;
445  value_type (*_M_func)(_Arg);
446  };
447 
448  template<class _Dom>
449  struct _ValFunClos<_Expr,_Dom> : _FunBase<_Dom, typename _Dom::value_type>
450  {
451  typedef _FunBase<_Dom, typename _Dom::value_type> _Base;
452  typedef typename _Base::value_type value_type;
453  typedef value_type _Tp;
454 
455  _ValFunClos(const _Dom& __e, _Tp __f(_Tp)) : _Base(__e, __f) {}
456  };
457 
458  template<typename _Tp>
459  struct _ValFunClos<_ValArray,_Tp> : _FunBase<valarray<_Tp>, _Tp>
460  {
461  typedef _FunBase<valarray<_Tp>, _Tp> _Base;
462  typedef _Tp value_type;
463 
464  _ValFunClos(const valarray<_Tp>& __v, _Tp __f(_Tp)) : _Base(__v, __f) {}
465  };
466 
467  template<class _Dom>
468  struct _RefFunClos<_Expr, _Dom>
469  : _FunBase<_Dom, const typename _Dom::value_type&>
470  {
471  typedef _FunBase<_Dom, const typename _Dom::value_type&> _Base;
472  typedef typename _Base::value_type value_type;
473  typedef value_type _Tp;
474 
475  _RefFunClos(const _Dom& __e, _Tp __f(const _Tp&))
476  : _Base(__e, __f) {}
477  };
478 
479  template<typename _Tp>
480  struct _RefFunClos<_ValArray, _Tp>
481  : _FunBase<valarray<_Tp>, const _Tp&>
482  {
483  typedef _FunBase<valarray<_Tp>, const _Tp&> _Base;
484  typedef _Tp value_type;
485 
486  _RefFunClos(const valarray<_Tp>& __v, _Tp __f(const _Tp&))
487  : _Base(__v, __f) {}
488  };
489 
490  //
491  // Unary expression closure.
492  //
493 
494  template<class _Oper, class _Arg>
495  class _UnBase
496  {
497  public:
498  typedef typename _Arg::value_type _Vt;
499  typedef typename __fun<_Oper, _Vt>::result_type value_type;
500 
501  _UnBase(const _Arg& __e) : _M_expr(__e) {}
502 
503  value_type operator[](size_t __i) const
504  { return _Oper()(_M_expr[__i]); }
505 
506  size_t size() const { return _M_expr.size(); }
507 
508  private:
509  typename _ValArrayRef<_Arg>::__type _M_expr;
510  };
511 
512  template<class _Oper, class _Dom>
513  struct _UnClos<_Oper, _Expr, _Dom>
514  : _UnBase<_Oper, _Dom>
515  {
516  typedef _Dom _Arg;
517  typedef _UnBase<_Oper, _Dom> _Base;
518  typedef typename _Base::value_type value_type;
519 
520  _UnClos(const _Arg& __e) : _Base(__e) {}
521  };
522 
523  template<class _Oper, typename _Tp>
524  struct _UnClos<_Oper, _ValArray, _Tp>
525  : _UnBase<_Oper, valarray<_Tp> >
526  {
527  typedef valarray<_Tp> _Arg;
528  typedef _UnBase<_Oper, valarray<_Tp> > _Base;
529  typedef typename _Base::value_type value_type;
530 
531  _UnClos(const _Arg& __e) : _Base(__e) {}
532  };
533 
534 
535  //
536  // Binary expression closure.
537  //
538 
539  template<class _Oper, class _FirstArg, class _SecondArg>
540  class _BinBase
541  {
542  public:
543  typedef typename _FirstArg::value_type _Vt;
544  typedef typename __fun<_Oper, _Vt>::result_type value_type;
545 
546  _BinBase(const _FirstArg& __e1, const _SecondArg& __e2)
547  : _M_expr1(__e1), _M_expr2(__e2) {}
548 
549  value_type operator[](size_t __i) const
550  { return _Oper()(_M_expr1[__i], _M_expr2[__i]); }
551 
552  size_t size() const { return _M_expr1.size(); }
553 
554  private:
555  typename _ValArrayRef<_FirstArg>::__type _M_expr1;
556  typename _ValArrayRef<_SecondArg>::__type _M_expr2;
557  };
558 
559 
560  template<class _Oper, class _Clos>
561  class _BinBase2
562  {
563  public:
564  typedef typename _Clos::value_type _Vt;
565  typedef typename __fun<_Oper, _Vt>::result_type value_type;
566 
567  _BinBase2(const _Clos& __e, const _Vt& __t)
568  : _M_expr1(__e), _M_expr2(__t) {}
569 
570  value_type operator[](size_t __i) const
571  { return _Oper()(_M_expr1[__i], _M_expr2); }
572 
573  size_t size() const { return _M_expr1.size(); }
574 
575  private:
576  typename _ValArrayRef<_Clos>::__type _M_expr1;
577  _Vt _M_expr2;
578  };
579 
580  template<class _Oper, class _Clos>
581  class _BinBase1
582  {
583  public:
584  typedef typename _Clos::value_type _Vt;
585  typedef typename __fun<_Oper, _Vt>::result_type value_type;
586 
587  _BinBase1(const _Vt& __t, const _Clos& __e)
588  : _M_expr1(__t), _M_expr2(__e) {}
589 
590  value_type operator[](size_t __i) const
591  { return _Oper()(_M_expr1, _M_expr2[__i]); }
592 
593  size_t size() const { return _M_expr2.size(); }
594 
595  private:
596  _Vt _M_expr1;
597  typename _ValArrayRef<_Clos>::__type _M_expr2;
598  };
599 
600  template<class _Oper, class _Dom1, class _Dom2>
601  struct _BinClos<_Oper, _Expr, _Expr, _Dom1, _Dom2>
602  : _BinBase<_Oper, _Dom1, _Dom2>
603  {
604  typedef _BinBase<_Oper, _Dom1, _Dom2> _Base;
605  typedef typename _Base::value_type value_type;
606 
607  _BinClos(const _Dom1& __e1, const _Dom2& __e2) : _Base(__e1, __e2) {}
608  };
609 
610  template<class _Oper, typename _Tp>
611  struct _BinClos<_Oper, _ValArray, _ValArray, _Tp, _Tp>
612  : _BinBase<_Oper, valarray<_Tp>, valarray<_Tp> >
613  {
614  typedef _BinBase<_Oper, valarray<_Tp>, valarray<_Tp> > _Base;
615  typedef typename _Base::value_type value_type;
616 
617  _BinClos(const valarray<_Tp>& __v, const valarray<_Tp>& __w)
618  : _Base(__v, __w) {}
619  };
620 
621  template<class _Oper, class _Dom>
622  struct _BinClos<_Oper, _Expr, _ValArray, _Dom, typename _Dom::value_type>
623  : _BinBase<_Oper, _Dom, valarray<typename _Dom::value_type> >
624  {
625  typedef typename _Dom::value_type _Tp;
626  typedef _BinBase<_Oper,_Dom,valarray<_Tp> > _Base;
627  typedef typename _Base::value_type value_type;
628 
629  _BinClos(const _Dom& __e1, const valarray<_Tp>& __e2)
630  : _Base(__e1, __e2) {}
631  };
632 
633  template<class _Oper, class _Dom>
634  struct _BinClos<_Oper, _ValArray, _Expr, typename _Dom::value_type, _Dom>
635  : _BinBase<_Oper, valarray<typename _Dom::value_type>,_Dom>
636  {
637  typedef typename _Dom::value_type _Tp;
638  typedef _BinBase<_Oper, valarray<_Tp>, _Dom> _Base;
639  typedef typename _Base::value_type value_type;
640 
641  _BinClos(const valarray<_Tp>& __e1, const _Dom& __e2)
642  : _Base(__e1, __e2) {}
643  };
644 
645  template<class _Oper, class _Dom>
646  struct _BinClos<_Oper, _Expr, _Constant, _Dom, typename _Dom::value_type>
647  : _BinBase2<_Oper, _Dom>
648  {
649  typedef typename _Dom::value_type _Tp;
650  typedef _BinBase2<_Oper,_Dom> _Base;
651  typedef typename _Base::value_type value_type;
652 
653  _BinClos(const _Dom& __e1, const _Tp& __e2) : _Base(__e1, __e2) {}
654  };
655 
656  template<class _Oper, class _Dom>
657  struct _BinClos<_Oper, _Constant, _Expr, typename _Dom::value_type, _Dom>
658  : _BinBase1<_Oper, _Dom>
659  {
660  typedef typename _Dom::value_type _Tp;
661  typedef _BinBase1<_Oper, _Dom> _Base;
662  typedef typename _Base::value_type value_type;
663 
664  _BinClos(const _Tp& __e1, const _Dom& __e2) : _Base(__e1, __e2) {}
665  };
666 
667  template<class _Oper, typename _Tp>
668  struct _BinClos<_Oper, _ValArray, _Constant, _Tp, _Tp>
669  : _BinBase2<_Oper, valarray<_Tp> >
670  {
671  typedef _BinBase2<_Oper,valarray<_Tp> > _Base;
672  typedef typename _Base::value_type value_type;
673 
674  _BinClos(const valarray<_Tp>& __v, const _Tp& __t) : _Base(__v, __t) {}
675  };
676 
677  template<class _Oper, typename _Tp>
678  struct _BinClos<_Oper, _Constant, _ValArray, _Tp, _Tp>
679  : _BinBase1<_Oper, valarray<_Tp> >
680  {
681  typedef _BinBase1<_Oper, valarray<_Tp> > _Base;
682  typedef typename _Base::value_type value_type;
683 
684  _BinClos(const _Tp& __t, const valarray<_Tp>& __v) : _Base(__t, __v) {}
685  };
686 
687  //
688  // slice_array closure.
689  //
690  template<typename _Dom>
691  class _SBase
692  {
693  public:
694  typedef typename _Dom::value_type value_type;
695 
696  _SBase (const _Dom& __e, const slice& __s)
697  : _M_expr (__e), _M_slice (__s) {}
698 
699  value_type
700  operator[] (size_t __i) const
701  { return _M_expr[_M_slice.start () + __i * _M_slice.stride ()]; }
702 
703  size_t
704  size() const
705  { return _M_slice.size (); }
706 
707  private:
708  typename _ValArrayRef<_Dom>::__type _M_expr;
709  const slice& _M_slice;
710  };
711 
712  template<typename _Tp>
713  class _SBase<_Array<_Tp> >
714  {
715  public:
716  typedef _Tp value_type;
717 
718  _SBase (_Array<_Tp> __a, const slice& __s)
719  : _M_array (__a._M_data+__s.start()), _M_size (__s.size()),
720  _M_stride (__s.stride()) {}
721 
722  value_type
723  operator[] (size_t __i) const
724  { return _M_array._M_data[__i * _M_stride]; }
725 
726  size_t
727  size() const
728  { return _M_size; }
729 
730  private:
731  const _Array<_Tp> _M_array;
732  const size_t _M_size;
733  const size_t _M_stride;
734  };
735 
736  template<class _Dom>
737  struct _SClos<_Expr, _Dom>
738  : _SBase<_Dom>
739  {
740  typedef _SBase<_Dom> _Base;
741  typedef typename _Base::value_type value_type;
742 
743  _SClos (const _Dom& __e, const slice& __s) : _Base (__e, __s) {}
744  };
745 
746  template<typename _Tp>
747  struct _SClos<_ValArray, _Tp>
748  : _SBase<_Array<_Tp> >
749  {
750  typedef _SBase<_Array<_Tp> > _Base;
751  typedef _Tp value_type;
752 
753  _SClos (_Array<_Tp> __a, const slice& __s) : _Base (__a, __s) {}
754  };
755 } // namespace __detail
756 
757 _GLIBCXX_END_NAMESPACE_VERSION
758 } // namespace
759 
760 #endif /* _CPP_VALARRAY_BEFORE_H */
complex< _Tp > log10(const complex< _Tp > &)
Return complex base 10 logarithm of z.
Definition: complex:1167
complex< _Tp > sin(const complex< _Tp > &)
Return complex sine of z.
Definition: complex:1197
complex< _Tp > log(const complex< _Tp > &)
Return complex natural logarithm of z.
Definition: complex:1162
complex< _Tp > tan(const complex< _Tp > &)
Return complex tangent of z.
Definition: complex:1298
_Tp abs(const complex< _Tp > &)
Return magnitude of z.
Definition: complex:968
complex< _Tp > exp(const complex< _Tp > &)
Return complex base e exponential of z.
Definition: complex:1135
complex< _Tp > cosh(const complex< _Tp > &)
Return complex hyperbolic cosine of z.
Definition: complex:1109
complex< _Tp > tanh(const complex< _Tp > &)
Return complex hyperbolic tangent of z.
Definition: complex:1326
complex< _Tp > pow(const complex< _Tp > &, int)
Return x to the y'th power.
Definition: complex:1357
complex< _Tp > sinh(const complex< _Tp > &)
Return complex hyperbolic sine of z.
Definition: complex:1227
complex< _Tp > cos(const complex< _Tp > &)
Return complex cosine of z.
Definition: complex:1079
complex< _Tp > sqrt(const complex< _Tp > &)
Return complex square root of z.
Definition: complex:1271
ISO C++ entities toplevel namespace is std.
constexpr auto size(const _Container &__cont) noexcept(noexcept(__cont.size())) -> decltype(__cont.size())
Return the size of a container.
Definition: range_access.h:274