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 #ifndef _VALARRAY_AFTER_H
00034 #define _VALARRAY_AFTER_H 1
00035
00036 #pragma GCC system_header
00037
00038 _GLIBCXX_BEGIN_NAMESPACE(std)
00039
00040
00041
00042
00043 template<class _Dom>
00044 class _GBase
00045 {
00046 public:
00047 typedef typename _Dom::value_type value_type;
00048
00049 _GBase (const _Dom& __e, const valarray<size_t>& __i)
00050 : _M_expr (__e), _M_index(__i) {}
00051
00052 value_type
00053 operator[] (size_t __i) const
00054 { return _M_expr[_M_index[__i]]; }
00055
00056 size_t
00057 size () const
00058 { return _M_index.size(); }
00059
00060 private:
00061 const _Dom& _M_expr;
00062 const valarray<size_t>& _M_index;
00063 };
00064
00065 template<typename _Tp>
00066 class _GBase<_Array<_Tp> >
00067 {
00068 public:
00069 typedef _Tp value_type;
00070
00071 _GBase (_Array<_Tp> __a, const valarray<size_t>& __i)
00072 : _M_array (__a), _M_index(__i) {}
00073
00074 value_type
00075 operator[] (size_t __i) const
00076 { return _M_array._M_data[_M_index[__i]]; }
00077
00078 size_t
00079 size () const
00080 { return _M_index.size(); }
00081
00082 private:
00083 const _Array<_Tp> _M_array;
00084 const valarray<size_t>& _M_index;
00085 };
00086
00087 template<class _Dom>
00088 struct _GClos<_Expr, _Dom>
00089 : _GBase<_Dom>
00090 {
00091 typedef _GBase<_Dom> _Base;
00092 typedef typename _Base::value_type value_type;
00093
00094 _GClos (const _Dom& __e, const valarray<size_t>& __i)
00095 : _Base (__e, __i) {}
00096 };
00097
00098 template<typename _Tp>
00099 struct _GClos<_ValArray, _Tp>
00100 : _GBase<_Array<_Tp> >
00101 {
00102 typedef _GBase<_Array<_Tp> > _Base;
00103 typedef typename _Base::value_type value_type;
00104
00105 _GClos (_Array<_Tp> __a, const valarray<size_t>& __i)
00106 : _Base (__a, __i) {}
00107 };
00108
00109
00110
00111
00112 template<class _Dom>
00113 class _IBase
00114 {
00115 public:
00116 typedef typename _Dom::value_type value_type;
00117
00118 _IBase (const _Dom& __e, const valarray<size_t>& __i)
00119 : _M_expr (__e), _M_index (__i) {}
00120
00121 value_type
00122 operator[] (size_t __i) const
00123 { return _M_expr[_M_index[__i]]; }
00124
00125 size_t
00126 size() const
00127 { return _M_index.size(); }
00128
00129 private:
00130 const _Dom& _M_expr;
00131 const valarray<size_t>& _M_index;
00132 };
00133
00134 template<class _Dom>
00135 struct _IClos<_Expr, _Dom>
00136 : _IBase<_Dom>
00137 {
00138 typedef _IBase<_Dom> _Base;
00139 typedef typename _Base::value_type value_type;
00140
00141 _IClos (const _Dom& __e, const valarray<size_t>& __i)
00142 : _Base (__e, __i) {}
00143 };
00144
00145 template<typename _Tp>
00146 struct _IClos<_ValArray, _Tp>
00147 : _IBase<valarray<_Tp> >
00148 {
00149 typedef _IBase<valarray<_Tp> > _Base;
00150 typedef _Tp value_type;
00151
00152 _IClos (const valarray<_Tp>& __a, const valarray<size_t>& __i)
00153 : _Base (__a, __i) {}
00154 };
00155
00156
00157
00158
00159 template<class _Clos, typename _Tp>
00160 class _Expr
00161 {
00162 public:
00163 typedef _Tp value_type;
00164
00165 _Expr(const _Clos&);
00166
00167 const _Clos& operator()() const;
00168
00169 value_type operator[](size_t) const;
00170 valarray<value_type> operator[](slice) const;
00171 valarray<value_type> operator[](const gslice&) const;
00172 valarray<value_type> operator[](const valarray<bool>&) const;
00173 valarray<value_type> operator[](const valarray<size_t>&) const;
00174
00175 _Expr<_UnClos<__unary_plus, std::_Expr, _Clos>, value_type>
00176 operator+() const;
00177
00178 _Expr<_UnClos<__negate, std::_Expr, _Clos>, value_type>
00179 operator-() const;
00180
00181 _Expr<_UnClos<__bitwise_not, std::_Expr, _Clos>, value_type>
00182 operator~() const;
00183
00184 _Expr<_UnClos<__logical_not, std::_Expr, _Clos>, bool>
00185 operator!() const;
00186
00187 size_t size() const;
00188 value_type sum() const;
00189
00190 valarray<value_type> shift(int) const;
00191 valarray<value_type> cshift(int) const;
00192
00193 value_type min() const;
00194 value_type max() const;
00195
00196 valarray<value_type> apply(value_type (*)(const value_type&)) const;
00197 valarray<value_type> apply(value_type (*)(value_type)) const;
00198
00199 private:
00200 const _Clos _M_closure;
00201 };
00202
00203 template<class _Clos, typename _Tp>
00204 inline
00205 _Expr<_Clos, _Tp>::_Expr(const _Clos& __c) : _M_closure(__c) {}
00206
00207 template<class _Clos, typename _Tp>
00208 inline const _Clos&
00209 _Expr<_Clos, _Tp>::operator()() const
00210 { return _M_closure; }
00211
00212 template<class _Clos, typename _Tp>
00213 inline _Tp
00214 _Expr<_Clos, _Tp>::operator[](size_t __i) const
00215 { return _M_closure[__i]; }
00216
00217 template<class _Clos, typename _Tp>
00218 inline valarray<_Tp>
00219 _Expr<_Clos, _Tp>::operator[](slice __s) const
00220 {
00221 valarray<_Tp> __v = valarray<_Tp>(*this)[__s];
00222 return __v;
00223 }
00224
00225 template<class _Clos, typename _Tp>
00226 inline valarray<_Tp>
00227 _Expr<_Clos, _Tp>::operator[](const gslice& __gs) const
00228 {
00229 valarray<_Tp> __v = valarray<_Tp>(*this)[__gs];
00230 return __v;
00231 }
00232
00233 template<class _Clos, typename _Tp>
00234 inline valarray<_Tp>
00235 _Expr<_Clos, _Tp>::operator[](const valarray<bool>& __m) const
00236 {
00237 valarray<_Tp> __v = valarray<_Tp>(*this)[__m];
00238 return __v;
00239 }
00240
00241 template<class _Clos, typename _Tp>
00242 inline valarray<_Tp>
00243 _Expr<_Clos, _Tp>::operator[](const valarray<size_t>& __i) const
00244 {
00245 valarray<_Tp> __v = valarray<_Tp>(*this)[__i];
00246 return __v;
00247 }
00248
00249 template<class _Clos, typename _Tp>
00250 inline size_t
00251 _Expr<_Clos, _Tp>::size() const
00252 { return _M_closure.size(); }
00253
00254 template<class _Clos, typename _Tp>
00255 inline valarray<_Tp>
00256 _Expr<_Clos, _Tp>::shift(int __n) const
00257 {
00258 valarray<_Tp> __v = valarray<_Tp>(*this).shift(__n);
00259 return __v;
00260 }
00261
00262 template<class _Clos, typename _Tp>
00263 inline valarray<_Tp>
00264 _Expr<_Clos, _Tp>::cshift(int __n) const
00265 {
00266 valarray<_Tp> __v = valarray<_Tp>(*this).cshift(__n);
00267 return __v;
00268 }
00269
00270 template<class _Clos, typename _Tp>
00271 inline valarray<_Tp>
00272 _Expr<_Clos, _Tp>::apply(_Tp __f(const _Tp&)) const
00273 {
00274 valarray<_Tp> __v = valarray<_Tp>(*this).apply(__f);
00275 return __v;
00276 }
00277
00278 template<class _Clos, typename _Tp>
00279 inline valarray<_Tp>
00280 _Expr<_Clos, _Tp>::apply(_Tp __f(_Tp)) const
00281 {
00282 valarray<_Tp> __v = valarray<_Tp>(*this).apply(__f);
00283 return __v;
00284 }
00285
00286
00287 template<class _Clos, typename _Tp>
00288 inline _Tp
00289 _Expr<_Clos, _Tp>::sum() const
00290 {
00291 size_t __n = _M_closure.size();
00292 if (__n == 0)
00293 return _Tp();
00294 else
00295 {
00296 _Tp __s = _M_closure[--__n];
00297 while (__n != 0)
00298 __s += _M_closure[--__n];
00299 return __s;
00300 }
00301 }
00302
00303 template<class _Clos, typename _Tp>
00304 inline _Tp
00305 _Expr<_Clos, _Tp>::min() const
00306 { return __valarray_min(_M_closure); }
00307
00308 template<class _Clos, typename _Tp>
00309 inline _Tp
00310 _Expr<_Clos, _Tp>::max() const
00311 { return __valarray_max(_M_closure); }
00312
00313 template<class _Dom, typename _Tp>
00314 inline _Expr<_UnClos<__logical_not, _Expr, _Dom>, bool>
00315 _Expr<_Dom, _Tp>::operator!() const
00316 {
00317 typedef _UnClos<__logical_not, std::_Expr, _Dom> _Closure;
00318 return _Expr<_Closure, bool>(_Closure(this->_M_closure));
00319 }
00320
00321 #define _DEFINE_EXPR_UNARY_OPERATOR(_Op, _Name) \
00322 template<class _Dom, typename _Tp> \
00323 inline _Expr<_UnClos<_Name, std::_Expr, _Dom>, _Tp> \
00324 _Expr<_Dom, _Tp>::operator _Op() const \
00325 { \
00326 typedef _UnClos<_Name, std::_Expr, _Dom> _Closure; \
00327 return _Expr<_Closure, _Tp>(_Closure(this->_M_closure)); \
00328 }
00329
00330 _DEFINE_EXPR_UNARY_OPERATOR(+, __unary_plus)
00331 _DEFINE_EXPR_UNARY_OPERATOR(-, __negate)
00332 _DEFINE_EXPR_UNARY_OPERATOR(~, __bitwise_not)
00333
00334 #undef _DEFINE_EXPR_UNARY_OPERATOR
00335
00336 #define _DEFINE_EXPR_BINARY_OPERATOR(_Op, _Name) \
00337 template<class _Dom1, class _Dom2> \
00338 inline _Expr<_BinClos<_Name, _Expr, _Expr, _Dom1, _Dom2>, \
00339 typename __fun<_Name, typename _Dom1::value_type>::result_type> \
00340 operator _Op(const _Expr<_Dom1, typename _Dom1::value_type>& __v, \
00341 const _Expr<_Dom2, typename _Dom2::value_type>& __w) \
00342 { \
00343 typedef typename _Dom1::value_type _Arg; \
00344 typedef typename __fun<_Name, _Arg>::result_type _Value; \
00345 typedef _BinClos<_Name, _Expr, _Expr, _Dom1, _Dom2> _Closure; \
00346 return _Expr<_Closure, _Value>(_Closure(__v(), __w())); \
00347 } \
00348 \
00349 template<class _Dom> \
00350 inline _Expr<_BinClos<_Name, _Expr, _Constant, _Dom, \
00351 typename _Dom::value_type>, \
00352 typename __fun<_Name, typename _Dom::value_type>::result_type> \
00353 operator _Op(const _Expr<_Dom, typename _Dom::value_type>& __v, \
00354 const typename _Dom::value_type& __t) \
00355 { \
00356 typedef typename _Dom::value_type _Arg; \
00357 typedef typename __fun<_Name, _Arg>::result_type _Value; \
00358 typedef _BinClos<_Name, _Expr, _Constant, _Dom, _Arg> _Closure; \
00359 return _Expr<_Closure, _Value>(_Closure(__v(), __t)); \
00360 } \
00361 \
00362 template<class _Dom> \
00363 inline _Expr<_BinClos<_Name, _Constant, _Expr, \
00364 typename _Dom::value_type, _Dom>, \
00365 typename __fun<_Name, typename _Dom::value_type>::result_type> \
00366 operator _Op(const typename _Dom::value_type& __t, \
00367 const _Expr<_Dom, typename _Dom::value_type>& __v) \
00368 { \
00369 typedef typename _Dom::value_type _Arg; \
00370 typedef typename __fun<_Name, _Arg>::result_type _Value; \
00371 typedef _BinClos<_Name, _Constant, _Expr, _Arg, _Dom> _Closure; \
00372 return _Expr<_Closure, _Value>(_Closure(__t, __v())); \
00373 } \
00374 \
00375 template<class _Dom> \
00376 inline _Expr<_BinClos<_Name, _Expr, _ValArray, \
00377 _Dom, typename _Dom::value_type>, \
00378 typename __fun<_Name, typename _Dom::value_type>::result_type> \
00379 operator _Op(const _Expr<_Dom,typename _Dom::value_type>& __e, \
00380 const valarray<typename _Dom::value_type>& __v) \
00381 { \
00382 typedef typename _Dom::value_type _Arg; \
00383 typedef typename __fun<_Name, _Arg>::result_type _Value; \
00384 typedef _BinClos<_Name, _Expr, _ValArray, _Dom, _Arg> _Closure; \
00385 return _Expr<_Closure, _Value>(_Closure(__e(), __v)); \
00386 } \
00387 \
00388 template<class _Dom> \
00389 inline _Expr<_BinClos<_Name, _ValArray, _Expr, \
00390 typename _Dom::value_type, _Dom>, \
00391 typename __fun<_Name, typename _Dom::value_type>::result_type> \
00392 operator _Op(const valarray<typename _Dom::value_type>& __v, \
00393 const _Expr<_Dom, typename _Dom::value_type>& __e) \
00394 { \
00395 typedef typename _Dom::value_type _Tp; \
00396 typedef typename __fun<_Name, _Tp>::result_type _Value; \
00397 typedef _BinClos<_Name, _ValArray, _Expr, _Tp, _Dom> _Closure; \
00398 return _Expr<_Closure, _Value>(_Closure(__v, __e ())); \
00399 }
00400
00401 _DEFINE_EXPR_BINARY_OPERATOR(+, __plus)
00402 _DEFINE_EXPR_BINARY_OPERATOR(-, __minus)
00403 _DEFINE_EXPR_BINARY_OPERATOR(*, __multiplies)
00404 _DEFINE_EXPR_BINARY_OPERATOR(/, __divides)
00405 _DEFINE_EXPR_BINARY_OPERATOR(%, __modulus)
00406 _DEFINE_EXPR_BINARY_OPERATOR(^, __bitwise_xor)
00407 _DEFINE_EXPR_BINARY_OPERATOR(&, __bitwise_and)
00408 _DEFINE_EXPR_BINARY_OPERATOR(|, __bitwise_or)
00409 _DEFINE_EXPR_BINARY_OPERATOR(<<, __shift_left)
00410 _DEFINE_EXPR_BINARY_OPERATOR(>>, __shift_right)
00411 _DEFINE_EXPR_BINARY_OPERATOR(&&, __logical_and)
00412 _DEFINE_EXPR_BINARY_OPERATOR(||, __logical_or)
00413 _DEFINE_EXPR_BINARY_OPERATOR(==, __equal_to)
00414 _DEFINE_EXPR_BINARY_OPERATOR(!=, __not_equal_to)
00415 _DEFINE_EXPR_BINARY_OPERATOR(<, __less)
00416 _DEFINE_EXPR_BINARY_OPERATOR(>, __greater)
00417 _DEFINE_EXPR_BINARY_OPERATOR(<=, __less_equal)
00418 _DEFINE_EXPR_BINARY_OPERATOR(>=, __greater_equal)
00419
00420 #undef _DEFINE_EXPR_BINARY_OPERATOR
00421
00422 #define _DEFINE_EXPR_UNARY_FUNCTION(_Name) \
00423 template<class _Dom> \
00424 inline _Expr<_UnClos<__##_Name, _Expr, _Dom>, \
00425 typename _Dom::value_type> \
00426 _Name(const _Expr<_Dom, typename _Dom::value_type>& __e) \
00427 { \
00428 typedef typename _Dom::value_type _Tp; \
00429 typedef _UnClos<__##_Name, _Expr, _Dom> _Closure; \
00430 return _Expr<_Closure, _Tp>(_Closure(__e())); \
00431 } \
00432 \
00433 template<typename _Tp> \
00434 inline _Expr<_UnClos<__##_Name, _ValArray, _Tp>, _Tp> \
00435 _Name(const valarray<_Tp>& __v) \
00436 { \
00437 typedef _UnClos<__##_Name, _ValArray, _Tp> _Closure; \
00438 return _Expr<_Closure, _Tp>(_Closure(__v)); \
00439 }
00440
00441 _DEFINE_EXPR_UNARY_FUNCTION(abs)
00442 _DEFINE_EXPR_UNARY_FUNCTION(cos)
00443 _DEFINE_EXPR_UNARY_FUNCTION(acos)
00444 _DEFINE_EXPR_UNARY_FUNCTION(cosh)
00445 _DEFINE_EXPR_UNARY_FUNCTION(sin)
00446 _DEFINE_EXPR_UNARY_FUNCTION(asin)
00447 _DEFINE_EXPR_UNARY_FUNCTION(sinh)
00448 _DEFINE_EXPR_UNARY_FUNCTION(tan)
00449 _DEFINE_EXPR_UNARY_FUNCTION(tanh)
00450 _DEFINE_EXPR_UNARY_FUNCTION(atan)
00451 _DEFINE_EXPR_UNARY_FUNCTION(exp)
00452 _DEFINE_EXPR_UNARY_FUNCTION(log)
00453 _DEFINE_EXPR_UNARY_FUNCTION(log10)
00454 _DEFINE_EXPR_UNARY_FUNCTION(sqrt)
00455
00456 #undef _DEFINE_EXPR_UNARY_FUNCTION
00457
00458 #define _DEFINE_EXPR_BINARY_FUNCTION(_Fun) \
00459 template<class _Dom1, class _Dom2> \
00460 inline _Expr<_BinClos<__##_Fun, _Expr, _Expr, _Dom1, _Dom2>, \
00461 typename _Dom1::value_type> \
00462 _Fun(const _Expr<_Dom1, typename _Dom1::value_type>& __e1, \
00463 const _Expr<_Dom2, typename _Dom2::value_type>& __e2) \
00464 { \
00465 typedef typename _Dom1::value_type _Tp; \
00466 typedef _BinClos<__##_Fun, _Expr, _Expr, _Dom1, _Dom2> _Closure; \
00467 return _Expr<_Closure, _Tp>(_Closure(__e1(), __e2())); \
00468 } \
00469 \
00470 template<class _Dom> \
00471 inline _Expr<_BinClos<__##_Fun, _Expr, _ValArray, _Dom, \
00472 typename _Dom::value_type>, \
00473 typename _Dom::value_type> \
00474 _Fun(const _Expr<_Dom, typename _Dom::value_type>& __e, \
00475 const valarray<typename _Dom::value_type>& __v) \
00476 { \
00477 typedef typename _Dom::value_type _Tp; \
00478 typedef _BinClos<__##_Fun, _Expr, _ValArray, _Dom, _Tp> _Closure; \
00479 return _Expr<_Closure, _Tp>(_Closure(__e(), __v)); \
00480 } \
00481 \
00482 template<class _Dom> \
00483 inline _Expr<_BinClos<__##_Fun, _ValArray, _Expr, \
00484 typename _Dom::value_type, _Dom>, \
00485 typename _Dom::value_type> \
00486 _Fun(const valarray<typename _Dom::valarray>& __v, \
00487 const _Expr<_Dom, typename _Dom::value_type>& __e) \
00488 { \
00489 typedef typename _Dom::value_type _Tp; \
00490 typedef _BinClos<__##_Fun, _ValArray, _Expr, _Tp, _Dom> _Closure; \
00491 return _Expr<_Closure, _Tp>(_Closure(__v, __e())); \
00492 } \
00493 \
00494 template<class _Dom> \
00495 inline _Expr<_BinClos<__##_Fun, _Expr, _Constant, _Dom, \
00496 typename _Dom::value_type>, \
00497 typename _Dom::value_type> \
00498 _Fun(const _Expr<_Dom, typename _Dom::value_type>& __e, \
00499 const typename _Dom::value_type& __t) \
00500 { \
00501 typedef typename _Dom::value_type _Tp; \
00502 typedef _BinClos<__##_Fun, _Expr, _Constant, _Dom, _Tp> _Closure;\
00503 return _Expr<_Closure, _Tp>(_Closure(__e(), __t)); \
00504 } \
00505 \
00506 template<class _Dom> \
00507 inline _Expr<_BinClos<__##_Fun, _Constant, _Expr, \
00508 typename _Dom::value_type, _Dom>, \
00509 typename _Dom::value_type> \
00510 _Fun(const typename _Dom::value_type& __t, \
00511 const _Expr<_Dom, typename _Dom::value_type>& __e) \
00512 { \
00513 typedef typename _Dom::value_type _Tp; \
00514 typedef _BinClos<__##_Fun, _Constant, _Expr, _Tp, _Dom> _Closure; \
00515 return _Expr<_Closure, _Tp>(_Closure(__t, __e())); \
00516 } \
00517 \
00518 template<typename _Tp> \
00519 inline _Expr<_BinClos<__##_Fun, _ValArray, _ValArray, _Tp, _Tp>, _Tp> \
00520 _Fun(const valarray<_Tp>& __v, const valarray<_Tp>& __w) \
00521 { \
00522 typedef _BinClos<__##_Fun, _ValArray, _ValArray, _Tp, _Tp> _Closure; \
00523 return _Expr<_Closure, _Tp>(_Closure(__v, __w)); \
00524 } \
00525 \
00526 template<typename _Tp> \
00527 inline _Expr<_BinClos<__##_Fun, _ValArray, _Constant, _Tp, _Tp>, _Tp> \
00528 _Fun(const valarray<_Tp>& __v, const _Tp& __t) \
00529 { \
00530 typedef _BinClos<__##_Fun, _ValArray, _Constant, _Tp, _Tp> _Closure; \
00531 return _Expr<_Closure, _Tp>(_Closure(__v, __t)); \
00532 } \
00533 \
00534 template<typename _Tp> \
00535 inline _Expr<_BinClos<__##_Fun, _Constant, _ValArray, _Tp, _Tp>, _Tp> \
00536 _Fun(const _Tp& __t, const valarray<_Tp>& __v) \
00537 { \
00538 typedef _BinClos<__##_Fun, _Constant, _ValArray, _Tp, _Tp> _Closure; \
00539 return _Expr<_Closure, _Tp>(_Closure(__t, __v)); \
00540 }
00541
00542 _DEFINE_EXPR_BINARY_FUNCTION(atan2)
00543 _DEFINE_EXPR_BINARY_FUNCTION(pow)
00544
00545 #undef _DEFINE_EXPR_BINARY_FUNCTION
00546
00547 _GLIBCXX_END_NAMESPACE
00548
00549 #endif