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
00038
#ifndef _CPP_VALARRAY
00039
#define _CPP_VALARRAY 1
00040
00041
#pragma GCC system_header
00042
00043
#include <bits/c++config.h>
00044
#include <cstddef>
00045
#include <cmath>
00046
#include <cstdlib>
00047
#include <numeric>
00048
#include <functional>
00049
#include <algorithm>
00050
00051
namespace std
00052 {
00053
template<
class _Clos,
typename _Tp>
class _Expr;
00054
00055
template<
typename _Tp1,
typename _Tp2>
class _ValArray;
00056
00057
template<
template<
class>
class _Oper,
00058
template<
class,
class>
class _Meta,
class _Dom>
struct _UnClos;
00059
00060
template<
template<
class>
class _Oper,
00061
template<
class,
class>
class _Meta1,
00062
template<
class,
class>
class _Meta2,
00063
class _Dom1,
class _Dom2>
class _BinClos;
00064
00065
template<
template<
class,
class>
class _Meta,
class _Dom>
class _SClos;
00066
00067
template<
template<
class,
class>
class _Meta,
class _Dom>
class _GClos;
00068
00069
template<
template<
class,
class>
class _Meta,
class _Dom>
class _IClos;
00070
00071
template<
template<
class,
class>
class _Meta,
class _Dom>
class _ValFunClos;
00072
00073
template<
template<
class,
class>
class _Meta,
class _Dom>
class _RefFunClos;
00074
00075
template<
class _Tp>
struct _Unary_plus;
00076
template<
class _Tp>
struct _Bitwise_and;
00077
template<
class _Tp>
struct _Bitwise_or;
00078
template<
class _Tp>
struct _Bitwise_xor;
00079
template<
class _Tp>
struct _Bitwise_not;
00080
template<
class _Tp>
struct _Shift_left;
00081
template<
class _Tp>
struct _Shift_right;
00082
00083
template<
class _Tp>
class valarray;
00084
class slice;
00085
template<
class _Tp>
class slice_array;
00086
class gslice;
00087
template<
class _Tp>
class gslice_array;
00088
template<
class _Tp>
class mask_array;
00089
template<
class _Tp>
class indirect_array;
00090
00091 }
00092
00093
#include <bits/valarray_array.h>
00094
#include <bits/valarray_meta.h>
00095
00096
namespace std
00097 {
00098
template<
class _Tp>
class valarray
00099 {
00100
public:
00101
typedef _Tp value_type;
00102
00103
00104 valarray();
00105
explicit valarray(size_t);
00106 valarray(
const _Tp&, size_t);
00107 valarray(
const _Tp* __restrict__, size_t);
00108 valarray(
const valarray&);
00109 valarray(
const slice_array<_Tp>&);
00110 valarray(
const gslice_array<_Tp>&);
00111 valarray(
const mask_array<_Tp>&);
00112 valarray(
const indirect_array<_Tp>&);
00113
template<
class _Dom>
00114 valarray(
const _Expr<_Dom,_Tp>& __e);
00115 ~valarray();
00116
00117
00118 valarray<_Tp>& operator=(
const valarray<_Tp>&);
00119 valarray<_Tp>& operator=(
const _Tp&);
00120 valarray<_Tp>& operator=(
const slice_array<_Tp>&);
00121 valarray<_Tp>& operator=(
const gslice_array<_Tp>&);
00122 valarray<_Tp>& operator=(
const mask_array<_Tp>&);
00123 valarray<_Tp>& operator=(
const indirect_array<_Tp>&);
00124
00125
template<
class _Dom> valarray<_Tp>&
00126 operator= (
const _Expr<_Dom,_Tp>&);
00127
00128
00129
00130
const _Tp& operator[](size_t) const;
00131 _Tp& operator[](size_t);
00132
00133 _Expr<_SClos<_ValArray,_Tp>, _Tp> operator[](slice) const;
00134 slice_array<_Tp> operator[](slice);
00135 _Expr<_GClos<_ValArray,_Tp>, _Tp> operator[](const gslice&) const;
00136 gslice_array<_Tp> operator[](const gslice&);
00137 valarray<_Tp> operator[](const valarray<
bool>&) const;
00138 mask_array<_Tp> operator[](const valarray<
bool>&);
00139 _Expr<_IClos<_ValArray, _Tp>, _Tp>
00140 operator[](const valarray<size_t>&) const;
00141 indirect_array<_Tp> operator[](const valarray<size_t>&);
00142
00143
00144 _Expr<_UnClos<_Unary_plus,_ValArray,_Tp>,_Tp> operator+ () const;
00145 _Expr<_UnClos<negate,_ValArray,_Tp>,_Tp> operator- () const;
00146 _Expr<_UnClos<_Bitwise_not,_ValArray,_Tp>,_Tp> operator~ () const;
00147 _Expr<_UnClos<logical_not,_ValArray,_Tp>,
bool> operator! () const;
00148
00149
00150 valarray<_Tp>& operator*= (const _Tp&);
00151 valarray<_Tp>& operator/= (const _Tp&);
00152 valarray<_Tp>& operator%= (const _Tp&);
00153 valarray<_Tp>& operator+= (const _Tp&);
00154 valarray<_Tp>& operator-= (const _Tp&);
00155 valarray<_Tp>& operator^= (const _Tp&);
00156 valarray<_Tp>& operator&= (const _Tp&);
00157 valarray<_Tp>& operator|= (const _Tp&);
00158 valarray<_Tp>& operator<<=(const _Tp&);
00159 valarray<_Tp>& operator>>=(const _Tp&);
00160 valarray<_Tp>& operator*= (const valarray<_Tp>&);
00161 valarray<_Tp>& operator/= (const valarray<_Tp>&);
00162 valarray<_Tp>& operator%= (const valarray<_Tp>&);
00163 valarray<_Tp>& operator+= (const valarray<_Tp>&);
00164 valarray<_Tp>& operator-= (const valarray<_Tp>&);
00165 valarray<_Tp>& operator^= (const valarray<_Tp>&);
00166 valarray<_Tp>& operator|= (const valarray<_Tp>&);
00167 valarray<_Tp>& operator&= (const valarray<_Tp>&);
00168 valarray<_Tp>& operator<<=(const valarray<_Tp>&);
00169 valarray<_Tp>& operator>>=(const valarray<_Tp>&);
00170
00171 template<class _Dom>
00172 valarray<_Tp>& operator*= (const _Expr<_Dom,_Tp>&);
00173 template<class _Dom>
00174 valarray<_Tp>& operator/= (const _Expr<_Dom,_Tp>&);
00175 template<class _Dom>
00176 valarray<_Tp>& operator%= (const _Expr<_Dom,_Tp>&);
00177 template<class _Dom>
00178 valarray<_Tp>& operator+= (const _Expr<_Dom,_Tp>&);
00179 template<class _Dom>
00180 valarray<_Tp>& operator-= (const _Expr<_Dom,_Tp>&);
00181 template<class _Dom>
00182 valarray<_Tp>& operator^= (const _Expr<_Dom,_Tp>&);
00183 template<class _Dom>
00184 valarray<_Tp>& operator|= (const _Expr<_Dom,_Tp>&);
00185 template<class _Dom>
00186 valarray<_Tp>& operator&= (const _Expr<_Dom,_Tp>&);
00187 template<class _Dom>
00188 valarray<_Tp>& operator<<=(const _Expr<_Dom,_Tp>&);
00189 template<class _Dom>
00190 valarray<_Tp>& operator>>=(const _Expr<_Dom,_Tp>&);
00191
00192
00193
00194 size_t size() const;
00195 _Tp sum() const;
00196 _Tp min() const;
00197 _Tp max() const;
00198
00199
00200
00201
00202 valarray<_Tp> shift (
int) const;
00203 valarray<_Tp> cshift(
int) const;
00204 _Expr<_ValFunClos<_ValArray,_Tp>,_Tp> apply(_Tp func(_Tp)) const;
00205 _Expr<_RefFunClos<_ValArray,_Tp>,_Tp> apply(_Tp func(const _Tp&)) const;
00206
void resize(size_t __size, _Tp __c = _Tp());
00207
00208 private:
00209 size_t _M_size;
00210 _Tp* __restrict__ _M_data;
00211
00212 friend class _Array<_Tp>;
00213 };
00214
00215
00216 template<typename _Tp> struct _Unary_plus : unary_function<_Tp,_Tp> {
00217 _Tp operator() (
const _Tp& __t)
const {
return __t; }
00218 };
00219
00220
template<
typename _Tp>
struct _Bitwise_and : binary_function<_Tp,_Tp,_Tp> {
00221 _Tp operator() (_Tp __x, _Tp __y)
const {
return __x & __y; }
00222 };
00223
00224
template<
typename _Tp>
struct _Bitwise_or : binary_function<_Tp,_Tp,_Tp> {
00225 _Tp operator() (_Tp __x, _Tp __y)
const {
return __x | __y; }
00226 };
00227
00228
template<
typename _Tp>
struct _Bitwise_xor : binary_function<_Tp,_Tp,_Tp> {
00229 _Tp operator() (_Tp __x, _Tp __y)
const {
return __x ^ __y; }
00230 };
00231
00232
template<
typename _Tp>
struct _Bitwise_not : unary_function<_Tp,_Tp> {
00233 _Tp operator() (_Tp __t)
const {
return ~__t; }
00234 };
00235
00236
template<
typename _Tp>
struct _Shift_left : unary_function<_Tp,_Tp> {
00237 _Tp operator() (_Tp __x, _Tp __y)
const {
return __x << __y; }
00238 };
00239
00240
template<
typename _Tp>
struct _Shift_right : unary_function<_Tp,_Tp> {
00241 _Tp operator() (_Tp __x, _Tp __y)
const {
return __x >> __y; }
00242 };
00243
00244
00245
template<
typename _Tp>
00246
inline const _Tp&
00247 valarray<_Tp>::operator[] (size_t __i)
const
00248
{
return _M_data[__i]; }
00249
00250
template<
typename _Tp>
00251
inline _Tp&
00252 valarray<_Tp>::operator[] (size_t __i)
00253 {
return _M_data[__i]; }
00254
00255 }
00256
00257
#include <bits/slice.h>
00258
#include <bits/slice_array.h>
00259
#include <bits/gslice.h>
00260
#include <bits/gslice_array.h>
00261
#include <bits/mask_array.h>
00262
#include <bits/indirect_array.h>
00263
00264
namespace std
00265 {
00266
template<
typename _Tp>
00267
inline valarray<_Tp>::valarray () : _M_size (0), _M_data (0) {}
00268
00269
template<
typename _Tp>
00270
inline valarray<_Tp>::valarray (size_t __n)
00271 : _M_size(__n), _M_data(__valarray_get_storage<_Tp>(__n))
00272 { __valarray_default_construct(_M_data, _M_data + __n); }
00273
00274
template<
typename _Tp>
00275
inline valarray<_Tp>::valarray (
const _Tp& __t, size_t __n)
00276 : _M_size(__n), _M_data(__valarray_get_storage<_Tp>(__n))
00277 { __valarray_fill_construct (_M_data, _M_data + __n, __t); }
00278
00279
template<
typename _Tp>
00280
inline valarray<_Tp>::valarray (
const _Tp* __restrict__ __p, size_t __n)
00281 : _M_size(__n), _M_data(__valarray_get_storage<_Tp>(__n))
00282 { __valarray_copy_construct (__p, __p + __n, _M_data); }
00283
00284
template<
typename _Tp>
00285
inline valarray<_Tp>::valarray (
const valarray<_Tp>& __v)
00286 : _M_size(__v._M_size), _M_data(__valarray_get_storage<_Tp>(__v._M_size))
00287 { __valarray_copy_construct (__v._M_data, __v._M_data + _M_size, _M_data); }
00288
00289
template<
typename _Tp>
00290
inline valarray<_Tp>::valarray (
const slice_array<_Tp>& __sa)
00291 : _M_size(__sa._M_sz), _M_data(__valarray_get_storage<_Tp>(__sa._M_sz))
00292 {
00293 __valarray_copy
00294 (__sa._M_array, __sa._M_sz, __sa._M_stride, _Array<_Tp>(_M_data));
00295 }
00296
00297
template<
typename _Tp>
00298
inline valarray<_Tp>::valarray (
const gslice_array<_Tp>& __ga)
00299 : _M_size(__ga._M_index.size()),
00300 _M_data(__valarray_get_storage<_Tp>(_M_size))
00301 {
00302 __valarray_copy
00303 (__ga._M_array, _Array<size_t>(__ga._M_index),
00304 _Array<_Tp>(_M_data), _M_size);
00305 }
00306
00307
template<
typename _Tp>
00308
inline valarray<_Tp>::valarray (
const mask_array<_Tp>& __ma)
00309 : _M_size(__ma._M_sz), _M_data(__valarray_get_storage<_Tp>(__ma._M_sz))
00310 {
00311 __valarray_copy
00312 (__ma._M_array, __ma._M_mask, _Array<_Tp>(_M_data), _M_size);
00313 }
00314
00315
template<
typename _Tp>
00316
inline valarray<_Tp>::valarray (
const indirect_array<_Tp>& __ia)
00317 : _M_size(__ia._M_sz), _M_data(__valarray_get_storage<_Tp>(__ia._M_sz))
00318 {
00319 __valarray_copy
00320 (__ia._M_array, __ia._M_index, _Array<_Tp>(_M_data), _M_size);
00321 }
00322
00323
template<
typename _Tp>
template<
class _Dom>
00324
inline valarray<_Tp>::valarray (
const _Expr<_Dom, _Tp>& __e)
00325 : _M_size(__e.size ()), _M_data(__valarray_get_storage<_Tp>(_M_size))
00326 { __valarray_copy (__e, _M_size, _Array<_Tp>(_M_data)); }
00327
00328
template<
typename _Tp>
00329
inline valarray<_Tp>::~valarray ()
00330 {
00331 __valarray_destroy_elements(_M_data, _M_data + _M_size);
00332 __valarray_release_memory(_M_data);
00333 }
00334
00335
template<
typename _Tp>
00336
inline valarray<_Tp>&
00337 valarray<_Tp>::operator= (
const valarray<_Tp>& __v)
00338 {
00339 __valarray_copy(__v._M_data, _M_size, _M_data);
00340
return *
this;
00341 }
00342
00343
template<
typename _Tp>
00344
inline valarray<_Tp>&
00345 valarray<_Tp>::operator= (
const _Tp& __t)
00346 {
00347 __valarray_fill (_M_data, _M_size, __t);
00348
return *
this;
00349 }
00350
00351
template<
typename _Tp>
00352
inline valarray<_Tp>&
00353 valarray<_Tp>::operator= (
const slice_array<_Tp>& __sa)
00354 {
00355 __valarray_copy (__sa._M_array, __sa._M_sz,
00356 __sa._M_stride, _Array<_Tp>(_M_data));
00357
return *
this;
00358 }
00359
00360
template<
typename _Tp>
00361
inline valarray<_Tp>&
00362 valarray<_Tp>::operator= (
const gslice_array<_Tp>& __ga)
00363 {
00364 __valarray_copy (__ga._M_array, _Array<size_t>(__ga._M_index),
00365 _Array<_Tp>(_M_data), _M_size);
00366
return *
this;
00367 }
00368
00369
template<
typename _Tp>
00370
inline valarray<_Tp>&
00371 valarray<_Tp>::operator= (
const mask_array<_Tp>& __ma)
00372 {
00373 __valarray_copy (__ma._M_array, __ma._M_mask,
00374 _Array<_Tp>(_M_data), _M_size);
00375
return *
this;
00376 }
00377
00378
template<
typename _Tp>
00379
inline valarray<_Tp>&
00380 valarray<_Tp>::operator= (
const indirect_array<_Tp>& __ia)
00381 {
00382 __valarray_copy (__ia._M_array, __ia._M_index,
00383 _Array<_Tp>(_M_data), _M_size);
00384
return *
this;
00385 }
00386
00387
template<
typename _Tp>
template<
class _Dom>
00388
inline valarray<_Tp>&
00389 valarray<_Tp>::operator= (
const _Expr<_Dom, _Tp>& __e)
00390 {
00391 __valarray_copy (__e, _M_size, _Array<_Tp>(_M_data));
00392
return *
this;
00393 }
00394
00395
template<
typename _Tp>
00396
inline _Expr<_SClos<_ValArray,_Tp>, _Tp>
00397 valarray<_Tp>::operator[] (slice __s)
const
00398
{
00399
typedef _SClos<_ValArray,_Tp> _Closure;
00400
return _Expr<_Closure, _Tp> (_Closure (_Array<_Tp>(_M_data), __s));
00401 }
00402
00403
template<
typename _Tp>
00404
inline slice_array<_Tp>
00405 valarray<_Tp>::operator[] (slice __s)
00406 {
00407
return slice_array<_Tp> (_Array<_Tp>(_M_data), __s);
00408 }
00409
00410
template<
typename _Tp>
00411
inline _Expr<_GClos<_ValArray,_Tp>, _Tp>
00412 valarray<_Tp>::operator[] (
const gslice& __gs)
const
00413
{
00414
typedef _GClos<_ValArray,_Tp> _Closure;
00415
return _Expr<_Closure, _Tp>
00416 (_Closure (_Array<_Tp>(_M_data), __gs._M_index->_M_index));
00417 }
00418
00419
template<
typename _Tp>
00420
inline gslice_array<_Tp>
00421 valarray<_Tp>::operator[] (
const gslice& __gs)
00422 {
00423
return gslice_array<_Tp>
00424 (_Array<_Tp>(_M_data), __gs._M_index->_M_index);
00425 }
00426
00427
template<
typename _Tp>
00428
inline valarray<_Tp>
00429 valarray<_Tp>::operator[] (
const valarray<bool>& __m)
const
00430
{
00431 size_t __s (0);
00432 size_t __e (__m.size ());
00433
for (size_t __i=0; __i<__e; ++__i)
00434
if (__m[__i]) ++__s;
00435
return valarray<_Tp> (mask_array<_Tp> (_Array<_Tp>(_M_data), __s,
00436 _Array<bool> (__m)));
00437 }
00438
00439
template<
typename _Tp>
00440
inline mask_array<_Tp>
00441 valarray<_Tp>::operator[] (
const valarray<bool>& __m)
00442 {
00443 size_t __s (0);
00444 size_t __e (__m.size ());
00445
for (size_t __i=0; __i<__e; ++__i)
00446
if (__m[__i]) ++__s;
00447
return mask_array<_Tp> (_Array<_Tp>(_M_data), __s, _Array<bool> (__m));
00448 }
00449
00450
template<
typename _Tp>
00451
inline _Expr<_IClos<_ValArray,_Tp>, _Tp>
00452 valarray<_Tp>::operator[] (
const valarray<size_t>& __i)
const
00453
{
00454
typedef _IClos<_ValArray,_Tp> _Closure;
00455
return _Expr<_Closure, _Tp> (_Closure (*
this, __i));
00456 }
00457
00458
template<
typename _Tp>
00459
inline indirect_array<_Tp>
00460 valarray<_Tp>::operator[] (
const valarray<size_t>& __i)
00461 {
00462
return indirect_array<_Tp> (_Array<_Tp>(_M_data), __i.size(),
00463 _Array<size_t> (__i));
00464 }
00465
00466
template<
class _Tp>
00467
inline size_t valarray<_Tp>::size ()
const {
return _M_size; }
00468
00469
template<
class _Tp>
00470
inline _Tp
00471 valarray<_Tp>::sum ()
const
00472
{
00473
return __valarray_sum(_M_data, _M_data + _M_size);
00474 }
00475
00476
00477
00478
00479
00480
00481
00482
00483
template <
class _Tp>
00484
inline valarray<_Tp>
00485 valarray<_Tp>::shift(
int __n)
const
00486
{
00487 _Tp*
const __a = static_cast<_Tp*>
00488 (__builtin_alloca(
sizeof(_Tp) * _M_size));
00489
if (__n == 0)
00490 __valarray_copy_construct(_M_data, _M_data + _M_size, __a);
00491
else if (__n > 0)
00492 {
00493
if (size_t(__n) > _M_size)
00494 __valarray_default_construct(__a, __a + __n);
00495
else
00496 {
00497 __valarray_copy_construct(_M_data+__n, _M_data + _M_size, __a);
00498 __valarray_default_construct(__a+_M_size-__n, __a + _M_size);
00499 }
00500 }
00501
else
00502 {
00503 __valarray_copy_construct (_M_data, _M_data+_M_size+__n, __a-__n);
00504 __valarray_default_construct(__a, __a - __n);
00505 }
00506
return valarray<_Tp> (__a, _M_size);
00507 }
00508
00509
template <
class _Tp>
00510
inline valarray<_Tp>
00511 valarray<_Tp>::cshift (
int __n)
const
00512
{
00513 _Tp*
const __a = static_cast<_Tp*>
00514 (__builtin_alloca (
sizeof(_Tp) * _M_size));
00515
if (__n == 0)
00516 __valarray_copy_construct(_M_data, _M_data + _M_size, __a);
00517
else if (__n > 0)
00518 {
00519 __valarray_copy_construct(_M_data, _M_data+__n, __a+_M_size-__n);
00520 __valarray_copy_construct(_M_data+__n, _M_data + _M_size, __a);
00521 }
00522
else
00523 {
00524 __valarray_copy_construct
00525 (_M_data + _M_size+__n, _M_data + _M_size, __a);
00526 __valarray_copy_construct
00527 (_M_data, _M_data + _M_size+__n, __a - __n);
00528 }
00529
return valarray<_Tp>(__a, _M_size);
00530 }
00531
00532
template <
class _Tp>
00533
inline void
00534 valarray<_Tp>::resize (size_t __n, _Tp __c)
00535 {
00536
00537
00538
00539 __valarray_destroy_elements(_M_data, _M_data + _M_size);
00540
if (_M_size != __n)
00541 {
00542 __valarray_release_memory(_M_data);
00543 _M_size = __n;
00544 _M_data = __valarray_get_storage<_Tp>(__n);
00545 }
00546 __valarray_fill_construct(_M_data, _M_data + __n, __c);
00547 }
00548
00549
template<
typename _Tp>
00550
inline _Tp
00551 valarray<_Tp>::min()
const
00552
{
00553
return *min_element (_M_data, _M_data+_M_size);
00554 }
00555
00556
template<
typename _Tp>
00557
inline _Tp
00558 valarray<_Tp>::max()
const
00559
{
00560
return *max_element (_M_data, _M_data+_M_size);
00561 }
00562
00563
template<
class _Tp>
00564
inline _Expr<_ValFunClos<_ValArray,_Tp>,_Tp>
00565 valarray<_Tp>::apply (_Tp func (_Tp))
const
00566
{
00567
typedef _ValFunClos<_ValArray,_Tp> _Closure;
00568
return _Expr<_Closure,_Tp> (_Closure (*
this, func));
00569 }
00570
00571
template<
class _Tp>
00572
inline _Expr<_RefFunClos<_ValArray,_Tp>,_Tp>
00573 valarray<_Tp>::apply (_Tp func (
const _Tp &))
const
00574
{
00575
typedef _RefFunClos<_ValArray,_Tp> _Closure;
00576
return _Expr<_Closure,_Tp> (_Closure (*
this, func));
00577 }
00578
00579
#define _DEFINE_VALARRAY_UNARY_OPERATOR(_Op, _Name) \
00580
template<typename _Tp> \
00581
inline _Expr<_UnClos<_Name,_ValArray,_Tp>, _Tp> \
00582
valarray<_Tp>::operator _Op() const \
00583
{ \
00584
typedef _UnClos<_Name,_ValArray,_Tp> _Closure; \
00585
return _Expr<_Closure, _Tp> (_Closure (*this)); \
00586
}
00587
00588 _DEFINE_VALARRAY_UNARY_OPERATOR(+, _Unary_plus)
00589 _DEFINE_VALARRAY_UNARY_OPERATOR(-, negate)
00590 _DEFINE_VALARRAY_UNARY_OPERATOR(~, _Bitwise_not)
00591
00592 #undef _DEFINE_VALARRAY_UNARY_OPERATOR
00593
00594 template<typename _Tp>
00595 inline _Expr<_UnClos<logical_not,_ValArray,_Tp>,
bool>
00596 valarray<_Tp>::operator!()
const
00597
{
00598
typedef _UnClos<logical_not,_ValArray,_Tp> _Closure;
00599
return _Expr<_Closure, bool> (_Closure (*
this));
00600 }
00601
00602
#define _DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(_Op, _Name) \
00603
template<class _Tp> \
00604
inline valarray<_Tp> & \
00605
valarray<_Tp>::operator _Op##= (const _Tp &__t) \
00606
{ \
00607
_Array_augmented_##_Name (_Array<_Tp>(_M_data), _M_size, __t); \
00608
return *this; \
00609
} \
00610
\
00611
template<class _Tp> \
00612
inline valarray<_Tp> & \
00613
valarray<_Tp>::operator _Op##= (const valarray<_Tp> &__v) \
00614
{ \
00615
_Array_augmented_##_Name (_Array<_Tp>(_M_data), _M_size, \
00616
_Array<_Tp>(__v._M_data)); \
00617
return *this; \
00618
}
00619
00620 _DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(+, plus)
00621 _DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(-, minus)
00622 _DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(*, multiplies)
00623 _DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(/, divides)
00624 _DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(%, modulus)
00625 _DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(^, xor)
00626 _DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(&, and)
00627 _DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(|, or)
00628 _DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(<<, shift_left)
00629 _DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(>>, shift_right)
00630
00631 #undef _DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT
00632
00633
00634 }
00635
00636
00637 namespace std
00638 {
00639
00640
#define _DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(_Op, _Name) \
00641
template<class _Tp> template<class _Dom> \
00642
inline valarray<_Tp> & \
00643
valarray<_Tp>::operator _Op##= (const _Expr<_Dom,_Tp> &__e) \
00644
{ \
00645
_Array_augmented_##_Name (_Array<_Tp>(_M_data), __e, _M_size); \
00646
return *this; \
00647
}
00648
00649 _DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(+, plus)
00650 _DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(-, minus)
00651 _DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(*, multiplies)
00652 _DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(/, divides)
00653 _DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(%, modulus)
00654 _DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(^, xor)
00655 _DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(&, and)
00656 _DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(|, or)
00657 _DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(<<, shift_left)
00658 _DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(>>, shift_right)
00659
00660 #undef _DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT
00661
00662
00663 #define _DEFINE_BINARY_OPERATOR(_Op, _Name) \
00664 template<typename _Tp> \
00665 inline _Expr<_BinClos<_Name,_ValArray,_ValArray,_Tp,_Tp>, _Tp> \
00666 operator _Op (const valarray<_Tp> &__v, const valarray<_Tp> &__w) \
00667 { \
00668
typedef _BinClos<_Name,_ValArray,_ValArray,_Tp,_Tp> _Closure; \
00669
return _Expr<_Closure, _Tp> (_Closure (__v, __w)); \
00670 } \
00671 \
00672
template<
typename _Tp> \
00673
inline _Expr<_BinClos<_Name,_ValArray,_Constant,_Tp,_Tp>,_Tp> \
00674 operator _Op (
const valarray<_Tp> &__v,
const _Tp &__t) \
00675 { \
00676
typedef _BinClos<_Name,_ValArray,_Constant,_Tp,_Tp> _Closure; \
00677
return _Expr<_Closure, _Tp> (_Closure (__v, __t)); \
00678 } \
00679 \
00680
template<
typename _Tp> \
00681
inline _Expr<_BinClos<_Name,_Constant,_ValArray,_Tp,_Tp>,_Tp> \
00682 operator _Op (
const _Tp &__t,
const valarray<_Tp> &__v) \
00683 { \
00684
typedef _BinClos<_Name,_Constant,_ValArray,_Tp,_Tp> _Closure; \
00685
return _Expr<_Closure, _Tp> (_Closure (__t, __v)); \
00686 }
00687
00688 _DEFINE_BINARY_OPERATOR(+, plus)
00689 _DEFINE_BINARY_OPERATOR(-, minus)
00690 _DEFINE_BINARY_OPERATOR(*, multiplies)
00691 _DEFINE_BINARY_OPERATOR(/, divides)
00692 _DEFINE_BINARY_OPERATOR(%, modulus)
00693 _DEFINE_BINARY_OPERATOR(^, _Bitwise_xor)
00694 _DEFINE_BINARY_OPERATOR(&, _Bitwise_and)
00695 _DEFINE_BINARY_OPERATOR(|, _Bitwise_or)
00696 _DEFINE_BINARY_OPERATOR(<<, _Shift_left)
00697 _DEFINE_BINARY_OPERATOR(>>, _Shift_right)
00698
00699 #undef _DEFINE_BINARY_OPERATOR
00700
00701 #define _DEFINE_LOGICAL_OPERATOR(_Op, _Name) \
00702 template<typename _Tp> \
00703 inline _Expr<_BinClos<_Name,_ValArray,_ValArray,_Tp,_Tp>,
bool> \
00704 operator _Op (const valarray<_Tp> &__v, const valarray<_Tp> &__w) \
00705 { \
00706
typedef _BinClos<_Name,_ValArray,_ValArray,_Tp,_Tp> _Closure; \
00707
return _Expr<_Closure, bool> (_Closure (__v, __w)); \
00708 } \
00709 \
00710
template<
class _Tp> \
00711
inline _Expr<_BinClos<_Name,_ValArray,_Constant,_Tp,_Tp>,
bool> \
00712 operator _Op (
const valarray<_Tp> &__v,
const _Tp &__t) \
00713 { \
00714
typedef _BinClos<_Name,_ValArray,_Constant,_Tp,_Tp> _Closure; \
00715
return _Expr<_Closure, bool> (_Closure (__v, __t)); \
00716 } \
00717 \
00718
template<
class _Tp> \
00719
inline _Expr<_BinClos<_Name,_Constant,_ValArray,_Tp,_Tp>,
bool> \
00720 operator _Op (
const _Tp &__t,
const valarray<_Tp> &__v) \
00721 { \
00722
typedef _BinClos<_Name,_Constant,_ValArray,_Tp,_Tp> _Closure; \
00723
return _Expr<_Closure, bool> (_Closure (__t, __v)); \
00724 }
00725
00726 _DEFINE_LOGICAL_OPERATOR(&&, logical_and)
00727 _DEFINE_LOGICAL_OPERATOR(||, logical_or)
00728 _DEFINE_LOGICAL_OPERATOR(==, equal_to)
00729 _DEFINE_LOGICAL_OPERATOR(!=, not_equal_to)
00730 _DEFINE_LOGICAL_OPERATOR(<, less)
00731 _DEFINE_LOGICAL_OPERATOR(>, greater)
00732 _DEFINE_LOGICAL_OPERATOR(<=, less_equal)
00733 _DEFINE_LOGICAL_OPERATOR(>=, greater_equal)
00734
00735 #undef _DEFINE_LOGICAL_OPERATOR
00736
00737 }
00738
00739 #endif
00740
00741
00742
00743