/elec/propeller-clock

To get this branch, use:
bzr branch http://bzr.ed.am/elec/propeller-clock

« back to all changes in this revision

Viewing changes to src/utility/valarray

  • Committer: edam
  • Date: 2012-02-25 14:54:33 UTC
  • Revision ID: edam@waxworlds.org-20120225145433-kih8qs45x05cum46
removed Bounce library and updated/fixed new code

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
1
/*      Copyright (C) 2004 Garrett A. Kajmowicz
 
2
 
 
3
        This file is part of the uClibc++ Library.
 
4
 
 
5
        This library is free software; you can redistribute it and/or
 
6
        modify it under the terms of the GNU Lesser General Public
 
7
        License as published by the Free Software Foundation; either
 
8
        version 2.1 of the License, or (at your option) any later version.
 
9
 
 
10
        This library is distributed in the hope that it will be useful,
 
11
        but WITHOUT ANY WARRANTY; without even the implied warranty of
 
12
        MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 
13
        Lesser General Public License for more details.
 
14
 
 
15
        You should have received a copy of the GNU Lesser General Public
 
16
        License along with this library; if not, write to the Free Software
 
17
        Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
18
*/
 
19
 
 
20
#include <basic_definitions>
 
21
 
 
22
#ifndef __HEADER_STD_VALARRAY
 
23
#define __HEADER_STD_VALARRAY 1
 
24
 
 
25
#include <cstddef>
 
26
#include <cmath>
 
27
 
 
28
#pragma GCC visibility push(default)
 
