libstdc++
valarray_after.h
Go to the documentation of this file.
1 // The template and inlines for the -*- C++ -*- internal _Meta class.
2 
3 // Copyright (C) 1997-2019 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_after.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 <[email protected]>
31 
32 #ifndef _VALARRAY_AFTER_H
33 #define _VALARRAY_AFTER_H 1
34 
35 #pragma GCC system_header
36 
37 namespace std _GLIBCXX_VISIBILITY(default)
38 {
39 _GLIBCXX_BEGIN_NAMESPACE_VERSION
40 
41 namespace __detail
42 {
43  //
44  // gslice_array closure.
45  //
46  template<class _Dom>
47  class _GBase
48  {
49  public:
50  typedef typename _Dom::value_type value_type;
51 
52  _GBase (const _Dom& __e, const valarray<size_t>& __i)
53  : _M_expr (__e), _M_index(__i) {}
54 
55  value_type
56  operator[] (size_t __i) const
57  { return _M_expr[_M_index[__i]]; }
58 
59  size_t
60  size () const
61  { return _M_index.size(); }
62 
63  private:
64  typename _ValArrayRef<_Dom>::__type _M_expr;
65  const valarray<size_t>& _M_index;
66  };
67 
68  template<typename _Tp>
69  class _GBase<_Array<_Tp> >
70  {
71  public:
72  typedef _Tp value_type;
73 
74  _GBase (_Array<_Tp> __a, const valarray<size_t>& __i)
75  : _M_array (__a), _M_index(__i) {}
76 
77  value_type
78  operator[] (size_t __i) const
79  { return _M_array._M_data[_M_index[__i]]; }
80 
81  size_t
82  size () const
83  { return _M_index.size(); }
84 
85  private:
86  const _Array<_Tp> _M_array;
87  const valarray<size_t>& _M_index;
88  };
89 
90  template<class _Dom>
91  struct _GClos<_Expr, _Dom>
92  : _GBase<_Dom>
93  {
94  typedef _GBase<_Dom> _Base;
95  typedef typename _Base::value_type value_type;
96 
97  _GClos (const _Dom& __e, const valarray<size_t>& __i)
98  : _Base (__e, __i) {}
99  };
100 
101  template<typename _Tp>
102  struct _GClos<_ValArray, _Tp>
103  : _GBase<_Array<_Tp> >
104  {
105  typedef _GBase<_Array<_Tp> > _Base;
106  typedef typename _Base::value_type value_type;
107 
108  _GClos (_Array<_Tp> __a, const valarray<size_t>& __i)
109  : _Base (__a, __i) {}
110  };
111 
112  //
113  // indirect_array closure
114  //
115  template<class _Dom>
116  class _IBase
117  {
118  public:
119  typedef typename _Dom::value_type value_type;
120 
121  _IBase (const _Dom& __e, const valarray<size_t>& __i)
122  : _M_expr (__e), _M_index (__i) {}
123 
124  value_type
125  operator[] (size_t __i) const
126  { return _M_expr[_M_index[__i]]; }
127 
128  size_t
129  size() const
130  { return _M_index.size(); }
131 
132  private:
133  typename _ValArrayRef<_Dom>::__type _M_expr;
134  const valarray<size_t>& _M_index;
135  };
136 
137  template<class _Dom>
138  struct _IClos<_Expr, _Dom>
139  : _IBase<_Dom>
140  {
141  typedef _IBase<_Dom> _Base;
142  typedef typename _Base::value_type value_type;
143 
144  _IClos (const _Dom& __e, const valarray<size_t>& __i)
145  : _Base (__e, __i) {}
146  };
147 
148  template<typename _Tp>
149  struct _IClos<_ValArray, _Tp>
150  : _IBase<valarray<_Tp> >
151  {
152  typedef _IBase<valarray<_Tp> > _Base;
153  typedef _Tp value_type;
154 
155  _IClos (const valarray<_Tp>& __a, const valarray<size_t>& __i)
156  : _Base (__a, __i) {}
157  };
158 } // namespace __detail
159 
160  //
161  // class _Expr
162  //
163  template<class _Clos, typename _Tp>
164  class _Expr
165  {
166  public:
167  typedef _Tp value_type;
168 
169  _Expr(const _Clos&);
170 
171  const _Clos& operator()() const;
172 
173  value_type operator[](size_t) const;
174  valarray<value_type> operator[](slice) const;
175  valarray<value_type> operator[](const gslice&) const;
176  valarray<value_type> operator[](const valarray<bool>&) const;
177  valarray<value_type> operator[](const valarray<size_t>&) const;
178 
179  _Expr<_UnClos<__unary_plus, std::_Expr, _Clos>, value_type>
180  operator+() const;
181 
182  _Expr<_UnClos<__negate, std::_Expr, _Clos>, value_type>
183  operator-() const;
184 
185  _Expr<_UnClos<__bitwise_not, std::_Expr, _Clos>, value_type>
186  operator~() const;
187 
188  _Expr<_UnClos<__logical_not, std::_Expr, _Clos>, bool>
189  operator!() const;
190 
191  size_t size() const;
192  value_type sum() const;
193 
194  valarray<value_type> shift(int) const;
195  valarray<value_type> cshift(int) const;
196 
197  value_type min() const;
198  value_type max() const;
199 
200  valarray<value_type> apply(value_type (*)(const value_type&)) const;
201  valarray<value_type> apply(value_type (*)(value_type)) const;
202 
203  private:
204  const _Clos _M_closure;
205  };
206 
207  template<class _Clos, typename _Tp>
208  inline
209  _Expr<_Clos, _Tp>::_Expr(const _Clos& __c) : _M_closure(__c) {}
210 
211  template<class _Clos, typename _Tp>
212  inline const _Clos&
213  _Expr<_Clos, _Tp>::operator()() const
214  { return _M_closure; }
215 
216  template<class _Clos, typename _Tp>
217  inline _Tp
218  _Expr<_Clos, _Tp>::operator[](size_t __i) const
219  { return _M_closure[__i]; }
220 
221  template<class _Clos, typename _Tp>
222  inline valarray<_Tp>
223  _Expr<_Clos, _Tp>::operator[](slice __s) const
224  {
225  valarray<_Tp> __v = valarray<_Tp>(*this)[__s];
226  return __v;
227  }
228 
229  template<class _Clos, typename _Tp>
230  inline valarray<_Tp>
231  _Expr<_Clos, _Tp>::operator[](const gslice& __gs) const
232  {
233  valarray<_Tp> __v = valarray<_Tp>(*this)[__gs];
234  return __v;
235  }
236 
237  template<class _Clos, typename _Tp>
238  inline valarray<_Tp>
239  _Expr<_Clos, _Tp>::operator[](const valarray<bool>& __m) const
240  {
241  valarray<_Tp> __v = valarray<_Tp>(*this)[__m];
242  return __v;
243  }
244 
245  template<class _Clos, typename _Tp>
246  inline valarray<_Tp>
247  _Expr<_Clos, _Tp>::operator[](const valarray<size_t>& __i) const
248  {
249  valarray<_Tp> __v = valarray<_Tp>(*this)[__i];
250  return __v;
251  }
252 
253  template<class _Clos, typename _Tp>
254  inline size_t
255  _Expr<_Clos, _Tp>::size() const
256  { return _M_closure.size(); }
257 
258  template<class _Clos, typename _Tp>
259  inline valarray<_Tp>
260  _Expr<_Clos, _Tp>::shift(int __n) const
261  {
262  valarray<_Tp> __v = valarray<_Tp>(*this).shift(__n);
263  return __v;
264  }
265 
266  template<class _Clos, typename _Tp>
267  inline valarray<_Tp>
268  _Expr<_Clos, _Tp>::cshift(int __n) const
269  {
270  valarray<_Tp> __v = valarray<_Tp>(*this).cshift(__n);
271  return __v;
272  }
273 
274  template<class _Clos, typename _Tp>
275  inline valarray<_Tp>
276  _Expr<_Clos, _Tp>::apply(_Tp __f(const _Tp&)) const
277  {
278  valarray<_Tp> __v = valarray<_Tp>(*this).apply(__f);
279  return __v;
280  }
281 
282  template<class _Clos, typename _Tp>
283  inline valarray<_Tp>
284  _Expr<_Clos, _Tp>::apply(_Tp __f(_Tp)) const
285  {
286  valarray<_Tp> __v = valarray<_Tp>(*this).apply(__f);
287  return __v;
288  }
289 
290  // XXX: replace this with a more robust summation algorithm.
291  template<class _Clos, typename _Tp>
292  inline _Tp
293  _Expr<_Clos, _Tp>::sum() const
294  {
295  size_t __n = _M_closure.size();
296  if (__n == 0)
297  return _Tp();
298  else
299  {
300  _Tp __s = _M_closure[--__n];
301  while (__n != 0)
302  __s += _M_closure[--__n];
303  return __s;
304  }
305  }
306 
307  template<class _Clos, typename _Tp>
308  inline _Tp
309  _Expr<_Clos, _Tp>::min() const
310  { return __valarray_min(_M_closure); }
311 
312  template<class _Clos, typename _Tp>
313  inline _Tp
314  _Expr<_Clos, _Tp>::max() const
315  { return __valarray_max(_M_closure); }
316 
317  template<class _Dom, typename _Tp>
318  inline _Expr<_UnClos<__logical_not, _Expr, _Dom>, bool>
319  _Expr<_Dom, _Tp>::operator!() const
320  {
321  typedef _UnClos<__logical_not, std::_Expr, _Dom> _Closure;
322  return _Expr<_Closure, bool>(_Closure(this->_M_closure));
323  }
324 
325 #define _DEFINE_EXPR_UNARY_OPERATOR(_Op, _Name) \
326  template<class _Dom, typename _Tp> \
327  inline _Expr<_UnClos<_Name, std::_Expr, _Dom>, _Tp> \
328  _Expr<_Dom, _Tp>::operator _Op() const \
329  { \
330  typedef _UnClos<_Name, std::_Expr, _Dom> _Closure; \
331  return _Expr<_Closure, _Tp>(_Closure(this->_M_closure)); \
332  }
333 
334  _DEFINE_EXPR_UNARY_OPERATOR(+, __unary_plus)
335  _DEFINE_EXPR_UNARY_OPERATOR(-, __negate)
336  _DEFINE_EXPR_UNARY_OPERATOR(~, __bitwise_not)
337 
338 #undef _DEFINE_EXPR_UNARY_OPERATOR
339 
340 #define _DEFINE_EXPR_BINARY_OPERATOR(_Op, _Name) \
341  template<class _Dom1, class _Dom2> \
342  inline _Expr<_BinClos<_Name, _Expr, _Expr, _Dom1, _Dom2>, \
343  typename __fun<_Name, typename _Dom1::value_type>::result_type> \
344  operator _Op(const _Expr<_Dom1, typename _Dom1::value_type>& __v, \
345  const _Expr<_Dom2, typename _Dom2::value_type>& __w) \
346  { \
347  typedef typename _Dom1::value_type _Arg; \
348  typedef typename __fun<_Name, _Arg>::result_type _Value; \
349  typedef _BinClos<_Name, _Expr, _Expr, _Dom1, _Dom2> _Closure; \
350  return _Expr<_Closure, _Value>(_Closure(__v(), __w())); \
351  } \
352  \
353  template<class _Dom> \
354  inline _Expr<_BinClos<_Name, _Expr, _Constant, _Dom, \
355  typename _Dom::value_type>, \
356  typename __fun<_Name, typename _Dom::value_type>::result_type> \
357  operator _Op(const _Expr<_Dom, typename _Dom::value_type>& __v, \
358  const typename _Dom::value_type& __t) \
359  { \
360  typedef typename _Dom::value_type _Arg; \
361  typedef typename __fun<_Name, _Arg>::result_type _Value; \
362  typedef _BinClos<_Name, _Expr, _Constant, _Dom, _Arg> _Closure; \
363  return _Expr<_Closure, _Value>(_Closure(__v(), __t)); \
364  } \
365  \
366  template<class _Dom> \
367  inline _Expr<_BinClos<_Name, _Constant, _Expr, \
368  typename _Dom::value_type, _Dom>, \
369  typename __fun<_Name, typename _Dom::value_type>::result_type> \
370  operator _Op(const typename _Dom::value_type& __t, \
371  const _Expr<_Dom, typename _Dom::value_type>& __v) \
372  { \
373  typedef typename _Dom::value_type _Arg; \
374  typedef typename __fun<_Name, _Arg>::result_type _Value; \
375  typedef _BinClos<_Name, _Constant, _Expr, _Arg, _Dom> _Closure; \
376  return _Expr<_Closure, _Value>(_Closure(__t, __v())); \
377  } \
378  \
379  template<class _Dom> \
380  inline _Expr<_BinClos<_Name, _Expr, _ValArray, \
381  _Dom, typename _Dom::value_type>, \
382  typename __fun<_Name, typename _Dom::value_type>::result_type> \
383  operator _Op(const _Expr<_Dom,typename _Dom::value_type>& __e, \
384  const valarray<typename _Dom::value_type>& __v) \
385  { \
386  typedef typename _Dom::value_type _Arg; \
387  typedef typename __fun<_Name, _Arg>::result_type _Value; \
388  typedef _BinClos<_Name, _Expr, _ValArray, _Dom, _Arg> _Closure; \
389  return _Expr<_Closure, _Value>(_Closure(__e(), __v)); \
390  } \
391  \
392  template<class _Dom> \
393  inline _Expr<_BinClos<_Name, _ValArray, _Expr, \
394  typename _Dom::value_type, _Dom>, \
395  typename __fun<_Name, typename _Dom::value_type>::result_type> \
396  operator _Op(const valarray<typename _Dom::value_type>& __v, \
397  const _Expr<_Dom, typename _Dom::value_type>& __e) \
398  { \
399  typedef typename _Dom::value_type _Tp; \
400  typedef typename __fun<_Name, _Tp>::result_type _Value; \
401  typedef _BinClos<_Name, _ValArray, _Expr, _Tp, _Dom> _Closure; \
402  return _Expr<_Closure, _Value>(_Closure(__v, __e ())); \
403  }
404 
405  _DEFINE_EXPR_BINARY_OPERATOR(+, __plus)
406  _DEFINE_EXPR_BINARY_OPERATOR(-, __minus)
407  _DEFINE_EXPR_BINARY_OPERATOR(*, __multiplies)
408  _DEFINE_EXPR_BINARY_OPERATOR(/, __divides)
409  _DEFINE_EXPR_BINARY_OPERATOR(%, __modulus)
410  _DEFINE_EXPR_BINARY_OPERATOR(^, __bitwise_xor)
411  _DEFINE_EXPR_BINARY_OPERATOR(&, __bitwise_and)
412  _DEFINE_EXPR_BINARY_OPERATOR(|, __bitwise_or)
413  _DEFINE_EXPR_BINARY_OPERATOR(<<, __shift_left)
414  _DEFINE_EXPR_BINARY_OPERATOR(>>, __shift_right)
415  _DEFINE_EXPR_BINARY_OPERATOR(&&, __logical_and)
416  _DEFINE_EXPR_BINARY_OPERATOR(||, __logical_or)
417  _DEFINE_EXPR_BINARY_OPERATOR(==, __equal_to)
418  _DEFINE_EXPR_BINARY_OPERATOR(!=, __not_equal_to)
419  _DEFINE_EXPR_BINARY_OPERATOR(<, __less)
420  _DEFINE_EXPR_BINARY_OPERATOR(>, __greater)
421  _DEFINE_EXPR_BINARY_OPERATOR(<=, __less_equal)
422  _DEFINE_EXPR_BINARY_OPERATOR(>=, __greater_equal)
423 
424 #undef _DEFINE_EXPR_BINARY_OPERATOR
425 
426 #define _DEFINE_EXPR_UNARY_FUNCTION(_Name, _UName) \
427  template<class _Dom> \
428  inline _Expr<_UnClos<_UName, _Expr, _Dom>, \
429  typename _Dom::value_type> \
430  _Name(const _Expr<_Dom, typename _Dom::value_type>& __e) \
431  { \
432  typedef typename _Dom::value_type _Tp; \
433  typedef _UnClos<_UName, _Expr, _Dom> _Closure; \
434  return _Expr<_Closure, _Tp>(_Closure(__e())); \
435  } \
436  \
437  template<typename _Tp> \
438  inline _Expr<_UnClos<_UName, _ValArray, _Tp>, _Tp> \
439  _Name(const valarray<_Tp>& __v) \
440  { \
441  typedef _UnClos<_UName, _ValArray, _Tp> _Closure; \
442  return _Expr<_Closure, _Tp>(_Closure(__v)); \
443  }
444 
445  _DEFINE_EXPR_UNARY_FUNCTION(abs, _Abs)
446  _DEFINE_EXPR_UNARY_FUNCTION(cos, _Cos)
447  _DEFINE_EXPR_UNARY_FUNCTION(acos, _Acos)
448  _DEFINE_EXPR_UNARY_FUNCTION(cosh, _Cosh)
449  _DEFINE_EXPR_UNARY_FUNCTION(sin, _Sin)
450  _DEFINE_EXPR_UNARY_FUNCTION(asin, _Asin)
451  _DEFINE_EXPR_UNARY_FUNCTION(sinh, _Sinh)
452  _DEFINE_EXPR_UNARY_FUNCTION(tan, _Tan)
453  _DEFINE_EXPR_UNARY_FUNCTION(tanh, _Tanh)
454  _DEFINE_EXPR_UNARY_FUNCTION(atan, _Atan)
455  _DEFINE_EXPR_UNARY_FUNCTION(exp, _Exp)
456  _DEFINE_EXPR_UNARY_FUNCTION(log, _Log)
457  _DEFINE_EXPR_UNARY_FUNCTION(log10, _Log10)
458  _DEFINE_EXPR_UNARY_FUNCTION(sqrt, _Sqrt)
459 
460 #undef _DEFINE_EXPR_UNARY_FUNCTION
461 
462 #define _DEFINE_EXPR_BINARY_FUNCTION(_Fun, _UFun) \
463  template<class _Dom1, class _Dom2> \
464  inline _Expr<_BinClos<_UFun, _Expr, _Expr, _Dom1, _Dom2>, \
465  typename _Dom1::value_type> \
466  _Fun(const _Expr<_Dom1, typename _Dom1::value_type>& __e1, \
467  const _Expr<_Dom2, typename _Dom2::value_type>& __e2) \
468  { \
469  typedef typename _Dom1::value_type _Tp; \
470  typedef _BinClos<_UFun, _Expr, _Expr, _Dom1, _Dom2> _Closure; \
471  return _Expr<_Closure, _Tp>(_Closure(__e1(), __e2())); \
472  } \
473  \
474  template<class _Dom> \
475  inline _Expr<_BinClos<_UFun, _Expr, _ValArray, _Dom, \
476  typename _Dom::value_type>, \
477  typename _Dom::value_type> \
478  _Fun(const _Expr<_Dom, typename _Dom::value_type>& __e, \
479  const valarray<typename _Dom::value_type>& __v) \
480  { \
481  typedef typename _Dom::value_type _Tp; \
482  typedef _BinClos<_UFun, _Expr, _ValArray, _Dom, _Tp> _Closure; \
483  return _Expr<_Closure, _Tp>(_Closure(__e(), __v)); \
484  } \
485  \
486  template<class _Dom> \
487  inline _Expr<_BinClos<_UFun, _ValArray, _Expr, \
488  typename _Dom::value_type, _Dom>, \
489  typename _Dom::value_type> \
490  _Fun(const valarray<typename _Dom::valarray>& __v, \
491  const _Expr<_Dom, typename _Dom::value_type>& __e) \
492  { \
493  typedef typename _Dom::value_type _Tp; \
494  typedef _BinClos<_UFun, _ValArray, _Expr, _Tp, _Dom> _Closure; \
495  return _Expr<_Closure, _Tp>(_Closure(__v, __e())); \
496  } \
497  \
498  template<class _Dom> \
499  inline _Expr<_BinClos<_UFun, _Expr, _Constant, _Dom, \
500  typename _Dom::value_type>, \
501  typename _Dom::value_type> \
502  _Fun(const _Expr<_Dom, typename _Dom::value_type>& __e, \
503  const typename _Dom::value_type& __t) \
504  { \
505  typedef typename _Dom::value_type _Tp; \
506  typedef _BinClos<_UFun, _Expr, _Constant, _Dom, _Tp> _Closure; \
507  return _Expr<_Closure, _Tp>(_Closure(__e(), __t)); \
508  } \
509  \
510  template<class _Dom> \
511  inline _Expr<_BinClos<_UFun, _Constant, _Expr, \
512  typename _Dom::value_type, _Dom>, \
513  typename _Dom::value_type> \
514  _Fun(const typename _Dom::value_type& __t, \
515  const _Expr<_Dom, typename _Dom::value_type>& __e) \
516  { \
517  typedef typename _Dom::value_type _Tp; \
518  typedef _BinClos<_UFun, _Constant, _Expr, _Tp, _Dom> _Closure; \
519  return _Expr<_Closure, _Tp>(_Closure(__t, __e())); \
520  } \
521  \
522  template<typename _Tp> \
523  inline _Expr<_BinClos<_UFun, _ValArray, _ValArray, _Tp, _Tp>, _Tp> \
524  _Fun(const valarray<_Tp>& __v, const valarray<_Tp>& __w) \
525  { \
526  typedef _BinClos<_UFun, _ValArray, _ValArray, _Tp, _Tp> _Closure;\
527  return _Expr<_Closure, _Tp>(_Closure(__v, __w)); \
528  } \
529  \
530  template<typename _Tp> \
531  inline _Expr<_BinClos<_UFun, _ValArray, _Constant, _Tp, _Tp>, _Tp> \
532  _Fun(const valarray<_Tp>& __v, \
533  const typename valarray<_Tp>::value_type& __t) \
534  { \
535  typedef _BinClos<_UFun, _ValArray, _Constant, _Tp, _Tp> _Closure;\
536  return _Expr<_Closure, _Tp>(_Closure(__v, __t)); \
537  } \
538  \
539  template<typename _Tp> \
540  inline _Expr<_BinClos<_UFun, _Constant, _ValArray, _Tp, _Tp>, _Tp> \
541  _Fun(const typename valarray<_Tp>::value_type& __t, \
542  const valarray<_Tp>& __v) \
543  { \
544  typedef _BinClos<_UFun, _Constant, _ValArray, _Tp, _Tp> _Closure;\
545  return _Expr<_Closure, _Tp>(_Closure(__t, __v)); \
546  }
547 
548 _DEFINE_EXPR_BINARY_FUNCTION(atan2, _Atan2)
549 _DEFINE_EXPR_BINARY_FUNCTION(pow, _Pow)
550 
551 #undef _DEFINE_EXPR_BINARY_FUNCTION
552 
553 _GLIBCXX_END_NAMESPACE_VERSION
554 } // namespace
555 
556 #endif /* _CPP_VALARRAY_AFTER_H */
std::atan
std::complex< _Tp > atan(const std::complex< _Tp > &)
atan(__z) [8.1.4].
Definition: complex:1708
std
ISO C++ entities toplevel namespace is std.
std::operator+
_GLIBCXX20_CONSTEXPR complex< _Tp > operator+(const complex< _Tp > &__x, const complex< _Tp > &__y)
Return new complex value x plus y.
Definition: complex:327
std::cos
complex< _Tp > cos(const complex< _Tp > &)
Return complex cosine of z.
Definition: complex:734
std::sqrt
complex< _Tp > sqrt(const complex< _Tp > &)
Return complex square root of z.
Definition: complex:926
std::exp
complex< _Tp > exp(const complex< _Tp > &)
Return complex base e exponential of z.
Definition: complex:790
std::abs
_Tp abs(const complex< _Tp > &)
Return magnitude of z.
Definition: complex:623
std::sinh
complex< _Tp > sinh(const complex< _Tp > &)
Return complex hyperbolic sine of z.
Definition: complex:882
std::asin
std::complex< _Tp > asin(const std::complex< _Tp > &)
asin(__z) [8.1.3].
Definition: complex:1664
std::tan
complex< _Tp > tan(const complex< _Tp > &)
Return complex tangent of z.
Definition: complex:953
std::log
complex< _Tp > log(const complex< _Tp > &)
Return complex natural logarithm of z.
Definition: complex:817
std::log10
complex< _Tp > log10(const complex< _Tp > &)
Return complex base 10 logarithm of z.
Definition: complex:822
std::pow
complex< _Tp > pow(const complex< _Tp > &, int)
Return x to the y&#39;th power.
Definition: complex:1012
std::acos
std::complex< _Tp > acos(const std::complex< _Tp > &)
acos(__z) [8.1.2].
Definition: complex:1628
std::min
_GLIBCXX14_CONSTEXPR const _Tp & min(const _Tp &, const _Tp &)
This does what you think it does.
Definition: stl_algobase.h:198
std::tanh
complex< _Tp > tanh(const complex< _Tp > &)
Return complex hyperbolic tangent of z.
Definition: complex:981
std::operator-
_GLIBCXX20_CONSTEXPR complex< _Tp > operator-(const complex< _Tp > &__x, const complex< _Tp > &__y)
Return new complex value x minus y.
Definition: complex:357
std::sin
complex< _Tp > sin(const complex< _Tp > &)
Return complex sine of z.
Definition: complex:852
std::max
_GLIBCXX14_CONSTEXPR const _Tp & max(const _Tp &, const _Tp &)
This does what you think it does.
Definition: stl_algobase.h:222
std::cosh
complex< _Tp > cosh(const complex< _Tp > &)
Return complex hyperbolic cosine of z.
Definition: complex:764