libstdc++-v3/include/bits/valarray_before.h

   1 // The template and inlines for the -*- C++ -*- internal _Meta class.
   2
   3 // Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
   4 // 2006, 2007, 2008, 2009, 2010, 2011  Free Software Foundation, Inc.
   5 //
   6 // This file is part of the GNU ISO C++ Library.  This library is free
   7 // software; you can redistribute it and/or modify it under the
   8 // terms of the GNU General Public License as published by the
   9 // Free Software Foundation; either version 3, or (at your option)
  10 // any later version.
  11
  12 // This library is distributed in the hope that it will be useful,
  13 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 // GNU General Public License for more details.
  16
  17 // Under Section 7 of GPL version 3, you are granted additional
  18 // permissions described in the GCC Runtime Library Exception, version
  19 // 3.1, as published by the Free Software Foundation.
  20
  21 // You should have received a copy of the GNU General Public License and
  22 // a copy of the GCC Runtime Library Exception along with this program;
  23 // see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
  24 // <http://www.gnu.org/licenses/>.
  25
  26 /** @file bits/valarray_before.h
  27  *  This is an internal header file, included by other library headers.
  28  *  Do not attempt to use it directly. @headername{valarray}
  29  */
  30
  31 // Written by Gabriel Dos Reis <Gabriel.Dos-Reis@cmla.ens-cachan.fr>
  32
  33 #ifndef _VALARRAY_BEFORE_H
  34 #define _VALARRAY_BEFORE_H 1
  35
  36 #pragma GCC system_header
  37
  38 #include <bits/slice_array.h>
  39
  40 namespace std _GLIBCXX_VISIBILITY(default)
  41 {
  42 _GLIBCXX_BEGIN_NAMESPACE_VERSION
  43
  44   //
  45   // Implementing a loosened valarray return value is tricky.
  46   // First we need to meet 26.3.1/3: we should not add more than
  47   // two levels of template nesting. Therefore we resort to template
  48   // template to "flatten" loosened return value types.
  49   // At some point we use partial specialization to remove one level
  50   // template nesting due to _Expr<>
  51   //
  52
  53   // This class is NOT defined. It doesn't need to.
  54   template<typename _Tp1, typename _Tp2> class _Constant;
  55
  56   // Implementations of unary functions applied to valarray<>s.
  57   // I use hard-coded object functions here instead of a generic
  58   // approach like pointers to function:
  59   //    1) correctness: some functions take references, others values.
  60   //       we can't deduce the correct type afterwards.
  61   //    2) efficiency -- object functions can be easily inlined
  62   //    3) be Koenig-lookup-friendly
  63
  64   struct _Abs
  65   {
  66     template<typename _Tp>
  67       _Tp operator()(const _Tp& __t) const
  68       { return abs(__t); }
  69   };
  70
  71   struct _Cos
  72   {
  73     template<typename _Tp>
  74       _Tp operator()(const _Tp& __t) const
  75       { return cos(__t); }
  76   };
  77
  78   struct _Acos
  79   {
  80     template<typename _Tp>
  81       _Tp operator()(const _Tp& __t) const
  82       { return acos(__t); }
  83   };
  84
  85   struct _Cosh
  86   {
  87     template<typename _Tp>
  88       _Tp operator()(const _Tp& __t) const
  89       { return cosh(__t); }
  90   };
  91
  92   struct _Sin
  93   {
  94     template<typename _Tp>
  95       _Tp operator()(const _Tp& __t) const
  96       { return sin(__t); }
  97   };
  98
  99   struct _Asin
 100   {
 101     template<typename _Tp>
 102       _Tp operator()(const _Tp& __t) const
 103       { return asin(__t); }
 104   };
 105
 106   struct _Sinh
 107   {
 108     template<typename _Tp>
 109       _Tp operator()(const _Tp& __t) const
 110       { return sinh(__t); }
 111   };
 112
 113   struct _Tan
 114   {
 115     template<typename _Tp>
 116       _Tp operator()(const _Tp& __t) const
 117       { return tan(__t); }
 118   };
 119
 120   struct _Atan
 121   {
 122     template<typename _Tp>
 123       _Tp operator()(const _Tp& __t) const
 124       { return atan(__t); }
 125   };
 126
 127   struct _Tanh
 128   {
 129     template<typename _Tp>
 130       _Tp operator()(const _Tp& __t) const
 131       { return tanh(__t); }
 132   };
 133
 134   struct _Exp
 135   {
 136     template<typename _Tp>
 137       _Tp operator()(const _Tp& __t) const
 138       { return exp(__t); }
 139   };
 140
 141   struct _Log
 142   {
 143     template<typename _Tp>
 144       _Tp operator()(const _Tp& __t) const
 145       { return log(__t); }
 146   };
 147
 148   struct _Log10
 149   {
 150     template<typename _Tp>
 151       _Tp operator()(const _Tp& __t) const
 152       { return log10(__t); }
 153   };
 154
 155   struct _Sqrt
 156   {
 157     template<typename _Tp>
 158       _Tp operator()(const _Tp& __t) const
 159       { return sqrt(__t); }
 160   };
 161
 162   // In the past, we used to tailor operator applications semantics
 163   // to the specialization of standard function objects (i.e. plus<>, etc.)
 164   // That is incorrect.  Therefore we provide our own surrogates.
 165
 166   struct __unary_plus
 167   {
 168     template<typename _Tp>
 169       _Tp operator()(const _Tp& __t) const
 170       { return +__t; }
 171   };
 172
 173   struct __negate
 174   {
 175     template<typename _Tp>
 176       _Tp operator()(const _Tp& __t) const
 177       { return -__t; }
 178   };
 179
 180   struct __bitwise_not
 181   {
 182     template<typename _Tp>
 183       _Tp operator()(const _Tp& __t) const
 184       { return ~__t; }
 185   };
 186
 187   struct __plus
 188   {
 189     template<typename _Tp>
 190       _Tp operator()(const _Tp& __x, const _Tp& __y) const
 191       { return __x + __y; }
 192   };
 193
 194   struct __minus
 195   {
 196     template<typename _Tp>
 197       _Tp operator()(const _Tp& __x, const _Tp& __y) const
 198       { return __x - __y; }
 199   };
 200
 201   struct __multiplies
 202   {
 203     template<typename _Tp>
 204       _Tp operator()(const _Tp& __x, const _Tp& __y) const
 205       { return __x * __y; }
 206   };
 207
 208   struct __divides
 209   {
 210     template<typename _Tp>
 211       _Tp operator()(const _Tp& __x, const _Tp& __y) const
 212       { return __x / __y; }
 213   };
 214
 215   struct __modulus
 216   {
 217     template<typename _Tp>
 218       _Tp operator()(const _Tp& __x, const _Tp& __y) const
 219       { return __x % __y; }
 220   };
 221
 222   struct __bitwise_xor
 223   {
 224     template<typename _Tp>
 225       _Tp operator()(const _Tp& __x, const _Tp& __y) const
 226       { return __x ^ __y; }
 227   };
 228
 229   struct __bitwise_and
 230   {
 231     template<typename _Tp>
 232       _Tp operator()(const _Tp& __x, const _Tp& __y) const
 233       { return __x & __y; }
 234   };
 235
 236   struct __bitwise_or
 237   {
 238     template<typename _Tp>
 239       _Tp operator()(const _Tp& __x, const _Tp& __y) const
 240       { return __x | __y; }
 241   };
 242
 243   struct __shift_left
 244   {
 245     template<typename _Tp>
 246       _Tp operator()(const _Tp& __x, const _Tp& __y) const
 247       { return __x << __y; }
 248   };
 249
 250   struct __shift_right
 251   {
 252     template<typename _Tp>
 253       _Tp operator()(const _Tp& __x, const _Tp& __y) const
 254       { return __x >> __y; }
 255   };
 256
 257   struct __logical_and
 258   {
 259     template<typename _Tp>
 260       bool operator()(const _Tp& __x, const _Tp& __y) const
 261       { return __x && __y; }
 262   };
 263
 264   struct __logical_or
 265   {
 266     template<typename _Tp>
 267       bool operator()(const _Tp& __x, const _Tp& __y) const
 268       { return __x || __y; }
 269   };
 270
 271   struct __logical_not
 272   {
 273     template<typename _Tp>
 274       bool operator()(const _Tp& __x) const
 275       { return !__x; }
 276   };
 277
 278   struct __equal_to
 279   {
 280     template<typename _Tp>
 281       bool operator()(const _Tp& __x, const _Tp& __y) const
 282       { return __x == __y; }
 283   };
 284
 285   struct __not_equal_to
 286   {
 287     template<typename _Tp>
 288       bool operator()(const _Tp& __x, const _Tp& __y) const
 289       { return __x != __y; }
 290   };
 291
 292   struct __less
 293   {
 294     template<typename _Tp>
 295       bool operator()(const _Tp& __x, const _Tp& __y) const
 296       { return __x < __y; }
 297   };
 298
 299   struct __greater
 300   {
 301     template<typename _Tp>
 302       bool operator()(const _Tp& __x, const _Tp& __y) const
 303       { return __x > __y; }
 304   };
 305
 306   struct __less_equal
 307   {
 308     template<typename _Tp>
 309       bool operator()(const _Tp& __x, const _Tp& __y) const
 310       { return __x <= __y; }
 311   };
 312
 313   struct __greater_equal
 314   {
 315     template<typename _Tp>
 316       bool operator()(const _Tp& __x, const _Tp& __y) const
 317       { return __x >= __y; }
 318   };
 319
 320   // The few binary functions we miss.
 321   struct _Atan2
 322   {
 323     template<typename _Tp>
 324       _Tp operator()(const _Tp& __x, const _Tp& __y) const
 325       { return atan2(__x, __y); }
 326   };
 327
 328   struct _Pow
 329   {
 330     template<typename _Tp>
 331       _Tp operator()(const _Tp& __x, const _Tp& __y) const
 332       { return pow(__x, __y); }
 333   };
 334
 335
 336   // We need these bits in order to recover the return type of
 337   // some functions/operators now that we're no longer using
 338   // function templates.
 339   template<typename, typename _Tp>
 340     struct __fun
 341     {
 342       typedef _Tp result_type;
 343     };
 344
 345   // several specializations for relational operators.
 346   template<typename _Tp>
 347     struct __fun<__logical_not, _Tp>
 348     {
 349       typedef bool result_type;
 350     };
 351
 352   template<typename _Tp>
 353     struct __fun<__logical_and, _Tp>
 354     {
 355       typedef bool result_type;
 356     };
 357
 358   template<typename _Tp>
 359     struct __fun<__logical_or, _Tp>
 360     {
 361       typedef bool result_type;
 362     };
 363
 364   template<typename _Tp>
 365     struct __fun<__less, _Tp>
 366     {
 367       typedef bool result_type;
 368     };
 369
 370   template<typename _Tp>
 371     struct __fun<__greater, _Tp>
 372     {
 373       typedef bool result_type;
 374     };
 375
 376   template<typename _Tp>
 377     struct __fun<__less_equal, _Tp>
 378     {
 379       typedef bool result_type;
 380     };
 381
 382   template<typename _Tp>
 383     struct __fun<__greater_equal, _Tp>
 384     {
 385       typedef bool result_type;
 386     };
 387
 388   template<typename _Tp>
 389     struct __fun<__equal_to, _Tp>
 390     {
 391       typedef bool result_type;
 392     };
 393
 394   template<typename _Tp>
 395     struct __fun<__not_equal_to, _Tp>
 396     {
 397       typedef bool result_type;
 398     };
 399
 400   //
 401   // Apply function taking a value/const reference closure
 402   //
 403
 404   template<typename _Dom, typename _Arg>
 405     class _FunBase
 406     {
 407     public:
 408       typedef typename _Dom::value_type value_type;
 409
 410       _FunBase(const _Dom& __e, value_type __f(_Arg))
 411       : _M_expr(__e), _M_func(__f) {}
 412
 413       value_type operator[](size_t __i) const
 414       { return _M_func (_M_expr[__i]); }
 415
 416       size_t size() const { return _M_expr.size ();}
 417
 418     private:
 419       const _Dom& _M_expr;
 420       value_type (*_M_func)(_Arg);
 421     };
 422
 423   template<class _Dom>
 424     struct _ValFunClos<_Expr,_Dom> : _FunBase<_Dom, typename _Dom::value_type>
 425     {
 426       typedef _FunBase<_Dom, typename _Dom::value_type> _Base;
 427       typedef typename _Base::value_type value_type;
 428       typedef value_type _Tp;
 429
 430       _ValFunClos(const _Dom& __e, _Tp __f(_Tp)) : _Base(__e, __f) {}
 431     };
 432
 433   template<typename _Tp>
 434     struct _ValFunClos<_ValArray,_Tp> : _FunBase<valarray<_Tp>, _Tp>
 435     {
 436       typedef _FunBase<valarray<_Tp>, _Tp> _Base;
 437       typedef _Tp value_type;
 438
 439       _ValFunClos(const valarray<_Tp>& __v, _Tp __f(_Tp)) : _Base(__v, __f) {}
 440     };
 441
 442   template<class _Dom>
 443     struct _RefFunClos<_Expr, _Dom>
 444     : _FunBase<_Dom, const typename _Dom::value_type&>
 445     {
 446       typedef _FunBase<_Dom, const typename _Dom::value_type&> _Base;
 447       typedef typename _Base::value_type value_type;
 448       typedef value_type _Tp;
 449
 450       _RefFunClos(const _Dom& __e, _Tp __f(const _Tp&))
 451       : _Base(__e, __f) {}
 452     };
 453
 454   template<typename _Tp>
 455     struct _RefFunClos<_ValArray, _Tp>
 456     : _FunBase<valarray<_Tp>, const _Tp&>
 457     {
 458       typedef _FunBase<valarray<_Tp>, const _Tp&> _Base;
 459       typedef _Tp value_type;
 460
 461       _RefFunClos(const valarray<_Tp>& __v, _Tp __f(const _Tp&))
 462       : _Base(__v, __f) {}
 463     };
 464
 465   //
 466   // Unary expression closure.
 467   //
 468
 469   template<class _Oper, class _Arg>
 470     class _UnBase
 471     {
 472     public:
 473       typedef typename _Arg::value_type _Vt;
 474       typedef typename __fun<_Oper, _Vt>::result_type value_type;
 475
 476       _UnBase(const _Arg& __e) : _M_expr(__e) {}
 477
 478       value_type operator[](size_t __i) const
 479       { return _Oper()(_M_expr[__i]); }
 480
 481       size_t size() const { return _M_expr.size(); }
 482
 483     private:
 484       const _Arg& _M_expr;
 485     };
 486
 487   template<class _Oper, class _Dom>
 488     struct _UnClos<_Oper, _Expr, _Dom>
 489     : _UnBase<_Oper, _Dom>
 490     {
 491       typedef _Dom _Arg;
 492       typedef _UnBase<_Oper, _Dom> _Base;
 493       typedef typename _Base::value_type value_type;
 494
 495       _UnClos(const _Arg& __e) : _Base(__e) {}
 496     };
 497
 498   template<class _Oper, typename _Tp>
 499     struct _UnClos<_Oper, _ValArray, _Tp>
 500     : _UnBase<_Oper, valarray<_Tp> >
 501     {
 502       typedef valarray<_Tp> _Arg;
 503       typedef _UnBase<_Oper, valarray<_Tp> > _Base;
 504       typedef typename _Base::value_type value_type;
 505
 506       _UnClos(const _Arg& __e) : _Base(__e) {}
 507     };
 508
 509
 510   //
 511   // Binary expression closure.
 512   //
 513
 514   template<class _Oper, class _FirstArg, class _SecondArg>
 515     class _BinBase
 516     {
 517     public:
 518       typedef typename _FirstArg::value_type _Vt;
 519       typedef typename __fun<_Oper, _Vt>::result_type value_type;
 520
 521       _BinBase(const _FirstArg& __e1, const _SecondArg& __e2)
 522       : _M_expr1(__e1), _M_expr2(__e2) {}
 523
 524       value_type operator[](size_t __i) const
 525       { return _Oper()(_M_expr1[__i], _M_expr2[__i]); }
 526
 527       size_t size() const { return _M_expr1.size(); }
 528
 529     private:
 530       const _FirstArg& _M_expr1;
 531       const _SecondArg& _M_expr2;
 532     };
 533
 534
 535   template<class _Oper, class _Clos>
 536     class _BinBase2
 537     {
 538     public:
 539       typedef typename _Clos::value_type _Vt;
 540       typedef typename __fun<_Oper, _Vt>::result_type value_type;
 541
 542       _BinBase2(const _Clos& __e, const _Vt& __t)
 543       : _M_expr1(__e), _M_expr2(__t) {}
 544
 545       value_type operator[](size_t __i) const
 546       { return _Oper()(_M_expr1[__i], _M_expr2); }
 547
 548       size_t size() const { return _M_expr1.size(); }
 549
 550     private:
 551       const _Clos& _M_expr1;
 552       const _Vt& _M_expr2;
 553     };
 554
 555   template<class _Oper, class _Clos>
 556     class _BinBase1
 557     {
 558     public:
 559       typedef typename _Clos::value_type _Vt;
 560       typedef typename __fun<_Oper, _Vt>::result_type value_type;
 561
 562       _BinBase1(const _Vt& __t, const _Clos& __e)
 563       : _M_expr1(__t), _M_expr2(__e) {}
 564
 565       value_type operator[](size_t __i) const
 566       { return _Oper()(_M_expr1, _M_expr2[__i]); }
 567
 568       size_t size() const { return _M_expr2.size(); }
 569
 570     private:
 571       const _Vt& _M_expr1;
 572       const _Clos& _M_expr2;
 573     };
 574
 575   template<class _Oper, class _Dom1, class _Dom2>
 576     struct _BinClos<_Oper, _Expr, _Expr, _Dom1, _Dom2>
 577     : _BinBase<_Oper, _Dom1, _Dom2>
 578     {
 579       typedef _BinBase<_Oper, _Dom1, _Dom2> _Base;
 580       typedef typename _Base::value_type value_type;
 581
 582       _BinClos(const _Dom1& __e1, const _Dom2& __e2) : _Base(__e1, __e2) {}
 583     };
 584
 585   template<class _Oper, typename _Tp>
 586     struct _BinClos<_Oper,_ValArray, _ValArray, _Tp, _Tp>
 587     : _BinBase<_Oper, valarray<_Tp>, valarray<_Tp> >
 588     {
 589       typedef _BinBase<_Oper, valarray<_Tp>, valarray<_Tp> > _Base;
 590       typedef typename _Base::value_type value_type;
 591
 592       _BinClos(const valarray<_Tp>& __v, const valarray<_Tp>& __w)
 593       : _Base(__v, __w) {}
 594     };
 595
 596   template<class _Oper, class _Dom>
 597     struct _BinClos<_Oper, _Expr, _ValArray, _Dom, typename _Dom::value_type>
 598     : _BinBase<_Oper, _Dom, valarray<typename _Dom::value_type> >
 599     {
 600       typedef typename _Dom::value_type _Tp;
 601       typedef _BinBase<_Oper,_Dom,valarray<_Tp> > _Base;
 602       typedef typename _Base::value_type value_type;
 603
 604       _BinClos(const _Dom& __e1, const valarray<_Tp>& __e2)
 605       : _Base(__e1, __e2) {}
 606     };
 607
 608   template<class _Oper, class _Dom>
 609     struct _BinClos<_Oper, _ValArray, _Expr, typename _Dom::value_type, _Dom>
 610     : _BinBase<_Oper, valarray<typename _Dom::value_type>,_Dom>
 611     {
 612       typedef typename _Dom::value_type _Tp;
 613       typedef _BinBase<_Oper, valarray<_Tp>, _Dom> _Base;
 614       typedef typename _Base::value_type value_type;
 615
 616       _BinClos(const valarray<_Tp>& __e1, const _Dom& __e2)
 617       : _Base(__e1, __e2) {}
 618     };
 619
 620   template<class _Oper, class _Dom>
 621     struct _BinClos<_Oper, _Expr, _Constant, _Dom, typename _Dom::value_type>
 622     : _BinBase2<_Oper, _Dom>
 623     {
 624       typedef typename _Dom::value_type _Tp;
 625       typedef _BinBase2<_Oper,_Dom> _Base;
 626       typedef typename _Base::value_type value_type;
 627
 628       _BinClos(const _Dom& __e1, const _Tp& __e2) : _Base(__e1, __e2) {}
 629     };
 630
 631   template<class _Oper, class _Dom>
 632     struct _BinClos<_Oper, _Constant, _Expr, typename _Dom::value_type, _Dom>
 633     : _BinBase1<_Oper, _Dom>
 634     {
 635       typedef typename _Dom::value_type _Tp;
 636       typedef _BinBase1<_Oper, _Dom> _Base;
 637       typedef typename _Base::value_type value_type;
 638
 639       _BinClos(const _Tp& __e1, const _Dom& __e2) : _Base(__e1, __e2) {}
 640     };
 641
 642   template<class _Oper, typename _Tp>
 643     struct _BinClos<_Oper, _ValArray, _Constant, _Tp, _Tp>
 644     : _BinBase2<_Oper, valarray<_Tp> >
 645     {
 646       typedef _BinBase2<_Oper,valarray<_Tp> > _Base;
 647       typedef typename _Base::value_type value_type;
 648
 649       _BinClos(const valarray<_Tp>& __v, const _Tp& __t) : _Base(__v, __t) {}
 650     };
 651
 652   template<class _Oper, typename _Tp>
 653     struct _BinClos<_Oper, _Constant, _ValArray, _Tp, _Tp>
 654     : _BinBase1<_Oper, valarray<_Tp> >
 655     {
 656       typedef _BinBase1<_Oper, valarray<_Tp> > _Base;
 657       typedef typename _Base::value_type value_type;
 658
 659       _BinClos(const _Tp& __t, const valarray<_Tp>& __v) : _Base(__t, __v) {}
 660     };
 661
 662     //
 663     // slice_array closure.
 664     //
 665   template<typename _Dom>
 666     class _SBase
 667     {
 668     public:
 669       typedef typename _Dom::value_type value_type;
 670
 671       _SBase (const _Dom& __e, const slice& __s)
 672       : _M_expr (__e), _M_slice (__s) {}
 673
 674       value_type
 675       operator[] (size_t __i) const
 676       { return _M_expr[_M_slice.start () + __i * _M_slice.stride ()]; }
 677
 678       size_t
 679       size() const
 680       { return _M_slice.size (); }
 681
 682     private:
 683       const _Dom& _M_expr;
 684       const slice& _M_slice;
 685     };
 686
 687   template<typename _Tp>
 688     class _SBase<_Array<_Tp> >
 689     {
 690     public:
 691       typedef _Tp value_type;
 692
 693       _SBase (_Array<_Tp> __a, const slice& __s)
 694       : _M_array (__a._M_data+__s.start()), _M_size (__s.size()),
 695         _M_stride (__s.stride()) {}
 696
 697       value_type
 698       operator[] (size_t __i) const
 699       { return _M_array._M_data[__i * _M_stride]; }
 700
 701       size_t
 702       size() const
 703       { return _M_size; }
 704
 705     private:
 706       const _Array<_Tp> _M_array;
 707       const size_t _M_size;
 708       const size_t _M_stride;
 709     };
 710
 711   template<class _Dom>
 712     struct _SClos<_Expr, _Dom>
 713     : _SBase<_Dom>
 714     {
 715       typedef _SBase<_Dom> _Base;
 716       typedef typename _Base::value_type value_type;
 717
 718       _SClos (const _Dom& __e, const slice& __s) : _Base (__e, __s) {}
 719     };
 720
 721   template<typename _Tp>
 722     struct _SClos<_ValArray, _Tp>
 723     : _SBase<_Array<_Tp> >
 724     {
 725       typedef  _SBase<_Array<_Tp> > _Base;
 726       typedef _Tp value_type;
 727
 728       _SClos (_Array<_Tp> __a, const slice& __s) : _Base (__a, __s) {}
 729     };
 730
 731 _GLIBCXX_END_NAMESPACE_VERSION
 732 } // namespace
 733
 734 #endif /* _CPP_VALARRAY_BEFORE_H */