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