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