29
 
 
30
namespace std{
 
31
 
 
32
        template<class T> class valarray;
 
33
        class slice;
 
34
        template<class T> class slice_array;
 
35
        class gslice;
 
36
        template<class T> class gslice_array;
 
37
        template<class T> class mask_array;
 
38
        template<class T> class indirect_array;
 
39
 
 
40
        //Actual class definitions
 
41
 
 
42
 
 
43
        class _UCXXEXPORT slice {
 
44
        protected:
 
45
                size_t sta;
 
46
                size_t siz;
 
47
                size_t str;
 
48
 
 
49
        public:
 
50
                slice() : sta(0), siz(0), str(0){  }
 
51
                slice(size_t a, size_t b, size_t c) : sta(a), siz(b), str(c) {  }
 
52
                slice(const slice& s) : sta(s.sta), siz(s.siz), str(s.str) {  }
 
53
                ~slice() {  }
 
54
                size_t start() const{
 
55
                        return sta;
 
56
                }
 
57
                size_t size() const{
 
58
                        return siz;
 
59
                }
 
60
                size_t stride() const{
 
61
                        return str;
 
62
                }
 
63
        };
 
64
 
 
65
 
 
66
 
 
67
        template<class T> class _UCXXEXPORT valarray {
 
68
                friend class slice_array<T>;
 
69
        protected:
 
70
                T * data;
 
71
                size_t length;
 
72
 
 
73
        public:
 
74
                typedef T value_type;
 
75
 
 
76
                valarray() : data(0), length(0) {  }
 
77
 
 
78
                explicit valarray(size_t t) : data(0), length(t){
 
79
                        data = new T[length];
 
80
                }
 
81
 
 
82
                valarray(const T& v, size_t t) : data(0), length(t){
 
83
                        data = new T[length];
 
84
                        for(size_t i = 0; i < length; ++i){
 
85
                                data[i] = v;
 
86
                        }
 
87
                }
 
88
                valarray(const T* p, size_t t) : data(0), length(t) {
 
89
                        data = new T[length];
 
90
                        for(size_t i = 0; i < length; ++i){
 
91
                                data[i] = p[i];
 
92
                        }
 
93
                }
 
94
                valarray(const valarray& v) : data(0), length(v.length){
 
95
                        data = new T[length];
 
96
                        for(size_t i = 0; i < length; ++i){
 
97
                                data[i] = v.data[i];
 
98
                        }
 
99
                }
 
100
                valarray(const slice_array<T> & sa) : data(0), length(sa.s.size()){
 
101
                        data = new T[length];
 
102
                        for(unsigned int i = 0; i < length; ++i){
 
103
                                data[i] = sa.array->data[sa.s.start() + i * sa.s.stride()];
 
104
                        }
 
105
                }
 
106
                valarray(const gslice_array<T>&);
 
107
                valarray(const mask_array<T>&);
 
108
                valarray(const indirect_array<T>&);
 
109
                ~valarray(){
 
110
                        delete [] data;
 
111
                        data = 0;
 
112
                        length = 0;
 
113
                }
 
114
 
 
115
                valarray<T>& operator=(const valarray<T>& v){
 
116
                        for(size_t i =0; i< length; ++i){
 
117
                                data[i] = v.data[i];
 
118
                        }
 
119
                        return *this;
 
120
                }
 
121
                valarray<T>& operator=(const T& t){
 
122
                        for(size_t i = 0; i < length; ++i){
 
123
                                data[i] = t;
 
124
                        }
 
125
                        return *this;
 
126
                }
 
127
                valarray<T>& operator=(const slice_array<T>& sa){
 
128
                        for(size_t i =0; i < length; ++i){
 
129
                                data[i] = sa.data[sa.s.start() + i * sa.s.stride()];
 
130
                        }
 
131
                        return *this;
 
132
                }
 
133
                valarray<T>& operator=(const gslice_array<T>&);
 
134
                valarray<T>& operator=(const mask_array<T>&);
 
135
                valarray<T>& operator=(const indirect_array<T>&);
 
136
 
 
137
                T operator[](size_t t) const{
 
138
                        return data[t];
 
139
                }
 
140
                T& operator[](size_t t){
 
141
                        return data[t];
 
142
                }
 
143
 
 
144
                valarray<T> operator[](slice s) const{
 
145
                        valarray<T> retval(s.size());
 
146
                        for(unsigned int i = 0; i< s.size(); ++i){
 
147
                                retval.data[i] = data[s.start() + i * s.stride()];
 
148
                        }
 
149
                        return retval;
 
150
                }
 
151
 
 
152
                slice_array<T> operator[](slice sl){
 
153
                        slice_array<T> retval;
 
154
                        retval.s = sl;
 
155
                        retval.array = this;
 
156
                        return retval;
 
157
                }
 
158
 
 
159
                valarray<T> operator[](const gslice&) const;
 
160
                gslice_array<T> operator[](const gslice&);
 
161
                valarray<T> operator[](const valarray<bool>&) const;
 
162
                mask_array<T> operator[](const valarray<bool>&);
 
163
                valarray<T> operator[](const valarray<size_t>&) const;
 
164
                indirect_array<T> operator[](const valarray<size_t>&);
 
165
 
 
166
                valarray<T> operator+() const{
 
167
                        valarray<T> retval(length);
 
168
                        for(size_t i = 0; i< length ; ++i){
 
169
                                retval.data[i] = +data[i];
 
170
                        }
 
171
                        return retval;
 
172
                }
 
173
                valarray<T> operator-() const{
 
174
                        valarray<T> retval(length);
 
175
                        for(size_t i = 0; i< length; ++i){
 
176
                                retval.data[i] = -data[i];
 
177
                        }
 
178
                        return retval;
 
179
                }
 
180
                valarray<T> operator~() const{
 
181
                        valarray<T> retval(length);
 
182
                        for(size_t i = 0; i< length ; ++i){
 
183
                                retval.data[i] = ~data[i];
 
184
                        }
 
185
                        return retval;
 
186
                }
 
187
                valarray<T> operator!() const{
 
188
                        valarray<T> retval(length);
 
189
                        for(size_t i = 0; i< length ; ++i){
 
190
                                retval.data[i] = !data[i];
 
191
                        }
 
192
                        return retval;
 
193
                }
 
194
                valarray<T>& operator*= (const T& t){
 
195
                        for(size_t i=0;i<length;++i){
 
196
                                data[i] *= t;
 
197
                        }
 
198
                        return *this;
 
199
                }
 
200
                valarray<T>& operator/= (const T& t){
 
201
                        for(size_t i=0;i<length;++i){
 
202
                                data[i] /= t;
 
203
                        }
 
204
                        return *this;
 
205
                }
 
206
                valarray<T>& operator%= (const T& t){
 
207
                        for(size_t i=0;i<length;++i){
 
208
                                data[i] %= t;
 
209
                        }
 
210
                        return *this;
 
211
                }
 
212
                valarray<T>& operator+= (const T& t){
 
213
                        for(size_t i=0;i<length;++i){
 
214
                                data[i] += t;
 
215
                        }
 
216
                        return *this;
 
217
                }
 
218
                valarray<T>& operator-= (const T& t){
 
219
                        for(size_t i=0;i<length;++i){
 
220
                                data[i] -= t;
 
221
                        }
 
222
                        return *this;
 
223
                }
 
224
                valarray<T>& operator^= (const T& t){
 
225
                        for(size_t i=0;i<length;++i){
 
226
                                data[i] ^= t;
 
227
                        }
 
228
                        return *this;
 
229
                }
 
230
                valarray<T>& operator&= (const T& t){
 
231
                        for(size_t i=0;i<length;++i){
 
232
                                data[i] &= t;
 
233
                        }
 
234
                        return *this;
 
235
                }
 
236
                valarray<T>& operator|= (const T& t){
 
237
                        for(size_t i=0;i<length; ++i){
 
238
                                data[i] != t;
 
239
                        }
 
240
                        return *this;
 
241
                }
 
242
                valarray<T>& operator<<=(const T& t){
 
243
                        for(size_t i=0;i<length;++i){
 
244
                                data[i] <<= t;
 
245
                        }
 
246
                        return *this;
 
247
                }
 
248
                valarray<T>& operator>>=(const T& t){
 
249
                        for(size_t i=0;i<length;++i){
 
250
                                data[i] >>= t;
 
251
                        }
 
252
                        return *this;
 
253
                }
 
254
                valarray<T>& operator*= (const valarray<T>& a){
 
255
                        for(size_t i=0;i<length;++i){
 
256
                                data[i] *= a.data[i];
 
257
                        }
 
258
                        return *this;
 
259
                }
 
260
                valarray<T>& operator/= (const valarray<T>& a){
 
261
                        for(size_t i=0;i<length;++i){
 
262
                                data[i] /= a.data[i];
 
263
                        }
 
264
                        return *this;
 
265
                }
 
266
                valarray<T>& operator%= (const valarray<T>& a){
 
267
                        for(size_t i=0;i<length;++i){
 
268
                                data[i] %= a.data[i];
 
269
                        }
 
270
                        return *this;
 
271
                }
 
272
                valarray<T>& operator+= (const valarray<T>& a){
 
273
                        for(size_t i=0;i<length;++i){
 
274
                                data[i] += a.data[i];
 
275
                        }
 
276
                        return *this;
 
277
                }
 
278
                valarray<T>& operator-= (const valarray<T>& a){
 
279
                        for(size_t i=0;i<length ;++i){
 
280
                                data[i] -= a.data[i];
 
281
                        }
 
282
                        return *this;
 
283
                }
 
284
                valarray<T>& operator^= (const valarray<T>& a){
 
285
                        for(size_t i=0;i<length;++i){
 
286
                                data[i] ^= a.data[i];
 
287
                        }
 
288
                        return *this;
 
289
                }
 
290
                valarray<T>& operator|= (const valarray<T>& a){
 
291
                        for(size_t i=0;i<length ;++i){
 
292
                                data[i] |= a.data[i];
 
293
                        }
 
294
                        return *this;
 
295
                }
 
296
                valarray<T>& operator&= (const valarray<T>& a){
 
297
                        for(size_t i=0;i<length;++i){
 
298
                                data[i] &= a.data[i];
 
299
                        }
 
300
                        return *this;
 
301
                }
 
302
                valarray<T>& operator<<=(const valarray<T>& a){
 
303
                        for(size_t i=0;i<length;++i){
 
304
                                data[i] <<= a.data[i];
 
305
                        }
 
306
                        return *this;
 
307
                }
 
308
                valarray<T>& operator>>=(const valarray<T>& a){
 
309
                        for(size_t i=0;i<length;++i){
 
310
                                data[i] >>= a.data[i];
 
311
                        }
 
312
                        return *this;
 
313
                }
 
314
 
 
315
                size_t size() const{
 
316
                        return length;
 
317
                }
 
318
 
 
319
                T sum() const{
 
320
                        T retval(data[0]);
 
321
                        for(size_t i = 1; i< length; ++i){
 
322
                                retval += data[i];
 
323
                        }
 
324
                        return retval;
 
325
                }
 
326
 
 
327
                T min() const{
 
328
                        T retval(data[0]);
 
329
                        for(size_t i = 1; i< length; ++i){
 
330
                                if(data[i] < retval){
 
331
                                        retval = data[i];
 
332
                                }
 
333
                        }
 
334
                        return retval;
 
335
                }
 
336
 
 
337
                T max() const{
 
338
                        T retval(data[0]);
 
339
                        for(size_t i = 1; i< length; ++i){
 
340
                                if(retval < data[i]){
 
341
                                        retval = data[i];
 
342
                                }
 
343
                        }
 
344
                        return retval;
 
345
                }
 
346
 
 
347
                valarray<T> shift (int n) const{
 
348
                        valarray<T> retval(length);
 
349
                        for(size_t i = 0; i < length ; ++i){
 
350
                                if(i + n > 0  && i + n < length){
 
351
                                        retval.data[i] = data[i + n];
 
352
                                }
 
353
                        }
 
354
                        return retval;
 
355
                }
 
356
                valarray<T> cshift(int n) const{
 
357
                        valarray<T> retval(length);
 
358
                        for(size_t i = 0; i < length ; ++i){
 
359
                                retval.data[i] = data[ (i + n) % length ];
 
360
                        }
 
361
                        return retval;
 
362
                }
 
363
                valarray<T> apply(T func(T) ) const{
 
364
                        valarray<T> retval(length);
 
365
                        for(size_t i = 0; i< length; ++i){
 
366
                                retval.data[i] = func(data[i]);
 
367
                        }
 
368
                        return retval;
 
369
                }
 
370
                valarray<T> apply(T func(const T&)) const{
 
371
                        valarray<T> retval(length);
 
372
                        for(size_t i = 0; i< length; ++i){
 
373
                                retval.data[i] = func(data[i]);
 
374
                        }
 
375
                        return retval;
 
376
                }
 
377
                void resize(size_t sz, T c = T()){
 
378
                        delete [] data;
 
379
                        data = 0;
 
380
                        if(sz > 0){
 
381
                                data = new T[sz];
 
382
                                for(size_t i = 0; i < sz; ++i){
 
383
                                        data[i] = c;
 
384
                                }
 
385
                        }
 
386
                        length = sz;
 
387
                }
 
388
        };
 
389
 
 
390
 
 
391
 
 
392
        template <class T> class _UCXXEXPORT slice_array {
 
393
                friend class valarray<T>;
 
394
        public:
 
395
                typedef T value_type;
 
396
 
 
397
                void operator=  (const valarray<T>& v) const{
 
398
                        for(unsigned int i = 0; i < s.size(); ++i){
 
399
                                array->data[s.start() + i * s.stride()] = v[i];
 
400
                        }
 
401
                }
 
402
                void operator=  (const T & v){
 
403
                        for(unsigned int i = 0; i < s.size(); ++i){
 
404
                                array->data[s.start() + i * s.stride()] = v;
 
405
                        }
 
406
                }
 
407
                void fill(const T & v){
 
408
                        for(unsigned int i = 0; i < s.size(); ++i){
 
409
                                array->data[s.start() + i * s.stride()] = v;
 
410
                        }
 
411
                }
 
412
                void operator*= (const valarray<T>& v) const{
 
413
                        for(unsigned int i = 0; i < s.size(); ++i){
 
414
                                array->data[s.start() + i * s.stride()] *= v[i];
 
415
                        }
 
416
                }
 
417
                void operator/= (const valarray<T>& v) const{
 
418
                        for(unsigned int i = 0; i < s.size(); ++i){
 
419
                                array->data[s.start() + i * s.stride()] /= v[i];
 
420
                        }
 
421
                }
 
422
                void operator%= (const valarray<T>& v) const{
 
423
                        for(unsigned int i = 0; i < s.size(); ++i){
 
424
                                array->data[s.start() + i * s.stride()] %= v[i];
 
425
                        }
 
426
                }
 
427
                void operator+= (const valarray<T>& v) const{
 
428
                        for(unsigned int i = 0; i < s.size(); ++i){
 
429
                                array->data[s.start() + i * s.stride()] += v[i];
 
430
                        }
 
431
                }
 
432
                void operator-= (const valarray<T>& v) const{
 
433
                        for(unsigned int i = 0; i < s.size(); ++i){
 
434
                                array->data[s.start() + i * s.stride()] -= v[i];
 
435
                        }
 
436
                }
 
437
                void operator^= (const valarray<T>& v) const{
 
438
                        for(unsigned int i = 0; i < s.size(); ++i){
 
439
                                array->data[s.start() + i * s.stride()] ^= v[i];
 
440
                        }
 
441
                }
 
442
                void operator&= (const valarray<T>& v) const{
 
443
                        for(unsigned int i = 0; i < s.size(); ++i){
 
444
                                array->data[s.start() + i * s.stride()] &= v[i];
 
445
                        }
 
446
                }
 
447
                void operator|= (const valarray<T>& v) const{
 
448
                        for(unsigned int i = 0; i < s.size(); ++i){
 
449
                                array->data[s.start() + i * s.stride()] |= v[i];
 
450
                        }
 
451
                }
 
452
                void operator<<=(const valarray<T>& v) const{
 
453
                        for(unsigned int i = 0; i < s.size(); ++i){
 
454
                                array->data[s.start() + i * s.stride()] <<= v[i];
 
455
                        }
 
456
                }
 
457
                void operator>>=(const valarray<T>& v) const{
 
458
                        for(unsigned int i = 0; i < s.size(); ++i){
 
459
                                array->data[s.start() + i * s.stride()] >>= v[i];
 
460
                        }
 
461
                }
 
462
                ~slice_array(){
 
463
                        array = 0;
 
464
                }
 
465
 
 
466
        private:
 
467
                slice_array() : array(0){  }
 
468
 
 
469
        public:
 
470
                slice_array(const slice_array& sa) : array(sa.array), s(sa.s){  }
 
471
                slice_array& operator=(const slice_array& sa){
 
472
                        array = sa.array;
 
473
                        s = sa.s;
 
474
                }
 
475
 
 
476
        private:
 
477
                valarray<T> * array;
 
478
                slice s;
 
479
        };
 
480
 
 
481
 
 
482
        class _UCXXEXPORT gslice {
 
483
        private:
 
484
                size_t sta;
 
485
                valarray<size_t> siz;
 
486
                valarray<size_t> str;
 
487
 
 
488
        public:
 
489
                gslice() : sta(0) { }
 
490
                gslice(size_t s, const valarray<size_t>& l, const valarray<size_t>& d)
 
491
                        : sta(s), siz(l), str(d) {  }
 
492
 
 
493
                size_t start() const{
 
494
                        return sta;
 
495
                }
 
496
                valarray<size_t> size() const{
 
497
                        return siz;
 
498
                }
 
499
                valarray<size_t> stride() const{
 
500
                        return str;
 
501
                }
 
502
        };
 
503
 
 
504
        template <class T> class gslice_array {
 
505
        private:
 
506
                friend class valarray<T>;
 
507
 
 
508
        public:
 
509
                ~gslice_array();
 
510
 
 
511
                void operator=(const valarray<T>& array) const;
 
512
                void operator*=(const valarray<T>& array) const;
 
513
                void operator/=(const valarray<T>& array) const;
 
514
                void operator%=(const valarray<T>& array) const;
 
515
                void operator+=(const valarray<T>& array) const;
 
516
                void operator-=(const valarray<T>& array) const;
 
517
                void operator^=(const valarray<T>& array) const;
 
518
                void operator&=(const valarray<T>& array) const;
 
519
                void operator|=(const valarray<T>& array) const;
 
520
                void operator<<=(const valarray<T>& array) const;
 
521
                void operator>>=(const valarray<T>& array) const;
 
522
 
 
523
                void operator=(const T&);  
 
524
 
 
525
        private:
 
526
                gslice_array();
 
527
                gslice_array(const gslice_array<T>&);
 
528
                gslice_array<T>& operator= (const gslice_array<T>& array);
 
529
        };
 
530
 
 
531
 
 
532
 
 
533
        template<class T> valarray<T> operator* (const valarray<T>& lhs, const valarray<T>& rhs){
 
534
                valarray<T> retval(lhs);
 
535
                retval *= rhs;
 
536
                return retval;
 
537
        }
 
538
 
 
539
        template<class T> valarray<T> operator* (const valarray<T>& lhs, const T& rhs){
 
540
                valarray<T> retval(lhs);
 
541
                retval *= rhs;
 
542
                return retval;
 
543
        }
 
544
        template<class T> valarray<T> operator* (const T& lhs, const valarray<T>& rhs){
 
545
                valarray<T> retval(rhs);
 
546
                retval *= lhs;
 
547
                return retval;
 
548
        }
 
549
        template<class T> valarray<T> operator/ (const valarray<T>& lhs, const valarray<T>& rhs){
 
550
                valarray<T> retval(lhs);
 
551
                retval /= rhs;
 
552
                return retval;
 
553
        }
 
554
        template<class T> valarray<T> operator/ (const valarray<T>& lhs, const T& rhs){
 
555
                valarray<T> retval(lhs);
 
556
                retval /= rhs;
 
557
                return retval;
 
558
        }
 
559
        template<class T> valarray<T> operator/ (const T& lhs, const valarray<T>& rhs){
 
560
                valarray<T> retval(lhs, rhs.size());
 
561
                retval /= rhs;
 
562
                return retval;
 
563
        }
 
564
        template<class T> valarray<T> operator% (const valarray<T>& lhs, const valarray<T>& rhs){
 
565
                valarray<T> retval(lhs);
 
566
                retval %= rhs;
 
567
                return retval;
 
568
        }
 
569
        template<class T> valarray<T> operator% (const valarray<T>& lhs, const T& rhs){
 
570
                valarray<T> retval(lhs);
 
571
                retval %= rhs;
 
572
                return retval;
 
573
        }
 
574
        template<class T> valarray<T> operator% (const T& lhs, const valarray<T>& rhs){
 
575
                valarray<T> retval(lhs, rhs.size());
 
576
                retval %= rhs;
 
577
                return retval;
 
578
        }
 
579
        template<class T> valarray<T> operator+ (const valarray<T>& lhs, const valarray<T>& rhs){
 
580
                valarray<T> retval(lhs);
 
581
                retval += rhs;
 
582
                return retval;
 
583
        }
 
584
        template<class T> valarray<T> operator+ (const valarray<T>& lhs, const T& rhs){
 
585
                valarray<T> retval(lhs);
 
586
                retval += rhs;
 
587
                return retval;
 
588
        }
 
589
        template<class T> valarray<T> operator+ (const T& lhs, const valarray<T>& rhs){
 
590
                valarray<T> retval(lhs, rhs.size());
 
591
                retval += rhs;
 
592
                return retval;
 
593
        }
 
594
        template<class T> valarray<T> operator- (const valarray<T>& lhs, const valarray<T>& rhs){
 
595
                valarray<T> retval(lhs);
 
596
                retval -= rhs;
 
597
                return retval;
 
598
        }
 
599
        template<class T> valarray<T> operator- (const valarray<T>& lhs, const T& rhs){
 
600
                valarray<T> retval(lhs);
 
601
                retval-= rhs;
 
602
                return retval;
 
603
        }
 
604
        template<class T> valarray<T> operator- (const T& lhs, const valarray<T>& rhs){
 
605
                valarray<T> retval(lhs, rhs.size());
 
606
                retval -= rhs;
 
607
                return retval;
 
608
        }
 
609
        template<class T> valarray<T> operator^ (const valarray<T>& lhs, const valarray<T>& rhs){
 
610
                valarray<T> retval(lhs);
 
611
                retval ^= rhs;
 
612
                return retval;
 
613
        }
 
614
        template<class T> valarray<T> operator^ (const valarray<T>& lhs, const T& rhs){
 
615
                valarray<T> retval(lhs);
 
616
                retval ^= rhs;
 
617
                return retval;
 
618
        }
 
619
        template<class T> valarray<T> operator^ (const T& lhs, const valarray<T>& rhs){
 
620
                valarray<T> retval(lhs, rhs.size());
 
621
                retval ^= rhs;
 
622
                return retval;
 
623
        }
 
624
        template<class T> valarray<T> operator& (const valarray<T>& lhs, const valarray<T>& rhs){
 
625
                valarray<T> retval(lhs);
 
626
                retval &= rhs;
 
627
                return retval;
 
628
        }
 
629
        template<class T> valarray<T> operator& (const valarray<T>& lhs, const T& rhs){
 
630
                valarray<T> retval(lhs);
 
631
                retval &= rhs;
 
632
                return retval;
 
633
        }
 
634
        template<class T> valarray<T> operator& (const T& lhs, const valarray<T>& rhs){
 
635
                valarray<T> retval(lhs, rhs.size());
 
636
                retval &= rhs;
 
637
                return retval;
 
638
        }
 
639
        template<class T> valarray<T> operator| (const valarray<T>& lhs, const valarray<T>& rhs){
 
640
                valarray<T> retval(lhs);
 
641
                retval |= rhs;
 
642
                return retval;
 
643
        }
 
644
        template<class T> valarray<T> operator| (const valarray<T>& lhs, const T& rhs){
 
645
                valarray<T> retval(lhs);
 
646
                retval |= rhs;
 
647
                return retval;
 
648
        }
 
649
        template<class T> valarray<T> operator| (const T& lhs, const valarray<T>& rhs){
 
650
                valarray<T> retval(lhs, rhs.size());
 
651
                retval |= rhs;
 
652
                return retval;
 
653
        }
 
654
        template<class T> valarray<T> operator<<(const valarray<T>& lhs, const valarray<T>& rhs){
 
655
                valarray<T> retval(lhs);
 
656
                retval <<= rhs;
 
657
                return retval;
 
658
        }
 
659
        template<class T> valarray<T> operator<<(const valarray<T>& lhs, const T& rhs){
 
660
                valarray<T> retval(lhs);
 
661
                retval <<= rhs;
 
662
                return retval;
 
663
        }
 
664
        template<class T> valarray<T> operator<<(const T& lhs, const valarray<T>& rhs){
 
665
                valarray<T> retval(lhs, rhs.size());
 
666
                retval <<= rhs;
 
667
                return retval;
 
668
        }
 
669
        template<class T> valarray<T> operator>>(const valarray<T>& lhs, const valarray<T>& rhs){
 
670
                valarray<T> retval(lhs);
 
671
                retval >>= rhs;
 
672
                return retval;
 
673
        }
 
674
        template<class T> valarray<T> operator>>(const valarray<T>& lhs, const T& rhs){
 
675
                valarray<T> retval(lhs);
 
676
                retval >>= rhs;
 
677
                return retval;
 
678
        }
 
679
        template<class T> valarray<T> operator>>(const T& lhs, const valarray<T>& rhs){
 
680
                valarray<T> retval(lhs, rhs.size());
 
681
                retval >>= rhs;
 
682
                return retval;
 
683
        }
 
684
 
 
685
        template<class T> valarray<bool> operator&&(const valarray<T>& lhs, const valarray<T>& rhs){
 
686
                valarray<bool> retval(lhs.size());
 
687
                for(size_t i = 0; i < retval.size(); ++i){
 
688
                        retval[i] = lhs[i] && rhs[i];
 
689
                }
 
690
                return retval;
 
691
        }
 
692
        template<class T> valarray<bool> operator&&(const valarray<T>& lhs, const T& rhs){
 
693
                valarray<bool> retval(lhs.size());
 
694
                for(size_t i = 0; i <retval.size(); ++i){
 
695
                        retval[i] = lhs[i] && rhs;
 
696
                }
 
697
                return retval;
 
698
        }
 
699
        template<class T> valarray<bool> operator&&(const T& lhs, const valarray<T>& rhs){
 
700
                valarray<bool> retval(rhs.size());
 
701
                for(size_t i = 0; i <retval.size(); ++i){
 
702
                        retval[i] = lhs && rhs[i];
 
703
                }
 
704
                return retval;
 
705
        }
 
706
        template<class T> valarray<bool> operator||(const valarray<T>&lhs, const valarray<T>& rhs){
 
707
                valarray<bool> retval(lhs.size());
 
708
                for(size_t i = 0; i <retval.size(); ++i){
 
709
                        retval[i] = lhs[i] || rhs[i];
 
710
                }
 
711
                return retval;
 
712
        }
 
713
        template<class T> valarray<bool> operator||(const valarray<T>& lhs, const T& rhs){
 
714
                valarray<bool> retval(lhs.size());
 
715
                for(size_t i = 0; i <retval.size(); ++i){
 
716
                        retval[i] = lhs[i] || rhs;
 
717
                }
 
718
                return retval;
 
719
        }
 
720
        template<class T> valarray<bool> operator||(const T& lhs, const valarray<T>& rhs){
 
721
                valarray<bool> retval(rhs.size());
 
722
                for(size_t i = 0; i < retval.size(); ++i){
 
723
                        retval[i] = lhs || rhs[i];
 
724
                }
 
725
                return retval;
 
726
        }
 
727
 
 
728
        template<class T> valarray<bool> operator==(const valarray<T>& lhs, const valarray<T>& rhs){
 
729
                valarray<bool> retval(lhs.size());
 
730
                for(size_t i = 0; i <retval.size(); ++i){
 
731
                        retval[i] = lhs[i] == rhs[i];
 
732
                }
 
733
                return retval;
 
734
        }
 
735
        template<class T> valarray<bool> operator==(const valarray<T>& lhs, const T& rhs){
 
736
                valarray<bool> retval(lhs.size());
 
737
                for(size_t i = 0; i < retval.size(); ++i){
 
738
                        retval[i] = lhs[i] == rhs;
 
739
                }
 
740
                return retval;
 
741
        }
 
742
        template<class T> valarray<bool> operator==(const T& lhs, const valarray<T>& rhs){
 
743
                valarray<bool> retval(rhs.size());
 
744
                for(size_t i = 0; i < retval.size(); ++i){
 
745
                        retval[i] = lhs == rhs[i];
 
746
                }
 
747
                return retval;
 
748
        }
 
749
        template<class T> valarray<bool> operator!=(const valarray<T>& lhs, const valarray<T>& rhs){
 
750
                valarray<bool> retval(lhs.size());
 
751
                for(size_t i = 0; i <retval.size(); ++i){
 
752
                        retval[i] = lhs[i] != rhs[i];
 
753
                }
 
754
                return retval;
 
755
        }
 
756
        template<class T> valarray<bool> operator!=(const valarray<T>& lhs, const T& rhs){
 
757
                valarray<bool> retval(lhs.size());
 
758
                for(size_t i = 0; i <retval.size(); ++i){
 
759
                        retval[i] = lhs[i] != rhs;
 
760
                }
 
761
                return retval;
 
762
        }
 
763
        template<class T> valarray<bool> operator!=(const T& lhs, const valarray<T>& rhs){
 
764
                valarray<bool> retval(rhs.size());
 
765
                for(size_t i = 0; i <retval.size(); ++i){
 
766
                        retval[i] = lhs != rhs[i];
 
767
                }
 
768
                return retval;
 
769
        }
 
770
        template<class T> valarray<bool> operator< (const valarray<T>& lhs, const valarray<T>& rhs){
 
771
                valarray<bool> retval(lhs.size());
 
772
                for(size_t i = 0; i <retval.size(); ++i){
 
773
                        retval[i] = lhs[i] < rhs[i];
 
774
                }
 
775
                return retval;
 
776
        }
 
777
        template<class T> valarray<bool> operator< (const valarray<T>& lhs, const T& rhs){
 
778
                valarray<bool> retval(lhs.size());
 
779
                for(size_t i = 0; i <retval.size(); ++i){
 
780
                        retval[i] = lhs[i] < rhs;
 
781
                }
 
782
                return retval;
 
783
        }
 
784
        template<class T> valarray<bool> operator< (const T& lhs, const valarray<T>& rhs){
 
785
                valarray<bool> retval(rhs.size());
 
786
                for(size_t i = 0; i <retval.size(); ++i){
 
787
                        retval[i] = lhs < rhs[i];
 
788
                }
 
789
                return retval;
 
790
        }
 
791
        template<class T> valarray<bool> operator> (const valarray<T>& lhs, const valarray<T>& rhs){
 
792
                valarray<bool> retval(lhs.size());
 
793
                for(size_t i = 0; i <retval.size(); ++i){
 
794
                        retval[i] = lhs[i] > rhs[i];
 
795
                }
 
796
                return retval;
 
797
        }
 
798
        template<class T> valarray<bool> operator> (const valarray<T>& lhs, const T& rhs){
 
799
                valarray<bool> retval(lhs.size());
 
800
                for(size_t i = 0; i <retval.size(); ++i){
 
801
                        retval[i] = lhs[i] > rhs;
 
802
                }
 
803
                return retval;
 
804
        }
 
805
        template<class T> valarray<bool> operator> (const T& rhs, const valarray<T>& lhs){
 
806
                valarray<bool> retval(rhs.size());
 
807
                for(size_t i = 0; i <retval.size(); ++i){
 
808
                        retval[i] = lhs > rhs[i];
 
809
                }
 
810
                return retval;
 
811
        }
 
812
        template<class T> valarray<bool> operator<=(const valarray<T>& lhs, const valarray<T>& rhs){
 
813
                valarray<bool> retval(lhs.size());
 
814
                for(size_t i = 0; i <retval.size(); ++i){
 
815
                        retval[i] = lhs[i] <= rhs[i];
 
816
                }
 
817
                return retval;
 
818
        }
 
819
        template<class T> valarray<bool> operator<=(const valarray<T>& lhs, const T& rhs){
 
820
                valarray<bool> retval(lhs.size());
 
821
                for(size_t i = 0; i <retval.size(); ++i){
 
822
                        retval[i] = lhs[i] <= rhs;
 
823
                }
 
824
                return retval;
 
825
        }
 
826
        template<class T> valarray<bool> operator<=(const T& lhs, const valarray<T>& rhs){
 
827
                valarray<bool> retval(rhs.size());
 
828
                for(size_t i = 0; i <retval.size(); ++i){
 
829
                        retval[i] = lhs <= rhs[i];
 
830
                }
 
831
                return retval;
 
832
        }
 
833
        template<class T> valarray<bool> operator>=(const valarray<T>& lhs, const valarray<T>& rhs){
 
834
                valarray<bool> retval(lhs.size());
 
835
                for(size_t i = 0; i <retval.size(); ++i){
 
836
                        retval[i] = lhs[i] >= rhs[i];
 
837
                }
 
838
                return retval;
 
839
        }
 
840
        template<class T> valarray<bool> operator>=(const valarray<T>& lhs, const T& rhs){
 
841
                valarray<bool> retval(lhs.size());
 
842
                for(size_t i = 0; i <retval.size(); ++i){
 
843
                        retval[i] = lhs[i] >= rhs;
 
844
                }
 
845
                return retval;
 
846
        }
 
847
        template<class T> valarray<bool> operator>=(const T& lhs, const valarray<T>& rhs){
 
848
                valarray<bool> retval(rhs.size());
 
849
                for(size_t i = 0; i <retval.size(); ++i){
 
850
                        retval[i] = lhs >= rhs[i];
 
851
                }
 
852
                return retval;
 
853
        }
 
854
        template<class T> T min(const valarray<T>& x){
 
855
                T retval(x[0]);
 
856
                for(size_t i = 1; i < x.size(); ++i){
 
857
                        if(x[i] < retval){
 
858
                                retval = x[i];
 
859
                        }
 
860
                }
 
861
        }
 
862
        template<class T> T max(const valarray<T>& x){
 
863
                T retval(x[0]);
 
864
                for(size_t i = 1; i < x.size(); ++i){
 
865
                        if(x[i] > retval){
 
866
                                retval = x[i];
 
867
                        }
 
868
                }
 
869
        }
 
870
 
 
871
        template<class T> valarray<T> abs  (const valarray<T>& x){
 
872
                valarray<T> retval(x.size());
 
873
                for(size_t i = 0; i < retval.size(); ++i){
 
874
                        retval[i] = abs(x[i]);
 
875
                }
 
876
        }
 
877
        template<class T> valarray<T> acos (const valarray<T>& x){
 
878
                valarray<T> retval(x.size());
 
879
                for(size_t i = 0; i < retval.size(); ++i){
 
880
                        retval[i] = acos(x[i]);
 
881
                }
 
882
        }
 
883
        template<class T> valarray<T> asin (const valarray<T>& x){
 
884
                valarray<T> retval(x.size());
 
885
                for(size_t i = 0; i < retval.size(); ++i){
 
886
                        retval[i] = asin(x[i]);
 
887
                }
 
888
        }
 
889
        template<class T> valarray<T> atan (const valarray<T>& x){
 
890
                valarray<T> retval(x.size());
 
891
                for(size_t i = 0; i < retval.size(); ++i){
 
892
                        retval[i] = atan(x[i]);
 
893
                }
 
894
        }
 
895
        template<class T> valarray<T> atan2(const valarray<T>& y, const valarray<T>& x){
 
896
                valarray<T> retval(y.size());
 
897
                for(size_t i = 0; i < retval.size(); ++i){
 
898
                        retval[i] = atan2(y[i], x[i]);
 
899
                }
 
900
        }
 
901
        template<class T> valarray<T> atan2(const valarray<T>& y, const T& x){
 
902
                valarray<T> retval(y.size());
 
903
                for(size_t i = 0; i < retval.size(); ++i){
 
904
                        retval[i] = atan2(y[i], x);
 
905
                }
 
906
        }
 
907
        template<class T> valarray<T> atan2(const T& y, const valarray<T>& x){
 
908
                valarray<T> retval(x.size());
 
909
                for(size_t i = 0; i < retval.size(); ++i){
 
910
                        retval[i] = abs(y, x[i]);
 
911
                }
 
912
        }
 
913
        template<class T> valarray<T> cos  (const valarray<T>& x){
 
914
                valarray<T> retval(x.size());
 
915
                for(size_t i = 0; i < retval.size(); ++i){
 
916
                        retval[i] = cos(x[i]);
 
917
                }
 
918
        }
 
919
        template<class T> valarray<T> cosh (const valarray<T>& x){
 
920
                valarray<T> retval(x.size());
 
921
                for(size_t i = 0; i < retval.size(); ++i){
 
922
                        retval[i] = cosh(x[i]);
 
923
                }
 
924
        }
 
925
        template<class T> valarray<T> exp  (const valarray<T>& x){
 
926
                valarray<T> retval(x.size());
 
927
                for(size_t i = 0; i < retval.size(); ++i){
 
928
                        retval[i] = exp(x[i]);
 
929
                }
 
930
        }
 
931
        template<class T> valarray<T> log  (const valarray<T>& x){
 
932
                valarray<T> retval(x.size());
 
933
                for(size_t i = 0; i < retval.size(); ++i){
 
934
                        retval[i] = log(x[i]);
 
935
                }
 
936
        }
 
937
        template<class T> valarray<T> log10(const valarray<T>& x){
 
938
                valarray<T> retval(x.size());
 
939
                for(size_t i = 0; i < retval.size(); ++i){
 
940
                        retval[i] = log10(x[i]);
 
941
                }
 
942
        }
 
943
        template<class T> valarray<T> pow (const valarray<T>& x, const valarray<T>& y){
 
944
                valarray<T> retval(x.size());
 
945
                for(size_t i = 0; i < retval.size(); ++i){
 
946
                        retval[i] = pow(x[i], y[i]);
 
947
                }
 
948
        }
 
949
        template<class T> valarray<T> pow  (const valarray<T>& x, const T& y){
 
950
                valarray<T> retval(x.size());
 
951
                for(size_t i = 0; i < retval.size(); ++i){
 
952
                        retval[i] = pow(x[i], y);
 
953
                }
 
954
        }
 
955
        template<class T> valarray<T> pow  (const T& x, const valarray<T>& y){
 
956
                valarray<T> retval(x.size());
 
957
                for(size_t i = 0; i < retval.size(); ++i){
 
958
                        retval[i] = pow(x, y[i]);
 
959
                }
 
960
        }
 
961
        template<class T> valarray<T> sin  (const valarray<T>& x){
 
962
                valarray<T> retval(x.size());
 
963
                for(size_t i = 0; i < retval.size(); ++i){
 
964
                        retval[i] = sin(x[i]);
 
965
                }
 
966
        }
 
967
        template<class T> valarray<T> sinh (const valarray<T>& x){
 
968
                valarray<T> retval(x.size());
 
969
                for(size_t i = 0; i < retval.size(); ++i){
 
970
                        retval[i] = sinh(x[i]);
 
971
                }
 
972
        }
 
973
        template<class T> valarray<T> sqrt (const valarray<T>& x){
 
974
                valarray<T> retval(x.size());
 
975
                for(size_t i = 0; i < retval.size(); ++i){
 
976
                        retval[i] = sqrt(x[i]);
 
977
                }
 
978
        }
 
979
        template<class T> valarray<T> tan  (const valarray<T>& x){
 
980
                valarray<T> retval(x.size());
 
981
                for(size_t i = 0; i < retval.size(); ++i){
 
982
                        retval[i] = tan(x[i]);
 
983
                }
 
984
        }
 
985
        template<class T> valarray<T> tanh (const valarray<T>& x){
 
986
                valarray<T> retval(x.size());
 
987
                for(size_t i = 0; i < retval.size(); ++i){
 
988
                        retval[i] = tanh(x[i]);
 
989
                }
 
990
        }
 
991
        
 
992
}
 
993
 
 
994
#pragma GCC visibility pop
 
995
 
 
996
#endif