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
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 <algorithm>
00049
00050 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 }
00091
00092 #include <bits/valarray_array.h>
00093 #include <bits/valarray_meta.h>
00094
00095 namespace std
00096 {
00097 template<class _Tp>
00098 class valarray
00099 {
00100 template<class _Op>
00101 struct _UnaryOp
00102 {
00103 typedef typename __fun<_Op, _Tp>::result_type __rt;
00104 typedef _Expr<_UnClos<_Op, _ValArray, _Tp>, __rt> _Rt;
00105 };
00106 public:
00107 typedef _Tp value_type;
00108
00109
00110 valarray();
00111 explicit valarray(size_t);
00112 valarray(const _Tp&, size_t);
00113 valarray(const _Tp* __restrict__, size_t);
00114 valarray(const valarray&);
00115 valarray(const slice_array<_Tp>&);
00116 valarray(const gslice_array<_Tp>&);
00117 valarray(const mask_array<_Tp>&);
00118 valarray(const indirect_array<_Tp>&);
00119 template<class _Dom>
00120 valarray(const _Expr<_Dom,_Tp>& __e);
00121 ~valarray();
00122
00123
00124 valarray<_Tp>& operator=(const valarray<_Tp>&);
00125 valarray<_Tp>& operator=(const _Tp&);
00126 valarray<_Tp>& operator=(const slice_array<_Tp>&);
00127 valarray<_Tp>& operator=(const gslice_array<_Tp>&);
00128 valarray<_Tp>& operator=(const mask_array<_Tp>&);
00129 valarray<_Tp>& operator=(const indirect_array<_Tp>&);
00130
00131 template<class _Dom> valarray<_Tp>&
00132 operator= (const _Expr<_Dom,_Tp>&);
00133
00134
00135
00136 const _Tp& operator[](size_t) const;
00137 _Tp& operator[](size_t);
00138
00139 _Expr<_SClos<_ValArray,_Tp>, _Tp> operator[](slice) const;
00140 slice_array<_Tp> operator[](slice);
00141 _Expr<_GClos<_ValArray,_Tp>, _Tp> operator[](const gslice&) const;
00142 gslice_array<_Tp> operator[](const gslice&);
00143 valarray<_Tp> operator[](const valarray<bool>&) const;
00144 mask_array<_Tp> operator[](const valarray<bool>&);
00145 _Expr<_IClos<_ValArray, _Tp>, _Tp>
00146 operator[](const valarray<size_t>&) const;
00147 indirect_array<_Tp> operator[](const valarray<size_t>&);
00148
00149
00150 typename _UnaryOp<__unary_plus>::_Rt operator+() const;
00151 typename _UnaryOp<__negate>::_Rt operator-() const;
00152 typename _UnaryOp<__bitwise_not>::_Rt operator~() const;
00153 typename _UnaryOp<__logical_not>::_Rt operator!() const;
00154
00155
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 _Tp&);
00161 valarray<_Tp>& operator^=(const _Tp&);
00162 valarray<_Tp>& operator&=(const _Tp&);
00163 valarray<_Tp>& operator|=(const _Tp&);
00164 valarray<_Tp>& operator<<=(const _Tp&);
00165 valarray<_Tp>& operator>>=(const _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 valarray<_Tp>& operator-=(const valarray<_Tp>&);
00171 valarray<_Tp>& operator^=(const valarray<_Tp>&);
00172 valarray<_Tp>& operator|=(const valarray<_Tp>&);
00173 valarray<_Tp>& operator&=(const valarray<_Tp>&);
00174 valarray<_Tp>& operator<<=(const valarray<_Tp>&);
00175 valarray<_Tp>& operator>>=(const valarray<_Tp>&);
00176
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 template<class _Dom>
00192 valarray<_Tp>& operator&=(const _Expr<_Dom,_Tp>&);
00193 template<class _Dom>
00194 valarray<_Tp>& operator<<=(const _Expr<_Dom,_Tp>&);
00195 template<class _Dom>
00196 valarray<_Tp>& operator>>=(const _Expr<_Dom,_Tp>&);
00197
00198
00199
00200 size_t size() const;
00201 _Tp sum() const;
00202 _Tp min() const;
00203 _Tp max() const;
00204
00205
00206
00207
00208 valarray<_Tp> shift (int) const;
00209 valarray<_Tp> cshift(int) const;
00210 _Expr<_ValFunClos<_ValArray,_Tp>,_Tp> apply(_Tp func(_Tp)) const;
00211 _Expr<_RefFunClos<_ValArray,_Tp>,_Tp> apply(_Tp func(const _Tp&)) const;
00212 void resize(size_t __size, _Tp __c = _Tp());
00213
00214 private:
00215 size_t _M_size;
00216 _Tp* __restrict__ _M_data;
00217
00218 friend class _Array<_Tp>;
00219 };
00220
00221 template<typename _Tp>
00222 inline const _Tp&
00223 valarray<_Tp>::operator[](size_t __i) const
00224 { return _M_data[__i]; }
00225
00226 template<typename _Tp>
00227 inline _Tp&
00228 valarray<_Tp>::operator[](size_t __i)
00229 { return _M_data[__i]; }
00230
00231 }
00232
00233 #include <bits/slice_array.h>
00234 #include <bits/gslice.h>
00235 #include <bits/gslice_array.h>
00236 #include <bits/mask_array.h>
00237 #include <bits/indirect_array.h>
00238
00239 namespace std
00240 {
00241 template<typename _Tp>
00242 inline
00243 valarray<_Tp>::valarray() : _M_size(0), _M_data(0) {}
00244
00245 template<typename _Tp>
00246 inline
00247 valarray<_Tp>::valarray(size_t __n)
00248 : _M_size(__n), _M_data(__valarray_get_storage<_Tp>(__n))
00249 { __valarray_default_construct(_M_data, _M_data + __n); }
00250
00251 template<typename _Tp>
00252 inline
00253 valarray<_Tp>::valarray(const _Tp& __t, size_t __n)
00254 : _M_size(__n), _M_data(__valarray_get_storage<_Tp>(__n))
00255 { __valarray_fill_construct(_M_data, _M_data + __n, __t); }
00256
00257 template<typename _Tp>
00258 inline
00259 valarray<_Tp>::valarray(const _Tp* __restrict__ __p, size_t __n)
00260 : _M_size(__n), _M_data(__valarray_get_storage<_Tp>(__n))
00261 { __valarray_copy_construct(__p, __p + __n, _M_data); }
00262
00263 template<typename _Tp>
00264 inline
00265 valarray<_Tp>::valarray(const valarray<_Tp>& __v)
00266 : _M_size(__v._M_size), _M_data(__valarray_get_storage<_Tp>(__v._M_size))
00267 { __valarray_copy_construct(__v._M_data, __v._M_data + _M_size, _M_data); }
00268
00269 template<typename _Tp>
00270 inline
00271 valarray<_Tp>::valarray(const slice_array<_Tp>& __sa)
00272 : _M_size(__sa._M_sz), _M_data(__valarray_get_storage<_Tp>(__sa._M_sz))
00273 {
00274 __valarray_copy
00275 (__sa._M_array, __sa._M_sz, __sa._M_stride, _Array<_Tp>(_M_data));
00276 }
00277
00278 template<typename _Tp>
00279 inline
00280 valarray<_Tp>::valarray(const gslice_array<_Tp>& __ga)
00281 : _M_size(__ga._M_index.size()),
00282 _M_data(__valarray_get_storage<_Tp>(_M_size))
00283 {
00284 __valarray_copy
00285 (__ga._M_array, _Array<size_t>(__ga._M_index),
00286 _Array<_Tp>(_M_data), _M_size);
00287 }
00288
00289 template<typename _Tp>
00290 inline
00291 valarray<_Tp>::valarray(const mask_array<_Tp>& __ma)
00292 : _M_size(__ma._M_sz), _M_data(__valarray_get_storage<_Tp>(__ma._M_sz))
00293 {
00294 __valarray_copy
00295 (__ma._M_array, __ma._M_mask, _Array<_Tp>(_M_data), _M_size);
00296 }
00297
00298 template<typename _Tp>
00299 inline
00300 valarray<_Tp>::valarray(const indirect_array<_Tp>& __ia)
00301 : _M_size(__ia._M_sz), _M_data(__valarray_get_storage<_Tp>(__ia._M_sz))
00302 {
00303 __valarray_copy
00304 (__ia._M_array, __ia._M_index, _Array<_Tp>(_M_data), _M_size);
00305 }
00306
00307 template<typename _Tp> template<class _Dom>
00308 inline
00309 valarray<_Tp>::valarray(const _Expr<_Dom, _Tp>& __e)
00310 : _M_size(__e.size()), _M_data(__valarray_get_storage<_Tp>(_M_size))
00311 { __valarray_copy(__e, _M_size, _Array<_Tp>(_M_data)); }
00312
00313 template<typename _Tp>
00314 inline
00315 valarray<_Tp>::~valarray()
00316 {
00317 __valarray_destroy_elements(_M_data, _M_data + _M_size);
00318 __valarray_release_memory(_M_data);
00319 }
00320
00321 template<typename _Tp>
00322 inline valarray<_Tp>&
00323 valarray<_Tp>::operator=(const valarray<_Tp>& __v)
00324 {
00325 __valarray_copy(__v._M_data, _M_size, _M_data);
00326 return *this;
00327 }
00328
00329 template<typename _Tp>
00330 inline valarray<_Tp>&
00331 valarray<_Tp>::operator=(const _Tp& __t)
00332 {
00333 __valarray_fill(_M_data, _M_size, __t);
00334 return *this;
00335 }
00336
00337 template<typename _Tp>
00338 inline valarray<_Tp>&
00339 valarray<_Tp>::operator=(const slice_array<_Tp>& __sa)
00340 {
00341 __valarray_copy(__sa._M_array, __sa._M_sz,
00342 __sa._M_stride, _Array<_Tp>(_M_data));
00343 return *this;
00344 }
00345
00346 template<typename _Tp>
00347 inline valarray<_Tp>&
00348 valarray<_Tp>::operator=(const gslice_array<_Tp>& __ga)
00349 {
00350 __valarray_copy(__ga._M_array, _Array<size_t>(__ga._M_index),
00351 _Array<_Tp>(_M_data), _M_size);
00352 return *this;
00353 }
00354
00355 template<typename _Tp>
00356 inline valarray<_Tp>&
00357 valarray<_Tp>::operator=(const mask_array<_Tp>& __ma)
00358 {
00359 __valarray_copy(__ma._M_array, __ma._M_mask,
00360 _Array<_Tp>(_M_data), _M_size);
00361 return *this;
00362 }
00363
00364 template<typename _Tp>
00365 inline valarray<_Tp>&
00366 valarray<_Tp>::operator=(const indirect_array<_Tp>& __ia)
00367 {
00368 __valarray_copy(__ia._M_array, __ia._M_index,
00369 _Array<_Tp>(_M_data), _M_size);
00370 return *this;
00371 }
00372
00373 template<typename _Tp> template<class _Dom>
00374 inline valarray<_Tp>&
00375 valarray<_Tp>::operator=(const _Expr<_Dom, _Tp>& __e)
00376 {
00377 __valarray_copy(__e, _M_size, _Array<_Tp>(_M_data));
00378 return *this;
00379 }
00380
00381 template<typename _Tp>
00382 inline _Expr<_SClos<_ValArray,_Tp>, _Tp>
00383 valarray<_Tp>::operator[](slice __s) const
00384 {
00385 typedef _SClos<_ValArray,_Tp> _Closure;
00386 return _Expr<_Closure, _Tp>(_Closure (_Array<_Tp>(_M_data), __s));
00387 }
00388
00389 template<typename _Tp>
00390 inline slice_array<_Tp>
00391 valarray<_Tp>::operator[](slice __s)
00392 {
00393 return slice_array<_Tp>(_Array<_Tp>(_M_data), __s);
00394 }
00395
00396 template<typename _Tp>
00397 inline _Expr<_GClos<_ValArray,_Tp>, _Tp>
00398 valarray<_Tp>::operator[](const gslice& __gs) const
00399 {
00400 typedef _GClos<_ValArray,_Tp> _Closure;
00401 return _Expr<_Closure, _Tp>
00402 (_Closure(_Array<_Tp>(_M_data), __gs._M_index->_M_index));
00403 }
00404
00405 template<typename _Tp>
00406 inline gslice_array<_Tp>
00407 valarray<_Tp>::operator[](const gslice& __gs)
00408 {
00409 return gslice_array<_Tp>
00410 (_Array<_Tp>(_M_data), __gs._M_index->_M_index);
00411 }
00412
00413 template<typename _Tp>
00414 inline valarray<_Tp>
00415 valarray<_Tp>::operator[](const valarray<bool>& __m) const
00416 {
00417 size_t __s = 0;
00418 size_t __e = __m.size();
00419 for (size_t __i=0; __i<__e; ++__i)
00420 if (__m[__i]) ++__s;
00421 return valarray<_Tp>(mask_array<_Tp>(_Array<_Tp>(_M_data), __s,
00422 _Array<bool> (__m)));
00423 }
00424
00425 template<typename _Tp>
00426 inline mask_array<_Tp>
00427 valarray<_Tp>::operator[](const valarray<bool>& __m)
00428 {
00429 size_t __s = 0;
00430 size_t __e = __m.size();
00431 for (size_t __i=0; __i<__e; ++__i)
00432 if (__m[__i]) ++__s;
00433 return mask_array<_Tp>(_Array<_Tp>(_M_data), __s, _Array<bool>(__m));
00434 }
00435
00436 template<typename _Tp>
00437 inline _Expr<_IClos<_ValArray,_Tp>, _Tp>
00438 valarray<_Tp>::operator[](const valarray<size_t>& __i) const
00439 {
00440 typedef _IClos<_ValArray,_Tp> _Closure;
00441 return _Expr<_Closure, _Tp>(_Closure(*this, __i));
00442 }
00443
00444 template<typename _Tp>
00445 inline indirect_array<_Tp>
00446 valarray<_Tp>::operator[](const valarray<size_t>& __i)
00447 {
00448 return indirect_array<_Tp>(_Array<_Tp>(_M_data), __i.size(),
00449 _Array<size_t>(__i));
00450 }
00451
00452 template<class _Tp>
00453 inline size_t
00454 valarray<_Tp>::size() const
00455 { return _M_size; }
00456
00457 template<class _Tp>
00458 inline _Tp
00459 valarray<_Tp>::sum() const
00460 {
00461 return __valarray_sum(_M_data, _M_data + _M_size);
00462 }
00463
00464
00465
00466
00467
00468
00469
00470
00471 template <class _Tp>
00472 inline valarray<_Tp>
00473 valarray<_Tp>::shift(int __n) const
00474 {
00475 _Tp* const __a = static_cast<_Tp*>
00476 (__builtin_alloca(sizeof(_Tp) * _M_size));
00477 if (__n == 0)
00478 __valarray_copy_construct(_M_data, _M_data + _M_size, __a);
00479 else if (__n > 0)
00480 {
00481 if (size_t(__n) > _M_size)
00482 __valarray_default_construct(__a, __a + __n);
00483 else
00484 {
00485 __valarray_copy_construct(_M_data+__n, _M_data + _M_size, __a);
00486 __valarray_default_construct(__a+_M_size-__n, __a + _M_size);
00487 }
00488 }
00489 else
00490 {
00491 __valarray_copy_construct (_M_data, _M_data+_M_size+__n, __a-__n);
00492 __valarray_default_construct(__a, __a - __n);
00493 }
00494 return valarray<_Tp> (__a, _M_size);
00495 }
00496
00497 template <class _Tp>
00498 inline valarray<_Tp>
00499 valarray<_Tp>::cshift (int __n) const
00500 {
00501 _Tp* const __a = static_cast<_Tp*>
00502 (__builtin_alloca (sizeof(_Tp) * _M_size));
00503 if (__n == 0)
00504 __valarray_copy_construct(_M_data, _M_data + _M_size, __a);
00505 else if (__n > 0)
00506 {
00507 __valarray_copy_construct(_M_data, _M_data+__n, __a+_M_size-__n);
00508 __valarray_copy_construct(_M_data+__n, _M_data + _M_size, __a);
00509 }
00510 else
00511 {
00512 __valarray_copy_construct
00513 (_M_data + _M_size+__n, _M_data + _M_size, __a);
00514 __valarray_copy_construct
00515 (_M_data, _M_data + _M_size+__n, __a - __n);
00516 }
00517 return valarray<_Tp>(__a, _M_size);
00518 }
00519
00520 template <class _Tp>
00521 inline void
00522 valarray<_Tp>::resize (size_t __n, _Tp __c)
00523 {
00524
00525
00526
00527 __valarray_destroy_elements(_M_data, _M_data + _M_size);
00528 if (_M_size != __n)
00529 {
00530 __valarray_release_memory(_M_data);
00531 _M_size = __n;
00532 _M_data = __valarray_get_storage<_Tp>(__n);
00533 }
00534 __valarray_fill_construct(_M_data, _M_data + __n, __c);
00535 }
00536
00537 template<typename _Tp>
00538 inline _Tp
00539 valarray<_Tp>::min() const
00540 {
00541 return *min_element (_M_data, _M_data+_M_size);
00542 }
00543
00544 template<typename _Tp>
00545 inline _Tp
00546 valarray<_Tp>::max() const
00547 {
00548 return *max_element (_M_data, _M_data+_M_size);
00549 }
00550
00551 template<class _Tp>
00552 inline _Expr<_ValFunClos<_ValArray,_Tp>,_Tp>
00553 valarray<_Tp>::apply(_Tp func(_Tp)) const
00554 {
00555 typedef _ValFunClos<_ValArray,_Tp> _Closure;
00556 return _Expr<_Closure,_Tp>(_Closure(*this, func));
00557 }
00558
00559 template<class _Tp>
00560 inline _Expr<_RefFunClos<_ValArray,_Tp>,_Tp>
00561 valarray<_Tp>::apply(_Tp func(const _Tp &)) const
00562 {
00563 typedef _RefFunClos<_ValArray,_Tp> _Closure;
00564 return _Expr<_Closure,_Tp>(_Closure(*this, func));
00565 }
00566
00567 #define _DEFINE_VALARRAY_UNARY_OPERATOR(_Op, _Name) \
00568 template<typename _Tp> \
00569 inline typename valarray<_Tp>::template _UnaryOp<_Name>::_Rt \
00570 valarray<_Tp>::operator _Op() const \
00571 { \
00572 typedef _UnClos<_Name,_ValArray,_Tp> _Closure; \
00573 typedef typename __fun<_Name, _Tp>::result_type _Rt; \
00574 return _Expr<_Closure, _Rt>(_Closure(*this)); \
00575 }
00576
00577 _DEFINE_VALARRAY_UNARY_OPERATOR(+, __unary_plus)
00578 _DEFINE_VALARRAY_UNARY_OPERATOR(-, __negate)
00579 _DEFINE_VALARRAY_UNARY_OPERATOR(~, __bitwise_not)
00580 _DEFINE_VALARRAY_UNARY_OPERATOR (!, __logical_not)
00581
00582 #undef _DEFINE_VALARRAY_UNARY_OPERATOR
00583
00584 #define _DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(_Op, _Name) \
00585 template<class _Tp> \
00586 inline valarray<_Tp>& \
00587 valarray<_Tp>::operator _Op##=(const _Tp &__t) \
00588 { \
00589 _Array_augmented_##_Name(_Array<_Tp>(_M_data), _M_size, __t); \
00590 return *this; \
00591 } \
00592 \
00593 template<class _Tp> \
00594 inline valarray<_Tp>& \
00595 valarray<_Tp>::operator _Op##=(const valarray<_Tp> &__v) \
00596 { \
00597 _Array_augmented_##_Name(_Array<_Tp>(_M_data), _M_size, \
00598 _Array<_Tp>(__v._M_data)); \
00599 return *this; \
00600 }
00601
00602 _DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(+, __plus)
00603 _DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(-, __minus)
00604 _DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(*, __multiplies)
00605 _DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(/, __divides)
00606 _DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(%, __modulus)
00607 _DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(^, __bitwise_xor)
00608 _DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(&, __bitwise_and)
00609 _DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(|, __bitwise_or)
00610 _DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(<<, __shift_left)
00611 _DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(>>, __shift_right)
00612
00613 #undef _DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT
00614
00615 #define _DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(_Op, _Name) \
00616 template<class _Tp> template<class _Dom> \
00617 inline valarray<_Tp>& \
00618 valarray<_Tp>::operator _Op##=(const _Expr<_Dom,_Tp>& __e) \
00619 { \
00620 _Array_augmented_##_Name(_Array<_Tp>(_M_data), __e, _M_size); \
00621 return *this; \
00622 }
00623
00624 _DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(+, __plus)
00625 _DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(-, __minus)
00626 _DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(*, __multiplies)
00627 _DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(/, __divides)
00628 _DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(%, __modulus)
00629 _DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(^, __bitwise_xor)
00630 _DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(&, __bitwise_and)
00631 _DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(|, __bitwise_or)
00632 _DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(<<, __shift_left)
00633 _DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(>>, __shift_right)
00634
00635 #undef _DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT
00636
00637
00638 #define _DEFINE_BINARY_OPERATOR(_Op, _Name) \
00639 template<typename _Tp> \
00640 inline _Expr<_BinClos<_Name,_ValArray,_ValArray,_Tp,_Tp>, \
00641 typename __fun<_Name, _Tp>::result_type> \
00642 operator _Op(const valarray<_Tp>& __v, const valarray<_Tp>& __w) \
00643 { \
00644 typedef _BinClos<_Name,_ValArray,_ValArray,_Tp,_Tp> _Closure; \
00645 typedef typename __fun<_Name, _Tp>::result_type _Rt; \
00646 return _Expr<_Closure, _Rt>(_Closure(__v, __w)); \
00647 } \
00648 \
00649 template<typename _Tp> \
00650 inline _Expr<_BinClos<_Name,_ValArray,_Constant,_Tp,_Tp>, \
00651 typename __fun<_Name, _Tp>::result_type> \
00652 operator _Op(const valarray<_Tp>& __v, const _Tp& __t) \
00653 { \
00654 typedef _BinClos<_Name,_ValArray,_Constant,_Tp,_Tp> _Closure; \
00655 typedef typename __fun<_Name, _Tp>::result_type _Rt; \
00656 return _Expr<_Closure, _Rt>(_Closure(__v, __t)); \
00657 } \
00658 \
00659 template<typename _Tp> \
00660 inline _Expr<_BinClos<_Name,_Constant,_ValArray,_Tp,_Tp>, \
00661 typename __fun<_Name, _Tp>::result_type> \
00662 operator _Op(const _Tp& __t, const valarray<_Tp>& __v) \
00663 { \
00664 typedef _BinClos<_Name,_Constant,_ValArray,_Tp,_Tp> _Closure; \
00665 typedef typename __fun<_Name, _Tp>::result_type _Rt; \
00666 return _Expr<_Closure, _Tp>(_Closure(__t, __v)); \
00667 }
00668
00669 _DEFINE_BINARY_OPERATOR(+, __plus)
00670 _DEFINE_BINARY_OPERATOR(-, __minus)
00671 _DEFINE_BINARY_OPERATOR(*, __multiplies)
00672 _DEFINE_BINARY_OPERATOR(/, __divides)
00673 _DEFINE_BINARY_OPERATOR(%, __modulus)
00674 _DEFINE_BINARY_OPERATOR(^, __bitwise_xor)
00675 _DEFINE_BINARY_OPERATOR(&, __bitwise_and)
00676 _DEFINE_BINARY_OPERATOR(|, __bitwise_or)
00677 _DEFINE_BINARY_OPERATOR(<<, __shift_left)
00678 _DEFINE_BINARY_OPERATOR(>>, __shift_right)
00679 _DEFINE_BINARY_OPERATOR(&&, __logical_and)
00680 _DEFINE_BINARY_OPERATOR(||, __logical_or)
00681 _DEFINE_BINARY_OPERATOR(==, __equal_to)
00682 _DEFINE_BINARY_OPERATOR(!=, __not_equal_to)
00683 _DEFINE_BINARY_OPERATOR(<, __less)
00684 _DEFINE_BINARY_OPERATOR(>, __greater)
00685 _DEFINE_BINARY_OPERATOR(<=, __less_equal)
00686 _DEFINE_BINARY_OPERATOR(>=, __greater_equal)
00687
00688 }
00689
00690 #endif
00691
00692
00693
00694