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 _VALARRAY_BEFORE_H
00038
#define _VALARRAY_BEFORE_H 1
00039
00040
#pragma GCC system_header
00041
00042
#include <bits/slice_array.h>
00043
00044
namespace std
00045 {
00046
00047
00048
00049
00050
00051
00052
00053
00054
00055
00056
template<
typename _Tp1,
typename _Tp2>
class _Constant;
00057
00058
00059
00060
00061
00062
00063
00064
00065
00066
struct __abs
00067 {
00068
template<
typename _Tp>
00069 _Tp operator()(
const _Tp& __t)
const {
return abs(__t); }
00070 };
00071
00072
struct __cos
00073 {
00074
template<
typename _Tp>
00075 _Tp operator()(
const _Tp& __t)
const {
return cos(__t); }
00076 };
00077
00078
struct __acos
00079 {
00080
template<
typename _Tp>
00081 _Tp operator()(
const _Tp& __t)
const {
return acos(__t); }
00082 };
00083
00084
struct __cosh
00085 {
00086
template<
typename _Tp>
00087 _Tp operator()(
const _Tp& __t)
const {
return cosh(__t); }
00088 };
00089
00090
struct __sin
00091 {
00092
template<
typename _Tp>
00093 _Tp operator()(
const _Tp& __t)
const {
return sin(__t); }
00094 };
00095
00096
struct __asin
00097 {
00098
template<
typename _Tp>
00099 _Tp operator()(
const _Tp& __t)
const {
return asin(__t); }
00100 };
00101
00102
struct __sinh
00103 {
00104
template<
typename _Tp>
00105 _Tp operator()(
const _Tp& __t)
const {
return sinh(__t); }
00106 };
00107
00108
struct __tan
00109 {
00110
template<
typename _Tp>
00111 _Tp operator()(
const _Tp& __t)
const {
return tan(__t); }
00112 };
00113
00114
struct __atan
00115 {
00116
template<
typename _Tp>
00117 _Tp operator()(
const _Tp& __t)
const {
return atan(__t); }
00118 };
00119
00120
struct __tanh
00121 {
00122
template<
typename _Tp>
00123 _Tp operator()(
const _Tp& __t)
const {
return tanh(__t); }
00124 };
00125
00126
struct __exp
00127 {
00128
template<
typename _Tp>
00129 _Tp operator()(
const _Tp& __t)
const {
return exp(__t); }
00130 };
00131
00132
struct __log
00133 {
00134
template<
typename _Tp>
00135 _Tp operator()(
const _Tp& __t)
const {
return log(__t); }
00136 };
00137
00138
struct __log10
00139 {
00140
template<
typename _Tp>
00141 _Tp operator()(
const _Tp& __t)
const {
return log10(__t); }
00142 };
00143
00144
struct __sqrt
00145 {
00146
template<
typename _Tp>
00147 _Tp operator()(
const _Tp& __t)
const {
return sqrt(__t); }
00148 };
00149
00150
00151
00152
00153
00154
struct __unary_plus
00155 {
00156
template<
typename _Tp>
00157 _Tp operator()(
const _Tp& __t)
const {
return +__t; }
00158 };
00159
00160
struct __negate
00161 {
00162
template<
typename _Tp>
00163 _Tp operator()(
const _Tp& __t)
const {
return -__t; }
00164 };
00165
00166
struct __bitwise_not
00167 {
00168
template<
typename _Tp>
00169 _Tp operator()(
const _Tp& __t)
const {
return ~__t; }
00170 };
00171
00172
struct __plus
00173 {
00174
template<
typename _Tp>
00175 _Tp operator()(
const _Tp& __x,
const _Tp& __y)
const
00176
{
return __x + __y; }
00177 };
00178
00179
struct __minus
00180 {
00181
template<
typename _Tp>
00182 _Tp operator()(
const _Tp& __x,
const _Tp& __y)
const
00183
{
return __x - __y; }
00184 };
00185
00186
struct __multiplies
00187 {
00188
template<
typename _Tp>
00189 _Tp operator()(
const _Tp& __x,
const _Tp& __y)
const
00190
{
return __x * __y; }
00191 };
00192
00193
struct __divides
00194 {
00195
template<
typename _Tp>
00196 _Tp operator()(
const _Tp& __x,
const _Tp& __y)
const
00197
{
return __x / __y; }
00198 };
00199
00200
struct __modulus
00201 {
00202
template<
typename _Tp>
00203 _Tp operator()(
const _Tp& __x,
const _Tp& __y)
const
00204
{
return __x % __y; }
00205 };
00206
00207
struct __bitwise_xor
00208 {
00209
template<
typename _Tp>
00210 _Tp operator()(
const _Tp& __x,
const _Tp& __y)
const
00211
{
return __x ^ __y; }
00212 };
00213
00214
struct __bitwise_and
00215 {
00216
template<
typename _Tp>
00217 _Tp operator()(
const _Tp& __x,
const _Tp& __y)
const
00218
{
return __x & __y; }
00219 };
00220
00221
struct __bitwise_or
00222 {
00223
template<
typename _Tp>
00224 _Tp operator()(
const _Tp& __x,
const _Tp& __y)
const
00225
{
return __x | __y; }
00226 };
00227
00228
struct __shift_left
00229 {
00230
template<
typename _Tp>
00231 _Tp operator()(
const _Tp& __x,
const _Tp& __y)
const
00232
{
return __x << __y; }
00233 };
00234
00235
struct __shift_right
00236 {
00237
template<
typename _Tp>
00238 _Tp operator()(
const _Tp& __x,
const _Tp& __y)
const
00239
{
return __x >> __y; }
00240 };
00241
00242
struct __logical_and
00243 {
00244
template<
typename _Tp>
00245
bool operator()(
const _Tp& __x,
const _Tp& __y)
const
00246
{
return __x && __y; }
00247 };
00248
00249
struct __logical_or
00250 {
00251
template<
typename _Tp>
00252
bool operator()(
const _Tp& __x,
const _Tp& __y)
const
00253
{
return __x || __y; }
00254 };
00255
00256
struct __logical_not
00257 {
00258
template<
typename _Tp>
00259
bool operator()(
const _Tp& __x)
const {
return !__x; }
00260 };
00261
00262
struct __equal_to
00263 {
00264
template<
typename _Tp>
00265
bool operator()(
const _Tp& __x,
const _Tp& __y)
const
00266
{
return __x == __y; }
00267 };
00268
00269
struct __not_equal_to
00270 {
00271
template<
typename _Tp>
00272
bool operator()(
const _Tp& __x,
const _Tp& __y)
const
00273
{
return __x != __y; }
00274 };
00275
00276
struct __less
00277 {
00278
template<
typename _Tp>
00279
bool operator()(
const _Tp& __x,
const _Tp& __y)
const
00280
{
return __x < __y; }
00281 };
00282
00283
struct __greater
00284 {
00285
template<
typename _Tp>
00286
bool operator()(
const _Tp& __x,
const _Tp& __y)
const
00287
{
return __x > __y; }
00288 };
00289
00290
struct __less_equal
00291 {
00292
template<
typename _Tp>
00293
bool operator()(
const _Tp& __x,
const _Tp& __y)
const
00294
{
return __x <= __y; }
00295 };
00296
00297
struct __greater_equal
00298 {
00299
template<
typename _Tp>
00300
bool operator()(
const _Tp& __x,
const _Tp& __y)
const
00301
{
return __x >= __y; }
00302 };
00303
00304
00305
struct __atan2
00306 {
00307
template<
typename _Tp>
00308 _Tp operator()(
const _Tp& __x,
const _Tp& __y)
const
00309
{
return atan2(__x, __y); }
00310 };
00311
00312
struct __pow
00313 {
00314
template<
typename _Tp>
00315 _Tp operator()(
const _Tp& __x,
const _Tp& __y)
const
00316
{
return pow(__x, __y); }
00317 };
00318
00319
00320
00321
00322
00323
template<
typename,
typename _Tp>
00324
struct __fun
00325 {
00326
typedef _Tp result_type;
00327 };
00328
00329
00330
template<
typename _Tp>
00331
struct __fun<__logical_not, _Tp>
00332 {
00333
typedef bool result_type;
00334 };
00335
00336
template<
typename _Tp>
00337
struct __fun<__logical_and, _Tp>
00338 {
00339
typedef bool result_type;
00340 };
00341
00342
template<
typename _Tp>
00343
struct __fun<__logical_or, _Tp>
00344 {
00345
typedef bool result_type;
00346 };
00347
00348
template<
typename _Tp>
00349
struct __fun<__less, _Tp>
00350 {
00351
typedef bool result_type;
00352 };
00353
00354
template<
typename _Tp>
00355
struct __fun<__greater, _Tp>
00356 {
00357
typedef bool result_type;
00358 };
00359
00360
template<
typename _Tp>
00361
struct __fun<__less_equal, _Tp>
00362 {
00363
typedef bool result_type;
00364 };
00365
00366
template<
typename _Tp>
00367
struct __fun<__greater_equal, _Tp>
00368 {
00369
typedef bool result_type;
00370 };
00371
00372
template<
typename _Tp>
00373
struct __fun<__equal_to, _Tp>
00374 {
00375
typedef bool result_type;
00376 };
00377
00378
template<
typename _Tp>
00379
struct __fun<__not_equal_to, _Tp>
00380 {
00381
typedef bool result_type;
00382 };
00383
00384
00385
00386
00387
00388
template<
typename _Dom,
typename _Arg>
00389
class _FunBase
00390 {
00391
public:
00392
typedef typename _Dom::value_type value_type;
00393
00394 _FunBase(
const _Dom& __e, value_type __f(_Arg))
00395 : _M_expr(__e), _M_func(__f) {}
00396
00397 value_type operator[](size_t __i)
const
00398
{
return _M_func (_M_expr[__i]); }
00399
00400 size_t size()
const {
return _M_expr.size ();}
00401
00402
private:
00403
const _Dom& _M_expr;
00404 value_type (*_M_func)(_Arg);
00405 };
00406
00407
template<
class _Dom>
00408
struct _ValFunClos<_Expr,_Dom> : _FunBase<_Dom, typename _Dom::value_type>
00409 {
00410
typedef _FunBase<_Dom, typename _Dom::value_type> _Base;
00411
typedef typename _Base::value_type value_type;
00412
typedef value_type _Tp;
00413
00414 _ValFunClos(
const _Dom& __e, _Tp __f(_Tp)) : _Base(__e, __f) {}
00415 };
00416
00417
template<
typename _Tp>
00418
struct _ValFunClos<_ValArray,_Tp> : _FunBase<valarray<_Tp>, _Tp>
00419 {
00420
typedef _FunBase<valarray<_Tp>, _Tp> _Base;
00421
typedef _Tp value_type;
00422
00423 _ValFunClos(
const valarray<_Tp>& __v, _Tp __f(_Tp)) : _Base(__v, __f) {}
00424 };
00425
00426
template<
class _Dom>
00427
struct _RefFunClos<_Expr,_Dom> :
00428 _FunBase<_Dom, const typename _Dom::value_type&>
00429 {
00430
typedef _FunBase<_Dom, const typename _Dom::value_type&> _Base;
00431
typedef typename _Base::value_type value_type;
00432
typedef value_type _Tp;
00433
00434 _RefFunClos(
const _Dom& __e, _Tp __f(
const _Tp&))
00435 : _Base(__e, __f) {}
00436 };
00437
00438
template<
typename _Tp>
00439
struct _RefFunClos<_ValArray,_Tp> : _FunBase<valarray<_Tp>, const _Tp&>
00440 {
00441
typedef _FunBase<valarray<_Tp>,
const _Tp&> _Base;
00442
typedef _Tp value_type;
00443
00444 _RefFunClos(
const valarray<_Tp>& __v, _Tp __f(
const _Tp&))
00445 : _Base(__v, __f) {}
00446 };
00447
00448
00449
00450
00451
00452
template<
class _Oper,
class _Arg>
00453
class _UnBase
00454 {
00455
public:
00456
typedef typename _Arg::value_type _Vt;
00457
typedef typename __fun<_Oper, _Vt>::result_type value_type;
00458
00459 _UnBase(
const _Arg& __e) : _M_expr(__e) {}
00460
00461 value_type operator[](size_t __i)
const
00462
{
return _Oper()(_M_expr[__i]); }
00463
00464 size_t size()
const {
return _M_expr.size(); }
00465
00466
private:
00467
const _Arg& _M_expr;
00468 };
00469
00470
template<
class _Oper,
class _Dom>
00471
struct _UnClos<_Oper, _Expr, _Dom> : _UnBase<_Oper, _Dom>
00472 {
00473
typedef _Dom _Arg;
00474
typedef _UnBase<_Oper, _Dom> _Base;
00475
typedef typename _Base::value_type value_type;
00476
00477 _UnClos(
const _Arg& __e) : _Base(__e) {}
00478 };
00479
00480
template<
class _Oper,
typename _Tp>
00481
struct _UnClos<_Oper, _ValArray, _Tp> : _UnBase<_Oper, valarray<_Tp> >
00482 {
00483
typedef valarray<_Tp> _Arg;
00484
typedef _UnBase<_Oper, valarray<_Tp> > _Base;
00485
typedef typename _Base::value_type value_type;
00486
00487 _UnClos(
const _Arg& __e) : _Base(__e) {}
00488 };
00489
00490
00491
00492
00493
00494
00495
template<
class _Oper,
class _FirstArg,
class _SecondArg>
00496
class _BinBase
00497 {
00498
public:
00499
typedef typename _FirstArg::value_type _Vt;
00500
typedef typename __fun<_Oper, _Vt>::result_type value_type;
00501
00502 _BinBase(
const _FirstArg& __e1,
const _SecondArg& __e2)
00503 : _M_expr1(__e1), _M_expr2(__e2) {}
00504
00505 value_type operator[](size_t __i)
const
00506
{
return _Oper()(_M_expr1[__i], _M_expr2[__i]); }
00507
00508 size_t size()
const {
return _M_expr1.size(); }
00509
00510
private:
00511
const _FirstArg& _M_expr1;
00512
const _SecondArg& _M_expr2;
00513 };
00514
00515
00516
template<
class _Oper,
class _Clos>
00517
class _BinBase2
00518 {
00519
public:
00520
typedef typename _Clos::value_type _Vt;
00521
typedef typename __fun<_Oper, _Vt>::result_type value_type;
00522
00523 _BinBase2(
const _Clos& __e,
const _Vt& __t)
00524 : _M_expr1(__e), _M_expr2(__t) {}
00525
00526 value_type operator[](size_t __i)
const
00527
{
return _Oper()(_M_expr1[__i], _M_expr2); }
00528
00529 size_t size()
const {
return _M_expr1.size(); }
00530
00531
private:
00532
const _Clos& _M_expr1;
00533
const _Vt& _M_expr2;
00534 };
00535
00536
template<
class _Oper,
class _Clos>
00537
class _BinBase1
00538 {
00539
public:
00540
typedef typename _Clos::value_type _Vt;
00541
typedef typename __fun<_Oper, _Vt>::result_type value_type;
00542
00543 _BinBase1(
const _Vt& __t,
const _Clos& __e)
00544 : _M_expr1(__t), _M_expr2(__e) {}
00545
00546 value_type operator[](size_t __i)
const
00547
{
return _Oper()(_M_expr1, _M_expr2[__i]); }
00548
00549 size_t size()
const {
return _M_expr2.size(); }
00550
00551
private:
00552
const _Vt& _M_expr1;
00553
const _Clos& _M_expr2;
00554 };
00555
00556
template<
class _Oper,
class _Dom1,
class _Dom2>
00557
struct _BinClos<_Oper, _Expr, _Expr, _Dom1, _Dom2>
00558 : _BinBase<_Oper,_Dom1,_Dom2>
00559 {
00560
typedef _BinBase<_Oper,_Dom1,_Dom2> _Base;
00561
typedef typename _Base::value_type value_type;
00562
00563 _BinClos(
const _Dom1& __e1,
const _Dom2& __e2) : _Base(__e1, __e2) {}
00564 };
00565
00566
template<
class _Oper,
typename _Tp>
00567
struct _BinClos<_Oper,_ValArray,_ValArray,_Tp,_Tp>
00568 : _BinBase<_Oper,valarray<_Tp>,valarray<_Tp> >
00569 {
00570
typedef _BinBase<_Oper,valarray<_Tp>,valarray<_Tp> > _Base;
00571
typedef _Tp value_type;
00572
00573 _BinClos(
const valarray<_Tp>& __v,
const valarray<_Tp>& __w)
00574 : _Base(__v, __w) {}
00575 };
00576
00577
template<
class _Oper,
class _Dom>
00578
struct _BinClos<_Oper,_Expr,_ValArray,_Dom,typename _Dom::value_type>
00579 : _BinBase<_Oper,_Dom,valarray<typename _Dom::value_type> >
00580 {
00581
typedef typename _Dom::value_type _Tp;
00582
typedef _BinBase<_Oper,_Dom,valarray<_Tp> > _Base;
00583
typedef typename _Base::value_type value_type;
00584
00585 _BinClos(
const _Dom& __e1,
const valarray<_Tp>& __e2)
00586 : _Base(__e1, __e2) {}
00587 };
00588
00589
template<
class _Oper,
class _Dom>
00590
struct _BinClos<_Oper,_ValArray,_Expr,typename _Dom::value_type,_Dom>
00591 : _BinBase<_Oper,valarray<typename _Dom::value_type>,_Dom>
00592 {
00593
typedef typename _Dom::value_type _Tp;
00594
typedef _BinBase<_Oper,valarray<_Tp>,_Dom> _Base;
00595
typedef typename _Base::value_type value_type;
00596
00597 _BinClos(
const valarray<_Tp>& __e1,
const _Dom& __e2)
00598 : _Base(__e1, __e2) {}
00599 };
00600
00601
template<
class _Oper,
class _Dom>
00602
struct _BinClos<_Oper,_Expr,_Constant,_Dom,typename _Dom::value_type>
00603 : _BinBase2<_Oper,_Dom>
00604 {
00605
typedef typename _Dom::value_type _Tp;
00606
typedef _BinBase2<_Oper,_Dom> _Base;
00607
typedef typename _Base::value_type value_type;
00608
00609 _BinClos(
const _Dom& __e1,
const _Tp& __e2) : _Base(__e1, __e2) {}
00610 };
00611
00612
template<
class _Oper,
class _Dom>
00613
struct _BinClos<_Oper,_Constant,_Expr,typename _Dom::value_type,_Dom>
00614 : _BinBase1<_Oper,_Dom>
00615 {
00616
typedef typename _Dom::value_type _Tp;
00617
typedef _BinBase1<_Oper,_Dom> _Base;
00618
typedef typename _Base::value_type value_type;
00619
00620 _BinClos(
const _Tp& __e1,
const _Dom& __e2) : _Base(__e1, __e2) {}
00621 };
00622
00623
template<
class _Oper,
typename _Tp>
00624
struct _BinClos<_Oper,_ValArray,_Constant,_Tp,_Tp>
00625 : _BinBase2<_Oper,valarray<_Tp> >
00626 {
00627
typedef _BinBase2<_Oper,valarray<_Tp> > _Base;
00628
typedef typename _Base::value_type value_type;
00629
00630 _BinClos(
const valarray<_Tp>& __v,
const _Tp& __t) : _Base(__v, __t) {}
00631 };
00632
00633
template<
class _Oper,
typename _Tp>
00634
struct _BinClos<_Oper,_Constant,_ValArray,_Tp,_Tp>
00635 : _BinBase1<_Oper,valarray<_Tp> >
00636 {
00637
typedef _BinBase1<_Oper,valarray<_Tp> > _Base;
00638
typedef typename _Base::value_type value_type;
00639
00640 _BinClos(
const _Tp& __t,
const valarray<_Tp>& __v) : _Base(__t, __v) {}
00641 };
00642
00643
00644
00645
00646
00647
template<
typename _Dom>
class _SBase {
00648
public:
00649
typedef typename _Dom::value_type value_type;
00650
00651 _SBase (
const _Dom& __e,
const slice& __s)
00652 : _M_expr (__e), _M_slice (__s) {}
00653 value_type operator[] (size_t __i)
const
00654
{
return _M_expr[_M_slice.start () + __i * _M_slice.stride ()]; }
00655 size_t size()
const {
return _M_slice.size (); }
00656
00657
private:
00658
const _Dom& _M_expr;
00659
const slice& _M_slice;
00660 };
00661
00662
template<
typename _Tp>
class _SBase<_Array<_Tp> > {
00663
public:
00664
typedef _Tp value_type;
00665
00666 _SBase (_Array<_Tp> __a,
const slice& __s)
00667 : _M_array (__a._M_data+__s.start()), _M_size (__s.size()),
00668 _M_stride (__s.stride()) {}
00669 value_type operator[] (size_t __i)
const
00670
{
return _M_array._M_data[__i * _M_stride]; }
00671 size_t size()
const {
return _M_size; }
00672
00673
private:
00674
const _Array<_Tp> _M_array;
00675
const size_t _M_size;
00676
const size_t _M_stride;
00677 };
00678
00679
template<
class _Dom>
struct _SClos<_Expr,_Dom> : _SBase<_Dom> {
00680
typedef _SBase<_Dom> _Base;
00681
typedef typename _Base::value_type value_type;
00682
00683 _SClos (
const _Dom& __e,
const slice& __s) : _Base (__e, __s) {}
00684 };
00685
00686
template<
typename _Tp>
00687
struct _SClos<_ValArray,_Tp> : _SBase<_Array<_Tp> > {
00688
typedef _SBase<_Array<_Tp> > _Base;
00689
typedef _Tp value_type;
00690
00691 _SClos (_Array<_Tp> __a,
const slice& __s) : _Base (__a, __s) {}
00692 };
00693
00694 }
00695
00696
00697
#endif
00698
00699
00700
00701