]> gcc.gnu.org Git - gcc.git/blame - libstdc++/std/valarray_meta.h
git://gcc.gnu.org / gcc.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
diagnostic.h (set_internal_error_function): Renamed.
[gcc.git] / libstdc++ / std / valarray_meta.h
CommitLineData
27ac1891
GDR		 1// The template and inlines for the -*- C++ -*- internal _Meta class.
2
3// Copyright (C) 1997-1999 Cygnus Solutions
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 2, 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// You should have received a copy of the GNU General Public License along
17// with this library; see the file COPYING. If not, write to the Free
18// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
19// USA.
20
21// As a special exception, you may use this file as part of a free software
22// library without restriction. Specifically, if other files instantiate
23// templates or use macros or inline functions from this file, or you compile
24// this file and link it with other files to produce an executable, this
25// file does not by itself cause the resulting executable to be covered by
26// the GNU General Public License. This exception does not however
27// invalidate any other reasons why the executable file might be covered by
28// the GNU General Public License.
29
30// Written by Gabriel Dos Reis <Gabriel.Dos-Reis@cmla.ens-cachan.fr>
31
32#ifndef _CPP_VALARRAY_META_H
33#define _CPP_VALARRAY_META_H 1
34
35//
36// Implementing a loosened valarray return value is tricky.
37// First we need to meet 26.3.1/3: we should not add more than
38// two levels of template nesting. Therefore we resort to template
39// template to "flatten" loosened return value types.
40// At some point we use partial specialization to remove one level
41// template nesting due to _Expr<>
42//
43
44
45// This class is NOT defined. It doesn't need to.
46template<typename _Tp1, typename _Tp2> class _Constant;
47
48//
49// Unary function application closure.
50//
51template<class _Dom> class _UnFunBase {
52public:
53 typedef typename _Dom::value_type value_type;
54 typedef value_type _Vt;
55
56 _UnFunBase (const _Dom& __e, _Vt __f(_Vt))
57 : _M_expr(__e), _M_func(__f) {}
58
59 _Vt operator[] (size_t __i) const { return _M_func(_M_expr[__i]); }
60 size_t size () const { return _M_expr.size(); }
61
62private:
63 const _Dom& _M_expr;
64 _Vt (*_M_func)(_Vt);
65};
66
67template<template<class, class> class _Meta, class _Dom> class _UnFunClos;
68
69template<class _Dom>
70struct _UnFunClos<_Expr,_Dom> : _UnFunBase<_Dom> {
71 typedef _UnFunBase<_Dom> _Base;
72 typedef typename _Base::value_type value_type;
73
74 _UnFunClos (const _Dom& __e, value_type __f(value_type))
75 : _Base (__e, __f) {}
76};
77
78template<typename _Tp>
79struct _UnFunClos<_ValArray,_Tp> : _UnFunBase<valarray<_Tp> > {
80 typedef _UnFunBase<valarray<_Tp> > _Base;
81 typedef typename _Base::value_type value_type;
82
83 _UnFunClos (const valarray<_Tp>& __v, _Tp __f(_Tp))
84 : _Base (__v, __f) {}
85};
86
87//
88// Binary function application closure.
89//
90template<template<class, class> class _Meta1,
91 template<class, class> class Meta2,
92 class _Dom1, class _Dom2> class _BinFunClos;
93
94template<class _Dom1, class _Dom2> class _BinFunBase {
95public:
96 typedef typename _Dom1::value_type value_type;
97 typedef value_type _Vt;
98
99 _BinFunBase (const _Dom1& __e1, const _Dom2& __e2,
100 _Vt __f (_Vt, _Vt))
101 : _M_expr1 (__e1), _M_expr2 (__e2), _M_func (__f) {}
102
103 value_type operator[] (size_t __i) const
104 { return _M_func (_M_expr1[__i], _M_expr2[__i]); }
105 size_t size () const { return _M_expr1.size (); }
106
107private:
108 const _Dom1& _M_expr1;
109 const _Dom2& _M_expr2;
110 _Vt (*_M_func)(_Vt, _Vt);
111};
112
113template<class _Dom> class _BinFunBase1 {
114public:
115 typedef typename _Dom::value_type value_type ;
116 typedef value_type _Vt;
117
118 _BinFunBase1 (const _Vt& __c, const _Dom& __e, _Vt __f(_Vt, _Vt))
119 : _M_expr1 (__c), _M_expr2 (__e), _M_func (__f) {}
120
121 value_type operator[] (size_t __i) const
122 { return _M_func (_M_expr1, _M_expr2[__i]); }
123 size_t size () const { return _M_expr2.size (); }
124
125private:
126 const _Vt& _M_expr1;
127 const _Dom& _M_expr2;
128 _Vt (*_M_func)(_Vt, _Vt);
129};
130
131template<class _Dom> class _BinFunBase2 {
132public:
133 typedef typename _Dom::value_type value_type;
134 typedef value_type _Vt;
135
136 _BinFunBase2 (const _Dom& __e, const _Vt& __c, _Vt __f(_Vt, _Vt))
137 : _M_expr1 (__e), _M_expr2 (__c), _M_func (__f) {}
138
139 value_type operator[] (size_t __i) const
140 { return _M_func (_M_expr1[__i], _M_expr2); }
141 size_t size () const { return _M_expr1.size (); }
142
143private:
144 const _Dom& _M_expr1;
145 const _Vt& _M_expr2;
146 _Vt (*_M_func)(_Vt, _Vt);
147};
148
149template<class _Dom1, class _Dom2>
150struct _BinFunClos<_Expr,_Expr,_Dom1,_Dom2> : _BinFunBase<_Dom1,_Dom2> {
151 typedef _BinFunBase<_Dom1,_Dom2> _Base;
152 typedef typename _Base::value_type value_type;
153 typedef value_type _Tp;
154
155 _BinFunClos (const _Dom1& __e1, const _Dom2& __e2,
156 _Tp __f(_Tp, _Tp))
157 : _Base (__e1, __e2, __f) {}
158};
159
160template<typename _Tp>
161struct _BinFunClos<_ValArray,_ValArray,_Tp,_Tp>
162 : _BinFunBase<valarray<_Tp>, valarray<_Tp> > {
163 typedef _BinFunBase<valarray<_Tp>, valarray<_Tp> > _Base;
164 typedef _Tp value_type;
165
166 _BinFunClos (const valarray<_Tp>& __v, const valarray<_Tp>& __w,
167 _Tp __f(_Tp, _Tp))
168 : _Base (__v, __w, __f) {}
169};
170
171template<class _Dom>
172struct _BinFunClos<_Expr,_ValArray,_Dom,typename _Dom::value_type>
173 : _BinFunBase<_Dom,valarray<typename _Dom::value_type> > {
174 typedef typename _Dom::value_type _Tp;
175 typedef _BinFunBase<_Dom,valarray<_Tp> > _Base;
176 typedef _Tp value_type;
177
178 _BinFunClos (const _Dom& __e, const valarray<_Tp>& __v,
179 _Tp __f(_Tp, _Tp))
180 : _Base (__e, __v, __f) {}
181};
182
183template<class _Dom>
184struct _BinFunClos<_ValArray,_Expr,typename _Dom::value_type,_Dom>
185 : _BinFunBase<valarray<typename _Dom::value_type>,_Dom> {
186 typedef typename _Dom::value_type _Tp;
187 typedef _BinFunBase<_Dom,valarray<_Tp> > _Base;
188 typedef _Tp value_type;
189
190 _BinFunClos (const valarray<_Tp>& __v, const _Dom& __e,
191 _Tp __f(_Tp, _Tp))
192 : _Base (__v, __e, __f) {}
193};
194
195template<class _Dom>
196struct _BinFunClos<_Expr,_Constant,_Dom,typename _Dom::value_type>
197 : _BinFunBase2<_Dom> {
198 typedef typename _Dom::value_type _Tp;
199 typedef _Tp value_type;
200 typedef _BinFunBase2<_Dom> _Base;
201
202 _BinFunClos (const _Dom& __e, const _Tp& __t, _Tp __f (_Tp, _Tp))
203 : _Base (__e, __t, __f) {}
204};
205
206template<class _Dom>
207struct _BinFunClos<_Constant,_Expr,_Dom,typename _Dom::value_type>
208 : _BinFunBase1<_Dom> {
209 typedef typename _Dom::value_type _Tp;
210 typedef _Tp value_type;
211 typedef _BinFunBase1<_Dom> _Base;
212
213 _BinFunClos (const _Tp& __t, const _Dom& __e, _Tp __f (_Tp, _Tp))
214 : _Base (__t, __e, __f) {}
215};
216
217template<typename _Tp>
218struct _BinFunClos<_ValArray,_Constant,_Tp,_Tp>
219 : _BinFunBase2<valarray<_Tp> > {
220 typedef _BinFunBase2<valarray<_Tp> > _Base;
221 typedef _Tp value_type;
222
223 _BinFunClos (const valarray<_Tp>& __v, const _Tp& __t,
224 _Tp __f(_Tp, _Tp))
225 : _Base (__v, __t, __f) {}
226};
227
228template<typename _Tp>
229struct _BinFunClos<_Constant,_ValArray,_Tp,_Tp>
230 : _BinFunBase1<valarray<_Tp> > {
231 typedef _BinFunBase1<valarray<_Tp> > _Base;
232 typedef _Tp value_type;
233
234 _BinFunClos (const _Tp& __t, const valarray<_Tp>& __v,
235 _Tp __f (_Tp, _Tp))
236 : _Base (__t, __v, __f) {}
237};
238
239//
240// Apply function taking a value/const reference closure
241//
242
243template<typename _Dom, typename _Arg> class _FunBase {
244public:
245 typedef typename _Dom::value_type value_type;
246
247 _FunBase (const _Dom& __e, value_type __f(_Arg))
248 : _M_expr (__e), _M_func (__f) {}
249
250 value_type operator[] (size_t __i) const
251 { return _M_func (_M_expr[__i]); }
252 size_t size() const { return _M_expr.size ();}
253
254private:
255 const _Dom& _M_expr;
256 value_type (*_M_func)(_Arg);
257};
258
259template<class _Dom>
260struct _ValFunClos<_Expr,_Dom>
261 : _FunBase<_Dom, typename _Dom::value_type> {
262 typedef _FunBase<_Dom, typename _Dom::value_type> _Base;
263 typedef typename _Base::value_type value_type;
264 typedef value_type _Tp;
265
266 _ValFunClos (const _Dom& __e, _Tp __f (_Tp)) : _Base (__e, __f) {}
267};
268
269template<typename _Tp>
270struct _ValFunClos<_ValArray,_Tp>
271 : _FunBase<valarray<_Tp>, _Tp> {
272 typedef _FunBase<valarray<_Tp>, _Tp> _Base;
273 typedef _Tp value_type;
274
275 _ValFunClos (const valarray<_Tp>& __v, _Tp __f(_Tp))
276 : _Base (__v, __f) {}
277};
278
279template<class _Dom>
280struct _RefFunClos<_Expr,_Dom> :
281 _FunBase<_Dom, const typename _Dom::value_type&> {
282 typedef _FunBase<_Dom, const typename _Dom::value_type&> _Base;
283 typedef typename _Base::value_type value_type;
284 typedef value_type _Tp;
285
286 _RefFunClos (const _Dom& __e, _Tp __f (const _Tp&))
287 : _Base (__e, __f) {}
288};
289
290template<typename _Tp>
291struct _RefFunClos<_ValArray,_Tp>
292 : _FunBase<valarray<_Tp>, const _Tp&> {
293 typedef _FunBase<valarray<_Tp>, const _Tp&> _Base;
294 typedef _Tp value_type;
295
296 _RefFunClos (const valarray<_Tp>& __v, _Tp __f(const _Tp&))
297 : _Base (__v, __f) {}
298};
299
300//
301// Unary expression closure.
302//
303
304template<template<class> class _Oper, typename _Arg>
305class _UnBase {
306public:
307 typedef _Oper<typename _Arg::value_type> _Op;
308 typedef typename _Op::result_type value_type;
309
310 _UnBase (const _Arg& __e) : _M_expr(__e) {}
311 value_type operator[] (size_t) const;
312 size_t size () const { return _M_expr.size (); }
313
314private:
315 const _Arg& _M_expr;
316};
317
318template<template<class> class _Oper, typename _Arg>
319inline typename _UnBase<_Oper, _Arg>::value_type
320_UnBase<_Oper, _Arg>::operator[] (size_t __i) const
321{ return _Op() (_M_expr[__i]); }
322
323template<template<class> class _Oper, class _Dom>
324struct _UnClos<_Oper, _Expr, _Dom> : _UnBase<_Oper, _Dom> {
325 typedef _Dom _Arg;
326 typedef _UnBase<_Oper, _Dom> _Base;
327 typedef typename _Base::value_type value_type;
328
329 _UnClos (const _Arg& __e) : _Base(__e) {}
330};
331
332template<template<class> class _Oper, typename _Tp>
333struct _UnClos<_Oper, _ValArray, _Tp> : _UnBase<_Oper, valarray<_Tp> > {
334 typedef valarray<_Tp> _Arg;
335 typedef _UnBase<_Oper, valarray<_Tp> > _Base;
336 typedef typename _Base::value_type value_type;
337
338 _UnClos (const _Arg& __e) : _Base(__e) {}
339};
340
341
342//
343// Binary expression closure.
344//
345
346template<template<class> class _Oper, typename _FirstArg, typename _SecondArg>
347class _BinBase {
348public:
349 typedef _Oper<typename _FirstArg::value_type> _Op;
350 typedef typename _Op::result_type value_type;
351
352 _BinBase (const _FirstArg& __e1, const _SecondArg& __e2)
353 : _M_expr1 (__e1), _M_expr2 (__e2) {}
354 value_type operator[] (size_t) const;
355 size_t size () const { return _M_expr1.size (); }
356
357private:
358 const _FirstArg& _M_expr1;
359 const _SecondArg& _M_expr2;
360};
361
362template<template<class> class _Oper, typename _FirstArg, typename _SecondArg>
363inline typename _BinBase<_Oper,_FirstArg,_SecondArg>::value_type
364_BinBase<_Oper,_FirstArg,_SecondArg>::operator[] (size_t __i) const
365{ return _Op() (_M_expr1[__i], _M_expr2[__i]); }
366
367
368template<template<class> class _Oper, class _Clos>
369class _BinBase2 {
370public:
371 typedef typename _Clos::value_type _Vt;
372 typedef _Oper<_Vt> _Op;
373 typedef typename _Op::result_type value_type;
374
375 _BinBase2 (const _Clos& __e, const _Vt& __t)
376 : _M_expr1 (__e), _M_expr2 (__t) {}
377 value_type operator[] (size_t) const;
378 size_t size () const { return _M_expr1.size (); }
379
380private:
381 const _Clos& _M_expr1;
382 const _Vt& _M_expr2;
383};
384
385template<template<class> class _Oper, class _Clos>
386inline typename _BinBase2<_Oper,_Clos>::value_type
387_BinBase2<_Oper,_Clos>::operator[] (size_t __i) const
388{ return _Op() (_M_expr1[__i], _M_expr2); }
389
390
391template<template<class> class _Oper, class _Clos>
392class _BinBase1 {
393public:
394 typedef typename _Clos::value_type _Vt;
395 typedef _Oper<_Vt> _Op;
396 typedef typename _Op::result_type value_type;
397
398 _BinBase1 (const _Vt& __t, const _Clos& __e)
399 : _M_expr1 (__t), _M_expr2 (__e) {}
400 value_type operator[] (size_t) const;
401 size_t size () const { return _M_expr2.size (); }
402
403private:
404 const _Vt& _M_expr1;
405 const _Clos& _M_expr2;
406};
407
408template<template<class> class _Oper, class _Clos>
409inline typename
410_BinBase1<_Oper,_Clos>::value_type
411_BinBase1<_Oper,_Clos>:: operator[] (size_t __i) const
412{ return _Op() (_M_expr1, _M_expr2[__i]); }
413
414
415template<template<class> class _Oper, class _Dom1, class _Dom2>
416struct _BinClos<_Oper, _Expr, _Expr, _Dom1, _Dom2>
417 : _BinBase<_Oper,_Dom1,_Dom2> {
418 typedef _BinBase<_Oper,_Dom1,_Dom2> _Base;
419 typedef typename _Base::value_type value_type;
420
421 _BinClos(const _Dom1& __e1, const _Dom2& __e2) : _Base(__e1, __e2) {}
422};
423
424template<template<class> class _Oper, typename _Tp>
425struct _BinClos<_Oper,_ValArray,_ValArray,_Tp,_Tp>
426 : _BinBase<_Oper,valarray<_Tp>,valarray<_Tp> > {
427 typedef _BinBase<_Oper,valarray<_Tp>,valarray<_Tp> > _Base;
428 typedef _Tp value_type;
429
430 _BinClos (const valarray<_Tp>& __v, const valarray<_Tp>& __w)
431 : _Base (__v, __w) {}
432};
433
434template<template<class> class _Oper, class _Dom>
435struct _BinClos<_Oper,_Expr,_ValArray,_Dom,typename _Dom::value_type>
436 : _BinBase<_Oper,_Dom,valarray<typename _Dom::value_type> > {
437 typedef typename _Dom::value_type _Tp;
438 typedef _BinBase<_Oper,_Dom,valarray<_Tp> > _Base;
439 typedef typename _Base::value_type value_type;
440
441 _BinClos(const _Dom& __e1, const valarray<_Tp>& __e2)
442 : _Base (__e1, __e2) {}
443};
444
445template<template<class> class _Oper, class _Dom>
446struct _BinClos<_Oper,_ValArray,_Expr,typename _Dom::value_type,_Dom>
447 : _BinBase<_Oper,valarray<typename _Dom::value_type>,_Dom> {
448 typedef typename _Dom::value_type _Tp;
449 typedef _BinBase<_Oper,valarray<_Tp>,_Dom> _Base;
450 typedef typename _Base::value_type value_type;
451
172d33bc 452 _BinClos (const valarray<_Tp>& __e1, const _Dom& __e2)
27ac1891
GDR		 453 : _Base (__e1, __e2) {}
454};
455
456template<template<class> class _Oper, class _Dom>
457struct _BinClos<_Oper,_Expr,_Constant,_Dom,typename _Dom::value_type>
458 : _BinBase2<_Oper,_Dom> {
459 typedef typename _Dom::value_type _Tp;
460 typedef _BinBase2<_Oper,_Dom> _Base;
461 typedef typename _Base::value_type value_type;
462
463 _BinClos (const _Dom& __e1, const _Tp& __e2) : _Base (__e1, __e2) {}
464};
465
466template<template<class> class _Oper, class _Dom>
467struct _BinClos<_Oper,_Constant,_Expr,typename _Dom::value_type,_Dom>
468 : _BinBase1<_Oper,_Dom> {
469 typedef typename _Dom::value_type _Tp;
470 typedef _BinBase1<_Oper,_Dom> _Base;
471 typedef typename _Base::value_type value_type;
472
473 _BinClos (const _Tp& __e1, const _Dom& __e2) : _Base (__e1, __e2) {}
474};
475
476template<template<class> class _Oper, typename _Tp>
477struct _BinClos<_Oper,_ValArray,_Constant,_Tp,_Tp>
478 : _BinBase2<_Oper,valarray<_Tp> > {
479 typedef _BinBase2<_Oper,valarray<_Tp> > _Base;
480 typedef typename _Base::value_type value_type;
481
482 _BinClos (const valarray<_Tp>& __v, const _Tp& __t)
483 : _Base (__v, __t) {}
484};
485
486template<template<class> class _Oper, typename _Tp>
487struct _BinClos<_Oper,_Constant,_ValArray,_Tp,_Tp>
488 : _BinBase1<_Oper,valarray<_Tp> > {
489 typedef _BinBase1<_Oper,valarray<_Tp> > _Base;
490 typedef typename _Base::value_type value_type;
491
492 _BinClos (const _Tp& __t, const valarray<_Tp>& __v)
493 : _Base (__t, __v) {}
494};
495
496
497//
498// slice_array closure.
499//
500template<typename _Dom> class _SBase {
501public:
502 typedef typename _Dom::value_type value_type;
503
504 _SBase (const _Dom& __e, const slice& __s)
505 : _M_expr (__e), _M_slice (__s) {}
506 value_type operator[] (size_t __i) const
507 { return _M_expr[_M_slice.start () + __i * _M_slice.stride ()]; }
508 size_t size() const { return _M_slice.size (); }
509
510private:
511 const _Dom& _M_expr;
512 const slice& _M_slice;
513};
514
515template<typename _Tp> class _SBase<_Array<_Tp> > {
516public:
517 typedef _Tp value_type;
518
519 _SBase (_Array<_Tp> __a, const slice& __s)
520 : _M_array (__a._M_data+__s.start()), _M_size (__s.size()),
521 _M_stride (__s.stride()) {}
522 value_type operator[] (size_t __i) const
523 { return _M_array._M_data[__i * _M_stride]; }
524 size_t size() const { return _M_size; }
525
526private:
527 const _Array<_Tp> _M_array;
528 const size_t _M_size;
529 const size_t _M_stride;
530};
531
532template<class _Dom> struct _SClos<_Expr,_Dom> : _SBase<_Dom> {
533 typedef _SBase<_Dom> _Base;
534 typedef typename _Base::value_type value_type;
535
536 _SClos (const _Dom& __e, const slice& __s) : _Base (__e, __s) {}
537};
538
539template<typename _Tp>
540struct _SClos<_ValArray,_Tp> : _SBase<_Array<_Tp> > {
541 typedef _SBase<_Array<_Tp> > _Base;
542 typedef _Tp value_type;
543
544 _SClos (_Array<_Tp> __a, const slice& __s) : _Base (__a, __s) {}
545};
546
547//
548// gslice_array closure.
549//
550template<class _Dom> class _GBase {
551public:
552 typedef typename _Dom::value_type value_type;
553
554 _GBase (const _Dom& __e, const valarray<size_t>& __i)
555 : _M_expr (__e), _M_index(__i) {}
556 value_type operator[] (size_t __i) const
557 { return _M_expr[_M_index[__i]]; }
558 size_t size () const { return _M_index.size(); }
559
560private:
561 const _Dom& _M_expr;
562 const valarray<size_t>& _M_index;
563};
564
565template<typename _Tp> class _GBase<_Array<_Tp> > {
566public:
567 typedef _Tp value_type;
568
569 _GBase (_Array<_Tp> __a, const valarray<size_t>& __i)
570 : _M_array (__a), _M_index(__i) {}
571 value_type operator[] (size_t __i) const
572 { return _M_array._M_data[_M_index[__i]]; }
573 size_t size () const { return _M_index.size(); }
574
575private:
576 const _Array<_Tp> _M_array;
577 const valarray<size_t>& _M_index;
578};
579
580template<class _Dom> struct _GClos<_Expr,_Dom> : _GBase<_Dom> {
581 typedef _GBase<_Dom> _Base;
582 typedef typename _Base::value_type value_type;
583
584 _GClos (const _Dom& __e, const valarray<size_t>& __i)
585 : _Base (__e, __i) {}
586};
587
588template<typename _Tp>
589struct _GClos<_ValArray,_Tp> : _GBase<_Array<_Tp> > {
590 typedef _GBase<_Array<_Tp> > _Base;
591 typedef typename _Base::value_type value_type;
592
593 _GClos (_Array<_Tp> __a, const valarray<size_t>& __i)
594 : _Base (__a, __i) {}
595};
596
597//
598// indirect_array closure
599//
600
601template<class _Dom> class _IBase {
602public:
603 typedef typename _Dom::value_type value_type;
604
605 _IBase (const _Dom& __e, const valarray<size_t>& __i)
606 : _M_expr (__e), _M_index (__i) {}
607 value_type operator[] (size_t __i) const
608 { return _M_expr[_M_index[__i]]; }
609 size_t size() const { return _M_index.size(); }
610
611private:
612 const _Dom& _M_expr;
613 const valarray<size_t>& _M_index;
614};
615
616template<class _Dom> struct _IClos<_Expr,_Dom> : _IBase<_Dom> {
617 typedef _IBase<_Dom> _Base;
618 typedef typename _Base::value_type value_type;
619
620 _IClos (const _Dom& __e, const valarray<size_t>& __i)
621 : _Base (__e, __i) {}
622};
623
624template<typename _Tp>
625struct _IClos<_ValArray,_Tp> : _IBase<valarray<_Tp> > {
626 typedef _IBase<valarray<_Tp> > _Base;
627 typedef _Tp value_type;
628
629 _IClos (const valarray<_Tp>& __a, const valarray<size_t>& __i)
630 : _Base (__a, __i) {}
631};
632
633//
634// class _Expr
635//
636template<class _Clos, typename _Tp> class _Expr {
637public:
638 typedef _Tp value_type;
639
640 _Expr (const _Clos&);
641
642 const _Clos& operator() () const;
643
644 value_type operator[] (size_t) const;
645 valarray<value_type> operator[] (slice) const;
646 valarray<value_type> operator[] (const gslice&) const;
647 valarray<value_type> operator[] (const valarray<bool>&) const;
648 valarray<value_type> operator[] (const valarray<size_t>&) const;
649
650 _Expr<_UnClos<_Unary_plus,_Expr,_Clos>, value_type>
651 operator+ () const;
652
653 _Expr<_UnClos<negate,_Expr,_Clos>, value_type>
654 operator- () const;
655
656 _Expr<_UnClos<_Bitwise_not,_Expr,_Clos>, value_type>
657 operator~ () const;
658
659 _Expr<_UnClos<logical_not,_Expr,_Clos>, bool>
660 operator! () const;
661
662 size_t size () const;
663 value_type sum () const;
664
665 valarray<value_type> shift (int) const;
666 valarray<value_type> cshift (int) const;
667// _Meta<_ApplyFunctionWithValue<_Expr>, value_type>
668// apply (value_type _M_func (value_type)) const;
669// _Meta<_ApplyFunctionWithConstRef<_Expr>, value_type>
670// apply (value_type _M_func (const value_type&)) const;
671
672private:
673 const _Clos _M_closure;
674};
675
676template<class _Clos, typename _Tp>
677inline
678_Expr<_Clos,_Tp>::_Expr (const _Clos& __c) : _M_closure(__c) {}
679
680template<class _Clos, typename _Tp>
681inline const _Clos&
682_Expr<_Clos,_Tp>::operator() () const
683{ return _M_closure; }
684
685template<class _Clos, typename _Tp>
686inline _Tp
687_Expr<_Clos,_Tp>::operator[] (size_t __i) const
688{ return _M_closure[__i]; }
689
690template<class _Clos, typename _Tp>
691inline valarray<_Tp>
692_Expr<_Clos,_Tp>::operator[] (slice __s) const
693{ return _M_closure[__s]; }
694
695template<class _Clos, typename _Tp>
696inline valarray<_Tp>
697_Expr<_Clos,_Tp>::operator[] (const gslice& __gs) const
698{ return _M_closure[__gs]; }
699
700template<class _Clos, typename _Tp>
701inline valarray<_Tp>
702_Expr<_Clos,_Tp>::operator[] (const valarray<bool>& __m) const
703{ return _M_closure[__m]; }
704
705template<class _Clos, typename _Tp>
706inline valarray<_Tp>
707_Expr<_Clos,_Tp>::operator[] (const valarray<size_t>& __i) const
708{ return _M_closure[__i]; }
709
710template<class _Clos, typename _Tp>
711inline size_t
712_Expr<_Clos,_Tp>::size () const { return _M_closure.size (); }
713
714// XXX: replace this with a more robust summation algorithm.
715template<class _Clos, typename _Tp>
716inline _Tp
717_Expr<_Clos,_Tp>::sum () const
718{
719 _Tp __s(_Tp());
720 size_t __n (_M_closure.size ());
721 for (size_t __i=0; __i<__n; ++__i) __s += _M_closure[__i];
722 return __s;
723}
724
725template<class _Dom, typename _Tp>
726inline _Tp
727min (const _Expr<_Dom,_Tp>& __e)
728{
729 size_t __s (__e.size ());
730 _Tp __m (__e[0]);
731 for (size_t __i=1; __i<__s; ++__i)
732 if (__m > __e[__i]) __m = __e[__i];
733 return __m;
734}
735
736template<class _Dom, typename _Tp>
737inline _Tp
738max (const _Expr<_Dom,_Tp>& __e)
739{
740 size_t __s (__e.size());
741 _Tp __m (__e[0]);
742 for (size_t __i=1; __i<__s; ++__i)
743 if (__m < __e[__i]) __m = __e[__i];
744 return __m;
745}
746
747template<class _Dom, typename _Tp>
748inline _Expr<_UnClos<logical_not,_Expr,_Dom>, bool>
749_Expr<_Dom,_Tp>::operator! () const
750{
751 typedef _UnClos<logical_not,_Expr,_Dom> _Closure;
752 return _Expr<_Closure,_Tp> (_Closure(this->_M_closure));
753}
754
755#define _DEFINE_EXPR_UNARY_OPERATOR(_Op, _Name) \
756template<class _Dom, typename _Tp> \
757inline _Expr<_UnClos<_Name,_Expr,_Dom>,_Tp> \
774c79ed 758_Expr<_Dom,_Tp>::operator _Op () const \
27ac1891
GDR		 759{ \
760 typedef _UnClos<_Name,_Expr,_Dom> _Closure; \
761 return _Expr<_Closure,_Tp> (_Closure (this->_M_closure)); \
762}
763
764 _DEFINE_EXPR_UNARY_OPERATOR(+, _Unary_plus)
765 _DEFINE_EXPR_UNARY_OPERATOR(-, negate)
766 _DEFINE_EXPR_UNARY_OPERATOR(~, _Bitwise_not)
767
768#undef _DEFINE_EXPR_UNARY_OPERATOR
769
770
771#define _DEFINE_EXPR_BINARY_OPERATOR(_Op, _Name) \
772template<class _Dom1, class _Dom2> \
773inline _Expr<_BinClos<_Name,_Expr,_Expr,_Dom1,_Dom2>, \
774 typename _Name<typename _Dom1::value_type>::result_type> \
774c79ed 775operator _Op (const _Expr<_Dom1,typename _Dom1::value_type>& __v, \
27ac1891
GDR		 776 const _Expr<_Dom2,typename _Dom2::value_type>& __w) \
777{ \
778 typedef typename _Dom1::value_type _Arg; \
779 typedef typename _Name<_Arg>::result_type _Value; \
780 typedef _BinClos<_Name,_Expr,_Expr,_Dom1,_Dom2> _Closure; \
781 return _Expr<_Closure,_Value> (_Closure (__v (), __w ())); \
782} \
783 \
784template<class _Dom> \
785inline _Expr<_BinClos<_Name,_Expr,_Constant,_Dom,typename _Dom::value_type>, \
786 typename _Name<typename _Dom::value_type>::result_type> \
774c79ed 787operator _Op (const _Expr<_Dom,typename _Dom::value_type>& __v, \
27ac1891
GDR		 788 const typename _Dom::value_type& __t) \
789{ \
790 typedef typename _Dom::value_type _Arg; \
791 typedef typename _Name<_Arg>::result_type _Value; \
792 typedef _BinClos<_Name,_Expr,_Constant,_Dom,_Arg> _Closure; \
793 return _Expr<_Closure,_Value> (_Closure (__v (), __t)); \
794} \
795 \
796template<class _Dom> \
797inline _Expr<_BinClos<_Name,_Constant,_Expr,typename _Dom::value_type,_Dom>, \
798 typename _Name<typename _Dom::value_type>::result_type> \
774c79ed 799operator _Op (const typename _Dom::value_type& __t, \
27ac1891
GDR		 800 const _Expr<_Dom,typename _Dom::value_type>& __v) \
801{ \
802 typedef typename _Dom::value_type _Arg; \
803 typedef typename _Name<_Arg>::result_type _Value; \
804 typedef _BinClos<_Name,_Constant,_Expr,_Arg,_Dom> _Closure; \
805 return _Expr<_Closure,_Value> (_Closure (__t, __v ())); \
806} \
807 \
808template<class _Dom> \
809inline _Expr<_BinClos<_Name,_Expr,_ValArray,_Dom,typename _Dom::value_type>, \
810 typename _Name<typename _Dom::value_type>::result_type> \
774c79ed 811operator _Op (const _Expr<_Dom,typename _Dom::value_type>& __e, \
27ac1891
GDR		 812 const valarray<typename _Dom::value_type>& __v) \
813{ \
814 typedef typename _Dom::value_type _Arg; \
815 typedef typename _Name<_Arg>::result_type _Value; \
816 typedef _BinClos<_Name,_Expr,_ValArray,_Dom,_Arg> _Closure; \
817 return _Expr<_Closure,_Value> (_Closure (__e (), __v)); \
818} \
819 \
820template<class _Dom> \
821inline _Expr<_BinClos<_Name,_ValArray,_Expr,typename _Dom::value_type,_Dom>, \
822 typename _Name<typename _Dom::value_type>::result_type> \
774c79ed 823operator _Op (const valarray<typename _Dom::value_type>& __v, \
27ac1891
GDR		 824 const _Expr<_Dom,typename _Dom::value_type>& __e) \
825{ \
826 typedef typename _Dom::value_type _Tp; \
827 typedef typename _Name<_Tp>::result_type _Value; \
828 typedef _BinClos<_Name,_ValArray,_Expr,_Tp,_Dom> _Closure; \
829 return _Expr<_Closure,_Value> (_Closure (__v, __e ())); \
830}
831
832 _DEFINE_EXPR_BINARY_OPERATOR(+, plus)
833 _DEFINE_EXPR_BINARY_OPERATOR(-, minus)
834 _DEFINE_EXPR_BINARY_OPERATOR(*, multiplies)
835 _DEFINE_EXPR_BINARY_OPERATOR(/, divides)
836 _DEFINE_EXPR_BINARY_OPERATOR(%, modulus)
837 _DEFINE_EXPR_BINARY_OPERATOR(^, _Bitwise_xor)
838 _DEFINE_EXPR_BINARY_OPERATOR(&, _Bitwise_and)
839 _DEFINE_EXPR_BINARY_OPERATOR(|, _Bitwise_or)
840 _DEFINE_EXPR_BINARY_OPERATOR(<<, _Shift_left)
841 _DEFINE_EXPR_BINARY_OPERATOR(>>, _Shift_right)
842
843#undef _DEFINE_EXPR_BINARY_OPERATOR
844
845#define _DEFINE_EXPR_RELATIONAL_OPERATOR(_Op, _Name) \
846template<class _Dom1, class _Dom2> \
847inline _Expr<_BinClos<_Name,_Expr,_Expr,_Dom1,_Dom2>, bool> \
774c79ed 848operator _Op (const _Expr<_Dom1,typename _Dom1::value_type>& __v, \
27ac1891
GDR		 849 const _Expr<_Dom2,typename _Dom2::value_type>& __w) \
850{ \
851 typedef typename _Dom1::value_type _Arg; \
852 typedef _BinClos<_Name,_Expr,_Expr,_Dom1,_Dom2> _Closure; \
853 return _Expr<_Closure,bool> (_Closure (__v (), __w ())); \
854} \
855 \
856template<class _Dom> \
857inline _Expr<_BinClos<_Name,_Expr,_Constant,_Dom,typename _Dom::value_type>, \
858 bool> \
774c79ed 859operator _Op (const _Expr<_Dom,typename _Dom::value_type>& __v, \
27ac1891
GDR		 860 const typename _Dom::value_type& __t) \
861{ \
862 typedef typename _Dom::value_type _Arg; \
863 typedef _BinClos<_Name,_Expr,_Constant,_Dom,_Arg> _Closure; \
864 return _Expr<_Closure,bool> (_Closure (__v (), __t)); \
865} \
866 \
867template<class _Dom> \
868inline _Expr<_BinClos<_Name,_Constant,_Expr,typename _Dom::value_type,_Dom>, \
869 bool> \
774c79ed 870operator _Op (const typename _Dom::value_type& __t, \
27ac1891
GDR		 871 const _Expr<_Dom,typename _Dom::value_type>& __v) \
872{ \
873 typedef typename _Dom::value_type _Arg; \
874 typedef _BinClos<_Name,_Constant,_Expr,_Arg,_Dom> _Closure; \
875 return _Expr<_Closure,bool> (_Closure (__t, __v ())); \
876} \
877 \
878template<class _Dom> \
879inline _Expr<_BinClos<_Name,_Expr,_ValArray,_Dom,typename _Dom::value_type>, \
880 bool> \
774c79ed 881operator _Op (const _Expr<_Dom,typename _Dom::value_type>& __e, \
27ac1891
GDR		 882 const valarray<typename _Dom::value_type>& __v) \
883{ \
884 typedef typename _Dom::value_type _Tp; \
885 typedef _BinClos<_Name,_Expr,_ValArray,_Dom,_Tp> _Closure; \
886 return _Expr<_Closure,bool> (_Closure (__e (), __v)); \
887} \
888 \
889template<class _Dom> \
890inline _Expr<_BinClos<_Name,_ValArray,_Expr,typename _Dom::value_type,_Dom>, \
891 bool> \
774c79ed 892operator _Op (const valarray<typename _Dom::value_type>& __v, \
27ac1891
GDR		 893 const _Expr<_Dom,typename _Dom::value_type>& __e) \
894{ \
895 typedef typename _Dom::value_type _Tp; \
896 typedef _BinClos<_Name,_ValArray,_Expr,_Tp,_Dom> _Closure; \
897 return _Expr<_Closure,bool> (_Closure (__v, __e ())); \
898}
899
900 _DEFINE_EXPR_RELATIONAL_OPERATOR(&&, logical_and)
901 _DEFINE_EXPR_RELATIONAL_OPERATOR(||, logical_or)
902 _DEFINE_EXPR_RELATIONAL_OPERATOR(==, equal_to)
903 _DEFINE_EXPR_RELATIONAL_OPERATOR(!=, not_equal_to)
904 _DEFINE_EXPR_RELATIONAL_OPERATOR(<, less)
905 _DEFINE_EXPR_RELATIONAL_OPERATOR(>, greater)
906 _DEFINE_EXPR_RELATIONAL_OPERATOR(<=, less_equal)
907 _DEFINE_EXPR_RELATIONAL_OPERATOR(>=, greater_equal)
908
909#undef _DEFINE_EXPR_RELATIONAL_OPERATOR
910
911
912
913#define _DEFINE_EXPR_UNARY_FUNCTION(_Name) \
914template<class _Dom> \
915inline _Expr<_UnFunClos<_Expr,_Dom>,typename _Dom::value_type> \
916_Name(const _Expr<_Dom,typename _Dom::value_type>& __e) \
917{ \
918 typedef typename _Dom::value_type _Tp; \
919 typedef _UnFunClos<_Expr,_Dom> _Closure; \
36a6e29f 920 return _Expr<_Closure,_Tp>(_Closure(__e(), (_Tp(*)(_Tp))(&_Name))); \
27ac1891
GDR		 921} \
922 \
923template<typename _Tp> \
924inline _Expr<_UnFunClos<_ValArray,_Tp>,_Tp> \
925_Name(const valarray<_Tp>& __v) \
926{ \
927 typedef _UnFunClos<_ValArray,_Tp> _Closure; \
928 return _Expr<_Closure,_Tp> (_Closure (__v, (_Tp(*)(_Tp))(&_Name))); \
929}
930
931
932 _DEFINE_EXPR_UNARY_FUNCTION(abs)
933 _DEFINE_EXPR_UNARY_FUNCTION(cos)
934 _DEFINE_EXPR_UNARY_FUNCTION(acos)
935 _DEFINE_EXPR_UNARY_FUNCTION(cosh)
936 _DEFINE_EXPR_UNARY_FUNCTION(sin)
937 _DEFINE_EXPR_UNARY_FUNCTION(asin)
938 _DEFINE_EXPR_UNARY_FUNCTION(sinh)
9c5c5c8a
GDR		 939 _DEFINE_EXPR_UNARY_FUNCTION(tan)
940 _DEFINE_EXPR_UNARY_FUNCTION(tanh)
27ac1891
GDR		 941 _DEFINE_EXPR_UNARY_FUNCTION(atan)
942 _DEFINE_EXPR_UNARY_FUNCTION(exp)
943 _DEFINE_EXPR_UNARY_FUNCTION(log)
944 _DEFINE_EXPR_UNARY_FUNCTION(log10)
945 _DEFINE_EXPR_UNARY_FUNCTION(sqrt)
946
947#undef _DEFINE_EXPR_UNARY_FUNCTION
948
949
950#define _DEFINE_EXPR_BINARY_FUNCTION(_Name) \
951template<class _Dom1, class _Dom2> \
952inline _Expr<_BinFunClos<_Expr,_Expr,_Dom1,_Dom2>,typename _Dom1::value_type>\
953_Name (const _Expr<_Dom1,typename _Dom1::value_type>& __e1, \
954 const _Expr<_Dom2,typename _Dom2::value_type>& __e2) \
955{ \
956 typedef typename _Dom1::value_type _Tp; \
957 typedef _BinFunClos<_Expr,_Expr,_Dom1,_Dom2> _Closure; \
958 return _Expr<_Closure,_Tp> \
959 (_Closure (__e1 (), __e2 (), (_Tp(*)(_Tp, _Tp))(&_Name))); \
960} \
961 \
962template<class _Dom> \
963inline _Expr<_BinFunClos<_Expr,_ValArray,_Dom,typename _Dom::value_type>, \
964 typename _Dom::value_type> \
965_Name (const _Expr<_Dom,typename _Dom::value_type>& __e, \
966 const valarray<typename _Dom::value_type>& __v) \
967{ \
968 typedef typename _Dom::value_type _Tp; \
969 typedef _BinFunClos<_Expr,_ValArray,_Dom,_Tp> _Closure; \
970 return _Expr<_Closure,_Tp> \
971 (_Closure (__e (), __v, (_Tp(*)(_Tp, _Tp))(&_Name))); \
972} \
973 \
974template<class _Dom> \
975inline _Expr<_BinFunClos<_ValArray,_Expr,typename _Dom::value_type,_Dom>, \
976 typename _Dom::value_type> \
977_Name (const valarray<typename _Dom::valarray>& __v, \
978 const _Expr<_Dom,typename _Dom::value_type>& __e) \
979{ \
980 typedef typename _Dom::value_type _Tp; \
981 typedef _BinFunClos<_ValArray,_Expr,_Tp,_Dom> _Closure; \
982 return _Expr<_Closure,_Tp> \
983 (_Closure (__v, __e (), (_Tp(*)(_Tp, _Tp))(&_Name))); \
984} \
985 \
986template<class _Dom> \
987inline _Expr<_BinFunClos<_Expr,_Constant,_Dom,typename _Dom::value_type>, \
988 typename _Dom::value_type> \
989_Name (const _Expr<_Dom, typename _Dom::value_type>& __e, \
990 const typename _Dom::value_type& __t) \
991{ \
992 typedef typename _Dom::value_type _Tp; \
993 typedef _BinFunClos<_Expr,_Constant,_Dom,_Tp> _Closure; \
994 return _Expr<_Closure,_Tp> \
995 (_Closure (__e (), __t, (_Tp(*)(_Tp, _Tp))(&_Name))); \
996} \
997 \
998template<class _Dom> \
999inline _Expr<_BinFunClos<_Constant,_Expr,typename _Dom::value_type,_Dom>, \
1000 typename _Dom::value_type> \
1001_Name (const typename _Dom::value_type& __t, \
1002 const _Expr<_Dom,typename _Dom::value_type>& __e) \
1003{ \
1004 typedef typename _Dom::value_type _Tp; \
1005 typedef _BinFunClos<_Constant,_Expr,_Tp,_Dom> _Closure; \
1006 return _Expr<_Closure,_Tp> \
1007 (_Closure (__t, __e (), (_Tp(*)(_Tp, _Tp))(&_Name))); \
1008} \
1009 \
1010template<typename _Tp> \
1011inline _Expr<_BinFunClos<_ValArray,_ValArray,_Tp,_Tp>, _Tp> \
1012_Name (const valarray<_Tp>& __v, const valarray<_Tp>& __w) \
1013{ \
1014 typedef _BinFunClos<_ValArray,_ValArray,_Tp,_Tp> _Closure; \
1015 return _Expr<_Closure,_Tp> \
1016 (_Closure (__v, __w, (_Tp(*)(_Tp,_Tp))(&_Name))); \
1017} \
1018 \
1019template<typename _Tp> \
1020inline _Expr<_BinFunClos<_ValArray,_Constant,_Tp,_Tp>,_Tp> \
1021_Name (const valarray<_Tp>& __v, const _Tp& __t) \
1022{ \
1023 typedef _BinFunClos<_ValArray,_Constant,_Tp,_Tp> _Closure; \
1024 return _Expr<_Closure,_Tp> \
1025 (_Closure (__v, __t, (_Tp(*)(_Tp,_Tp))(&_Name))); \
1026} \
1027 \
1028template<typename _Tp> \
1029inline _Expr<_BinFunClos<_Constant,_ValArray,_Tp,_Tp>,_Tp> \
1030_Name (const _Tp& __t, const valarray<_Tp>& __v) \
1031{ \
1032 typedef _BinFunClos<_Constant,_ValArray,_Tp,_Tp> _Closure; \
1033 return _Expr<_Closure,_Tp> \
1034 (_Closure (__t, __v, (_Tp(*)(_Tp,_Tp))(&_Name))); \
1035}
1036
1037_DEFINE_EXPR_BINARY_FUNCTION(atan2)
1038_DEFINE_EXPR_BINARY_FUNCTION(pow)
1039
1040#undef _DEFINE_EXPR_BINARY_FUNCTION
1041
1042#endif // _CPP_VALARRAY_META_H
1043
1044// Local Variables:
1045// mode:c++
1046// End:
GNU Compiler Collection
This page took 0.272268 seconds and 5 git commands to generate.