00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037 #ifndef _GLIBCXX_VALARRAY
00038 #define _GLIBCXX_VALARRAY 1
00039
00040 #pragma GCC system_header
00041
00042 #include <bits/c++config.h>
00043 #include <cstddef>
00044 #include <cmath>
00045 #include <cstdlib>
00046 #include <numeric>
00047 #include <algorithm>
00048 #include <debug/debug.h>
00049
00050 _GLIBCXX_BEGIN_NAMESPACE(std)
00051
00052 template<class _Clos, typename _Tp>
00053 class _Expr;
00054
00055 template<typename _Tp1, typename _Tp2>
00056 class _ValArray;
00057
00058 template<class _Oper, template<class, class> class _Meta, class _Dom>
00059 struct _UnClos;
00060
00061 template<class _Oper,
00062 template<class, class> class _Meta1,
00063 template<class, class> class _Meta2,
00064 class _Dom1, class _Dom2>
00065 class _BinClos;
00066
00067 template<template<class, class> class _Meta, class _Dom>
00068 class _SClos;
00069
00070 template<template<class, class> class _Meta, class _Dom>
00071 class _GClos;
00072
00073 template<template<class, class> class _Meta, class _Dom>
00074 class _IClos;
00075
00076 template<template<class, class> class _Meta, class _Dom>
00077 class _ValFunClos;
00078
00079 template<template<class, class> class _Meta, class _Dom>
00080 class _RefFunClos;
00081
00082 template<class _Tp> class valarray;
00083 class slice;
00084 template<class _Tp> class slice_array;
00085 class gslice;
00086 template<class _Tp> class gslice_array;
00087 template<class _Tp> class mask_array;
00088 template<class _Tp> class indirect_array;
00089
00090 _GLIBCXX_END_NAMESPACE
00091
00092 #include <bits/valarray_array.h>
00093 #include <bits/valarray_before.h>
00094
00095 _GLIBCXX_BEGIN_NAMESPACE(std)
00096
00097
00098
00099
00100
00101
00102
00103
00104
00105
00106
00107
00108 template<class _Tp>
00109 class valarray
00110 {
00111 template<class _Op>
00112 struct _UnaryOp
00113 {
00114 typedef typename __fun<_Op, _Tp>::result_type __rt;
00115 typedef _Expr<_UnClos<_Op, _ValArray, _Tp>, __rt> _Rt;
00116 };
00117 public:
00118 typedef _Tp value_type;
00119
00120
00121
00122 valarray();
00123
00124
00125 explicit valarray(size_t);
00126
00127
00128 valarray(const _Tp&, size_t);
00129
00130
00131 valarray(const _Tp* __restrict__, size_t);
00132
00133
00134 valarray(const valarray&);
00135
00136
00137 valarray(const slice_array<_Tp>&);
00138
00139
00140 valarray(const gslice_array<_Tp>&);
00141
00142
00143 valarray(const mask_array<_Tp>&);
00144
00145
00146 valarray(const indirect_array<_Tp>&);
00147
00148 template<class _Dom>
00149 valarray(const _Expr<_Dom, _Tp>& __e);
00150
00151 ~valarray();
00152
00153
00154
00155
00156
00157
00158
00159
00160
00161
00162 valarray<_Tp>& operator=(const valarray<_Tp>&);
00163
00164
00165
00166
00167
00168
00169
00170
00171 valarray<_Tp>& operator=(const _Tp&);
00172
00173
00174
00175
00176
00177
00178
00179
00180
00181 valarray<_Tp>& operator=(const slice_array<_Tp>&);
00182
00183
00184
00185
00186
00187
00188
00189
00190
00191 valarray<_Tp>& operator=(const gslice_array<_Tp>&);
00192
00193
00194
00195
00196
00197
00198
00199
00200
00201 valarray<_Tp>& operator=(const mask_array<_Tp>&);
00202
00203
00204
00205
00206
00207
00208
00209
00210
00211 valarray<_Tp>& operator=(const indirect_array<_Tp>&);
00212
00213 template<class _Dom> valarray<_Tp>&
00214 operator= (const _Expr<_Dom, _Tp>&);
00215
00216
00217
00218
00219
00220
00221
00222
00223 _Tp& operator[](size_t);
00224
00225
00226
00227 const _Tp& operator[](size_t) const;
00228
00229
00230
00231
00232
00233
00234
00235
00236
00237
00238
00239
00240 _Expr<_SClos<_ValArray, _Tp>, _Tp> operator[](slice) const;
00241
00242
00243
00244
00245
00246
00247
00248
00249
00250
00251
00252 slice_array<_Tp> operator[](slice);
00253
00254
00255
00256
00257
00258
00259
00260
00261
00262
00263 _Expr<_GClos<_ValArray, _Tp>, _Tp> operator[](const gslice&) const;
00264
00265
00266
00267
00268
00269
00270
00271
00272
00273
00274
00275 gslice_array<_Tp> operator[](const gslice&);
00276
00277
00278
00279
00280
00281
00282
00283
00284
00285
00286
00287
00288
00289 valarray<_Tp> operator[](const valarray<bool>&) const;
00290
00291
00292
00293
00294
00295
00296
00297
00298
00299
00300
00301
00302
00303 mask_array<_Tp> operator[](const valarray<bool>&);
00304
00305
00306
00307
00308
00309
00310
00311
00312
00313
00314
00315
00316 _Expr<_IClos<_ValArray, _Tp>, _Tp>
00317 operator[](const valarray<size_t>&) const;
00318
00319
00320
00321
00322
00323
00324
00325
00326
00327
00328
00329
00330
00331 indirect_array<_Tp> operator[](const valarray<size_t>&);
00332
00333
00334
00335 typename _UnaryOp<__unary_plus>::_Rt operator+() const;
00336
00337
00338 typename _UnaryOp<__negate>::_Rt operator-() const;
00339
00340
00341 typename _UnaryOp<__bitwise_not>::_Rt operator~() const;
00342
00343
00344 typename _UnaryOp<__logical_not>::_Rt operator!() const;
00345
00346
00347
00348 valarray<_Tp>& operator*=(const _Tp&);
00349
00350
00351 valarray<_Tp>& operator/=(const _Tp&);
00352
00353
00354 valarray<_Tp>& operator%=(const _Tp&);
00355
00356
00357 valarray<_Tp>& operator+=(const _Tp&);
00358
00359
00360 valarray<_Tp>& operator-=(const _Tp&);
00361
00362
00363 valarray<_Tp>& operator^=(const _Tp&);
00364
00365
00366 valarray<_Tp>& operator&=(const _Tp&);
00367
00368
00369 valarray<_Tp>& operator|=(const _Tp&);
00370
00371
00372 valarray<_Tp>& operator<<=(const _Tp&);
00373
00374
00375 valarray<_Tp>& operator>>=(const _Tp&);
00376
00377
00378 valarray<_Tp>& operator*=(const valarray<_Tp>&);
00379
00380
00381 valarray<_Tp>& operator/=(const valarray<_Tp>&);
00382
00383
00384 valarray<_Tp>& operator%=(const valarray<_Tp>&);
00385
00386
00387 valarray<_Tp>& operator+=(const valarray<_Tp>&);
00388
00389
00390 valarray<_Tp>& operator-=(const valarray<_Tp>&);
00391
00392
00393 valarray<_Tp>& operator^=(const valarray<_Tp>&);
00394
00395
00396 valarray<_Tp>& operator|=(const valarray<_Tp>&);
00397
00398
00399 valarray<_Tp>& operator&=(const valarray<_Tp>&);
00400
00401
00402 valarray<_Tp>& operator<<=(const valarray<_Tp>&);
00403
00404
00405 valarray<_Tp>& operator>>=(const valarray<_Tp>&);
00406
00407 template<class _Dom>
00408 valarray<_Tp>& operator*=(const _Expr<_Dom, _Tp>&);
00409 template<class _Dom>
00410 valarray<_Tp>& operator/=(const _Expr<_Dom, _Tp>&);
00411 template<class _Dom>
00412 valarray<_Tp>& operator%=(const _Expr<_Dom, _Tp>&);
00413 template<class _Dom>
00414 valarray<_Tp>& operator+=(const _Expr<_Dom, _Tp>&);
00415 template<class _Dom>
00416 valarray<_Tp>& operator-=(const _Expr<_Dom, _Tp>&);
00417 template<class _Dom>
00418 valarray<_Tp>& operator^=(const _Expr<_Dom, _Tp>&);
00419 template<class _Dom>
00420 valarray<_Tp>& operator|=(const _Expr<_Dom, _Tp>&);
00421 template<class _Dom>
00422 valarray<_Tp>& operator&=(const _Expr<_Dom, _Tp>&);
00423 template<class _Dom>
00424 valarray<_Tp>& operator<<=(const _Expr<_Dom, _Tp>&);
00425 template<class _Dom>
00426 valarray<_Tp>& operator>>=(const _Expr<_Dom, _Tp>&);
00427
00428
00429
00430 size_t size() const;
00431
00432
00433
00434
00435
00436
00437
00438 _Tp sum() const;
00439
00440
00441 _Tp min() const;
00442
00443
00444 _Tp max() const;
00445
00446
00447
00448
00449
00450
00451
00452
00453
00454
00455
00456
00457
00458
00459
00460
00461 valarray<_Tp> shift (int) const;
00462
00463
00464
00465
00466
00467
00468
00469
00470
00471
00472
00473
00474
00475
00476
00477
00478 valarray<_Tp> cshift(int) const;
00479
00480
00481
00482
00483
00484
00485
00486
00487
00488
00489
00490 _Expr<_ValFunClos<_ValArray, _Tp>, _Tp> apply(_Tp func(_Tp)) const;
00491
00492
00493
00494
00495
00496
00497
00498
00499
00500
00501
00502 _Expr<_RefFunClos<_ValArray, _Tp>, _Tp> apply(_Tp func(const _Tp&)) const;
00503
00504
00505
00506
00507
00508
00509
00510
00511
00512
00513 void resize(size_t __size, _Tp __c = _Tp());
00514
00515 private:
00516 size_t _M_size;
00517 _Tp* __restrict__ _M_data;
00518
00519 friend class _Array<_Tp>;
00520 };
00521
00522 template<typename _Tp>
00523 inline const _Tp&
00524 valarray<_Tp>::operator[](size_t __i) const
00525 {
00526 __glibcxx_requires_subscript(__i);
00527 return _M_data[__i];
00528 }
00529
00530 template<typename _Tp>
00531 inline _Tp&
00532 valarray<_Tp>::operator[](size_t __i)
00533 {
00534 __glibcxx_requires_subscript(__i);
00535 return _M_data[__i];
00536 }
00537
00538 _GLIBCXX_END_NAMESPACE
00539
00540 #include <bits/valarray_after.h>
00541 #include <bits/slice_array.h>
00542 #include <bits/gslice.h>
00543 #include <bits/gslice_array.h>
00544 #include <bits/mask_array.h>
00545 #include <bits/indirect_array.h>
00546
00547 _GLIBCXX_BEGIN_NAMESPACE(std)
00548
00549 template<typename _Tp>
00550 inline
00551 valarray<_Tp>::valarray() : _M_size(0), _M_data(0) {}
00552
00553 template<typename _Tp>
00554 inline
00555 valarray<_Tp>::valarray(size_t __n)
00556 : _M_size(__n), _M_data(__valarray_get_storage<_Tp>(__n))
00557 { std::__valarray_default_construct(_M_data, _M_data + __n); }
00558
00559 template<typename _Tp>
00560 inline
00561 valarray<_Tp>::valarray(const _Tp& __t, size_t __n)
00562 : _M_size(__n), _M_data(__valarray_get_storage<_Tp>(__n))
00563 { std::__valarray_fill_construct(_M_data, _M_data + __n, __t); }
00564
00565 template<typename _Tp>
00566 inline
00567 valarray<_Tp>::valarray(const _Tp* __restrict__ __p, size_t __n)
00568 : _M_size(__n), _M_data(__valarray_get_storage<_Tp>(__n))
00569 {
00570 _GLIBCXX_DEBUG_ASSERT(__p != 0 || __n == 0);
00571 std::__valarray_copy_construct(__p, __p + __n, _M_data);
00572 }
00573
00574 template<typename _Tp>
00575 inline
00576 valarray<_Tp>::valarray(const valarray<_Tp>& __v)
00577 : _M_size(__v._M_size), _M_data(__valarray_get_storage<_Tp>(__v._M_size))
00578 { std::__valarray_copy_construct(__v._M_data, __v._M_data + _M_size,
00579 _M_data); }
00580
00581 template<typename _Tp>
00582 inline
00583 valarray<_Tp>::valarray(const slice_array<_Tp>& __sa)
00584 : _M_size(__sa._M_sz), _M_data(__valarray_get_storage<_Tp>(__sa._M_sz))
00585 {
00586 std::__valarray_copy_construct
00587 (__sa._M_array, __sa._M_sz, __sa._M_stride, _Array<_Tp>(_M_data));
00588 }
00589
00590 template<typename _Tp>
00591 inline
00592 valarray<_Tp>::valarray(const gslice_array<_Tp>& __ga)
00593 : _M_size(__ga._M_index.size()),
00594 _M_data(__valarray_get_storage<_Tp>(_M_size))
00595 {
00596 std::__valarray_copy_construct
00597 (__ga._M_array, _Array<size_t>(__ga._M_index),
00598 _Array<_Tp>(_M_data), _M_size);
00599 }
00600
00601 template<typename _Tp>
00602 inline
00603 valarray<_Tp>::valarray(const mask_array<_Tp>& __ma)
00604 : _M_size(__ma._M_sz), _M_data(__valarray_get_storage<_Tp>(__ma._M_sz))
00605 {
00606 std::__valarray_copy_construct
00607 (__ma._M_array, __ma._M_mask, _Array<_Tp>(_M_data), _M_size);
00608 }
00609
00610 template<typename _Tp>
00611 inline
00612 valarray<_Tp>::valarray(const indirect_array<_Tp>& __ia)
00613 : _M_size(__ia._M_sz), _M_data(__valarray_get_storage<_Tp>(__ia._M_sz))
00614 {
00615 std::__valarray_copy_construct
00616 (__ia._M_array, __ia._M_index, _Array<_Tp>(_M_data), _M_size);
00617 }
00618
00619 template<typename _Tp> template<class _Dom>
00620 inline
00621 valarray<_Tp>::valarray(const _Expr<_Dom, _Tp>& __e)
00622 : _M_size(__e.size()), _M_data(__valarray_get_storage<_Tp>(_M_size))
00623 { std::__valarray_copy_construct(__e, _M_size, _Array<_Tp>(_M_data)); }
00624
00625 template<typename _Tp>
00626 inline
00627 valarray<_Tp>::~valarray()
00628 {
00629 std::__valarray_destroy_elements(_M_data, _M_data + _M_size);
00630 std::__valarray_release_memory(_M_data);
00631 }
00632
00633 template<typename _Tp>
00634 inline valarray<_Tp>&
00635 valarray<_Tp>::operator=(const valarray<_Tp>& __v)
00636 {
00637 _GLIBCXX_DEBUG_ASSERT(_M_size == __v._M_size);
00638 std::__valarray_copy(__v._M_data, _M_size, _M_data);
00639 return *this;
00640 }
00641
00642 template<typename _Tp>
00643 inline valarray<_Tp>&
00644 valarray<_Tp>::operator=(const _Tp& __t)
00645 {
00646 std::__valarray_fill(_M_data, _M_size, __t);
00647 return *this;
00648 }
00649
00650 template<typename _Tp>
00651 inline valarray<_Tp>&
00652 valarray<_Tp>::operator=(const slice_array<_Tp>& __sa)
00653 {
00654 _GLIBCXX_DEBUG_ASSERT(_M_size == __sa._M_sz);
00655 std::__valarray_copy(__sa._M_array, __sa._M_sz,
00656 __sa._M_stride, _Array<_Tp>(_M_data));
00657 return *this;
00658 }
00659
00660 template<typename _Tp>
00661 inline valarray<_Tp>&
00662 valarray<_Tp>::operator=(const gslice_array<_Tp>& __ga)
00663 {
00664 _GLIBCXX_DEBUG_ASSERT(_M_size == __ga._M_index.size());
00665 std::__valarray_copy(__ga._M_array, _Array<size_t>(__ga._M_index),
00666 _Array<_Tp>(_M_data), _M_size);
00667 return *this;
00668 }
00669
00670 template<typename _Tp>
00671 inline valarray<_Tp>&
00672 valarray<_Tp>::operator=(const mask_array<_Tp>& __ma)
00673 {
00674 _GLIBCXX_DEBUG_ASSERT(_M_size == __ma._M_sz);
00675 std::__valarray_copy(__ma._M_array, __ma._M_mask,
00676 _Array<_Tp>(_M_data), _M_size);
00677 return *this;
00678 }
00679
00680 template<typename _Tp>
00681 inline valarray<_Tp>&
00682 valarray<_Tp>::operator=(const indirect_array<_Tp>& __ia)
00683 {
00684 _GLIBCXX_DEBUG_ASSERT(_M_size == __ia._M_sz);
00685 std::__valarray_copy(__ia._M_array, __ia._M_index,
00686 _Array<_Tp>(_M_data), _M_size);
00687 return *this;
00688 }
00689
00690 template<typename _Tp> template<class _Dom>
00691 inline valarray<_Tp>&
00692 valarray<_Tp>::operator=(const _Expr<_Dom, _Tp>& __e)
00693 {
00694 _GLIBCXX_DEBUG_ASSERT(_M_size == __e.size());
00695 std::__valarray_copy(__e, _M_size, _Array<_Tp>(_M_data));
00696 return *this;
00697 }
00698
00699 template<typename _Tp>
00700 inline _Expr<_SClos<_ValArray,_Tp>, _Tp>
00701 valarray<_Tp>::operator[](slice __s) const
00702 {
00703 typedef _SClos<_ValArray,_Tp> _Closure;
00704 return _Expr<_Closure, _Tp>(_Closure (_Array<_Tp>(_M_data), __s));
00705 }
00706
00707 template<typename _Tp>
00708 inline slice_array<_Tp>
00709 valarray<_Tp>::operator[](slice __s)
00710 { return slice_array<_Tp>(_Array<_Tp>(_M_data), __s); }
00711
00712 template<typename _Tp>
00713 inline _Expr<_GClos<_ValArray,_Tp>, _Tp>
00714 valarray<_Tp>::operator[](const gslice& __gs) const
00715 {
00716 typedef _GClos<_ValArray,_Tp> _Closure;
00717 return _Expr<_Closure, _Tp>
00718 (_Closure(_Array<_Tp>(_M_data), __gs._M_index->_M_index));
00719 }
00720
00721 template<typename _Tp>
00722 inline gslice_array<_Tp>
00723 valarray<_Tp>::operator[](const gslice& __gs)
00724 {
00725 return gslice_array<_Tp>
00726 (_Array<_Tp>(_M_data), __gs._M_index->_M_index);
00727 }
00728
00729 template<typename _Tp>
00730 inline valarray<_Tp>
00731 valarray<_Tp>::operator[](const valarray<bool>& __m) const
00732 {
00733 size_t __s = 0;
00734 size_t __e = __m.size();
00735 for (size_t __i=0; __i<__e; ++__i)
00736 if (__m[__i]) ++__s;
00737 return valarray<_Tp>(mask_array<_Tp>(_Array<_Tp>(_M_data), __s,
00738 _Array<bool> (__m)));
00739 }
00740
00741 template<typename _Tp>
00742 inline mask_array<_Tp>
00743 valarray<_Tp>::operator[](const valarray<bool>& __m)
00744 {
00745 size_t __s = 0;
00746 size_t __e = __m.size();
00747 for (size_t __i=0; __i<__e; ++__i)
00748 if (__m[__i]) ++__s;
00749 return mask_array<_Tp>(_Array<_Tp>(_M_data), __s, _Array<bool>(__m));
00750 }
00751
00752 template<typename _Tp>
00753 inline _Expr<_IClos<_ValArray,_Tp>, _Tp>
00754 valarray<_Tp>::operator[](const valarray<size_t>& __i) const
00755 {
00756 typedef _IClos<_ValArray,_Tp> _Closure;
00757 return _Expr<_Closure, _Tp>(_Closure(*this, __i));
00758 }
00759
00760 template<typename _Tp>
00761 inline indirect_array<_Tp>
00762 valarray<_Tp>::operator[](const valarray<size_t>& __i)
00763 {
00764 return indirect_array<_Tp>(_Array<_Tp>(_M_data), __i.size(),
00765 _Array<size_t>(__i));
00766 }
00767
00768 template<class _Tp>
00769 inline size_t
00770 valarray<_Tp>::size() const
00771 { return _M_size; }
00772
00773 template<class _Tp>
00774 inline _Tp
00775 valarray<_Tp>::sum() const
00776 {
00777 _GLIBCXX_DEBUG_ASSERT(_M_size > 0);
00778 return std::__valarray_sum(_M_data, _M_data + _M_size);
00779 }
00780
00781 template<class _Tp>
00782 inline valarray<_Tp>
00783 valarray<_Tp>::shift(int __n) const
00784 {
00785 valarray<_Tp> __ret;
00786
00787 if (_M_size == 0)
00788 return __ret;
00789
00790 _Tp* __restrict__ __tmp_M_data =
00791 std::__valarray_get_storage<_Tp>(_M_size);
00792
00793 if (__n == 0)
00794 std::__valarray_copy_construct(_M_data,
00795 _M_data + _M_size, __tmp_M_data);
00796 else if (__n > 0)
00797 {
00798 if (size_t(__n) > _M_size)
00799 __n = _M_size;
00800
00801 std::__valarray_copy_construct(_M_data + __n,
00802 _M_data + _M_size, __tmp_M_data);
00803 std::__valarray_default_construct(__tmp_M_data + _M_size - __n,
00804 __tmp_M_data + _M_size);
00805 }
00806 else
00807 {
00808 if (size_t(-__n) > _M_size)
00809 __n = -_M_size;
00810
00811 std::__valarray_copy_construct(_M_data, _M_data + _M_size + __n,
00812 __tmp_M_data - __n);
00813 std::__valarray_default_construct(__tmp_M_data,
00814 __tmp_M_data - __n);
00815 }
00816
00817 __ret._M_size = _M_size;
00818 __ret._M_data = __tmp_M_data;
00819 return __ret;
00820 }
00821
00822 template<class _Tp>
00823 inline valarray<_Tp>
00824 valarray<_Tp>::cshift(int __n) const
00825 {
00826 valarray<_Tp> __ret;
00827
00828 if (_M_size == 0)
00829 return __ret;
00830
00831 _Tp* __restrict__ __tmp_M_data =
00832 std::__valarray_get_storage<_Tp>(_M_size);
00833
00834 if (__n == 0)
00835 std::__valarray_copy_construct(_M_data,
00836 _M_data + _M_size, __tmp_M_data);
00837 else if (__n > 0)
00838 {
00839 if (size_t(__n) > _M_size)
00840 __n = __n % _M_size;
00841
00842 std::__valarray_copy_construct(_M_data, _M_data + __n,
00843 __tmp_M_data + _M_size - __n);
00844 std::__valarray_copy_construct(_M_data + __n, _M_data + _M_size,
00845 __tmp_M_data);
00846 }
00847 else
00848 {
00849 if (size_t(-__n) > _M_size)
00850 __n = -(size_t(-__n) % _M_size);
00851
00852 std::__valarray_copy_construct(_M_data + _M_size + __n,
00853 _M_data + _M_size, __tmp_M_data);
00854 std::__valarray_copy_construct(_M_data, _M_data + _M_size + __n,
00855 __tmp_M_data - __n);
00856 }
00857
00858 __ret._M_size = _M_size;
00859 __ret._M_data = __tmp_M_data;
00860 return __ret;
00861 }
00862
00863 template<class _Tp>
00864 inline void
00865 valarray<_Tp>::resize(size_t __n, _Tp __c)
00866 {
00867
00868
00869
00870 std::__valarray_destroy_elements(_M_data, _M_data + _M_size);
00871 if (_M_size != __n)
00872 {
00873 std::__valarray_release_memory(_M_data);
00874 _M_size = __n;
00875 _M_data = __valarray_get_storage<_Tp>(__n);
00876 }
00877 std::__valarray_fill_construct(_M_data, _M_data + __n, __c);
00878 }
00879
00880 template<typename _Tp>
00881 inline _Tp
00882 valarray<_Tp>::min() const
00883 {
00884 _GLIBCXX_DEBUG_ASSERT(_M_size > 0);
00885 return *std::min_element(_M_data, _M_data+_M_size);
00886 }
00887
00888 template<typename _Tp>
00889 inline _Tp
00890 valarray<_Tp>::max() const
00891 {
00892 _GLIBCXX_DEBUG_ASSERT(_M_size > 0);
00893 return *std::max_element(_M_data, _M_data+_M_size);
00894 }
00895
00896 template<class _Tp>
00897 inline _Expr<_ValFunClos<_ValArray, _Tp>, _Tp>
00898 valarray<_Tp>::apply(_Tp func(_Tp)) const
00899 {
00900 typedef _ValFunClos<_ValArray, _Tp> _Closure;
00901 return _Expr<_Closure, _Tp>(_Closure(*this, func));
00902 }
00903
00904 template<class _Tp>
00905 inline _Expr<_RefFunClos<_ValArray, _Tp>, _Tp>
00906 valarray<_Tp>::apply(_Tp func(const _Tp &)) const
00907 {
00908 typedef _RefFunClos<_ValArray, _Tp> _Closure;
00909 return _Expr<_Closure, _Tp>(_Closure(*this, func));
00910 }
00911
00912 #define _DEFINE_VALARRAY_UNARY_OPERATOR(_Op, _Name) \
00913 template<typename _Tp> \
00914 inline typename valarray<_Tp>::template _UnaryOp<_Name>::_Rt \
00915 valarray<_Tp>::operator _Op() const \
00916 { \
00917 typedef _UnClos<_Name, _ValArray, _Tp> _Closure; \
00918 typedef typename __fun<_Name, _Tp>::result_type _Rt; \
00919 return _Expr<_Closure, _Rt>(_Closure(*this)); \
00920 }
00921
00922 _DEFINE_VALARRAY_UNARY_OPERATOR(+, __unary_plus)
00923 _DEFINE_VALARRAY_UNARY_OPERATOR(-, __negate)
00924 _DEFINE_VALARRAY_UNARY_OPERATOR(~, __bitwise_not)
00925 _DEFINE_VALARRAY_UNARY_OPERATOR (!, __logical_not)
00926
00927 #undef _DEFINE_VALARRAY_UNARY_OPERATOR
00928
00929 #define _DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(_Op, _Name) \
00930 template<class _Tp> \
00931 inline valarray<_Tp>& \
00932 valarray<_Tp>::operator _Op##=(const _Tp &__t) \
00933 { \
00934 _Array_augmented_##_Name(_Array<_Tp>(_M_data), _M_size, __t); \
00935 return *this; \
00936 } \
00937 \
00938 template<class _Tp> \
00939 inline valarray<_Tp>& \
00940 valarray<_Tp>::operator _Op##=(const valarray<_Tp> &__v) \
00941 { \
00942 _GLIBCXX_DEBUG_ASSERT(_M_size == __v._M_size); \
00943 _Array_augmented_##_Name(_Array<_Tp>(_M_data), _M_size, \
00944 _Array<_Tp>(__v._M_data)); \
00945 return *this; \
00946 }
00947
00948 _DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(+, __plus)
00949 _DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(-, __minus)
00950 _DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(*, __multiplies)
00951 _DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(/, __divides)
00952 _DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(%, __modulus)
00953 _DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(^, __bitwise_xor)
00954 _DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(&, __bitwise_and)
00955 _DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(|, __bitwise_or)
00956 _DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(<<, __shift_left)
00957 _DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(>>, __shift_right)
00958
00959 #undef _DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT
00960
00961 #define _DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(_Op, _Name) \
00962 template<class _Tp> template<class _Dom> \
00963 inline valarray<_Tp>& \
00964 valarray<_Tp>::operator _Op##=(const _Expr<_Dom, _Tp>& __e) \
00965 { \
00966 _Array_augmented_##_Name(_Array<_Tp>(_M_data), __e, _M_size); \
00967 return *this; \
00968 }
00969
00970 _DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(+, __plus)
00971 _DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(-, __minus)
00972 _DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(*, __multiplies)
00973 _DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(/, __divides)
00974 _DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(%, __modulus)
00975 _DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(^, __bitwise_xor)
00976 _DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(&, __bitwise_and)
00977 _DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(|, __bitwise_or)
00978 _DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(<<, __shift_left)
00979 _DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(>>, __shift_right)
00980
00981 #undef _DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT
00982
00983
00984 #define _DEFINE_BINARY_OPERATOR(_Op, _Name) \
00985 template<typename _Tp> \
00986 inline _Expr<_BinClos<_Name, _ValArray, _ValArray, _Tp, _Tp>, \
00987 typename __fun<_Name, _Tp>::result_type> \
00988 operator _Op(const valarray<_Tp>& __v, const valarray<_Tp>& __w) \
00989 { \
00990 _GLIBCXX_DEBUG_ASSERT(__v.size() == __w.size()); \
00991 typedef _BinClos<_Name, _ValArray, _ValArray, _Tp, _Tp> _Closure; \
00992 typedef typename __fun<_Name, _Tp>::result_type _Rt; \
00993 return _Expr<_Closure, _Rt>(_Closure(__v, __w)); \
00994 } \
00995 \
00996 template<typename _Tp> \
00997 inline _Expr<_BinClos<_Name, _ValArray,_Constant, _Tp, _Tp>, \
00998 typename __fun<_Name, _Tp>::result_type> \
00999 operator _Op(const valarray<_Tp>& __v, const _Tp& __t) \
01000 { \
01001 typedef _BinClos<_Name, _ValArray, _Constant, _Tp, _Tp> _Closure; \
01002 typedef typename __fun<_Name, _Tp>::result_type _Rt; \
01003 return _Expr<_Closure, _Rt>(_Closure(__v, __t)); \
01004 } \
01005 \
01006 template<typename _Tp> \
01007 inline _Expr<_BinClos<_Name, _Constant, _ValArray, _Tp, _Tp>, \
01008 typename __fun<_Name, _Tp>::result_type> \
01009 operator _Op(const _Tp& __t, const valarray<_Tp>& __v) \
01010 { \
01011 typedef _BinClos<_Name, _Constant, _ValArray, _Tp, _Tp> _Closure; \
01012 typedef typename __fun<_Name, _Tp>::result_type _Rt; \
01013 return _Expr<_Closure, _Rt>(_Closure(__t, __v)); \
01014 }
01015
01016 _DEFINE_BINARY_OPERATOR(+, __plus)
01017 _DEFINE_BINARY_OPERATOR(-, __minus)
01018 _DEFINE_BINARY_OPERATOR(*, __multiplies)
01019 _DEFINE_BINARY_OPERATOR(/, __divides)
01020 _DEFINE_BINARY_OPERATOR(%, __modulus)
01021 _DEFINE_BINARY_OPERATOR(^, __bitwise_xor)
01022 _DEFINE_BINARY_OPERATOR(&, __bitwise_and)
01023 _DEFINE_BINARY_OPERATOR(|, __bitwise_or)
01024 _DEFINE_BINARY_OPERATOR(<<, __shift_left)
01025 _DEFINE_BINARY_OPERATOR(>>, __shift_right)
01026 _DEFINE_BINARY_OPERATOR(&&, __logical_and)
01027 _DEFINE_BINARY_OPERATOR(||, __logical_or)
01028 _DEFINE_BINARY_OPERATOR(==, __equal_to)
01029 _DEFINE_BINARY_OPERATOR(!=, __not_equal_to)
01030 _DEFINE_BINARY_OPERATOR(<, __less)
01031 _DEFINE_BINARY_OPERATOR(>, __greater)
01032 _DEFINE_BINARY_OPERATOR(<=, __less_equal)
01033 _DEFINE_BINARY_OPERATOR(>=, __greater_equal)
01034
01035 #undef _DEFINE_BINARY_OPERATOR
01036
01037 _GLIBCXX_END_NAMESPACE
01038
01039 #endif