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_after.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_AFTER_H 33#define _VALARRAY_AFTER_H 1 34 35#pragma GCC system_header 36 37namespace std _GLIBCXX_VISIBILITY(default) 38{ 39_GLIBCXX_BEGIN_NAMESPACE_VERSION 40 41 // 42 // gslice_array closure. 43 // 44 template<class _Dom> 45 class _GBase 46 { 47 public: 48 typedef typename _Dom::value_type value_type; 49 50 _GBase (const _Dom& __e, const valarray<size_t>& __i) 51 : _M_expr (__e), _M_index(__i) {} 52 53 value_type 54 operator[] (size_t __i) const 55 { return _M_expr[_M_index[__i]]; } 56 57 size_t 58 size () const 59 { return _M_index.size(); } 60 61 private: 62 const _Dom& _M_expr; 63 const valarray<size_t>& _M_index; 64 }; 65 66 template<typename _Tp> 67 class _GBase<_Array<_Tp> > 68 { 69 public: 70 typedef _Tp value_type; 71 72 _GBase (_Array<_Tp> __a, const valarray<size_t>& __i) 73 : _M_array (__a), _M_index(__i) {} 74 75 value_type 76 operator[] (size_t __i) const 77 { return _M_array._M_data[_M_index[__i]]; } 78 79 size_t 80 size () const 81 { return _M_index.size(); } 82 83 private: 84 const _Array<_Tp> _M_array; 85 const valarray<size_t>& _M_index; 86 }; 87 88 template<class _Dom> 89 struct _GClos<_Expr, _Dom> 90 : _GBase<_Dom> 91 { 92 typedef _GBase<_Dom> _Base; 93 typedef typename _Base::value_type value_type; 94 95 _GClos (const _Dom& __e, const valarray<size_t>& __i) 96 : _Base (__e, __i) {} 97 }; 98 99 template<typename _Tp> 100 struct _GClos<_ValArray, _Tp> 101 : _GBase<_Array<_Tp> > 102 { 103 typedef _GBase<_Array<_Tp> > _Base; 104 typedef typename _Base::value_type value_type; 105 106 _GClos (_Array<_Tp> __a, const valarray<size_t>& __i) 107 : _Base (__a, __i) {} 108 }; 109 110 // 111 // indirect_array closure 112 // 113 template<class _Dom> 114 class _IBase 115 { 116 public: 117 typedef typename _Dom::value_type value_type; 118 119 _IBase (const _Dom& __e, const valarray<size_t>& __i) 120 : _M_expr (__e), _M_index (__i) {} 121 122 value_type 123 operator[] (size_t __i) const 124 { return _M_expr[_M_index[__i]]; } 125 126 size_t 127 size() const 128 { return _M_index.size(); } 129 130 private: 131 const _Dom& _M_expr; 132 const valarray<size_t>& _M_index; 133 }; 134 135 template<class _Dom> 136 struct _IClos<_Expr, _Dom> 137 : _IBase<_Dom> 138 { 139 typedef _IBase<_Dom> _Base; 140 typedef typename _Base::value_type value_type; 141 142 _IClos (const _Dom& __e, const valarray<size_t>& __i) 143 : _Base (__e, __i) {} 144 }; 145 146 template<typename _Tp> 147 struct _IClos<_ValArray, _Tp> 148 : _IBase<valarray<_Tp> > 149 { 150 typedef _IBase<valarray<_Tp> > _Base; 151 typedef _Tp value_type; 152 153 _IClos (const valarray<_Tp>& __a, const valarray<size_t>& __i) 154 : _Base (__a, __i) {} 155 }; 156 157 // 158 // class _Expr 159 // 160 template<class _Clos, typename _Tp> 161 class _Expr 162 { 163 public: 164 typedef _Tp value_type; 165 166 _Expr(const _Clos&); 167 168 const _Clos& operator()() const; 169 170 value_type operator[](size_t) const; 171 valarray<value_type> operator[](slice) const; 172 valarray<value_type> operator[](const gslice&) const; 173 valarray<value_type> operator[](const valarray<bool>&) const; 174 valarray<value_type> operator[](const valarray<size_t>&) const; 175 176 _Expr<_UnClos<__unary_plus, std::_Expr, _Clos>, value_type> 177 operator+() const; 178 179 _Expr<_UnClos<__negate, std::_Expr, _Clos>, value_type> 180 operator-() const; 181 182 _Expr<_UnClos<__bitwise_not, std::_Expr, _Clos>, value_type> 183 operator~() const; 184 185 _Expr<_UnClos<__logical_not, std::_Expr, _Clos>, bool> 186 operator!() const; 187 188 size_t size() const; 189 value_type sum() const; 190 191 valarray<value_type> shift(int) const; 192 valarray<value_type> cshift(int) const; 193 194 value_type min() const; 195 value_type max() const; 196 197 valarray<value_type> apply(value_type (*)(const value_type&)) const; 198 valarray<value_type> apply(value_type (*)(value_type)) const; 199 200 private: 201 const _Clos _M_closure; 202 }; 203 204 template<class _Clos, typename _Tp> 205 inline 206 _Expr<_Clos, _Tp>::_Expr(const _Clos& __c) : _M_closure(__c) {} 207 208 template<class _Clos, typename _Tp> 209 inline const _Clos& 210 _Expr<_Clos, _Tp>::operator()() const 211 { return _M_closure; } 212 213 template<class _Clos, typename _Tp> 214 inline _Tp 215 _Expr<_Clos, _Tp>::operator[](size_t __i) const 216 { return _M_closure[__i]; } 217 218 template<class _Clos, typename _Tp> 219 inline valarray<_Tp> 220 _Expr<_Clos, _Tp>::operator[](slice __s) const 221 { 222 valarray<_Tp> __v = valarray<_Tp>(*this)[__s]; 223 return __v; 224 } 225 226 template<class _Clos, typename _Tp> 227 inline valarray<_Tp> 228 _Expr<_Clos, _Tp>::operator[](const gslice& __gs) const 229 { 230 valarray<_Tp> __v = valarray<_Tp>(*this)[__gs]; 231 return __v; 232 } 233 234 template<class _Clos, typename _Tp> 235 inline valarray<_Tp> 236 _Expr<_Clos, _Tp>::operator[](const valarray<bool>& __m) const 237 { 238 valarray<_Tp> __v = valarray<_Tp>(*this)[__m]; 239 return __v; 240 } 241 242 template<class _Clos, typename _Tp> 243 inline valarray<_Tp> 244 _Expr<_Clos, _Tp>::operator[](const valarray<size_t>& __i) const 245 { 246 valarray<_Tp> __v = valarray<_Tp>(*this)[__i]; 247 return __v; 248 } 249 250 template<class _Clos, typename _Tp> 251 inline size_t 252 _Expr<_Clos, _Tp>::size() const 253 { return _M_closure.size(); } 254 255 template<class _Clos, typename _Tp> 256 inline valarray<_Tp> 257 _Expr<_Clos, _Tp>::shift(int __n) const 258 { 259 valarray<_Tp> __v = valarray<_Tp>(*this).shift(__n); 260 return __v; 261 } 262 263 template<class _Clos, typename _Tp> 264 inline valarray<_Tp> 265 _Expr<_Clos, _Tp>::cshift(int __n) const 266 { 267 valarray<_Tp> __v = valarray<_Tp>(*this).cshift(__n); 268 return __v; 269 } 270 271 template<class _Clos, typename _Tp> 272 inline valarray<_Tp> 273 _Expr<_Clos, _Tp>::apply(_Tp __f(const _Tp&)) const 274 { 275 valarray<_Tp> __v = valarray<_Tp>(*this).apply(__f); 276 return __v; 277 } 278 279 template<class _Clos, typename _Tp> 280 inline valarray<_Tp> 281 _Expr<_Clos, _Tp>::apply(_Tp __f(_Tp)) const 282 { 283 valarray<_Tp> __v = valarray<_Tp>(*this).apply(__f); 284 return __v; 285 } 286 287 // XXX: replace this with a more robust summation algorithm. 288 template<class _Clos, typename _Tp> 289 inline _Tp 290 _Expr<_Clos, _Tp>::sum() const 291 { 292 size_t __n = _M_closure.size(); 293 if (__n == 0) 294 return _Tp(); 295 else 296 { 297 _Tp __s = _M_closure[--__n]; 298 while (__n != 0) 299 __s += _M_closure[--__n]; 300 return __s; 301 } 302 } 303 304 template<class _Clos, typename _Tp> 305 inline _Tp 306 _Expr<_Clos, _Tp>::min() const 307 { return __valarray_min(_M_closure); } 308 309 template<class _Clos, typename _Tp> 310 inline _Tp 311 _Expr<_Clos, _Tp>::max() const 312 { return __valarray_max(_M_closure); } 313 314 template<class _Dom, typename _Tp> 315 inline _Expr<_UnClos<__logical_not, _Expr, _Dom>, bool> 316 _Expr<_Dom, _Tp>::operator!() const 317 { 318 typedef _UnClos<__logical_not, std::_Expr, _Dom> _Closure; 319 return _Expr<_Closure, bool>(_Closure(this->_M_closure)); 320 } 321 322#define _DEFINE_EXPR_UNARY_OPERATOR(_Op, _Name) \ 323 template<class _Dom, typename _Tp> \ 324 inline _Expr<_UnClos<_Name, std::_Expr, _Dom>, _Tp> \ 325 _Expr<_Dom, _Tp>::operator _Op() const \ 326 { \ 327 typedef _UnClos<_Name, std::_Expr, _Dom> _Closure; \ 328 return _Expr<_Closure, _Tp>(_Closure(this->_M_closure)); \ 329 } 330 331 _DEFINE_EXPR_UNARY_OPERATOR(+, __unary_plus) 332 _DEFINE_EXPR_UNARY_OPERATOR(-, __negate) 333 _DEFINE_EXPR_UNARY_OPERATOR(~, __bitwise_not) 334 335#undef _DEFINE_EXPR_UNARY_OPERATOR 336 337#define _DEFINE_EXPR_BINARY_OPERATOR(_Op, _Name) \ 338 template<class _Dom1, class _Dom2> \ 339 inline _Expr<_BinClos<_Name, _Expr, _Expr, _Dom1, _Dom2>, \ 340 typename __fun<_Name, typename _Dom1::value_type>::result_type> \ 341 operator _Op(const _Expr<_Dom1, typename _Dom1::value_type>& __v, \ 342 const _Expr<_Dom2, typename _Dom2::value_type>& __w) \ 343 { \ 344 typedef typename _Dom1::value_type _Arg; \ 345 typedef typename __fun<_Name, _Arg>::result_type _Value; \ 346 typedef _BinClos<_Name, _Expr, _Expr, _Dom1, _Dom2> _Closure; \ 347 return _Expr<_Closure, _Value>(_Closure(__v(), __w())); \ 348 } \ 349 \ 350 template<class _Dom> \ 351 inline _Expr<_BinClos<_Name, _Expr, _Constant, _Dom, \ 352 typename _Dom::value_type>, \ 353 typename __fun<_Name, typename _Dom::value_type>::result_type> \ 354 operator _Op(const _Expr<_Dom, typename _Dom::value_type>& __v, \ 355 const typename _Dom::value_type& __t) \ 356 { \ 357 typedef typename _Dom::value_type _Arg; \ 358 typedef typename __fun<_Name, _Arg>::result_type _Value; \ 359 typedef _BinClos<_Name, _Expr, _Constant, _Dom, _Arg> _Closure; \ 360 return _Expr<_Closure, _Value>(_Closure(__v(), __t)); \ 361 } \ 362 \ 363 template<class _Dom> \ 364 inline _Expr<_BinClos<_Name, _Constant, _Expr, \ 365 typename _Dom::value_type, _Dom>, \ 366 typename __fun<_Name, typename _Dom::value_type>::result_type> \ 367 operator _Op(const typename _Dom::value_type& __t, \ 368 const _Expr<_Dom, typename _Dom::value_type>& __v) \ 369 { \ 370 typedef typename _Dom::value_type _Arg; \ 371 typedef typename __fun<_Name, _Arg>::result_type _Value; \ 372 typedef _BinClos<_Name, _Constant, _Expr, _Arg, _Dom> _Closure; \ 373 return _Expr<_Closure, _Value>(_Closure(__t, __v())); \ 374 } \ 375 \ 376 template<class _Dom> \ 377 inline _Expr<_BinClos<_Name, _Expr, _ValArray, \ 378 _Dom, typename _Dom::value_type>, \ 379 typename __fun<_Name, typename _Dom::value_type>::result_type> \ 380 operator _Op(const _Expr<_Dom,typename _Dom::value_type>& __e, \ 381 const valarray<typename _Dom::value_type>& __v) \ 382 { \ 383 typedef typename _Dom::value_type _Arg; \ 384 typedef typename __fun<_Name, _Arg>::result_type _Value; \ 385 typedef _BinClos<_Name, _Expr, _ValArray, _Dom, _Arg> _Closure; \ 386 return _Expr<_Closure, _Value>(_Closure(__e(), __v)); \ 387 } \ 388 \ 389 template<class _Dom> \ 390 inline _Expr<_BinClos<_Name, _ValArray, _Expr, \ 391 typename _Dom::value_type, _Dom>, \ 392 typename __fun<_Name, typename _Dom::value_type>::result_type> \ 393 operator _Op(const valarray<typename _Dom::value_type>& __v, \ 394 const _Expr<_Dom, typename _Dom::value_type>& __e) \ 395 { \ 396 typedef typename _Dom::value_type _Tp; \ 397 typedef typename __fun<_Name, _Tp>::result_type _Value; \ 398 typedef _BinClos<_Name, _ValArray, _Expr, _Tp, _Dom> _Closure; \ 399 return _Expr<_Closure, _Value>(_Closure(__v, __e ())); \ 400 } 401 402 _DEFINE_EXPR_BINARY_OPERATOR(+, __plus) 403 _DEFINE_EXPR_BINARY_OPERATOR(-, __minus) 404 _DEFINE_EXPR_BINARY_OPERATOR(*, __multiplies) 405 _DEFINE_EXPR_BINARY_OPERATOR(/, __divides) 406 _DEFINE_EXPR_BINARY_OPERATOR(%, __modulus) 407 _DEFINE_EXPR_BINARY_OPERATOR(^, __bitwise_xor) 408 _DEFINE_EXPR_BINARY_OPERATOR(&, __bitwise_and) 409 _DEFINE_EXPR_BINARY_OPERATOR(|, __bitwise_or) 410 _DEFINE_EXPR_BINARY_OPERATOR(<<, __shift_left) 411 _DEFINE_EXPR_BINARY_OPERATOR(>>, __shift_right) 412 _DEFINE_EXPR_BINARY_OPERATOR(&&, __logical_and) 413 _DEFINE_EXPR_BINARY_OPERATOR(||, __logical_or) 414 _DEFINE_EXPR_BINARY_OPERATOR(==, __equal_to) 415 _DEFINE_EXPR_BINARY_OPERATOR(!=, __not_equal_to) 416 _DEFINE_EXPR_BINARY_OPERATOR(<, __less) 417 _DEFINE_EXPR_BINARY_OPERATOR(>, __greater) 418 _DEFINE_EXPR_BINARY_OPERATOR(<=, __less_equal) 419 _DEFINE_EXPR_BINARY_OPERATOR(>=, __greater_equal) 420 421#undef _DEFINE_EXPR_BINARY_OPERATOR 422 423#define _DEFINE_EXPR_UNARY_FUNCTION(_Name, _UName) \ 424 template<class _Dom> \ 425 inline _Expr<_UnClos<_UName, _Expr, _Dom>, \ 426 typename _Dom::value_type> \ 427 _Name(const _Expr<_Dom, typename _Dom::value_type>& __e) \ 428 { \ 429 typedef typename _Dom::value_type _Tp; \ 430 typedef _UnClos<_UName, _Expr, _Dom> _Closure; \ 431 return _Expr<_Closure, _Tp>(_Closure(__e())); \ 432 } \ 433 \ 434 template<typename _Tp> \ 435 inline _Expr<_UnClos<_UName, _ValArray, _Tp>, _Tp> \ 436 _Name(const valarray<_Tp>& __v) \ 437 { \ 438 typedef _UnClos<_UName, _ValArray, _Tp> _Closure; \ 439 return _Expr<_Closure, _Tp>(_Closure(__v)); \ 440 } 441 442 _DEFINE_EXPR_UNARY_FUNCTION(abs, _Abs) 443 _DEFINE_EXPR_UNARY_FUNCTION(cos, _Cos) 444 _DEFINE_EXPR_UNARY_FUNCTION(acos, _Acos) 445 _DEFINE_EXPR_UNARY_FUNCTION(cosh, _Cosh) 446 _DEFINE_EXPR_UNARY_FUNCTION(sin, _Sin) 447 _DEFINE_EXPR_UNARY_FUNCTION(asin, _Asin) 448 _DEFINE_EXPR_UNARY_FUNCTION(sinh, _Sinh) 449 _DEFINE_EXPR_UNARY_FUNCTION(tan, _Tan) 450 _DEFINE_EXPR_UNARY_FUNCTION(tanh, _Tanh) 451 _DEFINE_EXPR_UNARY_FUNCTION(atan, _Atan) 452 _DEFINE_EXPR_UNARY_FUNCTION(exp, _Exp) 453 _DEFINE_EXPR_UNARY_FUNCTION(log, _Log) 454 _DEFINE_EXPR_UNARY_FUNCTION(log10, _Log10) 455 _DEFINE_EXPR_UNARY_FUNCTION(sqrt, _Sqrt) 456 457#undef _DEFINE_EXPR_UNARY_FUNCTION 458 459#define _DEFINE_EXPR_BINARY_FUNCTION(_Fun, _UFun) \ 460 template<class _Dom1, class _Dom2> \ 461 inline _Expr<_BinClos<_UFun, _Expr, _Expr, _Dom1, _Dom2>, \ 462 typename _Dom1::value_type> \ 463 _Fun(const _Expr<_Dom1, typename _Dom1::value_type>& __e1, \ 464 const _Expr<_Dom2, typename _Dom2::value_type>& __e2) \ 465 { \ 466 typedef typename _Dom1::value_type _Tp; \ 467 typedef _BinClos<_UFun, _Expr, _Expr, _Dom1, _Dom2> _Closure; \ 468 return _Expr<_Closure, _Tp>(_Closure(__e1(), __e2())); \ 469 } \ 470 \ 471 template<class _Dom> \ 472 inline _Expr<_BinClos<_UFun, _Expr, _ValArray, _Dom, \ 473 typename _Dom::value_type>, \ 474 typename _Dom::value_type> \ 475 _Fun(const _Expr<_Dom, typename _Dom::value_type>& __e, \ 476 const valarray<typename _Dom::value_type>& __v) \ 477 { \ 478 typedef typename _Dom::value_type _Tp; \ 479 typedef _BinClos<_UFun, _Expr, _ValArray, _Dom, _Tp> _Closure; \ 480 return _Expr<_Closure, _Tp>(_Closure(__e(), __v)); \ 481 } \ 482 \ 483 template<class _Dom> \ 484 inline _Expr<_BinClos<_UFun, _ValArray, _Expr, \ 485 typename _Dom::value_type, _Dom>, \ 486 typename _Dom::value_type> \ 487 _Fun(const valarray<typename _Dom::valarray>& __v, \ 488 const _Expr<_Dom, typename _Dom::value_type>& __e) \ 489 { \ 490 typedef typename _Dom::value_type _Tp; \ 491 typedef _BinClos<_UFun, _ValArray, _Expr, _Tp, _Dom> _Closure; \ 492 return _Expr<_Closure, _Tp>(_Closure(__v, __e())); \ 493 } \ 494 \ 495 template<class _Dom> \ 496 inline _Expr<_BinClos<_UFun, _Expr, _Constant, _Dom, \ 497 typename _Dom::value_type>, \ 498 typename _Dom::value_type> \ 499 _Fun(const _Expr<_Dom, typename _Dom::value_type>& __e, \ 500 const typename _Dom::value_type& __t) \ 501 { \ 502 typedef typename _Dom::value_type _Tp; \ 503 typedef _BinClos<_UFun, _Expr, _Constant, _Dom, _Tp> _Closure; \ 504 return _Expr<_Closure, _Tp>(_Closure(__e(), __t)); \ 505 } \ 506 \ 507 template<class _Dom> \ 508 inline _Expr<_BinClos<_UFun, _Constant, _Expr, \ 509 typename _Dom::value_type, _Dom>, \ 510 typename _Dom::value_type> \ 511 _Fun(const typename _Dom::value_type& __t, \ 512 const _Expr<_Dom, typename _Dom::value_type>& __e) \ 513 { \ 514 typedef typename _Dom::value_type _Tp; \ 515 typedef _BinClos<_UFun, _Constant, _Expr, _Tp, _Dom> _Closure; \ 516 return _Expr<_Closure, _Tp>(_Closure(__t, __e())); \ 517 } \ 518 \ 519 template<typename _Tp> \ 520 inline _Expr<_BinClos<_UFun, _ValArray, _ValArray, _Tp, _Tp>, _Tp> \ 521 _Fun(const valarray<_Tp>& __v, const valarray<_Tp>& __w) \ 522 { \ 523 typedef _BinClos<_UFun, _ValArray, _ValArray, _Tp, _Tp> _Closure;\ 524 return _Expr<_Closure, _Tp>(_Closure(__v, __w)); \ 525 } \ 526 \ 527 template<typename _Tp> \ 528 inline _Expr<_BinClos<_UFun, _ValArray, _Constant, _Tp, _Tp>, _Tp> \ 529 _Fun(const valarray<_Tp>& __v, const _Tp& __t) \ 530 { \ 531 typedef _BinClos<_UFun, _ValArray, _Constant, _Tp, _Tp> _Closure;\ 532 return _Expr<_Closure, _Tp>(_Closure(__v, __t)); \ 533 } \ 534 \ 535 template<typename _Tp> \ 536 inline _Expr<_BinClos<_UFun, _Constant, _ValArray, _Tp, _Tp>, _Tp> \ 537 _Fun(const _Tp& __t, const valarray<_Tp>& __v) \ 538 { \ 539 typedef _BinClos<_UFun, _Constant, _ValArray, _Tp, _Tp> _Closure;\ 540 return _Expr<_Closure, _Tp>(_Closure(__t, __v)); \ 541 } 542 543_DEFINE_EXPR_BINARY_FUNCTION(atan2, _Atan2) 544_DEFINE_EXPR_BINARY_FUNCTION(pow, _Pow) 545 546#undef _DEFINE_EXPR_BINARY_FUNCTION 547 548_GLIBCXX_END_NAMESPACE_VERSION 549} // namespace 550 551#endif /* _CPP_VALARRAY_AFTER_H */ 552