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