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