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