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 #ifndef _CPP_VALARRAY_META_H
00038 #define _CPP_VALARRAY_META_H 1
00039
00040 #pragma GCC system_header
00041
00042 namespace std
00043 {
00044
00045
00046
00047
00048
00049
00050
00051
00052
00053
00054 template<typename _Tp1, typename _Tp2> class _Constant;
00055
00056
00057
00058
00059
00060
00061
00062
00063
00064 struct __abs
00065 {
00066 template<typename _Tp>
00067 _Tp operator()(const _Tp& __t) const { return abs(__t); }
00068 };
00069
00070 struct __cos
00071 {
00072 template<typename _Tp>
00073 _Tp operator()(const _Tp& __t) const { return cos(__t); }
00074 };
00075
00076 struct __acos
00077 {
00078 template<typename _Tp>
00079 _Tp operator()(const _Tp& __t) const { return acos(__t); }
00080 };
00081
00082 struct __cosh
00083 {
00084 template<typename _Tp>
00085 _Tp operator()(const _Tp& __t) const { return cosh(__t); }
00086 };
00087
00088 struct __sin
00089 {
00090 template<typename _Tp>
00091 _Tp operator()(const _Tp& __t) const { return sin(__t); }
00092 };
00093
00094 struct __asin
00095 {
00096 template<typename _Tp>
00097 _Tp operator()(const _Tp& __t) const { return asin(__t); }
00098 };
00099
00100 struct __sinh
00101 {
00102 template<typename _Tp>
00103 _Tp operator()(const _Tp& __t) const { return sinh(__t); }
00104 };
00105
00106 struct __tan
00107 {
00108 template<typename _Tp>
00109 _Tp operator()(const _Tp& __t) const { return tan(__t); }
00110 };
00111
00112 struct __atan
00113 {
00114 template<typename _Tp>
00115 _Tp operator()(const _Tp& __t) const { return atan(__t); }
00116 };
00117
00118 struct __tanh
00119 {
00120 template<typename _Tp>
00121 _Tp operator()(const _Tp& __t) const { return tanh(__t); }
00122 };
00123
00124 struct __exp
00125 {
00126 template<typename _Tp>
00127 _Tp operator()(const _Tp& __t) const { return exp(__t); }
00128 };
00129
00130 struct __log
00131 {
00132 template<typename _Tp>
00133 _Tp operator()(const _Tp& __t) const { return log(__t); }
00134 };
00135
00136 struct __log10
00137 {
00138 template<typename _Tp>
00139 _Tp operator()(const _Tp& __t) const { return log10(__t); }
00140 };
00141
00142 struct __sqrt
00143 {
00144 template<typename _Tp>
00145 _Tp operator()(const _Tp& __t) const { return sqrt(__t); }
00146 };
00147
00148
00149
00150
00151
00152 struct __unary_plus
00153 {
00154 template<typename _Tp>
00155 _Tp operator()(const _Tp& __t) const { return +__t; }
00156 };
00157
00158 struct __negate
00159 {
00160 template<typename _Tp>
00161 _Tp operator()(const _Tp& __t) const { return -__t; }
00162 };
00163
00164 struct __bitwise_not
00165 {
00166 template<typename _Tp>
00167 _Tp operator()(const _Tp& __t) const { return ~__t; }
00168 };
00169
00170 struct __plus
00171 {
00172 template<typename _Tp>
00173 _Tp operator()(const _Tp& __x, const _Tp& __y) const
00174 { return __x + __y; }
00175 };
00176
00177 struct __minus
00178 {
00179 template<typename _Tp>
00180 _Tp operator()(const _Tp& __x, const _Tp& __y) const
00181 { return __x - __y; }
00182 };
00183
00184 struct __multiplies
00185 {
00186 template<typename _Tp>
00187 _Tp operator()(const _Tp& __x, const _Tp& __y) const
00188 { return __x * __y; }
00189 };
00190
00191 struct __divides
00192 {
00193 template<typename _Tp>
00194 _Tp operator()(const _Tp& __x, const _Tp& __y) const
00195 { return __x / __y; }
00196 };
00197
00198 struct __modulus
00199 {
00200 template<typename _Tp>
00201 _Tp operator()(const _Tp& __x, const _Tp& __y) const
00202 { return __x % __y; }
00203 };
00204
00205 struct __bitwise_xor
00206 {
00207 template<typename _Tp>
00208 _Tp operator()(const _Tp& __x, const _Tp& __y) const
00209 { return __x ^ __y; }
00210 };
00211
00212 struct __bitwise_and
00213 {
00214 template<typename _Tp>
00215 _Tp operator()(const _Tp& __x, const _Tp& __y) const
00216 { return __x & __y; }
00217 };
00218
00219 struct __bitwise_or
00220 {
00221 template<typename _Tp>
00222 _Tp operator()(const _Tp& __x, const _Tp& __y) const
00223 { return __x | __y; }
00224 };
00225
00226 struct __shift_left
00227 {
00228 template<typename _Tp>
00229 _Tp operator()(const _Tp& __x, const _Tp& __y) const
00230 { return __x << __y; }
00231 };
00232
00233 struct __shift_right
00234 {
00235 template<typename _Tp>
00236 _Tp operator()(const _Tp& __x, const _Tp& __y) const
00237 { return __x >> __y; }
00238 };
00239
00240 struct __logical_and
00241 {
00242 template<typename _Tp>
00243 bool operator()(const _Tp& __x, const _Tp& __y) const
00244 { return __x && __y; }
00245 };
00246
00247 struct __logical_or
00248 {
00249 template<typename _Tp>
00250 bool operator()(const _Tp& __x, const _Tp& __y) const
00251 { return __x || __y; }
00252 };
00253
00254 struct __logical_not
00255 {
00256 template<typename _Tp>
00257 bool operator()(const _Tp& __x) const { return !__x; }
00258 };
00259
00260 struct __equal_to
00261 {
00262 template<typename _Tp>
00263 bool operator()(const _Tp& __x, const _Tp& __y) const
00264 { return __x == __y; }
00265 };
00266
00267 struct __not_equal_to
00268 {
00269 template<typename _Tp>
00270 bool operator()(const _Tp& __x, const _Tp& __y) const
00271 { return __x != __y; }
00272 };
00273
00274 struct __less
00275 {
00276 template<typename _Tp>
00277 bool operator()(const _Tp& __x, const _Tp& __y) const
00278 { return __x < __y; }
00279 };
00280
00281 struct __greater
00282 {
00283 template<typename _Tp>
00284 bool operator()(const _Tp& __x, const _Tp& __y) const
00285 { return __x > __y; }
00286 };
00287
00288 struct __less_equal
00289 {
00290 template<typename _Tp>
00291 bool operator()(const _Tp& __x, const _Tp& __y) const
00292 { return __x <= __y; }
00293 };
00294
00295 struct __greater_equal
00296 {
00297 template<typename _Tp>
00298 bool operator()(const _Tp& __x, const _Tp& __y) const
00299 { return __x >= __y; }
00300 };
00301
00302
00303 struct __atan2
00304 {
00305 template<typename _Tp>
00306 _Tp operator()(const _Tp& __x, const _Tp& __y) const
00307 { return atan2(__x, __y); }
00308 };
00309
00310 struct __pow
00311 {
00312 template<typename _Tp>
00313 _Tp operator()(const _Tp& __x, const _Tp& __y) const
00314 { return pow(__x, __y); }
00315 };
00316
00317
00318
00319
00320
00321 template<typename, typename _Tp>
00322 struct __fun
00323 {
00324 typedef _Tp result_type;
00325 };
00326
00327
00328 template<typename _Tp>
00329 struct __fun<__logical_not, _Tp>
00330 {
00331 typedef bool result_type;
00332 };
00333
00334 template<typename _Tp>
00335 struct __fun<__logical_and, _Tp>
00336 {
00337 typedef bool result_type;
00338 };
00339
00340 template<typename _Tp>
00341 struct __fun<__logical_or, _Tp>
00342 {
00343 typedef bool result_type;
00344 };
00345
00346 template<typename _Tp>
00347 struct __fun<__less, _Tp>
00348 {
00349 typedef bool result_type;
00350 };
00351
00352 template<typename _Tp>
00353 struct __fun<__greater, _Tp>
00354 {
00355 typedef bool result_type;
00356 };
00357
00358 template<typename _Tp>
00359 struct __fun<__less_equal, _Tp>
00360 {
00361 typedef bool result_type;
00362 };
00363
00364 template<typename _Tp>
00365 struct __fun<__greater_equal, _Tp>
00366 {
00367 typedef bool result_type;
00368 };
00369
00370 template<typename _Tp>
00371 struct __fun<__equal_to, _Tp>
00372 {
00373 typedef bool result_type;
00374 };
00375
00376 template<typename _Tp>
00377 struct __fun<__not_equal_to, _Tp>
00378 {
00379 typedef bool result_type;
00380 };
00381
00382
00383
00384
00385
00386 template<typename _Dom, typename _Arg>
00387 class _FunBase
00388 {
00389 public:
00390 typedef typename _Dom::value_type value_type;
00391
00392 _FunBase(const _Dom& __e, value_type __f(_Arg))
00393 : _M_expr(__e), _M_func(__f) {}
00394
00395 value_type operator[](size_t __i) const
00396 { return _M_func (_M_expr[__i]); }
00397
00398 size_t size() const { return _M_expr.size ();}
00399
00400 private:
00401 const _Dom& _M_expr;
00402 value_type (*_M_func)(_Arg);
00403 };
00404
00405 template<class _Dom>
00406 struct _ValFunClos<_Expr,_Dom> : _FunBase<_Dom, typename _Dom::value_type>
00407 {
00408 typedef _FunBase<_Dom, typename _Dom::value_type> _Base;
00409 typedef typename _Base::value_type value_type;
00410 typedef value_type _Tp;
00411
00412 _ValFunClos(const _Dom& __e, _Tp __f(_Tp)) : _Base(__e, __f) {}
00413 };
00414
00415 template<typename _Tp>
00416 struct _ValFunClos<_ValArray,_Tp> : _FunBase<valarray<_Tp>, _Tp>
00417 {
00418 typedef _FunBase<valarray<_Tp>, _Tp> _Base;
00419 typedef _Tp value_type;
00420
00421 _ValFunClos(const valarray<_Tp>& __v, _Tp __f(_Tp)) : _Base(__v, __f) {}
00422 };
00423
00424 template<class _Dom>
00425 struct _RefFunClos<_Expr,_Dom> :
00426 _FunBase<_Dom, const typename _Dom::value_type&>
00427 {
00428 typedef _FunBase<_Dom, const typename _Dom::value_type&> _Base;
00429 typedef typename _Base::value_type value_type;
00430 typedef value_type _Tp;
00431
00432 _RefFunClos(const _Dom& __e, _Tp __f(const _Tp&))
00433 : _Base(__e, __f) {}
00434 };
00435
00436 template<typename _Tp>
00437 struct _RefFunClos<_ValArray,_Tp> : _FunBase<valarray<_Tp>, const _Tp&>
00438 {
00439 typedef _FunBase<valarray<_Tp>, const _Tp&> _Base;
00440 typedef _Tp value_type;
00441
00442 _RefFunClos(const valarray<_Tp>& __v, _Tp __f(const _Tp&))
00443 : _Base(__v, __f) {}
00444 };
00445
00446
00447
00448
00449
00450 template<class _Oper, class _Arg>
00451 class _UnBase
00452 {
00453 public:
00454 typedef typename _Arg::value_type _Vt;
00455 typedef typename __fun<_Oper, _Vt>::result_type value_type;
00456
00457 _UnBase(const _Arg& __e) : _M_expr(__e) {}
00458
00459 value_type operator[](size_t __i) const
00460 { return _Oper()(_M_expr[__i]); }
00461
00462 size_t size() const { return _M_expr.size(); }
00463
00464 private:
00465 const _Arg& _M_expr;
00466 };
00467
00468 template<class _Oper, class _Dom>
00469 struct _UnClos<_Oper, _Expr, _Dom> : _UnBase<_Oper, _Dom>
00470 {
00471 typedef _Dom _Arg;
00472 typedef _UnBase<_Oper, _Dom> _Base;
00473 typedef typename _Base::value_type value_type;
00474
00475 _UnClos(const _Arg& __e) : _Base(__e) {}
00476 };
00477
00478 template<class _Oper, typename _Tp>
00479 struct _UnClos<_Oper, _ValArray, _Tp> : _UnBase<_Oper, valarray<_Tp> >
00480 {
00481 typedef valarray<_Tp> _Arg;
00482 typedef _UnBase<_Oper, valarray<_Tp> > _Base;
00483 typedef typename _Base::value_type value_type;
00484
00485 _UnClos(const _Arg& __e) : _Base(__e) {}
00486 };
00487
00488
00489
00490
00491
00492
00493 template<class _Oper, class _FirstArg, class _SecondArg>
00494 class _BinBase
00495 {
00496 public:
00497 typedef typename _FirstArg::value_type _Vt;
00498 typedef typename __fun<_Oper, _Vt>::result_type value_type;
00499
00500 _BinBase(const _FirstArg& __e1, const _SecondArg& __e2)
00501 : _M_expr1(__e1), _M_expr2(__e2) {}
00502
00503 value_type operator[](size_t __i) const
00504 { return _Oper()(_M_expr1[__i], _M_expr2[__i]); }
00505
00506 size_t size() const { return _M_expr1.size(); }
00507
00508 private:
00509 const _FirstArg& _M_expr1;
00510 const _SecondArg& _M_expr2;
00511 };
00512
00513
00514 template<class _Oper, class _Clos>
00515 class _BinBase2
00516 {
00517 public:
00518 typedef typename _Clos::value_type _Vt;
00519 typedef typename __fun<_Oper, _Vt>::result_type value_type;
00520
00521 _BinBase2(const _Clos& __e, const _Vt& __t)
00522 : _M_expr1(__e), _M_expr2(__t) {}
00523
00524 value_type operator[](size_t __i) const
00525 { return _Oper()(_M_expr1[__i], _M_expr2); }
00526
00527 size_t size() const { return _M_expr1.size(); }
00528
00529 private:
00530 const _Clos& _M_expr1;
00531 const _Vt& _M_expr2;
00532 };
00533
00534 template<class _Oper, class _Clos>
00535 class _BinBase1
00536 {
00537 public:
00538 typedef typename _Clos::value_type _Vt;
00539 typedef typename __fun<_Oper, _Vt>::result_type value_type;
00540
00541 _BinBase1(const _Vt& __t, const _Clos& __e)
00542 : _M_expr1(__t), _M_expr2(__e) {}
00543
00544 value_type operator[](size_t __i) const
00545 { return _Oper()(_M_expr1, _M_expr2[__i]); }
00546
00547 size_t size() const { return _M_expr2.size(); }
00548
00549 private:
00550 const _Vt& _M_expr1;
00551 const _Clos& _M_expr2;
00552 };
00553
00554 template<class _Oper, class _Dom1, class _Dom2>
00555 struct _BinClos<_Oper, _Expr, _Expr, _Dom1, _Dom2>
00556 : _BinBase<_Oper,_Dom1,_Dom2>
00557 {
00558 typedef _BinBase<_Oper,_Dom1,_Dom2> _Base;
00559 typedef typename _Base::value_type value_type;
00560
00561 _BinClos(const _Dom1& __e1, const _Dom2& __e2) : _Base(__e1, __e2) {}
00562 };
00563
00564 template<class _Oper, typename _Tp>
00565 struct _BinClos<_Oper,_ValArray,_ValArray,_Tp,_Tp>
00566 : _BinBase<_Oper,valarray<_Tp>,valarray<_Tp> >
00567 {
00568 typedef _BinBase<_Oper,valarray<_Tp>,valarray<_Tp> > _Base;
00569 typedef _Tp value_type;
00570
00571 _BinClos(const valarray<_Tp>& __v, const valarray<_Tp>& __w)
00572 : _Base(__v, __w) {}
00573 };
00574
00575 template<class _Oper, class _Dom>
00576 struct _BinClos<_Oper,_Expr,_ValArray,_Dom,typename _Dom::value_type>
00577 : _BinBase<_Oper,_Dom,valarray<typename _Dom::value_type> >
00578 {
00579 typedef typename _Dom::value_type _Tp;
00580 typedef _BinBase<_Oper,_Dom,valarray<_Tp> > _Base;
00581 typedef typename _Base::value_type value_type;
00582
00583 _BinClos(const _Dom& __e1, const valarray<_Tp>& __e2)
00584 : _Base(__e1, __e2) {}
00585 };
00586
00587 template<class _Oper, class _Dom>
00588 struct _BinClos<_Oper,_ValArray,_Expr,typename _Dom::value_type,_Dom>
00589 : _BinBase<_Oper,valarray<typename _Dom::value_type>,_Dom>
00590 {
00591 typedef typename _Dom::value_type _Tp;
00592 typedef _BinBase<_Oper,valarray<_Tp>,_Dom> _Base;
00593 typedef typename _Base::value_type value_type;
00594
00595 _BinClos(const valarray<_Tp>& __e1, const _Dom& __e2)
00596 : _Base(__e1, __e2) {}
00597 };
00598
00599 template<class _Oper, class _Dom>
00600 struct _BinClos<_Oper,_Expr,_Constant,_Dom,typename _Dom::value_type>
00601 : _BinBase2<_Oper,_Dom>
00602 {
00603 typedef typename _Dom::value_type _Tp;
00604 typedef _BinBase2<_Oper,_Dom> _Base;
00605 typedef typename _Base::value_type value_type;
00606
00607 _BinClos(const _Dom& __e1, const _Tp& __e2) : _Base(__e1, __e2) {}
00608 };
00609
00610 template<class _Oper, class _Dom>
00611 struct _BinClos<_Oper,_Constant,_Expr,typename _Dom::value_type,_Dom>
00612 : _BinBase1<_Oper,_Dom>
00613 {
00614 typedef typename _Dom::value_type _Tp;
00615 typedef _BinBase1<_Oper,_Dom> _Base;
00616 typedef typename _Base::value_type value_type;
00617
00618 _BinClos(const _Tp& __e1, const _Dom& __e2) : _Base(__e1, __e2) {}
00619 };
00620
00621 template<class _Oper, typename _Tp>
00622 struct _BinClos<_Oper,_ValArray,_Constant,_Tp,_Tp>
00623 : _BinBase2<_Oper,valarray<_Tp> >
00624 {
00625 typedef _BinBase2<_Oper,valarray<_Tp> > _Base;
00626 typedef typename _Base::value_type value_type;
00627
00628 _BinClos(const valarray<_Tp>& __v, const _Tp& __t) : _Base(__v, __t) {}
00629 };
00630
00631 template<class _Oper, typename _Tp>
00632 struct _BinClos<_Oper,_Constant,_ValArray,_Tp,_Tp>
00633 : _BinBase1<_Oper,valarray<_Tp> >
00634 {
00635 typedef _BinBase1<_Oper,valarray<_Tp> > _Base;
00636 typedef typename _Base::value_type value_type;
00637
00638 _BinClos(const _Tp& __t, const valarray<_Tp>& __v) : _Base(__t, __v) {}
00639 };
00640
00641
00642
00643
00644
00645 template<typename _Dom> class _SBase {
00646 public:
00647 typedef typename _Dom::value_type value_type;
00648
00649 _SBase (const _Dom& __e, const slice& __s)
00650 : _M_expr (__e), _M_slice (__s) {}
00651 value_type operator[] (size_t __i) const
00652 { return _M_expr[_M_slice.start () + __i * _M_slice.stride ()]; }
00653 size_t size() const { return _M_slice.size (); }
00654
00655 private:
00656 const _Dom& _M_expr;
00657 const slice& _M_slice;
00658 };
00659
00660 template<typename _Tp> class _SBase<_Array<_Tp> > {
00661 public:
00662 typedef _Tp value_type;
00663
00664 _SBase (_Array<_Tp> __a, const slice& __s)
00665 : _M_array (__a._M_data+__s.start()), _M_size (__s.size()),
00666 _M_stride (__s.stride()) {}
00667 value_type operator[] (size_t __i) const
00668 { return _M_array._M_data[__i * _M_stride]; }
00669 size_t size() const { return _M_size; }
00670
00671 private:
00672 const _Array<_Tp> _M_array;
00673 const size_t _M_size;
00674 const size_t _M_stride;
00675 };
00676
00677 template<class _Dom> struct _SClos<_Expr,_Dom> : _SBase<_Dom> {
00678 typedef _SBase<_Dom> _Base;
00679 typedef typename _Base::value_type value_type;
00680
00681 _SClos (const _Dom& __e, const slice& __s) : _Base (__e, __s) {}
00682 };
00683
00684 template<typename _Tp>
00685 struct _SClos<_ValArray,_Tp> : _SBase<_Array<_Tp> > {
00686 typedef _SBase<_Array<_Tp> > _Base;
00687 typedef _Tp value_type;
00688
00689 _SClos (_Array<_Tp> __a, const slice& __s) : _Base (__a, __s) {}
00690 };
00691
00692
00693
00694
00695 template<class _Dom> class _GBase {
00696 public:
00697 typedef typename _Dom::value_type value_type;
00698
00699 _GBase (const _Dom& __e, const valarray<size_t>& __i)
00700 : _M_expr (__e), _M_index(__i) {}
00701 value_type operator[] (size_t __i) const
00702 { return _M_expr[_M_index[__i]]; }
00703 size_t size () const { return _M_index.size(); }
00704
00705 private:
00706 const _Dom& _M_expr;
00707 const valarray<size_t>& _M_index;
00708 };
00709
00710 template<typename _Tp> class _GBase<_Array<_Tp> > {
00711 public:
00712 typedef _Tp value_type;
00713
00714 _GBase (_Array<_Tp> __a, const valarray<size_t>& __i)
00715 : _M_array (__a), _M_index(__i) {}
00716 value_type operator[] (size_t __i) const
00717 { return _M_array._M_data[_M_index[__i]]; }
00718 size_t size () const { return _M_index.size(); }
00719
00720 private:
00721 const _Array<_Tp> _M_array;
00722 const valarray<size_t>& _M_index;
00723 };
00724
00725 template<class _Dom> struct _GClos<_Expr,_Dom> : _GBase<_Dom> {
00726 typedef _GBase<_Dom> _Base;
00727 typedef typename _Base::value_type value_type;
00728
00729 _GClos (const _Dom& __e, const valarray<size_t>& __i)
00730 : _Base (__e, __i) {}
00731 };
00732
00733 template<typename _Tp>
00734 struct _GClos<_ValArray,_Tp> : _GBase<_Array<_Tp> > {
00735 typedef _GBase<_Array<_Tp> > _Base;
00736 typedef typename _Base::value_type value_type;
00737
00738 _GClos (_Array<_Tp> __a, const valarray<size_t>& __i)
00739 : _Base (__a, __i) {}
00740 };
00741
00742
00743
00744
00745
00746 template<class _Dom> class _IBase {
00747 public:
00748 typedef typename _Dom::value_type value_type;
00749
00750 _IBase (const _Dom& __e, const valarray<size_t>& __i)
00751 : _M_expr (__e), _M_index (__i) {}
00752 value_type operator[] (size_t __i) const
00753 { return _M_expr[_M_index[__i]]; }
00754 size_t size() const { return _M_index.size(); }
00755
00756 private:
00757 const _Dom& _M_expr;
00758 const valarray<size_t>& _M_index;
00759 };
00760
00761 template<class _Dom> struct _IClos<_Expr,_Dom> : _IBase<_Dom> {
00762 typedef _IBase<_Dom> _Base;
00763 typedef typename _Base::value_type value_type;
00764
00765 _IClos (const _Dom& __e, const valarray<size_t>& __i)
00766 : _Base (__e, __i) {}
00767 };
00768
00769 template<typename _Tp>
00770 struct _IClos<_ValArray,_Tp> : _IBase<valarray<_Tp> > {
00771 typedef _IBase<valarray<_Tp> > _Base;
00772 typedef _Tp value_type;
00773
00774 _IClos (const valarray<_Tp>& __a, const valarray<size_t>& __i)
00775 : _Base (__a, __i) {}
00776 };
00777
00778
00779
00780
00781 template<class _Clos, typename _Tp>
00782 class _Expr
00783 {
00784 public:
00785 typedef _Tp value_type;
00786
00787 _Expr(const _Clos&);
00788
00789 const _Clos& operator()() const;
00790
00791 value_type operator[](size_t) const;
00792 valarray<value_type> operator[](slice) const;
00793 valarray<value_type> operator[](const gslice&) const;
00794 valarray<value_type> operator[](const valarray<bool>&) const;
00795 valarray<value_type> operator[](const valarray<size_t>&) const;
00796
00797 _Expr<_UnClos<__unary_plus,std::_Expr,_Clos>, value_type>
00798 operator+() const;
00799
00800 _Expr<_UnClos<__negate,std::_Expr,_Clos>, value_type>
00801 operator-() const;
00802
00803 _Expr<_UnClos<__bitwise_not,std::_Expr,_Clos>, value_type>
00804 operator~() const;
00805
00806 _Expr<_UnClos<__logical_not,std::_Expr,_Clos>, bool>
00807 operator!() const;
00808
00809 size_t size() const;
00810 value_type sum() const;
00811
00812 valarray<value_type> shift(int) const;
00813 valarray<value_type> cshift(int) const;
00814
00815 value_type min() const;
00816 value_type max() const;
00817
00818 valarray<value_type> apply(value_type (*)(const value_type&)) const;
00819 valarray<value_type> apply(value_type (*)(value_type)) const;
00820
00821 private:
00822 const _Clos _M_closure;
00823 };
00824
00825 template<class _Clos, typename _Tp>
00826 inline
00827 _Expr<_Clos,_Tp>::_Expr(const _Clos& __c) : _M_closure(__c) {}
00828
00829 template<class _Clos, typename _Tp>
00830 inline const _Clos&
00831 _Expr<_Clos,_Tp>::operator()() const
00832 { return _M_closure; }
00833
00834 template<class _Clos, typename _Tp>
00835 inline _Tp
00836 _Expr<_Clos,_Tp>::operator[](size_t __i) const
00837 { return _M_closure[__i]; }
00838
00839 template<class _Clos, typename _Tp>
00840 inline valarray<_Tp>
00841 _Expr<_Clos,_Tp>::operator[](slice __s) const
00842 { return _M_closure[__s]; }
00843
00844 template<class _Clos, typename _Tp>
00845 inline valarray<_Tp>
00846 _Expr<_Clos,_Tp>::operator[](const gslice& __gs) const
00847 { return _M_closure[__gs]; }
00848
00849 template<class _Clos, typename _Tp>
00850 inline valarray<_Tp>
00851 _Expr<_Clos,_Tp>::operator[](const valarray<bool>& __m) const
00852 { return _M_closure[__m]; }
00853
00854 template<class _Clos, typename _Tp>
00855 inline valarray<_Tp>
00856 _Expr<_Clos,_Tp>::operator[](const valarray<size_t>& __i) const
00857 { return _M_closure[__i]; }
00858
00859 template<class _Clos, typename _Tp>
00860 inline size_t
00861 _Expr<_Clos,_Tp>::size() const { return _M_closure.size (); }
00862
00863 template<class _Clos, typename _Tp>
00864 inline valarray<_Tp>
00865 _Expr<_Clos, _Tp>::shift(int __n) const
00866 { return valarray<_Tp>(_M_closure).shift(__n); }
00867
00868 template<class _Clos, typename _Tp>
00869 inline valarray<_Tp>
00870 _Expr<_Clos, _Tp>::cshift(int __n) const
00871 { return valarray<_Tp>(_M_closure).cshift(__n); }
00872
00873 template<class _Clos, typename _Tp>
00874 inline valarray<_Tp>
00875 _Expr<_Clos, _Tp>::apply(_Tp __f(const _Tp&)) const
00876 { return valarray<_Tp>(_M_closure).apply(__f); }
00877
00878 template<class _Clos, typename _Tp>
00879 inline valarray<_Tp>
00880 _Expr<_Clos, _Tp>::apply(_Tp __f(_Tp)) const
00881 { return valarray<_Tp>(_M_closure).apply(__f); }
00882
00883
00884 template<class _Clos, typename _Tp>
00885 inline _Tp
00886 _Expr<_Clos,_Tp>::sum() const
00887 {
00888 size_t __n = _M_closure.size();
00889 if (__n == 0)
00890 return _Tp();
00891 else
00892 {
00893 _Tp __s = _M_closure[--__n];
00894 while (__n != 0)
00895 __s += _M_closure[--__n];
00896 return __s;
00897 }
00898 }
00899
00900 template<class _Clos, typename _Tp>
00901 inline _Tp
00902 _Expr<_Clos, _Tp>::min() const
00903 { return __valarray_min(_M_closure); }
00904
00905 template<class _Clos, typename _Tp>
00906 inline _Tp
00907 _Expr<_Clos, _Tp>::max() const
00908 { return __valarray_max(_M_closure); }
00909
00910 template<class _Dom, typename _Tp>
00911 inline _Expr<_UnClos<__logical_not,_Expr,_Dom>, bool>
00912 _Expr<_Dom,_Tp>::operator!() const
00913 {
00914 typedef _UnClos<__logical_not,std::_Expr,_Dom> _Closure;
00915 return _Expr<_Closure,_Tp>(_Closure(this->_M_closure));
00916 }
00917
00918 #define _DEFINE_EXPR_UNARY_OPERATOR(_Op, _Name) \
00919 template<class _Dom, typename _Tp> \
00920 inline _Expr<_UnClos<_Name,std::_Expr,_Dom>,_Tp> \
00921 _Expr<_Dom,_Tp>::operator _Op() const \
00922 { \
00923 typedef _UnClos<_Name,std::_Expr,_Dom> _Closure; \
00924 return _Expr<_Closure,_Tp>(_Closure(this->_M_closure)); \
00925 }
00926
00927 _DEFINE_EXPR_UNARY_OPERATOR(+, __unary_plus)
00928 _DEFINE_EXPR_UNARY_OPERATOR(-, __negate)
00929 _DEFINE_EXPR_UNARY_OPERATOR(~, __bitwise_not)
00930
00931 #undef _DEFINE_EXPR_UNARY_OPERATOR
00932
00933
00934 #define _DEFINE_EXPR_BINARY_OPERATOR(_Op, _Name) \
00935 template<class _Dom1, class _Dom2> \
00936 inline _Expr<_BinClos<_Name,_Expr,_Expr,_Dom1,_Dom2>, \
00937 typename __fun<_Name, typename _Dom1::value_type>::result_type>\
00938 operator _Op(const _Expr<_Dom1,typename _Dom1::value_type>& __v, \
00939 const _Expr<_Dom2,typename _Dom2::value_type>& __w) \
00940 { \
00941 typedef typename _Dom1::value_type _Arg; \
00942 typedef typename __fun<_Name, _Arg>::result_type _Value; \
00943 typedef _BinClos<_Name,_Expr,_Expr,_Dom1,_Dom2> _Closure; \
00944 return _Expr<_Closure,_Value>(_Closure(__v(), __w())); \
00945 } \
00946 \
00947 template<class _Dom> \
00948 inline _Expr<_BinClos<_Name,_Expr,_Constant,_Dom,typename _Dom::value_type>,\
00949 typename __fun<_Name, typename _Dom::value_type>::result_type>\
00950 operator _Op(const _Expr<_Dom,typename _Dom::value_type>& __v, \
00951 const typename _Dom::value_type& __t) \
00952 { \
00953 typedef typename _Dom::value_type _Arg; \
00954 typedef typename __fun<_Name, _Arg>::result_type _Value; \
00955 typedef _BinClos<_Name,_Expr,_Constant,_Dom,_Arg> _Closure; \
00956 return _Expr<_Closure,_Value>(_Closure(__v(), __t)); \
00957 } \
00958 \
00959 template<class _Dom> \
00960 inline _Expr<_BinClos<_Name,_Constant,_Expr,typename _Dom::value_type,_Dom>,\
00961 typename __fun<_Name, typename _Dom::value_type>::result_type>\
00962 operator _Op(const typename _Dom::value_type& __t, \
00963 const _Expr<_Dom,typename _Dom::value_type>& __v) \
00964 { \
00965 typedef typename _Dom::value_type _Arg; \
00966 typedef typename __fun<_Name, _Arg>::result_type _Value; \
00967 typedef _BinClos<_Name,_Constant,_Expr,_Arg,_Dom> _Closure; \
00968 return _Expr<_Closure,_Value>(_Closure(__t, __v())); \
00969 } \
00970 \
00971 template<class _Dom> \
00972 inline _Expr<_BinClos<_Name,_Expr,_ValArray,_Dom,typename _Dom::value_type>,\
00973 typename __fun<_Name, typename _Dom::value_type>::result_type>\
00974 operator _Op(const _Expr<_Dom,typename _Dom::value_type>& __e, \
00975 const valarray<typename _Dom::value_type>& __v) \
00976 { \
00977 typedef typename _Dom::value_type _Arg; \
00978 typedef typename __fun<_Name, _Arg>::result_type _Value; \
00979 typedef _BinClos<_Name,_Expr,_ValArray,_Dom,_Arg> _Closure; \
00980 return _Expr<_Closure,_Value>(_Closure(__e(), __v)); \
00981 } \
00982 \
00983 template<class _Dom> \
00984 inline _Expr<_BinClos<_Name,_ValArray,_Expr,typename _Dom::value_type,_Dom>,\
00985 typename __fun<_Name, typename _Dom::value_type>::result_type>\
00986 operator _Op(const valarray<typename _Dom::value_type>& __v, \
00987 const _Expr<_Dom,typename _Dom::value_type>& __e) \
00988 { \
00989 typedef typename _Dom::value_type _Tp; \
00990 typedef typename __fun<_Name, _Tp>::result_type _Value; \
00991 typedef _BinClos<_Name,_ValArray,_Expr,_Tp,_Dom> _Closure; \
00992 return _Expr<_Closure,_Value> (_Closure (__v, __e ())); \
00993 }
00994
00995 _DEFINE_EXPR_BINARY_OPERATOR(+, __plus)
00996 _DEFINE_EXPR_BINARY_OPERATOR(-, __minus)
00997 _DEFINE_EXPR_BINARY_OPERATOR(*, __multiplies)
00998 _DEFINE_EXPR_BINARY_OPERATOR(/, __divides)
00999 _DEFINE_EXPR_BINARY_OPERATOR(%, __modulus)
01000 _DEFINE_EXPR_BINARY_OPERATOR(^, __bitwise_xor)
01001 _DEFINE_EXPR_BINARY_OPERATOR(&, __bitwise_and)
01002 _DEFINE_EXPR_BINARY_OPERATOR(|, __bitwise_or)
01003 _DEFINE_EXPR_BINARY_OPERATOR(<<, __shift_left)
01004 _DEFINE_EXPR_BINARY_OPERATOR(>>, __shift_right)
01005 _DEFINE_EXPR_BINARY_OPERATOR(&&, __logical_and)
01006 _DEFINE_EXPR_BINARY_OPERATOR(||, __logical_or)
01007 _DEFINE_EXPR_BINARY_OPERATOR(==, __equal_to)
01008 _DEFINE_EXPR_BINARY_OPERATOR(!=, __not_equal_to)
01009 _DEFINE_EXPR_BINARY_OPERATOR(<, __less)
01010 _DEFINE_EXPR_BINARY_OPERATOR(>, __greater)
01011 _DEFINE_EXPR_BINARY_OPERATOR(<=, __less_equal)
01012 _DEFINE_EXPR_BINARY_OPERATOR(>=, __greater_equal)
01013
01014 #undef _DEFINE_EXPR_BINARY_OPERATOR
01015
01016 #define _DEFINE_EXPR_UNARY_FUNCTION(_Name) \
01017 template<class _Dom> \
01018 inline _Expr<_UnClos<__##_Name,_Expr,_Dom>,typename _Dom::value_type>\
01019 _Name(const _Expr<_Dom,typename _Dom::value_type>& __e) \
01020 { \
01021 typedef typename _Dom::value_type _Tp; \
01022 typedef _UnClos<__##_Name,_Expr,_Dom> _Closure; \
01023 return _Expr<_Closure,_Tp>(_Closure(__e())); \
01024 } \
01025 \
01026 template<typename _Tp> \
01027 inline _Expr<_UnClos<__##_Name,_ValArray,_Tp>,_Tp> \
01028 _Name(const valarray<_Tp>& __v) \
01029 { \
01030 typedef _UnClos<__##_Name,_ValArray,_Tp> _Closure; \
01031 return _Expr<_Closure,_Tp>(_Closure(__v)); \
01032 }
01033
01034 _DEFINE_EXPR_UNARY_FUNCTION(abs)
01035 _DEFINE_EXPR_UNARY_FUNCTION(cos)
01036 _DEFINE_EXPR_UNARY_FUNCTION(acos)
01037 _DEFINE_EXPR_UNARY_FUNCTION(cosh)
01038 _DEFINE_EXPR_UNARY_FUNCTION(sin)
01039 _DEFINE_EXPR_UNARY_FUNCTION(asin)
01040 _DEFINE_EXPR_UNARY_FUNCTION(sinh)
01041 _DEFINE_EXPR_UNARY_FUNCTION(tan)
01042 _DEFINE_EXPR_UNARY_FUNCTION(tanh)
01043 _DEFINE_EXPR_UNARY_FUNCTION(atan)
01044 _DEFINE_EXPR_UNARY_FUNCTION(exp)
01045 _DEFINE_EXPR_UNARY_FUNCTION(log)
01046 _DEFINE_EXPR_UNARY_FUNCTION(log10)
01047 _DEFINE_EXPR_UNARY_FUNCTION(sqrt)
01048
01049 #undef _DEFINE_EXPR_UNARY_FUNCTION
01050
01051 #define _DEFINE_EXPR_BINARY_FUNCTION(_Fun) \
01052 template<class _Dom1, class _Dom2> \
01053 inline _Expr<_BinClos<__##_Fun,_Expr,_Expr,_Dom1,_Dom2>, \
01054 typename _Dom1::value_type> \
01055 _Fun(const _Expr<_Dom1,typename _Dom1::value_type>& __e1, \
01056 const _Expr<_Dom2,typename _Dom2::value_type>& __e2) \
01057 { \
01058 typedef typename _Dom1::value_type _Tp; \
01059 typedef _BinClos<__##_Fun,_Expr,_Expr,_Dom1,_Dom2> _Closure; \
01060 return _Expr<_Closure,_Tp>(_Closure(__e1(), __e2())); \
01061 } \
01062 \
01063 template<class _Dom> \
01064 inline _Expr<_BinClos<__##_Fun, _Expr, _ValArray, _Dom, \
01065 typename _Dom::value_type>, \
01066 typename _Dom::value_type> \
01067 _Fun(const _Expr<_Dom,typename _Dom::value_type>& __e, \
01068 const valarray<typename _Dom::value_type>& __v) \
01069 { \
01070 typedef typename _Dom::value_type _Tp; \
01071 typedef _BinClos<__##_Fun, _Expr, _ValArray, _Dom, _Tp> _Closure;\
01072 return _Expr<_Closure,_Tp>(_Closure(__e(), __v)); \
01073 } \
01074 \
01075 template<class _Dom> \
01076 inline _Expr<_BinClos<__##_Fun, _ValArray, _Expr, \
01077 typename _Dom::value_type,_Dom>, \
01078 typename _Dom::value_type> \
01079 _Fun(const valarray<typename _Dom::valarray>& __v, \
01080 const _Expr<_Dom,typename _Dom::value_type>& __e) \
01081 { \
01082 typedef typename _Dom::value_type _Tp; \
01083 typedef _BinClos<__##_Fun,_ValArray,_Expr,_Tp,_Dom> _Closure; \
01084 return _Expr<_Closure,_Tp>(_Closure(__v, __e())); \
01085 } \
01086 \
01087 template<class _Dom> \
01088 inline _Expr<_BinClos<__##_Fun,_Expr,_Constant,_Dom, \
01089 typename _Dom::value_type>, \
01090 typename _Dom::value_type> \
01091 _Fun(const _Expr<_Dom, typename _Dom::value_type>& __e, \
01092 const typename _Dom::value_type& __t) \
01093 { \
01094 typedef typename _Dom::value_type _Tp; \
01095 typedef _BinClos<__##_Fun,_Expr,_Constant,_Dom,_Tp> _Closure; \
01096 return _Expr<_Closure,_Tp>(_Closure(__e(), __t)); \
01097 } \
01098 \
01099 template<class _Dom> \
01100 inline _Expr<_BinClos<__##_Fun,_Constant,_Expr, \
01101 typename _Dom::value_type,_Dom>, \
01102 typename _Dom::value_type> \
01103 _Fun(const typename _Dom::value_type& __t, \
01104 const _Expr<_Dom,typename _Dom::value_type>& __e) \
01105 { \
01106 typedef typename _Dom::value_type _Tp; \
01107 typedef _BinClos<__##_Fun, _Constant,_Expr,_Tp,_Dom> _Closure; \
01108 return _Expr<_Closure,_Tp>(_Closure(__t, __e())); \
01109 } \
01110 \
01111 template<typename _Tp> \
01112 inline _Expr<_BinClos<__##_Fun,_ValArray,_ValArray,_Tp,_Tp>, _Tp> \
01113 _Fun(const valarray<_Tp>& __v, const valarray<_Tp>& __w) \
01114 { \
01115 typedef _BinClos<__##_Fun,_ValArray,_ValArray,_Tp,_Tp> _Closure; \
01116 return _Expr<_Closure,_Tp>(_Closure(__v, __w)); \
01117 } \
01118 \
01119 template<typename _Tp> \
01120 inline _Expr<_BinClos<__##_Fun,_ValArray,_Constant,_Tp,_Tp>,_Tp> \
01121 _Fun(const valarray<_Tp>& __v, const _Tp& __t) \
01122 { \
01123 typedef _BinClos<__##_Fun,_ValArray,_Constant,_Tp,_Tp> _Closure; \
01124 return _Expr<_Closure,_Tp>(_Closure(__v, __t)); \
01125 } \
01126 \
01127 template<typename _Tp> \
01128 inline _Expr<_BinClos<__##_Fun,_Constant,_ValArray,_Tp,_Tp>,_Tp> \
01129 _Fun(const _Tp& __t, const valarray<_Tp>& __v) \
01130 { \
01131 typedef _BinClos<__##_Fun,_Constant,_ValArray,_Tp,_Tp> _Closure; \
01132 return _Expr<_Closure,_Tp>(_Closure(__t, __v)); \
01133 }
01134
01135 _DEFINE_EXPR_BINARY_FUNCTION(atan2)
01136 _DEFINE_EXPR_BINARY_FUNCTION(pow)
01137
01138 #undef _DEFINE_EXPR_BINARY_FUNCTION
01139
01140 }
01141
01142
01143 #endif
01144
01145
01146
01147