1 // -*- C++ -*- 2 //===-------------------------- valarray ----------------------------------===// 3 // 4 // The LLVM Compiler Infrastructure 5 // 6 // This file is dual licensed under the MIT and the University of Illinois Open 7 // Source Licenses. See LICENSE.TXT for details. 8 // 9 //===----------------------------------------------------------------------===// 10 11 #ifndef _LIBCPP_VALARRAY 12 #define _LIBCPP_VALARRAY 13 14 /* 15 valarray synopsis 16 17 namespace std 18 { 19 20 template<class T> 21 class valarray 22 { 23 public: 24 typedef T value_type; 25 26 // construct/destroy: 27 valarray(); 28 explicit valarray(size_t n); 29 valarray(const value_type& x, size_t n); 30 valarray(const value_type* px, size_t n); 31 valarray(const valarray& v); 32 valarray(valarray&& v) noexcept; 33 valarray(const slice_array<value_type>& sa); 34 valarray(const gslice_array<value_type>& ga); 35 valarray(const mask_array<value_type>& ma); 36 valarray(const indirect_array<value_type>& ia); 37 valarray(initializer_list<value_type> il); 38 ~valarray(); 39 40 // assignment: 41 valarray& operator=(const valarray& v); 42 valarray& operator=(valarray&& v) noexcept; 43 valarray& operator=(initializer_list<value_type> il); 44 valarray& operator=(const value_type& x); 45 valarray& operator=(const slice_array<value_type>& sa); 46 valarray& operator=(const gslice_array<value_type>& ga); 47 valarray& operator=(const mask_array<value_type>& ma); 48 valarray& operator=(const indirect_array<value_type>& ia); 49 50 // element access: 51 const value_type& operator[](size_t i) const; 52 value_type& operator[](size_t i); 53 54 // subset operations: 55 valarray operator[](slice s) const; 56 slice_array<value_type> operator[](slice s); 57 valarray operator[](const gslice& gs) const; 58 gslice_array<value_type> operator[](const gslice& gs); 59 valarray operator[](const valarray<bool>& vb) const; 60 mask_array<value_type> operator[](const valarray<bool>& vb); 61 valarray operator[](const valarray<size_t>& vs) const; 62 indirect_array<value_type> operator[](const valarray<size_t>& vs); 63 64 // unary operators: 65 valarray operator+() const; 66 valarray operator-() const; 67 valarray operator~() const; 68 valarray<bool> operator!() const; 69 70 // computed assignment: 71 valarray& operator*= (const value_type& x); 72 valarray& operator/= (const value_type& x); 73 valarray& operator%= (const value_type& x); 74 valarray& operator+= (const value_type& x); 75 valarray& operator-= (const value_type& x); 76 valarray& operator^= (const value_type& x); 77 valarray& operator&= (const value_type& x); 78 valarray& operator|= (const value_type& x); 79 valarray& operator<<=(const value_type& x); 80 valarray& operator>>=(const value_type& x); 81 82 valarray& operator*= (const valarray& v); 83 valarray& operator/= (const valarray& v); 84 valarray& operator%= (const valarray& v); 85 valarray& operator+= (const valarray& v); 86 valarray& operator-= (const valarray& v); 87 valarray& operator^= (const valarray& v); 88 valarray& operator|= (const valarray& v); 89 valarray& operator&= (const valarray& v); 90 valarray& operator<<=(const valarray& v); 91 valarray& operator>>=(const valarray& v); 92 93 // member functions: 94 void swap(valarray& v) noexcept; 95 96 size_t size() const; 97 98 value_type sum() const; 99 value_type min() const; 100 value_type max() const; 101 102 valarray shift (int i) const; 103 valarray cshift(int i) const; 104 valarray apply(value_type f(value_type)) const; 105 valarray apply(value_type f(const value_type&)) const; 106 void resize(size_t n, value_type x = value_type()); 107 }; 108 109 class slice 110 { 111 public: 112 slice(); 113 slice(size_t start, size_t size, size_t stride); 114 115 size_t start() const; 116 size_t size() const; 117 size_t stride() const; 118 }; 119 120 template <class T> 121 class slice_array 122 { 123 public: 124 typedef T value_type; 125 126 const slice_array& operator=(const slice_array& sa) const; 127 void operator= (const valarray<value_type>& v) const; 128 void operator*= (const valarray<value_type>& v) const; 129 void operator/= (const valarray<value_type>& v) const; 130 void operator%= (const valarray<value_type>& v) const; 131 void operator+= (const valarray<value_type>& v) const; 132 void operator-= (const valarray<value_type>& v) const; 133 void operator^= (const valarray<value_type>& v) const; 134 void operator&= (const valarray<value_type>& v) const; 135 void operator|= (const valarray<value_type>& v) const; 136 void operator<<=(const valarray<value_type>& v) const; 137 void operator>>=(const valarray<value_type>& v) const; 138 139 void operator=(const value_type& x) const; 140 141 slice_array() = delete; 142 }; 143 144 class gslice 145 { 146 public: 147 gslice(); 148 gslice(size_t start, const valarray<size_t>& size, 149 const valarray<size_t>& stride); 150 151 size_t start() const; 152 valarray<size_t> size() const; 153 valarray<size_t> stride() const; 154 }; 155 156 template <class T> 157 class gslice_array 158 { 159 public: 160 typedef T value_type; 161 162 void operator= (const valarray<value_type>& v) const; 163 void operator*= (const valarray<value_type>& v) const; 164 void operator/= (const valarray<value_type>& v) const; 165 void operator%= (const valarray<value_type>& v) const; 166 void operator+= (const valarray<value_type>& v) const; 167 void operator-= (const valarray<value_type>& v) const; 168 void operator^= (const valarray<value_type>& v) const; 169 void operator&= (const valarray<value_type>& v) const; 170 void operator|= (const valarray<value_type>& v) const; 171 void operator<<=(const valarray<value_type>& v) const; 172 void operator>>=(const valarray<value_type>& v) const; 173 174 gslice_array(const gslice_array& ga); 175 ~gslice_array(); 176 const gslice_array& operator=(const gslice_array& ga) const; 177 void operator=(const value_type& x) const; 178 179 gslice_array() = delete; 180 }; 181 182 template <class T> 183 class mask_array 184 { 185 public: 186 typedef T value_type; 187 188 void operator= (const valarray<value_type>& v) const; 189 void operator*= (const valarray<value_type>& v) const; 190 void operator/= (const valarray<value_type>& v) const; 191 void operator%= (const valarray<value_type>& v) const; 192 void operator+= (const valarray<value_type>& v) const; 193 void operator-= (const valarray<value_type>& v) const; 194 void operator^= (const valarray<value_type>& v) const; 195 void operator&= (const valarray<value_type>& v) const; 196 void operator|= (const valarray<value_type>& v) const; 197 void operator<<=(const valarray<value_type>& v) const; 198 void operator>>=(const valarray<value_type>& v) const; 199 200 mask_array(const mask_array& ma); 201 ~mask_array(); 202 const mask_array& operator=(const mask_array& ma) const; 203 void operator=(const value_type& x) const; 204 205 mask_array() = delete; 206 }; 207 208 template <class T> 209 class indirect_array 210 { 211 public: 212 typedef T value_type; 213 214 void operator= (const valarray<value_type>& v) const; 215 void operator*= (const valarray<value_type>& v) const; 216 void operator/= (const valarray<value_type>& v) const; 217 void operator%= (const valarray<value_type>& v) const; 218 void operator+= (const valarray<value_type>& v) const; 219 void operator-= (const valarray<value_type>& v) const; 220 void operator^= (const valarray<value_type>& v) const; 221 void operator&= (const valarray<value_type>& v) const; 222 void operator|= (const valarray<value_type>& v) const; 223 void operator<<=(const valarray<value_type>& v) const; 224 void operator>>=(const valarray<value_type>& v) const; 225 226 indirect_array(const indirect_array& ia); 227 ~indirect_array(); 228 const indirect_array& operator=(const indirect_array& ia) const; 229 void operator=(const value_type& x) const; 230 231 indirect_array() = delete; 232 }; 233 234 template<class T> void swap(valarray<T>& x, valarray<T>& y) noexcept; 235 236 template<class T> valarray<T> operator* (const valarray<T>& x, const valarray<T>& y); 237 template<class T> valarray<T> operator* (const valarray<T>& x, const T& y); 238 template<class T> valarray<T> operator* (const T& x, const valarray<T>& y); 239 240 template<class T> valarray<T> operator/ (const valarray<T>& x, const valarray<T>& y); 241 template<class T> valarray<T> operator/ (const valarray<T>& x, const T& y); 242 template<class T> valarray<T> operator/ (const T& x, const valarray<T>& y); 243 244 template<class T> valarray<T> operator% (const valarray<T>& x, const valarray<T>& y); 245 template<class T> valarray<T> operator% (const valarray<T>& x, const T& y); 246 template<class T> valarray<T> operator% (const T& x, const valarray<T>& y); 247 248 template<class T> valarray<T> operator+ (const valarray<T>& x, const valarray<T>& y); 249 template<class T> valarray<T> operator+ (const valarray<T>& x, const T& y); 250 template<class T> valarray<T> operator+ (const T& x, const valarray<T>& y); 251 252 template<class T> valarray<T> operator- (const valarray<T>& x, const valarray<T>& y); 253 template<class T> valarray<T> operator- (const valarray<T>& x, const T& y); 254 template<class T> valarray<T> operator- (const T& x, const valarray<T>& y); 255 256 template<class T> valarray<T> operator^ (const valarray<T>& x, const valarray<T>& y); 257 template<class T> valarray<T> operator^ (const valarray<T>& x, const T& y); 258 template<class T> valarray<T> operator^ (const T& x, const valarray<T>& y); 259 260 template<class T> valarray<T> operator& (const valarray<T>& x, const valarray<T>& y); 261 template<class T> valarray<T> operator& (const valarray<T>& x, const T& y); 262 template<class T> valarray<T> operator& (const T& x, const valarray<T>& y); 263 264 template<class T> valarray<T> operator| (const valarray<T>& x, const valarray<T>& y); 265 template<class T> valarray<T> operator| (const valarray<T>& x, const T& y); 266 template<class T> valarray<T> operator| (const T& x, const valarray<T>& y); 267 268 template<class T> valarray<T> operator<<(const valarray<T>& x, const valarray<T>& y); 269 template<class T> valarray<T> operator<<(const valarray<T>& x, const T& y); 270 template<class T> valarray<T> operator<<(const T& x, const valarray<T>& y); 271 272 template<class T> valarray<T> operator>>(const valarray<T>& x, const valarray<T>& y); 273 template<class T> valarray<T> operator>>(const valarray<T>& x, const T& y); 274 template<class T> valarray<T> operator>>(const T& x, const valarray<T>& y); 275 276 template<class T> valarray<bool> operator&&(const valarray<T>& x, const valarray<T>& y); 277 template<class T> valarray<bool> operator&&(const valarray<T>& x, const T& y); 278 template<class T> valarray<bool> operator&&(const T& x, const valarray<T>& y); 279 280 template<class T> valarray<bool> operator||(const valarray<T>& x, const valarray<T>& y); 281 template<class T> valarray<bool> operator||(const valarray<T>& x, const T& y); 282 template<class T> valarray<bool> operator||(const T& x, const valarray<T>& y); 283 284 template<class T> valarray<bool> operator==(const valarray<T>& x, const valarray<T>& y); 285 template<class T> valarray<bool> operator==(const valarray<T>& x, const T& y); 286 template<class T> valarray<bool> operator==(const T& x, const valarray<T>& y); 287 288 template<class T> valarray<bool> operator!=(const valarray<T>& x, const valarray<T>& y); 289 template<class T> valarray<bool> operator!=(const valarray<T>& x, const T& y); 290 template<class T> valarray<bool> operator!=(const T& x, const valarray<T>& y); 291 292 template<class T> valarray<bool> operator< (const valarray<T>& x, const valarray<T>& y); 293 template<class T> valarray<bool> operator< (const valarray<T>& x, const T& y); 294 template<class T> valarray<bool> operator< (const T& x, const valarray<T>& y); 295 296 template<class T> valarray<bool> operator> (const valarray<T>& x, const valarray<T>& y); 297 template<class T> valarray<bool> operator> (const valarray<T>& x, const T& y); 298 template<class T> valarray<bool> operator> (const T& x, const valarray<T>& y); 299 300 template<class T> valarray<bool> operator<=(const valarray<T>& x, const valarray<T>& y); 301 template<class T> valarray<bool> operator<=(const valarray<T>& x, const T& y); 302 template<class T> valarray<bool> operator<=(const T& x, const valarray<T>& y); 303 304 template<class T> valarray<bool> operator>=(const valarray<T>& x, const valarray<T>& y); 305 template<class T> valarray<bool> operator>=(const valarray<T>& x, const T& y); 306 template<class T> valarray<bool> operator>=(const T& x, const valarray<T>& y); 307 308 template<class T> valarray<T> abs (const valarray<T>& x); 309 template<class T> valarray<T> acos (const valarray<T>& x); 310 template<class T> valarray<T> asin (const valarray<T>& x); 311 template<class T> valarray<T> atan (const valarray<T>& x); 312 313 template<class T> valarray<T> atan2(const valarray<T>& x, const valarray<T>& y); 314 template<class T> valarray<T> atan2(const valarray<T>& x, const T& y); 315 template<class T> valarray<T> atan2(const T& x, const valarray<T>& y); 316 317 template<class T> valarray<T> cos (const valarray<T>& x); 318 template<class T> valarray<T> cosh (const valarray<T>& x); 319 template<class T> valarray<T> exp (const valarray<T>& x); 320 template<class T> valarray<T> log (const valarray<T>& x); 321 template<class T> valarray<T> log10(const valarray<T>& x); 322 323 template<class T> valarray<T> pow(const valarray<T>& x, const valarray<T>& y); 324 template<class T> valarray<T> pow(const valarray<T>& x, const T& y); 325 template<class T> valarray<T> pow(const T& x, const valarray<T>& y); 326 327 template<class T> valarray<T> sin (const valarray<T>& x); 328 template<class T> valarray<T> sinh (const valarray<T>& x); 329 template<class T> valarray<T> sqrt (const valarray<T>& x); 330 template<class T> valarray<T> tan (const valarray<T>& x); 331 template<class T> valarray<T> tanh (const valarray<T>& x); 332 333 template <class T> unspecified1 begin(valarray<T>& v); 334 template <class T> unspecified2 begin(const valarray<T>& v); 335 template <class T> unspecified1 end(valarray<T>& v); 336 template <class T> unspecified2 end(const valarray<T>& v); 337 338 } // std 339 340 */ 341 342 #include <__config> 343 #include <cstddef> 344 #include <cmath> 345 #include <initializer_list> 346 #include <algorithm> 347 #include <functional> 348 #include <new> 349 350 #include <__undef_min_max> 351 352 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) 353 #pragma GCC system_header 354 #endif 355 356 _LIBCPP_BEGIN_NAMESPACE_STD 357 358 template<class _Tp> class _LIBCPP_TEMPLATE_VIS valarray; 359 360 class _LIBCPP_TEMPLATE_VIS slice 361 { 362 size_t __start_; 363 size_t __size_; 364 size_t __stride_; 365 public: 366 _LIBCPP_INLINE_VISIBILITY 367 slice() 368 : __start_(0), 369 __size_(0), 370 __stride_(0) 371 {} 372 373 _LIBCPP_INLINE_VISIBILITY 374 slice(size_t __start, size_t __size, size_t __stride) 375 : __start_(__start), 376 __size_(__size), 377 __stride_(__stride) 378 {} 379 380 _LIBCPP_INLINE_VISIBILITY size_t start() const {return __start_;} 381 _LIBCPP_INLINE_VISIBILITY size_t size() const {return __size_;} 382 _LIBCPP_INLINE_VISIBILITY size_t stride() const {return __stride_;} 383 }; 384 385 template <class _Tp> class _LIBCPP_TEMPLATE_VIS slice_array; 386 class _LIBCPP_TYPE_VIS gslice; 387 template <class _Tp> class _LIBCPP_TEMPLATE_VIS gslice_array; 388 template <class _Tp> class _LIBCPP_TEMPLATE_VIS mask_array; 389 template <class _Tp> class _LIBCPP_TEMPLATE_VIS indirect_array; 390 391 template <class _Tp> 392 _LIBCPP_INLINE_VISIBILITY 393 _Tp* 394 begin(valarray<_Tp>& __v); 395 396 template <class _Tp> 397 _LIBCPP_INLINE_VISIBILITY 398 const _Tp* 399 begin(const valarray<_Tp>& __v); 400 401 template <class _Tp> 402 _LIBCPP_INLINE_VISIBILITY 403 _Tp* 404 end(valarray<_Tp>& __v); 405 406 template <class _Tp> 407 _LIBCPP_INLINE_VISIBILITY 408 const _Tp* 409 end(const valarray<_Tp>& __v); 410 411 template <class _Op, class _A0> 412 struct _UnaryOp 413 { 414 typedef typename _Op::result_type result_type; 415 typedef typename _A0::value_type value_type; 416 417 _Op __op_; 418 _A0 __a0_; 419 420 _LIBCPP_INLINE_VISIBILITY 421 _UnaryOp(const _Op& __op, const _A0& __a0) : __op_(__op), __a0_(__a0) {} 422 423 _LIBCPP_INLINE_VISIBILITY 424 result_type operator[](size_t __i) const {return __op_(__a0_[__i]);} 425 426 _LIBCPP_INLINE_VISIBILITY 427 size_t size() const {return __a0_.size();} 428 }; 429 430 template <class _Op, class _A0, class _A1> 431 struct _BinaryOp 432 { 433 typedef typename _Op::result_type result_type; 434 typedef typename _A0::value_type value_type; 435 436 _Op __op_; 437 _A0 __a0_; 438 _A1 __a1_; 439 440 _LIBCPP_INLINE_VISIBILITY 441 _BinaryOp(const _Op& __op, const _A0& __a0, const _A1& __a1) 442 : __op_(__op), __a0_(__a0), __a1_(__a1) {} 443 444 _LIBCPP_INLINE_VISIBILITY 445 value_type operator[](size_t __i) const {return __op_(__a0_[__i], __a1_[__i]);} 446 447 _LIBCPP_INLINE_VISIBILITY 448 size_t size() const {return __a0_.size();} 449 }; 450 451 template <class _Tp> 452 class __scalar_expr 453 { 454 public: 455 typedef _Tp value_type; 456 typedef const _Tp& result_type; 457 private: 458 const value_type& __t_; 459 size_t __s_; 460 public: 461 _LIBCPP_INLINE_VISIBILITY 462 explicit __scalar_expr(const value_type& __t, size_t __s) : __t_(__t), __s_(__s) {} 463 464 _LIBCPP_INLINE_VISIBILITY 465 result_type operator[](size_t) const {return __t_;} 466 467 _LIBCPP_INLINE_VISIBILITY 468 size_t size() const {return __s_;} 469 }; 470 471 template <class _Tp> 472 struct __unary_plus : unary_function<_Tp, _Tp> 473 { 474 _LIBCPP_INLINE_VISIBILITY 475 _Tp operator()(const _Tp& __x) const 476 {return +__x;} 477 }; 478 479 template <class _Tp> 480 struct __bit_not : unary_function<_Tp, _Tp> 481 { 482 _LIBCPP_INLINE_VISIBILITY 483 _Tp operator()(const _Tp& __x) const 484 {return ~__x;} 485 }; 486 487 template <class _Tp> 488 struct __bit_shift_left : binary_function<_Tp, _Tp, _Tp> 489 { 490 _LIBCPP_INLINE_VISIBILITY 491 _Tp operator()(const _Tp& __x, const _Tp& __y) const 492 {return __x << __y;} 493 }; 494 495 template <class _Tp> 496 struct __bit_shift_right : binary_function<_Tp, _Tp, _Tp> 497 { 498 _LIBCPP_INLINE_VISIBILITY 499 _Tp operator()(const _Tp& __x, const _Tp& __y) const 500 {return __x >> __y;} 501 }; 502 503 template <class _Tp, class _Fp> 504 struct __apply_expr : unary_function<_Tp, _Tp> 505 { 506 private: 507 _Fp __f_; 508 public: 509 _LIBCPP_INLINE_VISIBILITY 510 explicit __apply_expr(_Fp __f) : __f_(__f) {} 511 512 _LIBCPP_INLINE_VISIBILITY 513 _Tp operator()(const _Tp& __x) const 514 {return __f_(__x);} 515 }; 516 517 template <class _Tp> 518 struct __abs_expr : unary_function<_Tp, _Tp> 519 { 520 _LIBCPP_INLINE_VISIBILITY 521 _Tp operator()(const _Tp& __x) const 522 {return abs(__x);} 523 }; 524 525 template <class _Tp> 526 struct __acos_expr : unary_function<_Tp, _Tp> 527 { 528 _LIBCPP_INLINE_VISIBILITY 529 _Tp operator()(const _Tp& __x) const 530 {return acos(__x);} 531 }; 532 533 template <class _Tp> 534 struct __asin_expr : unary_function<_Tp, _Tp> 535 { 536 _LIBCPP_INLINE_VISIBILITY 537 _Tp operator()(const _Tp& __x) const 538 {return asin(__x);} 539 }; 540 541 template <class _Tp> 542 struct __atan_expr : unary_function<_Tp, _Tp> 543 { 544 _LIBCPP_INLINE_VISIBILITY 545 _Tp operator()(const _Tp& __x) const 546 {return atan(__x);} 547 }; 548 549 template <class _Tp> 550 struct __atan2_expr : binary_function<_Tp, _Tp, _Tp> 551 { 552 _LIBCPP_INLINE_VISIBILITY 553 _Tp operator()(const _Tp& __x, const _Tp& __y) const 554 {return atan2(__x, __y);} 555 }; 556 557 template <class _Tp> 558 struct __cos_expr : unary_function<_Tp, _Tp> 559 { 560 _LIBCPP_INLINE_VISIBILITY 561 _Tp operator()(const _Tp& __x) const 562 {return cos(__x);} 563 }; 564 565 template <class _Tp> 566 struct __cosh_expr : unary_function<_Tp, _Tp> 567 { 568 _LIBCPP_INLINE_VISIBILITY 569 _Tp operator()(const _Tp& __x) const 570 {return cosh(__x);} 571 }; 572 573 template <class _Tp> 574 struct __exp_expr : unary_function<_Tp, _Tp> 575 { 576 _LIBCPP_INLINE_VISIBILITY 577 _Tp operator()(const _Tp& __x) const 578 {return exp(__x);} 579 }; 580 581 template <class _Tp> 582 struct __log_expr : unary_function<_Tp, _Tp> 583 { 584 _LIBCPP_INLINE_VISIBILITY 585 _Tp operator()(const _Tp& __x) const 586 {return log(__x);} 587 }; 588 589 template <class _Tp> 590 struct __log10_expr : unary_function<_Tp, _Tp> 591 { 592 _LIBCPP_INLINE_VISIBILITY 593 _Tp operator()(const _Tp& __x) const 594 {return log10(__x);} 595 }; 596 597 template <class _Tp> 598 struct __pow_expr : binary_function<_Tp, _Tp, _Tp> 599 { 600 _LIBCPP_INLINE_VISIBILITY 601 _Tp operator()(const _Tp& __x, const _Tp& __y) const 602 {return pow(__x, __y);} 603 }; 604 605 template <class _Tp> 606 struct __sin_expr : unary_function<_Tp, _Tp> 607 { 608 _LIBCPP_INLINE_VISIBILITY 609 _Tp operator()(const _Tp& __x) const 610 {return sin(__x);} 611 }; 612 613 template <class _Tp> 614 struct __sinh_expr : unary_function<_Tp, _Tp> 615 { 616 _LIBCPP_INLINE_VISIBILITY 617 _Tp operator()(const _Tp& __x) const 618 {return sinh(__x);} 619 }; 620 621 template <class _Tp> 622 struct __sqrt_expr : unary_function<_Tp, _Tp> 623 { 624 _LIBCPP_INLINE_VISIBILITY 625 _Tp operator()(const _Tp& __x) const 626 {return sqrt(__x);} 627 }; 628 629 template <class _Tp> 630 struct __tan_expr : unary_function<_Tp, _Tp> 631 { 632 _LIBCPP_INLINE_VISIBILITY 633 _Tp operator()(const _Tp& __x) const 634 {return tan(__x);} 635 }; 636 637 template <class _Tp> 638 struct __tanh_expr : unary_function<_Tp, _Tp> 639 { 640 _LIBCPP_INLINE_VISIBILITY 641 _Tp operator()(const _Tp& __x) const 642 {return tanh(__x);} 643 }; 644 645 template <class _ValExpr> 646 class __slice_expr 647 { 648 typedef typename remove_reference<_ValExpr>::type _RmExpr; 649 public: 650 typedef typename _RmExpr::value_type value_type; 651 typedef value_type result_type; 652 653 private: 654 _ValExpr __expr_; 655 size_t __start_; 656 size_t __size_; 657 size_t __stride_; 658 659 _LIBCPP_INLINE_VISIBILITY 660 __slice_expr(const slice& __sl, const _RmExpr& __e) 661 : __expr_(__e), 662 __start_(__sl.start()), 663 __size_(__sl.size()), 664 __stride_(__sl.stride()) 665 {} 666 public: 667 668 _LIBCPP_INLINE_VISIBILITY 669 result_type operator[](size_t __i) const 670 {return __expr_[__start_ + __i * __stride_];} 671 672 _LIBCPP_INLINE_VISIBILITY 673 size_t size() const {return __size_;} 674 675 template <class> friend class _LIBCPP_TEMPLATE_VIS valarray; 676 }; 677 678 template <class _ValExpr> 679 class __mask_expr; 680 681 template <class _ValExpr> 682 class __indirect_expr; 683 684 template <class _ValExpr> 685 class __shift_expr 686 { 687 typedef typename remove_reference<_ValExpr>::type _RmExpr; 688 public: 689 typedef typename _RmExpr::value_type value_type; 690 typedef value_type result_type; 691 692 private: 693 _ValExpr __expr_; 694 size_t __size_; 695 ptrdiff_t __ul_; 696 ptrdiff_t __sn_; 697 ptrdiff_t __n_; 698 static const ptrdiff_t _Np = static_cast<ptrdiff_t>( 699 sizeof(ptrdiff_t) * __CHAR_BIT__ - 1); 700 701 _LIBCPP_INLINE_VISIBILITY 702 __shift_expr(int __n, const _RmExpr& __e) 703 : __expr_(__e), 704 __size_(__e.size()), 705 __n_(__n) 706 { 707 ptrdiff_t __neg_n = static_cast<ptrdiff_t>(__n_ >> _Np); 708 __sn_ = __neg_n | static_cast<ptrdiff_t>(static_cast<size_t>(-__n_) >> _Np); 709 __ul_ = ((__size_ - __n_) & ~__neg_n) | ((__n_ + 1) & __neg_n); 710 } 711 public: 712 713 _LIBCPP_INLINE_VISIBILITY 714 result_type operator[](size_t __j) const 715 { 716 ptrdiff_t __i = static_cast<ptrdiff_t>(__j); 717 ptrdiff_t __m = (__sn_ * __i - __ul_) >> _Np; 718 return (__expr_[(__i + __n_) & __m] & __m) | (value_type() & ~__m); 719 } 720 721 _LIBCPP_INLINE_VISIBILITY 722 size_t size() const {return __size_;} 723 724 template <class> friend class __val_expr; 725 }; 726 727 template <class _ValExpr> 728 class __cshift_expr 729 { 730 typedef typename remove_reference<_ValExpr>::type _RmExpr; 731 public: 732 typedef typename _RmExpr::value_type value_type; 733 typedef value_type result_type; 734 735 private: 736 _ValExpr __expr_; 737 size_t __size_; 738 size_t __m_; 739 size_t __o1_; 740 size_t __o2_; 741 742 _LIBCPP_INLINE_VISIBILITY 743 __cshift_expr(int __n, const _RmExpr& __e) 744 : __expr_(__e), 745 __size_(__e.size()) 746 { 747 __n %= static_cast<int>(__size_); 748 if (__n >= 0) 749 { 750 __m_ = __size_ - __n; 751 __o1_ = __n; 752 __o2_ = __n - __size_; 753 } 754 else 755 { 756 __m_ = -__n; 757 __o1_ = __n + __size_; 758 __o2_ = __n; 759 } 760 } 761 public: 762 763 _LIBCPP_INLINE_VISIBILITY 764 result_type operator[](size_t __i) const 765 { 766 if (__i < __m_) 767 return __expr_[__i + __o1_]; 768 return __expr_[__i + __o2_]; 769 } 770 771 _LIBCPP_INLINE_VISIBILITY 772 size_t size() const {return __size_;} 773 774 template <class> friend class __val_expr; 775 }; 776 777 template<class _ValExpr> 778 class __val_expr; 779 780 template<class _ValExpr> 781 struct __is_val_expr : false_type {}; 782 783 template<class _ValExpr> 784 struct __is_val_expr<__val_expr<_ValExpr> > : true_type {}; 785 786 template<class _Tp> 787 struct __is_val_expr<valarray<_Tp> > : true_type {}; 788 789 template<class _Tp> 790 class _LIBCPP_TEMPLATE_VIS valarray 791 { 792 public: 793 typedef _Tp value_type; 794 typedef _Tp result_type; 795 796 private: 797 value_type* __begin_; 798 value_type* __end_; 799 800 public: 801 // construct/destroy: 802 _LIBCPP_INLINE_VISIBILITY 803 valarray() : __begin_(0), __end_(0) {} 804 inline _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY 805 explicit valarray(size_t __n); 806 _LIBCPP_INLINE_VISIBILITY 807 valarray(const value_type& __x, size_t __n); 808 valarray(const value_type* __p, size_t __n); 809 valarray(const valarray& __v); 810 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 811 _LIBCPP_INLINE_VISIBILITY 812 valarray(valarray&& __v) _NOEXCEPT; 813 #endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 814 #ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS 815 valarray(initializer_list<value_type> __il); 816 #endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS 817 valarray(const slice_array<value_type>& __sa); 818 valarray(const gslice_array<value_type>& __ga); 819 valarray(const mask_array<value_type>& __ma); 820 valarray(const indirect_array<value_type>& __ia); 821 inline _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY 822 ~valarray(); 823 824 // assignment: 825 valarray& operator=(const valarray& __v); 826 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 827 _LIBCPP_INLINE_VISIBILITY 828 valarray& operator=(valarray&& __v) _NOEXCEPT; 829 #endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 830 #ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS 831 _LIBCPP_INLINE_VISIBILITY 832 valarray& operator=(initializer_list<value_type>); 833 #endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS 834 _LIBCPP_INLINE_VISIBILITY 835 valarray& operator=(const value_type& __x); 836 _LIBCPP_INLINE_VISIBILITY 837 valarray& operator=(const slice_array<value_type>& __sa); 838 _LIBCPP_INLINE_VISIBILITY 839 valarray& operator=(const gslice_array<value_type>& __ga); 840 _LIBCPP_INLINE_VISIBILITY 841 valarray& operator=(const mask_array<value_type>& __ma); 842 _LIBCPP_INLINE_VISIBILITY 843 valarray& operator=(const indirect_array<value_type>& __ia); 844 template <class _ValExpr> 845 _LIBCPP_INLINE_VISIBILITY 846 valarray& operator=(const __val_expr<_ValExpr>& __v); 847 848 // element access: 849 _LIBCPP_INLINE_VISIBILITY 850 const value_type& operator[](size_t __i) const {return __begin_[__i];} 851 852 _LIBCPP_INLINE_VISIBILITY 853 value_type& operator[](size_t __i) {return __begin_[__i];} 854 855 // subset operations: 856 _LIBCPP_INLINE_VISIBILITY 857 __val_expr<__slice_expr<const valarray&> > operator[](slice __s) const; 858 _LIBCPP_INLINE_VISIBILITY 859 slice_array<value_type> operator[](slice __s); 860 _LIBCPP_INLINE_VISIBILITY 861 __val_expr<__indirect_expr<const valarray&> > operator[](const gslice& __gs) const; 862 _LIBCPP_INLINE_VISIBILITY 863 gslice_array<value_type> operator[](const gslice& __gs); 864 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 865 _LIBCPP_INLINE_VISIBILITY 866 __val_expr<__indirect_expr<const valarray&> > operator[](gslice&& __gs) const; 867 _LIBCPP_INLINE_VISIBILITY 868 gslice_array<value_type> operator[](gslice&& __gs); 869 #endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 870 _LIBCPP_INLINE_VISIBILITY 871 __val_expr<__mask_expr<const valarray&> > operator[](const valarray<bool>& __vb) const; 872 _LIBCPP_INLINE_VISIBILITY 873 mask_array<value_type> operator[](const valarray<bool>& __vb); 874 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 875 _LIBCPP_INLINE_VISIBILITY 876 __val_expr<__mask_expr<const valarray&> > operator[](valarray<bool>&& __vb) const; 877 _LIBCPP_INLINE_VISIBILITY 878 mask_array<value_type> operator[](valarray<bool>&& __vb); 879 #endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 880 _LIBCPP_INLINE_VISIBILITY 881 __val_expr<__indirect_expr<const valarray&> > operator[](const valarray<size_t>& __vs) const; 882 _LIBCPP_INLINE_VISIBILITY 883 indirect_array<value_type> operator[](const valarray<size_t>& __vs); 884 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 885 _LIBCPP_INLINE_VISIBILITY 886 __val_expr<__indirect_expr<const valarray&> > operator[](valarray<size_t>&& __vs) const; 887 _LIBCPP_INLINE_VISIBILITY 888 indirect_array<value_type> operator[](valarray<size_t>&& __vs); 889 #endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 890 891 // unary operators: 892 valarray operator+() const; 893 valarray operator-() const; 894 valarray operator~() const; 895 valarray<bool> operator!() const; 896 897 // computed assignment: 898 _LIBCPP_INLINE_VISIBILITY 899 valarray& operator*= (const value_type& __x); 900 _LIBCPP_INLINE_VISIBILITY 901 valarray& operator/= (const value_type& __x); 902 _LIBCPP_INLINE_VISIBILITY 903 valarray& operator%= (const value_type& __x); 904 _LIBCPP_INLINE_VISIBILITY 905 valarray& operator+= (const value_type& __x); 906 _LIBCPP_INLINE_VISIBILITY 907 valarray& operator-= (const value_type& __x); 908 _LIBCPP_INLINE_VISIBILITY 909 valarray& operator^= (const value_type& __x); 910 _LIBCPP_INLINE_VISIBILITY 911 valarray& operator&= (const value_type& __x); 912 _LIBCPP_INLINE_VISIBILITY 913 valarray& operator|= (const value_type& __x); 914 _LIBCPP_INLINE_VISIBILITY 915 valarray& operator<<=(const value_type& __x); 916 _LIBCPP_INLINE_VISIBILITY 917 valarray& operator>>=(const value_type& __x); 918 919 template <class _Expr> 920 typename enable_if 921 < 922 __is_val_expr<_Expr>::value, 923 valarray& 924 >::type 925 _LIBCPP_INLINE_VISIBILITY 926 operator*= (const _Expr& __v); 927 928 template <class _Expr> 929 typename enable_if 930 < 931 __is_val_expr<_Expr>::value, 932 valarray& 933 >::type 934 _LIBCPP_INLINE_VISIBILITY 935 operator/= (const _Expr& __v); 936 937 template <class _Expr> 938 typename enable_if 939 < 940 __is_val_expr<_Expr>::value, 941 valarray& 942 >::type 943 _LIBCPP_INLINE_VISIBILITY 944 operator%= (const _Expr& __v); 945 946 template <class _Expr> 947 typename enable_if 948 < 949 __is_val_expr<_Expr>::value, 950 valarray& 951 >::type 952 _LIBCPP_INLINE_VISIBILITY 953 operator+= (const _Expr& __v); 954 955 template <class _Expr> 956 typename enable_if 957 < 958 __is_val_expr<_Expr>::value, 959 valarray& 960 >::type 961 _LIBCPP_INLINE_VISIBILITY 962 operator-= (const _Expr& __v); 963 964 template <class _Expr> 965 typename enable_if 966 < 967 __is_val_expr<_Expr>::value, 968 valarray& 969 >::type 970 _LIBCPP_INLINE_VISIBILITY 971 operator^= (const _Expr& __v); 972 973 template <class _Expr> 974 typename enable_if 975 < 976 __is_val_expr<_Expr>::value, 977 valarray& 978 >::type 979 _LIBCPP_INLINE_VISIBILITY 980 operator|= (const _Expr& __v); 981 982 template <class _Expr> 983 typename enable_if 984 < 985 __is_val_expr<_Expr>::value, 986 valarray& 987 >::type 988 _LIBCPP_INLINE_VISIBILITY 989 operator&= (const _Expr& __v); 990 991 template <class _Expr> 992 typename enable_if 993 < 994 __is_val_expr<_Expr>::value, 995 valarray& 996 >::type 997 _LIBCPP_INLINE_VISIBILITY 998 operator<<= (const _Expr& __v); 999 1000 template <class _Expr> 1001 typename enable_if 1002 < 1003 __is_val_expr<_Expr>::value, 1004 valarray& 1005 >::type 1006 _LIBCPP_INLINE_VISIBILITY 1007 operator>>= (const _Expr& __v); 1008 1009 // member functions: 1010 _LIBCPP_INLINE_VISIBILITY 1011 void swap(valarray& __v) _NOEXCEPT; 1012 1013 _LIBCPP_INLINE_VISIBILITY 1014 size_t size() const {return static_cast<size_t>(__end_ - __begin_);} 1015 1016 _LIBCPP_INLINE_VISIBILITY 1017 value_type sum() const; 1018 _LIBCPP_INLINE_VISIBILITY 1019 value_type min() const; 1020 _LIBCPP_INLINE_VISIBILITY 1021 value_type max() const; 1022 1023 valarray shift (int __i) const; 1024 valarray cshift(int __i) const; 1025 valarray apply(value_type __f(value_type)) const; 1026 valarray apply(value_type __f(const value_type&)) const; 1027 void resize(size_t __n, value_type __x = value_type()); 1028 1029 private: 1030 template <class> friend class _LIBCPP_TEMPLATE_VIS valarray; 1031 template <class> friend class _LIBCPP_TEMPLATE_VIS slice_array; 1032 template <class> friend class _LIBCPP_TEMPLATE_VIS gslice_array; 1033 template <class> friend class _LIBCPP_TEMPLATE_VIS mask_array; 1034 template <class> friend class __mask_expr; 1035 template <class> friend class _LIBCPP_TEMPLATE_VIS indirect_array; 1036 template <class> friend class __indirect_expr; 1037 template <class> friend class __val_expr; 1038 1039 template <class _Up> 1040 friend 1041 _Up* 1042 begin(valarray<_Up>& __v); 1043 1044 template <class _Up> 1045 friend 1046 const _Up* 1047 begin(const valarray<_Up>& __v); 1048 1049 template <class _Up> 1050 friend 1051 _Up* 1052 end(valarray<_Up>& __v); 1053 1054 template <class _Up> 1055 friend 1056 const _Up* 1057 end(const valarray<_Up>& __v); 1058 }; 1059 1060 _LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS valarray<size_t>::valarray(size_t)) 1061 _LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS valarray<size_t>::~valarray()) 1062 _LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS void valarray<size_t>::resize(size_t, size_t)) 1063 1064 template <class _Op, class _Tp> 1065 struct _UnaryOp<_Op, valarray<_Tp> > 1066 { 1067 typedef typename _Op::result_type result_type; 1068 typedef _Tp value_type; 1069 1070 _Op __op_; 1071 const valarray<_Tp>& __a0_; 1072 1073 _LIBCPP_INLINE_VISIBILITY 1074 _UnaryOp(const _Op& __op, const valarray<_Tp>& __a0) : __op_(__op), __a0_(__a0) {} 1075 1076 _LIBCPP_INLINE_VISIBILITY 1077 result_type operator[](size_t __i) const {return __op_(__a0_[__i]);} 1078 1079 _LIBCPP_INLINE_VISIBILITY 1080 size_t size() const {return __a0_.size();} 1081 }; 1082 1083 template <class _Op, class _Tp, class _A1> 1084 struct _BinaryOp<_Op, valarray<_Tp>, _A1> 1085 { 1086 typedef typename _Op::result_type result_type; 1087 typedef _Tp value_type; 1088 1089 _Op __op_; 1090 const valarray<_Tp>& __a0_; 1091 _A1 __a1_; 1092 1093 _LIBCPP_INLINE_VISIBILITY 1094 _BinaryOp(const _Op& __op, const valarray<_Tp>& __a0, const _A1& __a1) 1095 : __op_(__op), __a0_(__a0), __a1_(__a1) {} 1096 1097 _LIBCPP_INLINE_VISIBILITY 1098 value_type operator[](size_t __i) const {return __op_(__a0_[__i], __a1_[__i]);} 1099 1100 _LIBCPP_INLINE_VISIBILITY 1101 size_t size() const {return __a0_.size();} 1102 }; 1103 1104 template <class _Op, class _A0, class _Tp> 1105 struct _BinaryOp<_Op, _A0, valarray<_Tp> > 1106 { 1107 typedef typename _Op::result_type result_type; 1108 typedef _Tp value_type; 1109 1110 _Op __op_; 1111 _A0 __a0_; 1112 const valarray<_Tp>& __a1_; 1113 1114 _LIBCPP_INLINE_VISIBILITY 1115 _BinaryOp(const _Op& __op, const _A0& __a0, const valarray<_Tp>& __a1) 1116 : __op_(__op), __a0_(__a0), __a1_(__a1) {} 1117 1118 _LIBCPP_INLINE_VISIBILITY 1119 value_type operator[](size_t __i) const {return __op_(__a0_[__i], __a1_[__i]);} 1120 1121 _LIBCPP_INLINE_VISIBILITY 1122 size_t size() const {return __a0_.size();} 1123 }; 1124 1125 template <class _Op, class _Tp> 1126 struct _BinaryOp<_Op, valarray<_Tp>, valarray<_Tp> > 1127 { 1128 typedef typename _Op::result_type result_type; 1129 typedef _Tp value_type; 1130 1131 _Op __op_; 1132 const valarray<_Tp>& __a0_; 1133 const valarray<_Tp>& __a1_; 1134 1135 _LIBCPP_INLINE_VISIBILITY 1136 _BinaryOp(const _Op& __op, const valarray<_Tp>& __a0, const valarray<_Tp>& __a1) 1137 : __op_(__op), __a0_(__a0), __a1_(__a1) {} 1138 1139 _LIBCPP_INLINE_VISIBILITY 1140 value_type operator[](size_t __i) const {return __op_(__a0_[__i], __a1_[__i]);} 1141 1142 _LIBCPP_INLINE_VISIBILITY 1143 size_t size() const {return __a0_.size();} 1144 }; 1145 1146 // slice_array 1147 1148 template <class _Tp> 1149 class _LIBCPP_TEMPLATE_VIS slice_array 1150 { 1151 public: 1152 typedef _Tp value_type; 1153 1154 private: 1155 value_type* __vp_; 1156 size_t __size_; 1157 size_t __stride_; 1158 1159 public: 1160 template <class _Expr> 1161 typename enable_if 1162 < 1163 __is_val_expr<_Expr>::value, 1164 void 1165 >::type 1166 _LIBCPP_INLINE_VISIBILITY 1167 operator=(const _Expr& __v) const; 1168 1169 template <class _Expr> 1170 typename enable_if 1171 < 1172 __is_val_expr<_Expr>::value, 1173 void 1174 >::type 1175 _LIBCPP_INLINE_VISIBILITY 1176 operator*=(const _Expr& __v) const; 1177 1178 template <class _Expr> 1179 typename enable_if 1180 < 1181 __is_val_expr<_Expr>::value, 1182 void 1183 >::type 1184 _LIBCPP_INLINE_VISIBILITY 1185 operator/=(const _Expr& __v) const; 1186 1187 template <class _Expr> 1188 typename enable_if 1189 < 1190 __is_val_expr<_Expr>::value, 1191 void 1192 >::type 1193 _LIBCPP_INLINE_VISIBILITY 1194 operator%=(const _Expr& __v) const; 1195 1196 template <class _Expr> 1197 typename enable_if 1198 < 1199 __is_val_expr<_Expr>::value, 1200 void 1201 >::type 1202 _LIBCPP_INLINE_VISIBILITY 1203 operator+=(const _Expr& __v) const; 1204 1205 template <class _Expr> 1206 typename enable_if 1207 < 1208 __is_val_expr<_Expr>::value, 1209 void 1210 >::type 1211 _LIBCPP_INLINE_VISIBILITY 1212 operator-=(const _Expr& __v) const; 1213 1214 template <class _Expr> 1215 typename enable_if 1216 < 1217 __is_val_expr<_Expr>::value, 1218 void 1219 >::type 1220 _LIBCPP_INLINE_VISIBILITY 1221 operator^=(const _Expr& __v) const; 1222 1223 template <class _Expr> 1224 typename enable_if 1225 < 1226 __is_val_expr<_Expr>::value, 1227 void 1228 >::type 1229 _LIBCPP_INLINE_VISIBILITY 1230 operator&=(const _Expr& __v) const; 1231 1232 template <class _Expr> 1233 typename enable_if 1234 < 1235 __is_val_expr<_Expr>::value, 1236 void 1237 >::type 1238 _LIBCPP_INLINE_VISIBILITY 1239 operator|=(const _Expr& __v) const; 1240 1241 template <class _Expr> 1242 typename enable_if 1243 < 1244 __is_val_expr<_Expr>::value, 1245 void 1246 >::type 1247 _LIBCPP_INLINE_VISIBILITY 1248 operator<<=(const _Expr& __v) const; 1249 1250 template <class _Expr> 1251 typename enable_if 1252 < 1253 __is_val_expr<_Expr>::value, 1254 void 1255 >::type 1256 _LIBCPP_INLINE_VISIBILITY 1257 operator>>=(const _Expr& __v) const; 1258 1259 _LIBCPP_INLINE_VISIBILITY 1260 const slice_array& operator=(const slice_array& __sa) const; 1261 1262 _LIBCPP_INLINE_VISIBILITY 1263 void operator=(const value_type& __x) const; 1264 1265 private: 1266 _LIBCPP_INLINE_VISIBILITY 1267 slice_array(const slice& __sl, const valarray<value_type>& __v) 1268 : __vp_(const_cast<value_type*>(__v.__begin_ + __sl.start())), 1269 __size_(__sl.size()), 1270 __stride_(__sl.stride()) 1271 {} 1272 1273 template <class> friend class valarray; 1274 template <class> friend class sliceExpr; 1275 }; 1276 1277 template <class _Tp> 1278 inline 1279 const slice_array<_Tp>& 1280 slice_array<_Tp>::operator=(const slice_array& __sa) const 1281 { 1282 value_type* __t = __vp_; 1283 const value_type* __s = __sa.__vp_; 1284 for (size_t __n = __size_; __n; --__n, __t += __stride_, __s += __sa.__stride_) 1285 *__t = *__s; 1286 return *this; 1287 } 1288 1289 template <class _Tp> 1290 template <class _Expr> 1291 inline 1292 typename enable_if 1293 < 1294 __is_val_expr<_Expr>::value, 1295 void 1296 >::type 1297 slice_array<_Tp>::operator=(const _Expr& __v) const 1298 { 1299 value_type* __t = __vp_; 1300 for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_) 1301 *__t = __v[__i]; 1302 } 1303 1304 template <class _Tp> 1305 template <class _Expr> 1306 inline 1307 typename enable_if 1308 < 1309 __is_val_expr<_Expr>::value, 1310 void 1311 >::type 1312 slice_array<_Tp>::operator*=(const _Expr& __v) const 1313 { 1314 value_type* __t = __vp_; 1315 for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_) 1316 *__t *= __v[__i]; 1317 } 1318 1319 template <class _Tp> 1320 template <class _Expr> 1321 inline 1322 typename enable_if 1323 < 1324 __is_val_expr<_Expr>::value, 1325 void 1326 >::type 1327 slice_array<_Tp>::operator/=(const _Expr& __v) const 1328 { 1329 value_type* __t = __vp_; 1330 for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_) 1331 *__t /= __v[__i]; 1332 } 1333 1334 template <class _Tp> 1335 template <class _Expr> 1336 inline 1337 typename enable_if 1338 < 1339 __is_val_expr<_Expr>::value, 1340 void 1341 >::type 1342 slice_array<_Tp>::operator%=(const _Expr& __v) const 1343 { 1344 value_type* __t = __vp_; 1345 for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_) 1346 *__t %= __v[__i]; 1347 } 1348 1349 template <class _Tp> 1350 template <class _Expr> 1351 inline 1352 typename enable_if 1353 < 1354 __is_val_expr<_Expr>::value, 1355 void 1356 >::type 1357 slice_array<_Tp>::operator+=(const _Expr& __v) const 1358 { 1359 value_type* __t = __vp_; 1360 for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_) 1361 *__t += __v[__i]; 1362 } 1363 1364 template <class _Tp> 1365 template <class _Expr> 1366 inline 1367 typename enable_if 1368 < 1369 __is_val_expr<_Expr>::value, 1370 void 1371 >::type 1372 slice_array<_Tp>::operator-=(const _Expr& __v) const 1373 { 1374 value_type* __t = __vp_; 1375 for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_) 1376 *__t -= __v[__i]; 1377 } 1378 1379 template <class _Tp> 1380 template <class _Expr> 1381 inline 1382 typename enable_if 1383 < 1384 __is_val_expr<_Expr>::value, 1385 void 1386 >::type 1387 slice_array<_Tp>::operator^=(const _Expr& __v) const 1388 { 1389 value_type* __t = __vp_; 1390 for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_) 1391 *__t ^= __v[__i]; 1392 } 1393 1394 template <class _Tp> 1395 template <class _Expr> 1396 inline 1397 typename enable_if 1398 < 1399 __is_val_expr<_Expr>::value, 1400 void 1401 >::type 1402 slice_array<_Tp>::operator&=(const _Expr& __v) const 1403 { 1404 value_type* __t = __vp_; 1405 for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_) 1406 *__t &= __v[__i]; 1407 } 1408 1409 template <class _Tp> 1410 template <class _Expr> 1411 inline 1412 typename enable_if 1413 < 1414 __is_val_expr<_Expr>::value, 1415 void 1416 >::type 1417 slice_array<_Tp>::operator|=(const _Expr& __v) const 1418 { 1419 value_type* __t = __vp_; 1420 for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_) 1421 *__t |= __v[__i]; 1422 } 1423 1424 template <class _Tp> 1425 template <class _Expr> 1426 inline 1427 typename enable_if 1428 < 1429 __is_val_expr<_Expr>::value, 1430 void 1431 >::type 1432 slice_array<_Tp>::operator<<=(const _Expr& __v) const 1433 { 1434 value_type* __t = __vp_; 1435 for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_) 1436 *__t <<= __v[__i]; 1437 } 1438 1439 template <class _Tp> 1440 template <class _Expr> 1441 inline 1442 typename enable_if 1443 < 1444 __is_val_expr<_Expr>::value, 1445 void 1446 >::type 1447 slice_array<_Tp>::operator>>=(const _Expr& __v) const 1448 { 1449 value_type* __t = __vp_; 1450 for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_) 1451 *__t >>= __v[__i]; 1452 } 1453 1454 template <class _Tp> 1455 inline 1456 void 1457 slice_array<_Tp>::operator=(const value_type& __x) const 1458 { 1459 value_type* __t = __vp_; 1460 for (size_t __n = __size_; __n; --__n, __t += __stride_) 1461 *__t = __x; 1462 } 1463 1464 // gslice 1465 1466 class _LIBCPP_TYPE_VIS gslice 1467 { 1468 valarray<size_t> __size_; 1469 valarray<size_t> __stride_; 1470 valarray<size_t> __1d_; 1471 1472 public: 1473 _LIBCPP_INLINE_VISIBILITY 1474 gslice() {} 1475 1476 _LIBCPP_INLINE_VISIBILITY 1477 gslice(size_t __start, const valarray<size_t>& __size, 1478 const valarray<size_t>& __stride) 1479 : __size_(__size), 1480 __stride_(__stride) 1481 {__init(__start);} 1482 1483 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 1484 1485 _LIBCPP_INLINE_VISIBILITY 1486 gslice(size_t __start, const valarray<size_t>& __size, 1487 valarray<size_t>&& __stride) 1488 : __size_(__size), 1489 __stride_(move(__stride)) 1490 {__init(__start);} 1491 1492 _LIBCPP_INLINE_VISIBILITY 1493 gslice(size_t __start, valarray<size_t>&& __size, 1494 const valarray<size_t>& __stride) 1495 : __size_(move(__size)), 1496 __stride_(__stride) 1497 {__init(__start);} 1498 1499 _LIBCPP_INLINE_VISIBILITY 1500 gslice(size_t __start, valarray<size_t>&& __size, 1501 valarray<size_t>&& __stride) 1502 : __size_(move(__size)), 1503 __stride_(move(__stride)) 1504 {__init(__start);} 1505 1506 #endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 1507 1508 // gslice(const gslice&) = default; 1509 // gslice(gslice&&) = default; 1510 // gslice& operator=(const gslice&) = default; 1511 // gslice& operator=(gslice&&) = default; 1512 1513 _LIBCPP_INLINE_VISIBILITY 1514 size_t start() const {return __1d_.size() ? __1d_[0] : 0;} 1515 1516 _LIBCPP_INLINE_VISIBILITY 1517 valarray<size_t> size() const {return __size_;} 1518 1519 _LIBCPP_INLINE_VISIBILITY 1520 valarray<size_t> stride() const {return __stride_;} 1521 1522 private: 1523 void __init(size_t __start); 1524 1525 template <class> friend class gslice_array; 1526 template <class> friend class valarray; 1527 template <class> friend class __val_expr; 1528 }; 1529 1530 // gslice_array 1531 1532 template <class _Tp> 1533 class _LIBCPP_TEMPLATE_VIS gslice_array 1534 { 1535 public: 1536 typedef _Tp value_type; 1537 1538 private: 1539 value_type* __vp_; 1540 valarray<size_t> __1d_; 1541 1542 public: 1543 template <class _Expr> 1544 typename enable_if 1545 < 1546 __is_val_expr<_Expr>::value, 1547 void 1548 >::type 1549 _LIBCPP_INLINE_VISIBILITY 1550 operator=(const _Expr& __v) const; 1551 1552 template <class _Expr> 1553 typename enable_if 1554 < 1555 __is_val_expr<_Expr>::value, 1556 void 1557 >::type 1558 _LIBCPP_INLINE_VISIBILITY 1559 operator*=(const _Expr& __v) const; 1560 1561 template <class _Expr> 1562 typename enable_if 1563 < 1564 __is_val_expr<_Expr>::value, 1565 void 1566 >::type 1567 _LIBCPP_INLINE_VISIBILITY 1568 operator/=(const _Expr& __v) const; 1569 1570 template <class _Expr> 1571 typename enable_if 1572 < 1573 __is_val_expr<_Expr>::value, 1574 void 1575 >::type 1576 _LIBCPP_INLINE_VISIBILITY 1577 operator%=(const _Expr& __v) const; 1578 1579 template <class _Expr> 1580 typename enable_if 1581 < 1582 __is_val_expr<_Expr>::value, 1583 void 1584 >::type 1585 _LIBCPP_INLINE_VISIBILITY 1586 operator+=(const _Expr& __v) const; 1587 1588 template <class _Expr> 1589 typename enable_if 1590 < 1591 __is_val_expr<_Expr>::value, 1592 void 1593 >::type 1594 _LIBCPP_INLINE_VISIBILITY 1595 operator-=(const _Expr& __v) const; 1596 1597 template <class _Expr> 1598 typename enable_if 1599 < 1600 __is_val_expr<_Expr>::value, 1601 void 1602 >::type 1603 _LIBCPP_INLINE_VISIBILITY 1604 operator^=(const _Expr& __v) const; 1605 1606 template <class _Expr> 1607 typename enable_if 1608 < 1609 __is_val_expr<_Expr>::value, 1610 void 1611 >::type 1612 _LIBCPP_INLINE_VISIBILITY 1613 operator&=(const _Expr& __v) const; 1614 1615 template <class _Expr> 1616 typename enable_if 1617 < 1618 __is_val_expr<_Expr>::value, 1619 void 1620 >::type 1621 _LIBCPP_INLINE_VISIBILITY 1622 operator|=(const _Expr& __v) const; 1623 1624 template <class _Expr> 1625 typename enable_if 1626 < 1627 __is_val_expr<_Expr>::value, 1628 void 1629 >::type 1630 _LIBCPP_INLINE_VISIBILITY 1631 operator<<=(const _Expr& __v) const; 1632 1633 template <class _Expr> 1634 typename enable_if 1635 < 1636 __is_val_expr<_Expr>::value, 1637 void 1638 >::type 1639 _LIBCPP_INLINE_VISIBILITY 1640 operator>>=(const _Expr& __v) const; 1641 1642 _LIBCPP_INLINE_VISIBILITY 1643 const gslice_array& operator=(const gslice_array& __ga) const; 1644 1645 _LIBCPP_INLINE_VISIBILITY 1646 void operator=(const value_type& __x) const; 1647 1648 // gslice_array(const gslice_array&) = default; 1649 // gslice_array(gslice_array&&) = default; 1650 // gslice_array& operator=(const gslice_array&) = default; 1651 // gslice_array& operator=(gslice_array&&) = default; 1652 1653 private: 1654 gslice_array(const gslice& __gs, const valarray<value_type>& __v) 1655 : __vp_(const_cast<value_type*>(__v.__begin_)), 1656 __1d_(__gs.__1d_) 1657 {} 1658 1659 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 1660 gslice_array(gslice&& __gs, const valarray<value_type>& __v) 1661 : __vp_(const_cast<value_type*>(__v.__begin_)), 1662 __1d_(move(__gs.__1d_)) 1663 {} 1664 #endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 1665 1666 template <class> friend class valarray; 1667 }; 1668 1669 template <class _Tp> 1670 template <class _Expr> 1671 inline 1672 typename enable_if 1673 < 1674 __is_val_expr<_Expr>::value, 1675 void 1676 >::type 1677 gslice_array<_Tp>::operator=(const _Expr& __v) const 1678 { 1679 typedef const size_t* _Ip; 1680 size_t __j = 0; 1681 for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j) 1682 __vp_[*__i] = __v[__j]; 1683 } 1684 1685 template <class _Tp> 1686 template <class _Expr> 1687 inline 1688 typename enable_if 1689 < 1690 __is_val_expr<_Expr>::value, 1691 void 1692 >::type 1693 gslice_array<_Tp>::operator*=(const _Expr& __v) const 1694 { 1695 typedef const size_t* _Ip; 1696 size_t __j = 0; 1697 for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j) 1698 __vp_[*__i] *= __v[__j]; 1699 } 1700 1701 template <class _Tp> 1702 template <class _Expr> 1703 inline 1704 typename enable_if 1705 < 1706 __is_val_expr<_Expr>::value, 1707 void 1708 >::type 1709 gslice_array<_Tp>::operator/=(const _Expr& __v) const 1710 { 1711 typedef const size_t* _Ip; 1712 size_t __j = 0; 1713 for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j) 1714 __vp_[*__i] /= __v[__j]; 1715 } 1716 1717 template <class _Tp> 1718 template <class _Expr> 1719 inline 1720 typename enable_if 1721 < 1722 __is_val_expr<_Expr>::value, 1723 void 1724 >::type 1725 gslice_array<_Tp>::operator%=(const _Expr& __v) const 1726 { 1727 typedef const size_t* _Ip; 1728 size_t __j = 0; 1729 for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j) 1730 __vp_[*__i] %= __v[__j]; 1731 } 1732 1733 template <class _Tp> 1734 template <class _Expr> 1735 inline 1736 typename enable_if 1737 < 1738 __is_val_expr<_Expr>::value, 1739 void 1740 >::type 1741 gslice_array<_Tp>::operator+=(const _Expr& __v) const 1742 { 1743 typedef const size_t* _Ip; 1744 size_t __j = 0; 1745 for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j) 1746 __vp_[*__i] += __v[__j]; 1747 } 1748 1749 template <class _Tp> 1750 template <class _Expr> 1751 inline 1752 typename enable_if 1753 < 1754 __is_val_expr<_Expr>::value, 1755 void 1756 >::type 1757 gslice_array<_Tp>::operator-=(const _Expr& __v) const 1758 { 1759 typedef const size_t* _Ip; 1760 size_t __j = 0; 1761 for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j) 1762 __vp_[*__i] -= __v[__j]; 1763 } 1764 1765 template <class _Tp> 1766 template <class _Expr> 1767 inline 1768 typename enable_if 1769 < 1770 __is_val_expr<_Expr>::value, 1771 void 1772 >::type 1773 gslice_array<_Tp>::operator^=(const _Expr& __v) const 1774 { 1775 typedef const size_t* _Ip; 1776 size_t __j = 0; 1777 for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j) 1778 __vp_[*__i] ^= __v[__j]; 1779 } 1780 1781 template <class _Tp> 1782 template <class _Expr> 1783 inline 1784 typename enable_if 1785 < 1786 __is_val_expr<_Expr>::value, 1787 void 1788 >::type 1789 gslice_array<_Tp>::operator&=(const _Expr& __v) const 1790 { 1791 typedef const size_t* _Ip; 1792 size_t __j = 0; 1793 for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j) 1794 __vp_[*__i] &= __v[__j]; 1795 } 1796 1797 template <class _Tp> 1798 template <class _Expr> 1799 inline 1800 typename enable_if 1801 < 1802 __is_val_expr<_Expr>::value, 1803 void 1804 >::type 1805 gslice_array<_Tp>::operator|=(const _Expr& __v) const 1806 { 1807 typedef const size_t* _Ip; 1808 size_t __j = 0; 1809 for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j) 1810 __vp_[*__i] |= __v[__j]; 1811 } 1812 1813 template <class _Tp> 1814 template <class _Expr> 1815 inline 1816 typename enable_if 1817 < 1818 __is_val_expr<_Expr>::value, 1819 void 1820 >::type 1821 gslice_array<_Tp>::operator<<=(const _Expr& __v) const 1822 { 1823 typedef const size_t* _Ip; 1824 size_t __j = 0; 1825 for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j) 1826 __vp_[*__i] <<= __v[__j]; 1827 } 1828 1829 template <class _Tp> 1830 template <class _Expr> 1831 inline 1832 typename enable_if 1833 < 1834 __is_val_expr<_Expr>::value, 1835 void 1836 >::type 1837 gslice_array<_Tp>::operator>>=(const _Expr& __v) const 1838 { 1839 typedef const size_t* _Ip; 1840 size_t __j = 0; 1841 for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j) 1842 __vp_[*__i] >>= __v[__j]; 1843 } 1844 1845 template <class _Tp> 1846 inline 1847 const gslice_array<_Tp>& 1848 gslice_array<_Tp>::operator=(const gslice_array& __ga) const 1849 { 1850 typedef const size_t* _Ip; 1851 const value_type* __s = __ga.__vp_; 1852 for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_, __j = __ga.__1d_.__begin_; 1853 __i != __e; ++__i, ++__j) 1854 __vp_[*__i] = __s[*__j]; 1855 return *this; 1856 } 1857 1858 template <class _Tp> 1859 inline 1860 void 1861 gslice_array<_Tp>::operator=(const value_type& __x) const 1862 { 1863 typedef const size_t* _Ip; 1864 for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i) 1865 __vp_[*__i] = __x; 1866 } 1867 1868 // mask_array 1869 1870 template <class _Tp> 1871 class _LIBCPP_TEMPLATE_VIS mask_array 1872 { 1873 public: 1874 typedef _Tp value_type; 1875 1876 private: 1877 value_type* __vp_; 1878 valarray<size_t> __1d_; 1879 1880 public: 1881 template <class _Expr> 1882 typename enable_if 1883 < 1884 __is_val_expr<_Expr>::value, 1885 void 1886 >::type 1887 _LIBCPP_INLINE_VISIBILITY 1888 operator=(const _Expr& __v) const; 1889 1890 template <class _Expr> 1891 typename enable_if 1892 < 1893 __is_val_expr<_Expr>::value, 1894 void 1895 >::type 1896 _LIBCPP_INLINE_VISIBILITY 1897 operator*=(const _Expr& __v) const; 1898 1899 template <class _Expr> 1900 typename enable_if 1901 < 1902 __is_val_expr<_Expr>::value, 1903 void 1904 >::type 1905 _LIBCPP_INLINE_VISIBILITY 1906 operator/=(const _Expr& __v) const; 1907 1908 template <class _Expr> 1909 typename enable_if 1910 < 1911 __is_val_expr<_Expr>::value, 1912 void 1913 >::type 1914 _LIBCPP_INLINE_VISIBILITY 1915 operator%=(const _Expr& __v) const; 1916 1917 template <class _Expr> 1918 typename enable_if 1919 < 1920 __is_val_expr<_Expr>::value, 1921 void 1922 >::type 1923 _LIBCPP_INLINE_VISIBILITY 1924 operator+=(const _Expr& __v) const; 1925 1926 template <class _Expr> 1927 typename enable_if 1928 < 1929 __is_val_expr<_Expr>::value, 1930 void 1931 >::type 1932 _LIBCPP_INLINE_VISIBILITY 1933 operator-=(const _Expr& __v) const; 1934 1935 template <class _Expr> 1936 typename enable_if 1937 < 1938 __is_val_expr<_Expr>::value, 1939 void 1940 >::type 1941 _LIBCPP_INLINE_VISIBILITY 1942 operator^=(const _Expr& __v) const; 1943 1944 template <class _Expr> 1945 typename enable_if 1946 < 1947 __is_val_expr<_Expr>::value, 1948 void 1949 >::type 1950 _LIBCPP_INLINE_VISIBILITY 1951 operator&=(const _Expr& __v) const; 1952 1953 template <class _Expr> 1954 typename enable_if 1955 < 1956 __is_val_expr<_Expr>::value, 1957 void 1958 >::type 1959 _LIBCPP_INLINE_VISIBILITY 1960 operator|=(const _Expr& __v) const; 1961 1962 template <class _Expr> 1963 typename enable_if 1964 < 1965 __is_val_expr<_Expr>::value, 1966 void 1967 >::type 1968 _LIBCPP_INLINE_VISIBILITY 1969 operator<<=(const _Expr& __v) const; 1970 1971 template <class _Expr> 1972 typename enable_if 1973 < 1974 __is_val_expr<_Expr>::value, 1975 void 1976 >::type 1977 _LIBCPP_INLINE_VISIBILITY 1978 operator>>=(const _Expr& __v) const; 1979 1980 _LIBCPP_INLINE_VISIBILITY 1981 const mask_array& operator=(const mask_array& __ma) const; 1982 1983 _LIBCPP_INLINE_VISIBILITY 1984 void operator=(const value_type& __x) const; 1985 1986 // mask_array(const mask_array&) = default; 1987 // mask_array(mask_array&&) = default; 1988 // mask_array& operator=(const mask_array&) = default; 1989 // mask_array& operator=(mask_array&&) = default; 1990 1991 private: 1992 _LIBCPP_INLINE_VISIBILITY 1993 mask_array(const valarray<bool>& __vb, const valarray<value_type>& __v) 1994 : __vp_(const_cast<value_type*>(__v.__begin_)), 1995 __1d_(static_cast<size_t>(count(__vb.__begin_, __vb.__end_, true))) 1996 { 1997 size_t __j = 0; 1998 for (size_t __i = 0; __i < __vb.size(); ++__i) 1999 if (__vb[__i]) 2000 __1d_[__j++] = __i; 2001 } 2002 2003 template <class> friend class valarray; 2004 }; 2005 2006 template <class _Tp> 2007 template <class _Expr> 2008 inline 2009 typename enable_if 2010 < 2011 __is_val_expr<_Expr>::value, 2012 void 2013 >::type 2014 mask_array<_Tp>::operator=(const _Expr& __v) const 2015 { 2016 size_t __n = __1d_.size(); 2017 for (size_t __i = 0; __i < __n; ++__i) 2018 __vp_[__1d_[__i]] = __v[__i]; 2019 } 2020 2021 template <class _Tp> 2022 template <class _Expr> 2023 inline 2024 typename enable_if 2025 < 2026 __is_val_expr<_Expr>::value, 2027 void 2028 >::type 2029 mask_array<_Tp>::operator*=(const _Expr& __v) const 2030 { 2031 size_t __n = __1d_.size(); 2032 for (size_t __i = 0; __i < __n; ++__i) 2033 __vp_[__1d_[__i]] *= __v[__i]; 2034 } 2035 2036 template <class _Tp> 2037 template <class _Expr> 2038 inline 2039 typename enable_if 2040 < 2041 __is_val_expr<_Expr>::value, 2042 void 2043 >::type 2044 mask_array<_Tp>::operator/=(const _Expr& __v) const 2045 { 2046 size_t __n = __1d_.size(); 2047 for (size_t __i = 0; __i < __n; ++__i) 2048 __vp_[__1d_[__i]] /= __v[__i]; 2049 } 2050 2051 template <class _Tp> 2052 template <class _Expr> 2053 inline 2054 typename enable_if 2055 < 2056 __is_val_expr<_Expr>::value, 2057 void 2058 >::type 2059 mask_array<_Tp>::operator%=(const _Expr& __v) const 2060 { 2061 size_t __n = __1d_.size(); 2062 for (size_t __i = 0; __i < __n; ++__i) 2063 __vp_[__1d_[__i]] %= __v[__i]; 2064 } 2065 2066 template <class _Tp> 2067 template <class _Expr> 2068 inline 2069 typename enable_if 2070 < 2071 __is_val_expr<_Expr>::value, 2072 void 2073 >::type 2074 mask_array<_Tp>::operator+=(const _Expr& __v) const 2075 { 2076 size_t __n = __1d_.size(); 2077 for (size_t __i = 0; __i < __n; ++__i) 2078 __vp_[__1d_[__i]] += __v[__i]; 2079 } 2080 2081 template <class _Tp> 2082 template <class _Expr> 2083 inline 2084 typename enable_if 2085 < 2086 __is_val_expr<_Expr>::value, 2087 void 2088 >::type 2089 mask_array<_Tp>::operator-=(const _Expr& __v) const 2090 { 2091 size_t __n = __1d_.size(); 2092 for (size_t __i = 0; __i < __n; ++__i) 2093 __vp_[__1d_[__i]] -= __v[__i]; 2094 } 2095 2096 template <class _Tp> 2097 template <class _Expr> 2098 inline 2099 typename enable_if 2100 < 2101 __is_val_expr<_Expr>::value, 2102 void 2103 >::type 2104 mask_array<_Tp>::operator^=(const _Expr& __v) const 2105 { 2106 size_t __n = __1d_.size(); 2107 for (size_t __i = 0; __i < __n; ++__i) 2108 __vp_[__1d_[__i]] ^= __v[__i]; 2109 } 2110 2111 template <class _Tp> 2112 template <class _Expr> 2113 inline 2114 typename enable_if 2115 < 2116 __is_val_expr<_Expr>::value, 2117 void 2118 >::type 2119 mask_array<_Tp>::operator&=(const _Expr& __v) const 2120 { 2121 size_t __n = __1d_.size(); 2122 for (size_t __i = 0; __i < __n; ++__i) 2123 __vp_[__1d_[__i]] &= __v[__i]; 2124 } 2125 2126 template <class _Tp> 2127 template <class _Expr> 2128 inline 2129 typename enable_if 2130 < 2131 __is_val_expr<_Expr>::value, 2132 void 2133 >::type 2134 mask_array<_Tp>::operator|=(const _Expr& __v) const 2135 { 2136 size_t __n = __1d_.size(); 2137 for (size_t __i = 0; __i < __n; ++__i) 2138 __vp_[__1d_[__i]] |= __v[__i]; 2139 } 2140 2141 template <class _Tp> 2142 template <class _Expr> 2143 inline 2144 typename enable_if 2145 < 2146 __is_val_expr<_Expr>::value, 2147 void 2148 >::type 2149 mask_array<_Tp>::operator<<=(const _Expr& __v) const 2150 { 2151 size_t __n = __1d_.size(); 2152 for (size_t __i = 0; __i < __n; ++__i) 2153 __vp_[__1d_[__i]] <<= __v[__i]; 2154 } 2155 2156 template <class _Tp> 2157 template <class _Expr> 2158 inline 2159 typename enable_if 2160 < 2161 __is_val_expr<_Expr>::value, 2162 void 2163 >::type 2164 mask_array<_Tp>::operator>>=(const _Expr& __v) const 2165 { 2166 size_t __n = __1d_.size(); 2167 for (size_t __i = 0; __i < __n; ++__i) 2168 __vp_[__1d_[__i]] >>= __v[__i]; 2169 } 2170 2171 template <class _Tp> 2172 inline 2173 const mask_array<_Tp>& 2174 mask_array<_Tp>::operator=(const mask_array& __ma) const 2175 { 2176 size_t __n = __1d_.size(); 2177 for (size_t __i = 0; __i < __n; ++__i) 2178 __vp_[__1d_[__i]] = __ma.__vp_[__1d_[__i]]; 2179 return *this; 2180 } 2181 2182 template <class _Tp> 2183 inline 2184 void 2185 mask_array<_Tp>::operator=(const value_type& __x) const 2186 { 2187 size_t __n = __1d_.size(); 2188 for (size_t __i = 0; __i < __n; ++__i) 2189 __vp_[__1d_[__i]] = __x; 2190 } 2191 2192 template <class _ValExpr> 2193 class __mask_expr 2194 { 2195 typedef typename remove_reference<_ValExpr>::type _RmExpr; 2196 public: 2197 typedef typename _RmExpr::value_type value_type; 2198 typedef value_type result_type; 2199 2200 private: 2201 _ValExpr __expr_; 2202 valarray<size_t> __1d_; 2203 2204 _LIBCPP_INLINE_VISIBILITY 2205 __mask_expr(const valarray<bool>& __vb, const _RmExpr& __e) 2206 : __expr_(__e), 2207 __1d_(static_cast<size_t>(count(__vb.__begin_, __vb.__end_, true))) 2208 { 2209 size_t __j = 0; 2210 for (size_t __i = 0; __i < __vb.size(); ++__i) 2211 if (__vb[__i]) 2212 __1d_[__j++] = __i; 2213 } 2214 2215 public: 2216 _LIBCPP_INLINE_VISIBILITY 2217 result_type operator[](size_t __i) const 2218 {return __expr_[__1d_[__i]];} 2219 2220 _LIBCPP_INLINE_VISIBILITY 2221 size_t size() const {return __1d_.size();} 2222 2223 template <class> friend class valarray; 2224 }; 2225 2226 // indirect_array 2227 2228 template <class _Tp> 2229 class _LIBCPP_TEMPLATE_VIS indirect_array 2230 { 2231 public: 2232 typedef _Tp value_type; 2233 2234 private: 2235 value_type* __vp_; 2236 valarray<size_t> __1d_; 2237 2238 public: 2239 template <class _Expr> 2240 typename enable_if 2241 < 2242 __is_val_expr<_Expr>::value, 2243 void 2244 >::type 2245 _LIBCPP_INLINE_VISIBILITY 2246 operator=(const _Expr& __v) const; 2247 2248 template <class _Expr> 2249 typename enable_if 2250 < 2251 __is_val_expr<_Expr>::value, 2252 void 2253 >::type 2254 _LIBCPP_INLINE_VISIBILITY 2255 operator*=(const _Expr& __v) const; 2256 2257 template <class _Expr> 2258 typename enable_if 2259 < 2260 __is_val_expr<_Expr>::value, 2261 void 2262 >::type 2263 _LIBCPP_INLINE_VISIBILITY 2264 operator/=(const _Expr& __v) const; 2265 2266 template <class _Expr> 2267 typename enable_if 2268 < 2269 __is_val_expr<_Expr>::value, 2270 void 2271 >::type 2272 _LIBCPP_INLINE_VISIBILITY 2273 operator%=(const _Expr& __v) const; 2274 2275 template <class _Expr> 2276 typename enable_if 2277 < 2278 __is_val_expr<_Expr>::value, 2279 void 2280 >::type 2281 _LIBCPP_INLINE_VISIBILITY 2282 operator+=(const _Expr& __v) const; 2283 2284 template <class _Expr> 2285 typename enable_if 2286 < 2287 __is_val_expr<_Expr>::value, 2288 void 2289 >::type 2290 _LIBCPP_INLINE_VISIBILITY 2291 operator-=(const _Expr& __v) const; 2292 2293 template <class _Expr> 2294 typename enable_if 2295 < 2296 __is_val_expr<_Expr>::value, 2297 void 2298 >::type 2299 _LIBCPP_INLINE_VISIBILITY 2300 operator^=(const _Expr& __v) const; 2301 2302 template <class _Expr> 2303 typename enable_if 2304 < 2305 __is_val_expr<_Expr>::value, 2306 void 2307 >::type 2308 _LIBCPP_INLINE_VISIBILITY 2309 operator&=(const _Expr& __v) const; 2310 2311 template <class _Expr> 2312 typename enable_if 2313 < 2314 __is_val_expr<_Expr>::value, 2315 void 2316 >::type 2317 _LIBCPP_INLINE_VISIBILITY 2318 operator|=(const _Expr& __v) const; 2319 2320 template <class _Expr> 2321 typename enable_if 2322 < 2323 __is_val_expr<_Expr>::value, 2324 void 2325 >::type 2326 _LIBCPP_INLINE_VISIBILITY 2327 operator<<=(const _Expr& __v) const; 2328 2329 template <class _Expr> 2330 typename enable_if 2331 < 2332 __is_val_expr<_Expr>::value, 2333 void 2334 >::type 2335 _LIBCPP_INLINE_VISIBILITY 2336 operator>>=(const _Expr& __v) const; 2337 2338 _LIBCPP_INLINE_VISIBILITY 2339 const indirect_array& operator=(const indirect_array& __ia) const; 2340 2341 _LIBCPP_INLINE_VISIBILITY 2342 void operator=(const value_type& __x) const; 2343 2344 // indirect_array(const indirect_array&) = default; 2345 // indirect_array(indirect_array&&) = default; 2346 // indirect_array& operator=(const indirect_array&) = default; 2347 // indirect_array& operator=(indirect_array&&) = default; 2348 2349 private: 2350 _LIBCPP_INLINE_VISIBILITY 2351 indirect_array(const valarray<size_t>& __ia, const valarray<value_type>& __v) 2352 : __vp_(const_cast<value_type*>(__v.__begin_)), 2353 __1d_(__ia) 2354 {} 2355 2356 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 2357 2358 _LIBCPP_INLINE_VISIBILITY 2359 indirect_array(valarray<size_t>&& __ia, const valarray<value_type>& __v) 2360 : __vp_(const_cast<value_type*>(__v.__begin_)), 2361 __1d_(move(__ia)) 2362 {} 2363 2364 #endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 2365 2366 template <class> friend class valarray; 2367 }; 2368 2369 template <class _Tp> 2370 template <class _Expr> 2371 inline 2372 typename enable_if 2373 < 2374 __is_val_expr<_Expr>::value, 2375 void 2376 >::type 2377 indirect_array<_Tp>::operator=(const _Expr& __v) const 2378 { 2379 size_t __n = __1d_.size(); 2380 for (size_t __i = 0; __i < __n; ++__i) 2381 __vp_[__1d_[__i]] = __v[__i]; 2382 } 2383 2384 template <class _Tp> 2385 template <class _Expr> 2386 inline 2387 typename enable_if 2388 < 2389 __is_val_expr<_Expr>::value, 2390 void 2391 >::type 2392 indirect_array<_Tp>::operator*=(const _Expr& __v) const 2393 { 2394 size_t __n = __1d_.size(); 2395 for (size_t __i = 0; __i < __n; ++__i) 2396 __vp_[__1d_[__i]] *= __v[__i]; 2397 } 2398 2399 template <class _Tp> 2400 template <class _Expr> 2401 inline 2402 typename enable_if 2403 < 2404 __is_val_expr<_Expr>::value, 2405 void 2406 >::type 2407 indirect_array<_Tp>::operator/=(const _Expr& __v) const 2408 { 2409 size_t __n = __1d_.size(); 2410 for (size_t __i = 0; __i < __n; ++__i) 2411 __vp_[__1d_[__i]] /= __v[__i]; 2412 } 2413 2414 template <class _Tp> 2415 template <class _Expr> 2416 inline 2417 typename enable_if 2418 < 2419 __is_val_expr<_Expr>::value, 2420 void 2421 >::type 2422 indirect_array<_Tp>::operator%=(const _Expr& __v) const 2423 { 2424 size_t __n = __1d_.size(); 2425 for (size_t __i = 0; __i < __n; ++__i) 2426 __vp_[__1d_[__i]] %= __v[__i]; 2427 } 2428 2429 template <class _Tp> 2430 template <class _Expr> 2431 inline 2432 typename enable_if 2433 < 2434 __is_val_expr<_Expr>::value, 2435 void 2436 >::type 2437 indirect_array<_Tp>::operator+=(const _Expr& __v) const 2438 { 2439 size_t __n = __1d_.size(); 2440 for (size_t __i = 0; __i < __n; ++__i) 2441 __vp_[__1d_[__i]] += __v[__i]; 2442 } 2443 2444 template <class _Tp> 2445 template <class _Expr> 2446 inline 2447 typename enable_if 2448 < 2449 __is_val_expr<_Expr>::value, 2450 void 2451 >::type 2452 indirect_array<_Tp>::operator-=(const _Expr& __v) const 2453 { 2454 size_t __n = __1d_.size(); 2455 for (size_t __i = 0; __i < __n; ++__i) 2456 __vp_[__1d_[__i]] -= __v[__i]; 2457 } 2458 2459 template <class _Tp> 2460 template <class _Expr> 2461 inline 2462 typename enable_if 2463 < 2464 __is_val_expr<_Expr>::value, 2465 void 2466 >::type 2467 indirect_array<_Tp>::operator^=(const _Expr& __v) const 2468 { 2469 size_t __n = __1d_.size(); 2470 for (size_t __i = 0; __i < __n; ++__i) 2471 __vp_[__1d_[__i]] ^= __v[__i]; 2472 } 2473 2474 template <class _Tp> 2475 template <class _Expr> 2476 inline 2477 typename enable_if 2478 < 2479 __is_val_expr<_Expr>::value, 2480 void 2481 >::type 2482 indirect_array<_Tp>::operator&=(const _Expr& __v) const 2483 { 2484 size_t __n = __1d_.size(); 2485 for (size_t __i = 0; __i < __n; ++__i) 2486 __vp_[__1d_[__i]] &= __v[__i]; 2487 } 2488 2489 template <class _Tp> 2490 template <class _Expr> 2491 inline 2492 typename enable_if 2493 < 2494 __is_val_expr<_Expr>::value, 2495 void 2496 >::type 2497 indirect_array<_Tp>::operator|=(const _Expr& __v) const 2498 { 2499 size_t __n = __1d_.size(); 2500 for (size_t __i = 0; __i < __n; ++__i) 2501 __vp_[__1d_[__i]] |= __v[__i]; 2502 } 2503 2504 template <class _Tp> 2505 template <class _Expr> 2506 inline 2507 typename enable_if 2508 < 2509 __is_val_expr<_Expr>::value, 2510 void 2511 >::type 2512 indirect_array<_Tp>::operator<<=(const _Expr& __v) const 2513 { 2514 size_t __n = __1d_.size(); 2515 for (size_t __i = 0; __i < __n; ++__i) 2516 __vp_[__1d_[__i]] <<= __v[__i]; 2517 } 2518 2519 template <class _Tp> 2520 template <class _Expr> 2521 inline 2522 typename enable_if 2523 < 2524 __is_val_expr<_Expr>::value, 2525 void 2526 >::type 2527 indirect_array<_Tp>::operator>>=(const _Expr& __v) const 2528 { 2529 size_t __n = __1d_.size(); 2530 for (size_t __i = 0; __i < __n; ++__i) 2531 __vp_[__1d_[__i]] >>= __v[__i]; 2532 } 2533 2534 template <class _Tp> 2535 inline 2536 const indirect_array<_Tp>& 2537 indirect_array<_Tp>::operator=(const indirect_array& __ia) const 2538 { 2539 typedef const size_t* _Ip; 2540 const value_type* __s = __ia.__vp_; 2541 for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_, __j = __ia.__1d_.__begin_; 2542 __i != __e; ++__i, ++__j) 2543 __vp_[*__i] = __s[*__j]; 2544 return *this; 2545 } 2546 2547 template <class _Tp> 2548 inline 2549 void 2550 indirect_array<_Tp>::operator=(const value_type& __x) const 2551 { 2552 typedef const size_t* _Ip; 2553 for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i) 2554 __vp_[*__i] = __x; 2555 } 2556 2557 template <class _ValExpr> 2558 class __indirect_expr 2559 { 2560 typedef typename remove_reference<_ValExpr>::type _RmExpr; 2561 public: 2562 typedef typename _RmExpr::value_type value_type; 2563 typedef value_type result_type; 2564 2565 private: 2566 _ValExpr __expr_; 2567 valarray<size_t> __1d_; 2568 2569 _LIBCPP_INLINE_VISIBILITY 2570 __indirect_expr(const valarray<size_t>& __ia, const _RmExpr& __e) 2571 : __expr_(__e), 2572 __1d_(__ia) 2573 {} 2574 2575 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 2576 2577 _LIBCPP_INLINE_VISIBILITY 2578 __indirect_expr(valarray<size_t>&& __ia, const _RmExpr& __e) 2579 : __expr_(__e), 2580 __1d_(move(__ia)) 2581 {} 2582 2583 #endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 2584 2585 public: 2586 _LIBCPP_INLINE_VISIBILITY 2587 result_type operator[](size_t __i) const 2588 {return __expr_[__1d_[__i]];} 2589 2590 _LIBCPP_INLINE_VISIBILITY 2591 size_t size() const {return __1d_.size();} 2592 2593 template <class> friend class _LIBCPP_TEMPLATE_VIS valarray; 2594 }; 2595 2596 template<class _ValExpr> 2597 class __val_expr 2598 { 2599 typedef typename remove_reference<_ValExpr>::type _RmExpr; 2600 2601 _ValExpr __expr_; 2602 public: 2603 typedef typename _RmExpr::value_type value_type; 2604 typedef typename _RmExpr::result_type result_type; 2605 2606 _LIBCPP_INLINE_VISIBILITY 2607 explicit __val_expr(const _RmExpr& __e) : __expr_(__e) {} 2608 2609 _LIBCPP_INLINE_VISIBILITY 2610 result_type operator[](size_t __i) const 2611 {return __expr_[__i];} 2612 2613 _LIBCPP_INLINE_VISIBILITY 2614 __val_expr<__slice_expr<_ValExpr> > operator[](slice __s) const 2615 {return __val_expr<__slice_expr<_ValExpr> >(__expr_, __s);} 2616 2617 _LIBCPP_INLINE_VISIBILITY 2618 __val_expr<__indirect_expr<_ValExpr> > operator[](const gslice& __gs) const 2619 {return __val_expr<__indirect_expr<_ValExpr> >(__expr_, __gs.__1d_);} 2620 2621 _LIBCPP_INLINE_VISIBILITY 2622 __val_expr<__mask_expr<_ValExpr> > operator[](const valarray<bool>& __vb) const 2623 {return __val_expr<__mask_expr<_ValExpr> >(__expr_, __vb);} 2624 2625 _LIBCPP_INLINE_VISIBILITY 2626 __val_expr<__indirect_expr<_ValExpr> > operator[](const valarray<size_t>& __vs) const 2627 {return __val_expr<__indirect_expr<_ValExpr> >(__expr_, __vs);} 2628 2629 _LIBCPP_INLINE_VISIBILITY 2630 __val_expr<_UnaryOp<__unary_plus<value_type>, _ValExpr> > 2631 operator+() const 2632 { 2633 typedef _UnaryOp<__unary_plus<value_type>, _ValExpr> _NewExpr; 2634 return __val_expr<_NewExpr>(_NewExpr(__unary_plus<value_type>(), __expr_)); 2635 } 2636 2637 _LIBCPP_INLINE_VISIBILITY 2638 __val_expr<_UnaryOp<negate<value_type>, _ValExpr> > 2639 operator-() const 2640 { 2641 typedef _UnaryOp<negate<value_type>, _ValExpr> _NewExpr; 2642 return __val_expr<_NewExpr>(_NewExpr(negate<value_type>(), __expr_)); 2643 } 2644 2645 _LIBCPP_INLINE_VISIBILITY 2646 __val_expr<_UnaryOp<__bit_not<value_type>, _ValExpr> > 2647 operator~() const 2648 { 2649 typedef _UnaryOp<__bit_not<value_type>, _ValExpr> _NewExpr; 2650 return __val_expr<_NewExpr>(_NewExpr(__bit_not<value_type>(), __expr_)); 2651 } 2652 2653 _LIBCPP_INLINE_VISIBILITY 2654 __val_expr<_UnaryOp<logical_not<value_type>, _ValExpr> > 2655 operator!() const 2656 { 2657 typedef _UnaryOp<logical_not<value_type>, _ValExpr> _NewExpr; 2658 return __val_expr<_NewExpr>(_NewExpr(logical_not<value_type>(), __expr_)); 2659 } 2660 2661 operator valarray<result_type>() const; 2662 2663 _LIBCPP_INLINE_VISIBILITY 2664 size_t size() const {return __expr_.size();} 2665 2666 _LIBCPP_INLINE_VISIBILITY 2667 result_type sum() const 2668 { 2669 size_t __n = __expr_.size(); 2670 result_type __r = __n ? __expr_[0] : result_type(); 2671 for (size_t __i = 1; __i < __n; ++__i) 2672 __r += __expr_[__i]; 2673 return __r; 2674 } 2675 2676 _LIBCPP_INLINE_VISIBILITY 2677 result_type min() const 2678 { 2679 size_t __n = size(); 2680 result_type __r = __n ? (*this)[0] : result_type(); 2681 for (size_t __i = 1; __i < __n; ++__i) 2682 { 2683 result_type __x = __expr_[__i]; 2684 if (__x < __r) 2685 __r = __x; 2686 } 2687 return __r; 2688 } 2689 2690 _LIBCPP_INLINE_VISIBILITY 2691 result_type max() const 2692 { 2693 size_t __n = size(); 2694 result_type __r = __n ? (*this)[0] : result_type(); 2695 for (size_t __i = 1; __i < __n; ++__i) 2696 { 2697 result_type __x = __expr_[__i]; 2698 if (__r < __x) 2699 __r = __x; 2700 } 2701 return __r; 2702 } 2703 2704 _LIBCPP_INLINE_VISIBILITY 2705 __val_expr<__shift_expr<_ValExpr> > shift (int __i) const 2706 {return __val_expr<__shift_expr<_ValExpr> >(__shift_expr<_ValExpr>(__i, __expr_));} 2707 2708 _LIBCPP_INLINE_VISIBILITY 2709 __val_expr<__cshift_expr<_ValExpr> > cshift(int __i) const 2710 {return __val_expr<__cshift_expr<_ValExpr> >(__cshift_expr<_ValExpr>(__i, __expr_));} 2711 2712 _LIBCPP_INLINE_VISIBILITY 2713 __val_expr<_UnaryOp<__apply_expr<value_type, value_type(*)(value_type)>, _ValExpr> > 2714 apply(value_type __f(value_type)) const 2715 { 2716 typedef __apply_expr<value_type, value_type(*)(value_type)> _Op; 2717 typedef _UnaryOp<_Op, _ValExpr> _NewExpr; 2718 return __val_expr<_NewExpr>(_NewExpr(_Op(__f), __expr_)); 2719 } 2720 2721 _LIBCPP_INLINE_VISIBILITY 2722 __val_expr<_UnaryOp<__apply_expr<value_type, value_type(*)(const value_type&)>, _ValExpr> > 2723 apply(value_type __f(const value_type&)) const 2724 { 2725 typedef __apply_expr<value_type, value_type(*)(const value_type&)> _Op; 2726 typedef _UnaryOp<_Op, _ValExpr> _NewExpr; 2727 return __val_expr<_NewExpr>(_NewExpr(_Op(__f), __expr_)); 2728 } 2729 }; 2730 2731 template<class _ValExpr> 2732 __val_expr<_ValExpr>::operator valarray<__val_expr::result_type>() const 2733 { 2734 valarray<result_type> __r; 2735 size_t __n = __expr_.size(); 2736 if (__n) 2737 { 2738 __r.__begin_ = 2739 __r.__end_ = 2740 static_cast<result_type*>(_VSTD::__allocate(__n * sizeof(result_type))); 2741 for (size_t __i = 0; __i != __n; ++__r.__end_, ++__i) 2742 ::new (__r.__end_) result_type(__expr_[__i]); 2743 } 2744 return __r; 2745 } 2746 2747 // valarray 2748 2749 template <class _Tp> 2750 inline 2751 valarray<_Tp>::valarray(size_t __n) 2752 : __begin_(0), 2753 __end_(0) 2754 { 2755 resize(__n); 2756 } 2757 2758 template <class _Tp> 2759 inline 2760 valarray<_Tp>::valarray(const value_type& __x, size_t __n) 2761 : __begin_(0), 2762 __end_(0) 2763 { 2764 resize(__n, __x); 2765 } 2766 2767 template <class _Tp> 2768 valarray<_Tp>::valarray(const value_type* __p, size_t __n) 2769 : __begin_(0), 2770 __end_(0) 2771 { 2772 if (__n) 2773 { 2774 __begin_ = __end_ = static_cast<value_type*>(_VSTD::__allocate(__n * sizeof(value_type))); 2775 #ifndef _LIBCPP_NO_EXCEPTIONS 2776 try 2777 { 2778 #endif // _LIBCPP_NO_EXCEPTIONS 2779 for (; __n; ++__end_, ++__p, --__n) 2780 ::new (__end_) value_type(*__p); 2781 #ifndef _LIBCPP_NO_EXCEPTIONS 2782 } 2783 catch (...) 2784 { 2785 resize(0); 2786 throw; 2787 } 2788 #endif // _LIBCPP_NO_EXCEPTIONS 2789 } 2790 } 2791 2792 template <class _Tp> 2793 valarray<_Tp>::valarray(const valarray& __v) 2794 : __begin_(0), 2795 __end_(0) 2796 { 2797 if (__v.size()) 2798 { 2799 __begin_ = __end_ = static_cast<value_type*>(_VSTD::__allocate(__v.size() * sizeof(value_type))); 2800 #ifndef _LIBCPP_NO_EXCEPTIONS 2801 try 2802 { 2803 #endif // _LIBCPP_NO_EXCEPTIONS 2804 for (value_type* __p = __v.__begin_; __p != __v.__end_; ++__end_, ++__p) 2805 ::new (__end_) value_type(*__p); 2806 #ifndef _LIBCPP_NO_EXCEPTIONS 2807 } 2808 catch (...) 2809 { 2810 resize(0); 2811 throw; 2812 } 2813 #endif // _LIBCPP_NO_EXCEPTIONS 2814 } 2815 } 2816 2817 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 2818 2819 template <class _Tp> 2820 inline 2821 valarray<_Tp>::valarray(valarray&& __v) _NOEXCEPT 2822 : __begin_(__v.__begin_), 2823 __end_(__v.__end_) 2824 { 2825 __v.__begin_ = __v.__end_ = nullptr; 2826 } 2827 2828 #endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 2829 2830 #ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS 2831 2832 template <class _Tp> 2833 valarray<_Tp>::valarray(initializer_list<value_type> __il) 2834 : __begin_(0), 2835 __end_(0) 2836 { 2837 size_t __n = __il.size(); 2838 if (__n) 2839 { 2840 __begin_ = __end_ = static_cast<value_type*>(_VSTD::__allocate(__n * sizeof(value_type))); 2841 #ifndef _LIBCPP_NO_EXCEPTIONS 2842 try 2843 { 2844 #endif // _LIBCPP_NO_EXCEPTIONS 2845 for (const value_type* __p = __il.begin(); __n; ++__end_, ++__p, --__n) 2846 ::new (__end_) value_type(*__p); 2847 #ifndef _LIBCPP_NO_EXCEPTIONS 2848 } 2849 catch (...) 2850 { 2851 resize(0); 2852 throw; 2853 } 2854 #endif // _LIBCPP_NO_EXCEPTIONS 2855 } 2856 } 2857 2858 #endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS 2859 2860 template <class _Tp> 2861 valarray<_Tp>::valarray(const slice_array<value_type>& __sa) 2862 : __begin_(0), 2863 __end_(0) 2864 { 2865 size_t __n = __sa.__size_; 2866 if (__n) 2867 { 2868 __begin_ = __end_ = static_cast<value_type*>(_VSTD::__allocate(__n * sizeof(value_type))); 2869 #ifndef _LIBCPP_NO_EXCEPTIONS 2870 try 2871 { 2872 #endif // _LIBCPP_NO_EXCEPTIONS 2873 for (const value_type* __p = __sa.__vp_; __n; ++__end_, __p += __sa.__stride_, --__n) 2874 ::new (__end_) value_type(*__p); 2875 #ifndef _LIBCPP_NO_EXCEPTIONS 2876 } 2877 catch (...) 2878 { 2879 resize(0); 2880 throw; 2881 } 2882 #endif // _LIBCPP_NO_EXCEPTIONS 2883 } 2884 } 2885 2886 template <class _Tp> 2887 valarray<_Tp>::valarray(const gslice_array<value_type>& __ga) 2888 : __begin_(0), 2889 __end_(0) 2890 { 2891 size_t __n = __ga.__1d_.size(); 2892 if (__n) 2893 { 2894 __begin_ = __end_ = static_cast<value_type*>(_VSTD::__allocate(__n * sizeof(value_type))); 2895 #ifndef _LIBCPP_NO_EXCEPTIONS 2896 try 2897 { 2898 #endif // _LIBCPP_NO_EXCEPTIONS 2899 typedef const size_t* _Ip; 2900 const value_type* __s = __ga.__vp_; 2901 for (_Ip __i = __ga.__1d_.__begin_, __e = __ga.__1d_.__end_; 2902 __i != __e; ++__i, ++__end_) 2903 ::new (__end_) value_type(__s[*__i]); 2904 #ifndef _LIBCPP_NO_EXCEPTIONS 2905 } 2906 catch (...) 2907 { 2908 resize(0); 2909 throw; 2910 } 2911 #endif // _LIBCPP_NO_EXCEPTIONS 2912 } 2913 } 2914 2915 template <class _Tp> 2916 valarray<_Tp>::valarray(const mask_array<value_type>& __ma) 2917 : __begin_(0), 2918 __end_(0) 2919 { 2920 size_t __n = __ma.__1d_.size(); 2921 if (__n) 2922 { 2923 __begin_ = __end_ = static_cast<value_type*>(_VSTD::__allocate(__n * sizeof(value_type))); 2924 #ifndef _LIBCPP_NO_EXCEPTIONS 2925 try 2926 { 2927 #endif // _LIBCPP_NO_EXCEPTIONS 2928 typedef const size_t* _Ip; 2929 const value_type* __s = __ma.__vp_; 2930 for (_Ip __i = __ma.__1d_.__begin_, __e = __ma.__1d_.__end_; 2931 __i != __e; ++__i, ++__end_) 2932 ::new (__end_) value_type(__s[*__i]); 2933 #ifndef _LIBCPP_NO_EXCEPTIONS 2934 } 2935 catch (...) 2936 { 2937 resize(0); 2938 throw; 2939 } 2940 #endif // _LIBCPP_NO_EXCEPTIONS 2941 } 2942 } 2943 2944 template <class _Tp> 2945 valarray<_Tp>::valarray(const indirect_array<value_type>& __ia) 2946 : __begin_(0), 2947 __end_(0) 2948 { 2949 size_t __n = __ia.__1d_.size(); 2950 if (__n) 2951 { 2952 __begin_ = __end_ = static_cast<value_type*>(_VSTD::__allocate(__n * sizeof(value_type))); 2953 #ifndef _LIBCPP_NO_EXCEPTIONS 2954 try 2955 { 2956 #endif // _LIBCPP_NO_EXCEPTIONS 2957 typedef const size_t* _Ip; 2958 const value_type* __s = __ia.__vp_; 2959 for (_Ip __i = __ia.__1d_.__begin_, __e = __ia.__1d_.__end_; 2960 __i != __e; ++__i, ++__end_) 2961 ::new (__end_) value_type(__s[*__i]); 2962 #ifndef _LIBCPP_NO_EXCEPTIONS 2963 } 2964 catch (...) 2965 { 2966 resize(0); 2967 throw; 2968 } 2969 #endif // _LIBCPP_NO_EXCEPTIONS 2970 } 2971 } 2972 2973 template <class _Tp> 2974 inline 2975 valarray<_Tp>::~valarray() 2976 { 2977 resize(0); 2978 } 2979 2980 template <class _Tp> 2981 valarray<_Tp>& 2982 valarray<_Tp>::operator=(const valarray& __v) 2983 { 2984 if (this != &__v) 2985 { 2986 if (size() != __v.size()) 2987 resize(__v.size()); 2988 _VSTD::copy(__v.__begin_, __v.__end_, __begin_); 2989 } 2990 return *this; 2991 } 2992 2993 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 2994 2995 template <class _Tp> 2996 inline 2997 valarray<_Tp>& 2998 valarray<_Tp>::operator=(valarray&& __v) _NOEXCEPT 2999 { 3000 resize(0); 3001 __begin_ = __v.__begin_; 3002 __end_ = __v.__end_; 3003 __v.__begin_ = nullptr; 3004 __v.__end_ = nullptr; 3005 return *this; 3006 } 3007 3008 #endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 3009 3010 #ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS 3011 3012 template <class _Tp> 3013 inline 3014 valarray<_Tp>& 3015 valarray<_Tp>::operator=(initializer_list<value_type> __il) 3016 { 3017 if (size() != __il.size()) 3018 resize(__il.size()); 3019 _VSTD::copy(__il.begin(), __il.end(), __begin_); 3020 return *this; 3021 } 3022 3023 #endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS 3024 3025 template <class _Tp> 3026 inline 3027 valarray<_Tp>& 3028 valarray<_Tp>::operator=(const value_type& __x) 3029 { 3030 _VSTD::fill(__begin_, __end_, __x); 3031 return *this; 3032 } 3033 3034 template <class _Tp> 3035 inline 3036 valarray<_Tp>& 3037 valarray<_Tp>::operator=(const slice_array<value_type>& __sa) 3038 { 3039 value_type* __t = __begin_; 3040 const value_type* __s = __sa.__vp_; 3041 for (size_t __n = __sa.__size_; __n; --__n, __s += __sa.__stride_, ++__t) 3042 *__t = *__s; 3043 return *this; 3044 } 3045 3046 template <class _Tp> 3047 inline 3048 valarray<_Tp>& 3049 valarray<_Tp>::operator=(const gslice_array<value_type>& __ga) 3050 { 3051 typedef const size_t* _Ip; 3052 value_type* __t = __begin_; 3053 const value_type* __s = __ga.__vp_; 3054 for (_Ip __i = __ga.__1d_.__begin_, __e = __ga.__1d_.__end_; 3055 __i != __e; ++__i, ++__t) 3056 *__t = __s[*__i]; 3057 return *this; 3058 } 3059 3060 template <class _Tp> 3061 inline 3062 valarray<_Tp>& 3063 valarray<_Tp>::operator=(const mask_array<value_type>& __ma) 3064 { 3065 typedef const size_t* _Ip; 3066 value_type* __t = __begin_; 3067 const value_type* __s = __ma.__vp_; 3068 for (_Ip __i = __ma.__1d_.__begin_, __e = __ma.__1d_.__end_; 3069 __i != __e; ++__i, ++__t) 3070 *__t = __s[*__i]; 3071 return *this; 3072 } 3073 3074 template <class _Tp> 3075 inline 3076 valarray<_Tp>& 3077 valarray<_Tp>::operator=(const indirect_array<value_type>& __ia) 3078 { 3079 typedef const size_t* _Ip; 3080 value_type* __t = __begin_; 3081 const value_type* __s = __ia.__vp_; 3082 for (_Ip __i = __ia.__1d_.__begin_, __e = __ia.__1d_.__end_; 3083 __i != __e; ++__i, ++__t) 3084 *__t = __s[*__i]; 3085 return *this; 3086 } 3087 3088 template <class _Tp> 3089 template <class _ValExpr> 3090 inline 3091 valarray<_Tp>& 3092 valarray<_Tp>::operator=(const __val_expr<_ValExpr>& __v) 3093 { 3094 size_t __n = __v.size(); 3095 if (size() != __n) 3096 resize(__n); 3097 value_type* __t = __begin_; 3098 for (size_t __i = 0; __i != __n; ++__t, ++__i) 3099 *__t = result_type(__v[__i]); 3100 return *this; 3101 } 3102 3103 template <class _Tp> 3104 inline 3105 __val_expr<__slice_expr<const valarray<_Tp>&> > 3106 valarray<_Tp>::operator[](slice __s) const 3107 { 3108 return __val_expr<__slice_expr<const valarray&> >(__slice_expr<const valarray&>(__s, *this)); 3109 } 3110 3111 template <class _Tp> 3112 inline 3113 slice_array<_Tp> 3114 valarray<_Tp>::operator[](slice __s) 3115 { 3116 return slice_array<value_type>(__s, *this); 3117 } 3118 3119 template <class _Tp> 3120 inline 3121 __val_expr<__indirect_expr<const valarray<_Tp>&> > 3122 valarray<_Tp>::operator[](const gslice& __gs) const 3123 { 3124 return __val_expr<__indirect_expr<const valarray&> >(__indirect_expr<const valarray&>(__gs.__1d_, *this)); 3125 } 3126 3127 template <class _Tp> 3128 inline 3129 gslice_array<_Tp> 3130 valarray<_Tp>::operator[](const gslice& __gs) 3131 { 3132 return gslice_array<value_type>(__gs, *this); 3133 } 3134 3135 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 3136 3137 template <class _Tp> 3138 inline 3139 __val_expr<__indirect_expr<const valarray<_Tp>&> > 3140 valarray<_Tp>::operator[](gslice&& __gs) const 3141 { 3142 return __val_expr<__indirect_expr<const valarray&> >(__indirect_expr<const valarray&>(move(__gs.__1d_), *this)); 3143 } 3144 3145 template <class _Tp> 3146 inline 3147 gslice_array<_Tp> 3148 valarray<_Tp>::operator[](gslice&& __gs) 3149 { 3150 return gslice_array<value_type>(move(__gs), *this); 3151 } 3152 3153 #endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 3154 3155 template <class _Tp> 3156 inline 3157 __val_expr<__mask_expr<const valarray<_Tp>&> > 3158 valarray<_Tp>::operator[](const valarray<bool>& __vb) const 3159 { 3160 return __val_expr<__mask_expr<const valarray&> >(__mask_expr<const valarray&>(__vb, *this)); 3161 } 3162 3163 template <class _Tp> 3164 inline 3165 mask_array<_Tp> 3166 valarray<_Tp>::operator[](const valarray<bool>& __vb) 3167 { 3168 return mask_array<value_type>(__vb, *this); 3169 } 3170 3171 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 3172 3173 template <class _Tp> 3174 inline 3175 __val_expr<__mask_expr<const valarray<_Tp>&> > 3176 valarray<_Tp>::operator[](valarray<bool>&& __vb) const 3177 { 3178 return __val_expr<__mask_expr<const valarray&> >(__mask_expr<const valarray&>(move(__vb), *this)); 3179 } 3180 3181 template <class _Tp> 3182 inline 3183 mask_array<_Tp> 3184 valarray<_Tp>::operator[](valarray<bool>&& __vb) 3185 { 3186 return mask_array<value_type>(move(__vb), *this); 3187 } 3188 3189 #endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 3190 3191 template <class _Tp> 3192 inline 3193 __val_expr<__indirect_expr<const valarray<_Tp>&> > 3194 valarray<_Tp>::operator[](const valarray<size_t>& __vs) const 3195 { 3196 return __val_expr<__indirect_expr<const valarray&> >(__indirect_expr<const valarray&>(__vs, *this)); 3197 } 3198 3199 template <class _Tp> 3200 inline 3201 indirect_array<_Tp> 3202 valarray<_Tp>::operator[](const valarray<size_t>& __vs) 3203 { 3204 return indirect_array<value_type>(__vs, *this); 3205 } 3206 3207 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 3208 3209 template <class _Tp> 3210 inline 3211 __val_expr<__indirect_expr<const valarray<_Tp>&> > 3212 valarray<_Tp>::operator[](valarray<size_t>&& __vs) const 3213 { 3214 return __val_expr<__indirect_expr<const valarray&> >(__indirect_expr<const valarray&>(move(__vs), *this)); 3215 } 3216 3217 template <class _Tp> 3218 inline 3219 indirect_array<_Tp> 3220 valarray<_Tp>::operator[](valarray<size_t>&& __vs) 3221 { 3222 return indirect_array<value_type>(move(__vs), *this); 3223 } 3224 3225 #endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 3226 3227 template <class _Tp> 3228 valarray<_Tp> 3229 valarray<_Tp>::operator+() const 3230 { 3231 valarray<value_type> __r; 3232 size_t __n = size(); 3233 if (__n) 3234 { 3235 __r.__begin_ = 3236 __r.__end_ = 3237 static_cast<value_type*>(_VSTD::__allocate(__n * sizeof(value_type))); 3238 for (const value_type* __p = __begin_; __n; ++__r.__end_, ++__p, --__n) 3239 ::new (__r.__end_) value_type(+*__p); 3240 } 3241 return __r; 3242 } 3243 3244 template <class _Tp> 3245 valarray<_Tp> 3246 valarray<_Tp>::operator-() const 3247 { 3248 valarray<value_type> __r; 3249 size_t __n = size(); 3250 if (__n) 3251 { 3252 __r.__begin_ = 3253 __r.__end_ = 3254 static_cast<value_type*>(_VSTD::__allocate(__n * sizeof(value_type))); 3255 for (const value_type* __p = __begin_; __n; ++__r.__end_, ++__p, --__n) 3256 ::new (__r.__end_) value_type(-*__p); 3257 } 3258 return __r; 3259 } 3260 3261 template <class _Tp> 3262 valarray<_Tp> 3263 valarray<_Tp>::operator~() const 3264 { 3265 valarray<value_type> __r; 3266 size_t __n = size(); 3267 if (__n) 3268 { 3269 __r.__begin_ = 3270 __r.__end_ = 3271 static_cast<value_type*>(_VSTD::__allocate(__n * sizeof(value_type))); 3272 for (const value_type* __p = __begin_; __n; ++__r.__end_, ++__p, --__n) 3273 ::new (__r.__end_) value_type(~*__p); 3274 } 3275 return __r; 3276 } 3277 3278 template <class _Tp> 3279 valarray<bool> 3280 valarray<_Tp>::operator!() const 3281 { 3282 valarray<bool> __r; 3283 size_t __n = size(); 3284 if (__n) 3285 { 3286 __r.__begin_ = 3287 __r.__end_ = 3288 static_cast<bool*>(_VSTD::__allocate(__n * sizeof(bool))); 3289 for (const value_type* __p = __begin_; __n; ++__r.__end_, ++__p, --__n) 3290 ::new (__r.__end_) bool(!*__p); 3291 } 3292 return __r; 3293 } 3294 3295 template <class _Tp> 3296 inline 3297 valarray<_Tp>& 3298 valarray<_Tp>::operator*=(const value_type& __x) 3299 { 3300 for (value_type* __p = __begin_; __p != __end_; ++__p) 3301 *__p *= __x; 3302 return *this; 3303 } 3304 3305 template <class _Tp> 3306 inline 3307 valarray<_Tp>& 3308 valarray<_Tp>::operator/=(const value_type& __x) 3309 { 3310 for (value_type* __p = __begin_; __p != __end_; ++__p) 3311 *__p /= __x; 3312 return *this; 3313 } 3314 3315 template <class _Tp> 3316 inline 3317 valarray<_Tp>& 3318 valarray<_Tp>::operator%=(const value_type& __x) 3319 { 3320 for (value_type* __p = __begin_; __p != __end_; ++__p) 3321 *__p %= __x; 3322 return *this; 3323 } 3324 3325 template <class _Tp> 3326 inline 3327 valarray<_Tp>& 3328 valarray<_Tp>::operator+=(const value_type& __x) 3329 { 3330 for (value_type* __p = __begin_; __p != __end_; ++__p) 3331 *__p += __x; 3332 return *this; 3333 } 3334 3335 template <class _Tp> 3336 inline 3337 valarray<_Tp>& 3338 valarray<_Tp>::operator-=(const value_type& __x) 3339 { 3340 for (value_type* __p = __begin_; __p != __end_; ++__p) 3341 *__p -= __x; 3342 return *this; 3343 } 3344 3345 template <class _Tp> 3346 inline 3347 valarray<_Tp>& 3348 valarray<_Tp>::operator^=(const value_type& __x) 3349 { 3350 for (value_type* __p = __begin_; __p != __end_; ++__p) 3351 *__p ^= __x; 3352 return *this; 3353 } 3354 3355 template <class _Tp> 3356 inline 3357 valarray<_Tp>& 3358 valarray<_Tp>::operator&=(const value_type& __x) 3359 { 3360 for (value_type* __p = __begin_; __p != __end_; ++__p) 3361 *__p &= __x; 3362 return *this; 3363 } 3364 3365 template <class _Tp> 3366 inline 3367 valarray<_Tp>& 3368 valarray<_Tp>::operator|=(const value_type& __x) 3369 { 3370 for (value_type* __p = __begin_; __p != __end_; ++__p) 3371 *__p |= __x; 3372 return *this; 3373 } 3374 3375 template <class _Tp> 3376 inline 3377 valarray<_Tp>& 3378 valarray<_Tp>::operator<<=(const value_type& __x) 3379 { 3380 for (value_type* __p = __begin_; __p != __end_; ++__p) 3381 *__p <<= __x; 3382 return *this; 3383 } 3384 3385 template <class _Tp> 3386 inline 3387 valarray<_Tp>& 3388 valarray<_Tp>::operator>>=(const value_type& __x) 3389 { 3390 for (value_type* __p = __begin_; __p != __end_; ++__p) 3391 *__p >>= __x; 3392 return *this; 3393 } 3394 3395 template <class _Tp> 3396 template <class _Expr> 3397 inline 3398 typename enable_if 3399 < 3400 __is_val_expr<_Expr>::value, 3401 valarray<_Tp>& 3402 >::type 3403 valarray<_Tp>::operator*=(const _Expr& __v) 3404 { 3405 size_t __i = 0; 3406 for (value_type* __t = __begin_; __t != __end_ ; ++__t, ++__i) 3407 *__t *= __v[__i]; 3408 return *this; 3409 } 3410 3411 template <class _Tp> 3412 template <class _Expr> 3413 inline 3414 typename enable_if 3415 < 3416 __is_val_expr<_Expr>::value, 3417 valarray<_Tp>& 3418 >::type 3419 valarray<_Tp>::operator/=(const _Expr& __v) 3420 { 3421 size_t __i = 0; 3422 for (value_type* __t = __begin_; __t != __end_ ; ++__t, ++__i) 3423 *__t /= __v[__i]; 3424 return *this; 3425 } 3426 3427 template <class _Tp> 3428 template <class _Expr> 3429 inline 3430 typename enable_if 3431 < 3432 __is_val_expr<_Expr>::value, 3433 valarray<_Tp>& 3434 >::type 3435 valarray<_Tp>::operator%=(const _Expr& __v) 3436 { 3437 size_t __i = 0; 3438 for (value_type* __t = __begin_; __t != __end_ ; ++__t, ++__i) 3439 *__t %= __v[__i]; 3440 return *this; 3441 } 3442 3443 template <class _Tp> 3444 template <class _Expr> 3445 inline 3446 typename enable_if 3447 < 3448 __is_val_expr<_Expr>::value, 3449 valarray<_Tp>& 3450 >::type 3451 valarray<_Tp>::operator+=(const _Expr& __v) 3452 { 3453 size_t __i = 0; 3454 for (value_type* __t = __begin_; __t != __end_ ; ++__t, ++__i) 3455 *__t += __v[__i]; 3456 return *this; 3457 } 3458 3459 template <class _Tp> 3460 template <class _Expr> 3461 inline 3462 typename enable_if 3463 < 3464 __is_val_expr<_Expr>::value, 3465 valarray<_Tp>& 3466 >::type 3467 valarray<_Tp>::operator-=(const _Expr& __v) 3468 { 3469 size_t __i = 0; 3470 for (value_type* __t = __begin_; __t != __end_ ; ++__t, ++__i) 3471 *__t -= __v[__i]; 3472 return *this; 3473 } 3474 3475 template <class _Tp> 3476 template <class _Expr> 3477 inline 3478 typename enable_if 3479 < 3480 __is_val_expr<_Expr>::value, 3481 valarray<_Tp>& 3482 >::type 3483 valarray<_Tp>::operator^=(const _Expr& __v) 3484 { 3485 size_t __i = 0; 3486 for (value_type* __t = __begin_; __t != __end_ ; ++__t, ++__i) 3487 *__t ^= __v[__i]; 3488 return *this; 3489 } 3490 3491 template <class _Tp> 3492 template <class _Expr> 3493 inline 3494 typename enable_if 3495 < 3496 __is_val_expr<_Expr>::value, 3497 valarray<_Tp>& 3498 >::type 3499 valarray<_Tp>::operator|=(const _Expr& __v) 3500 { 3501 size_t __i = 0; 3502 for (value_type* __t = __begin_; __t != __end_ ; ++__t, ++__i) 3503 *__t |= __v[__i]; 3504 return *this; 3505 } 3506 3507 template <class _Tp> 3508 template <class _Expr> 3509 inline 3510 typename enable_if 3511 < 3512 __is_val_expr<_Expr>::value, 3513 valarray<_Tp>& 3514 >::type 3515 valarray<_Tp>::operator&=(const _Expr& __v) 3516 { 3517 size_t __i = 0; 3518 for (value_type* __t = __begin_; __t != __end_ ; ++__t, ++__i) 3519 *__t &= __v[__i]; 3520 return *this; 3521 } 3522 3523 template <class _Tp> 3524 template <class _Expr> 3525 inline 3526 typename enable_if 3527 < 3528 __is_val_expr<_Expr>::value, 3529 valarray<_Tp>& 3530 >::type 3531 valarray<_Tp>::operator<<=(const _Expr& __v) 3532 { 3533 size_t __i = 0; 3534 for (value_type* __t = __begin_; __t != __end_ ; ++__t, ++__i) 3535 *__t <<= __v[__i]; 3536 return *this; 3537 } 3538 3539 template <class _Tp> 3540 template <class _Expr> 3541 inline 3542 typename enable_if 3543 < 3544 __is_val_expr<_Expr>::value, 3545 valarray<_Tp>& 3546 >::type 3547 valarray<_Tp>::operator>>=(const _Expr& __v) 3548 { 3549 size_t __i = 0; 3550 for (value_type* __t = __begin_; __t != __end_ ; ++__t, ++__i) 3551 *__t >>= __v[__i]; 3552 return *this; 3553 } 3554 3555 template <class _Tp> 3556 inline 3557 void 3558 valarray<_Tp>::swap(valarray& __v) _NOEXCEPT 3559 { 3560 _VSTD::swap(__begin_, __v.__begin_); 3561 _VSTD::swap(__end_, __v.__end_); 3562 } 3563 3564 template <class _Tp> 3565 inline 3566 _Tp 3567 valarray<_Tp>::sum() const 3568 { 3569 if (__begin_ == __end_) 3570 return value_type(); 3571 const value_type* __p = __begin_; 3572 _Tp __r = *__p; 3573 for (++__p; __p != __end_; ++__p) 3574 __r += *__p; 3575 return __r; 3576 } 3577 3578 template <class _Tp> 3579 inline 3580 _Tp 3581 valarray<_Tp>::min() const 3582 { 3583 if (__begin_ == __end_) 3584 return value_type(); 3585 return *_VSTD::min_element(__begin_, __end_); 3586 } 3587 3588 template <class _Tp> 3589 inline 3590 _Tp 3591 valarray<_Tp>::max() const 3592 { 3593 if (__begin_ == __end_) 3594 return value_type(); 3595 return *_VSTD::max_element(__begin_, __end_); 3596 } 3597 3598 template <class _Tp> 3599 valarray<_Tp> 3600 valarray<_Tp>::shift(int __i) const 3601 { 3602 valarray<value_type> __r; 3603 size_t __n = size(); 3604 if (__n) 3605 { 3606 __r.__begin_ = 3607 __r.__end_ = 3608 static_cast<value_type*>(_VSTD::__allocate(__n * sizeof(value_type))); 3609 const value_type* __sb; 3610 value_type* __tb; 3611 value_type* __te; 3612 if (__i >= 0) 3613 { 3614 __i = _VSTD::min(__i, static_cast<int>(__n)); 3615 __sb = __begin_ + __i; 3616 __tb = __r.__begin_; 3617 __te = __r.__begin_ + (__n - __i); 3618 } 3619 else 3620 { 3621 __i = _VSTD::min(-__i, static_cast<int>(__n)); 3622 __sb = __begin_; 3623 __tb = __r.__begin_ + __i; 3624 __te = __r.__begin_ + __n; 3625 } 3626 for (; __r.__end_ != __tb; ++__r.__end_) 3627 ::new (__r.__end_) value_type(); 3628 for (; __r.__end_ != __te; ++__r.__end_, ++__sb) 3629 ::new (__r.__end_) value_type(*__sb); 3630 for (__te = __r.__begin_ + __n; __r.__end_ != __te; ++__r.__end_) 3631 ::new (__r.__end_) value_type(); 3632 } 3633 return __r; 3634 } 3635 3636 template <class _Tp> 3637 valarray<_Tp> 3638 valarray<_Tp>::cshift(int __i) const 3639 { 3640 valarray<value_type> __r; 3641 size_t __n = size(); 3642 if (__n) 3643 { 3644 __r.__begin_ = 3645 __r.__end_ = 3646 static_cast<value_type*>(_VSTD::__allocate(__n * sizeof(value_type))); 3647 __i %= static_cast<int>(__n); 3648 const value_type* __m = __i >= 0 ? __begin_ + __i : __end_ + __i; 3649 for (const value_type* __s = __m; __s != __end_; ++__r.__end_, ++__s) 3650 ::new (__r.__end_) value_type(*__s); 3651 for (const value_type* __s = __begin_; __s != __m; ++__r.__end_, ++__s) 3652 ::new (__r.__end_) value_type(*__s); 3653 } 3654 return __r; 3655 } 3656 3657 template <class _Tp> 3658 valarray<_Tp> 3659 valarray<_Tp>::apply(value_type __f(value_type)) const 3660 { 3661 valarray<value_type> __r; 3662 size_t __n = size(); 3663 if (__n) 3664 { 3665 __r.__begin_ = 3666 __r.__end_ = 3667 static_cast<value_type*>(_VSTD::__allocate(__n * sizeof(value_type))); 3668 for (const value_type* __p = __begin_; __n; ++__r.__end_, ++__p, --__n) 3669 ::new (__r.__end_) value_type(__f(*__p)); 3670 } 3671 return __r; 3672 } 3673 3674 template <class _Tp> 3675 valarray<_Tp> 3676 valarray<_Tp>::apply(value_type __f(const value_type&)) const 3677 { 3678 valarray<value_type> __r; 3679 size_t __n = size(); 3680 if (__n) 3681 { 3682 __r.__begin_ = 3683 __r.__end_ = 3684 static_cast<value_type*>(_VSTD::__allocate(__n * sizeof(value_type))); 3685 for (const value_type* __p = __begin_; __n; ++__r.__end_, ++__p, --__n) 3686 ::new (__r.__end_) value_type(__f(*__p)); 3687 } 3688 return __r; 3689 } 3690 3691 template <class _Tp> 3692 void 3693 valarray<_Tp>::resize(size_t __n, value_type __x) 3694 { 3695 if (__begin_ != nullptr) 3696 { 3697 while (__end_ != __begin_) 3698 (--__end_)->~value_type(); 3699 _VSTD::__libcpp_deallocate(__begin_); 3700 __begin_ = __end_ = nullptr; 3701 } 3702 if (__n) 3703 { 3704 __begin_ = __end_ = static_cast<value_type*>(_VSTD::__allocate(__n * sizeof(value_type))); 3705 #ifndef _LIBCPP_NO_EXCEPTIONS 3706 try 3707 { 3708 #endif // _LIBCPP_NO_EXCEPTIONS 3709 for (; __n; --__n, ++__end_) 3710 ::new (__end_) value_type(__x); 3711 #ifndef _LIBCPP_NO_EXCEPTIONS 3712 } 3713 catch (...) 3714 { 3715 resize(0); 3716 throw; 3717 } 3718 #endif // _LIBCPP_NO_EXCEPTIONS 3719 } 3720 } 3721 3722 template<class _Tp> 3723 inline _LIBCPP_INLINE_VISIBILITY 3724 void 3725 swap(valarray<_Tp>& __x, valarray<_Tp>& __y) _NOEXCEPT 3726 { 3727 __x.swap(__y); 3728 } 3729 3730 template<class _Expr1, class _Expr2> 3731 inline _LIBCPP_INLINE_VISIBILITY 3732 typename enable_if 3733 < 3734 __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, 3735 __val_expr<_BinaryOp<multiplies<typename _Expr1::value_type>, _Expr1, _Expr2> > 3736 >::type 3737 operator*(const _Expr1& __x, const _Expr2& __y) 3738 { 3739 typedef typename _Expr1::value_type value_type; 3740 typedef _BinaryOp<multiplies<value_type>, _Expr1, _Expr2> _Op; 3741 return __val_expr<_Op>(_Op(multiplies<value_type>(), __x, __y)); 3742 } 3743 3744 template<class _Expr> 3745 inline _LIBCPP_INLINE_VISIBILITY 3746 typename enable_if 3747 < 3748 __is_val_expr<_Expr>::value, 3749 __val_expr<_BinaryOp<multiplies<typename _Expr::value_type>, 3750 _Expr, __scalar_expr<typename _Expr::value_type> > > 3751 >::type 3752 operator*(const _Expr& __x, const typename _Expr::value_type& __y) 3753 { 3754 typedef typename _Expr::value_type value_type; 3755 typedef _BinaryOp<multiplies<value_type>, _Expr, __scalar_expr<value_type> > _Op; 3756 return __val_expr<_Op>(_Op(multiplies<value_type>(), 3757 __x, __scalar_expr<value_type>(__y, __x.size()))); 3758 } 3759 3760 template<class _Expr> 3761 inline _LIBCPP_INLINE_VISIBILITY 3762 typename enable_if 3763 < 3764 __is_val_expr<_Expr>::value, 3765 __val_expr<_BinaryOp<multiplies<typename _Expr::value_type>, 3766 __scalar_expr<typename _Expr::value_type>, _Expr> > 3767 >::type 3768 operator*(const typename _Expr::value_type& __x, const _Expr& __y) 3769 { 3770 typedef typename _Expr::value_type value_type; 3771 typedef _BinaryOp<multiplies<value_type>, __scalar_expr<value_type>, _Expr> _Op; 3772 return __val_expr<_Op>(_Op(multiplies<value_type>(), 3773 __scalar_expr<value_type>(__x, __y.size()), __y)); 3774 } 3775 3776 template<class _Expr1, class _Expr2> 3777 inline _LIBCPP_INLINE_VISIBILITY 3778 typename enable_if 3779 < 3780 __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, 3781 __val_expr<_BinaryOp<divides<typename _Expr1::value_type>, _Expr1, _Expr2> > 3782 >::type 3783 operator/(const _Expr1& __x, const _Expr2& __y) 3784 { 3785 typedef typename _Expr1::value_type value_type; 3786 typedef _BinaryOp<divides<value_type>, _Expr1, _Expr2> _Op; 3787 return __val_expr<_Op>(_Op(divides<value_type>(), __x, __y)); 3788 } 3789 3790 template<class _Expr> 3791 inline _LIBCPP_INLINE_VISIBILITY 3792 typename enable_if 3793 < 3794 __is_val_expr<_Expr>::value, 3795 __val_expr<_BinaryOp<divides<typename _Expr::value_type>, 3796 _Expr, __scalar_expr<typename _Expr::value_type> > > 3797 >::type 3798 operator/(const _Expr& __x, const typename _Expr::value_type& __y) 3799 { 3800 typedef typename _Expr::value_type value_type; 3801 typedef _BinaryOp<divides<value_type>, _Expr, __scalar_expr<value_type> > _Op; 3802 return __val_expr<_Op>(_Op(divides<value_type>(), 3803 __x, __scalar_expr<value_type>(__y, __x.size()))); 3804 } 3805 3806 template<class _Expr> 3807 inline _LIBCPP_INLINE_VISIBILITY 3808 typename enable_if 3809 < 3810 __is_val_expr<_Expr>::value, 3811 __val_expr<_BinaryOp<divides<typename _Expr::value_type>, 3812 __scalar_expr<typename _Expr::value_type>, _Expr> > 3813 >::type 3814 operator/(const typename _Expr::value_type& __x, const _Expr& __y) 3815 { 3816 typedef typename _Expr::value_type value_type; 3817 typedef _BinaryOp<divides<value_type>, __scalar_expr<value_type>, _Expr> _Op; 3818 return __val_expr<_Op>(_Op(divides<value_type>(), 3819 __scalar_expr<value_type>(__x, __y.size()), __y)); 3820 } 3821 3822 template<class _Expr1, class _Expr2> 3823 inline _LIBCPP_INLINE_VISIBILITY 3824 typename enable_if 3825 < 3826 __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, 3827 __val_expr<_BinaryOp<modulus<typename _Expr1::value_type>, _Expr1, _Expr2> > 3828 >::type 3829 operator%(const _Expr1& __x, const _Expr2& __y) 3830 { 3831 typedef typename _Expr1::value_type value_type; 3832 typedef _BinaryOp<modulus<value_type>, _Expr1, _Expr2> _Op; 3833 return __val_expr<_Op>(_Op(modulus<value_type>(), __x, __y)); 3834 } 3835 3836 template<class _Expr> 3837 inline _LIBCPP_INLINE_VISIBILITY 3838 typename enable_if 3839 < 3840 __is_val_expr<_Expr>::value, 3841 __val_expr<_BinaryOp<modulus<typename _Expr::value_type>, 3842 _Expr, __scalar_expr<typename _Expr::value_type> > > 3843 >::type 3844 operator%(const _Expr& __x, const typename _Expr::value_type& __y) 3845 { 3846 typedef typename _Expr::value_type value_type; 3847 typedef _BinaryOp<modulus<value_type>, _Expr, __scalar_expr<value_type> > _Op; 3848 return __val_expr<_Op>(_Op(modulus<value_type>(), 3849 __x, __scalar_expr<value_type>(__y, __x.size()))); 3850 } 3851 3852 template<class _Expr> 3853 inline _LIBCPP_INLINE_VISIBILITY 3854 typename enable_if 3855 < 3856 __is_val_expr<_Expr>::value, 3857 __val_expr<_BinaryOp<modulus<typename _Expr::value_type>, 3858 __scalar_expr<typename _Expr::value_type>, _Expr> > 3859 >::type 3860 operator%(const typename _Expr::value_type& __x, const _Expr& __y) 3861 { 3862 typedef typename _Expr::value_type value_type; 3863 typedef _BinaryOp<modulus<value_type>, __scalar_expr<value_type>, _Expr> _Op; 3864 return __val_expr<_Op>(_Op(modulus<value_type>(), 3865 __scalar_expr<value_type>(__x, __y.size()), __y)); 3866 } 3867 3868 template<class _Expr1, class _Expr2> 3869 inline _LIBCPP_INLINE_VISIBILITY 3870 typename enable_if 3871 < 3872 __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, 3873 __val_expr<_BinaryOp<plus<typename _Expr1::value_type>, _Expr1, _Expr2> > 3874 >::type 3875 operator+(const _Expr1& __x, const _Expr2& __y) 3876 { 3877 typedef typename _Expr1::value_type value_type; 3878 typedef _BinaryOp<plus<value_type>, _Expr1, _Expr2> _Op; 3879 return __val_expr<_Op>(_Op(plus<value_type>(), __x, __y)); 3880 } 3881 3882 template<class _Expr> 3883 inline _LIBCPP_INLINE_VISIBILITY 3884 typename enable_if 3885 < 3886 __is_val_expr<_Expr>::value, 3887 __val_expr<_BinaryOp<plus<typename _Expr::value_type>, 3888 _Expr, __scalar_expr<typename _Expr::value_type> > > 3889 >::type 3890 operator+(const _Expr& __x, const typename _Expr::value_type& __y) 3891 { 3892 typedef typename _Expr::value_type value_type; 3893 typedef _BinaryOp<plus<value_type>, _Expr, __scalar_expr<value_type> > _Op; 3894 return __val_expr<_Op>(_Op(plus<value_type>(), 3895 __x, __scalar_expr<value_type>(__y, __x.size()))); 3896 } 3897 3898 template<class _Expr> 3899 inline _LIBCPP_INLINE_VISIBILITY 3900 typename enable_if 3901 < 3902 __is_val_expr<_Expr>::value, 3903 __val_expr<_BinaryOp<plus<typename _Expr::value_type>, 3904 __scalar_expr<typename _Expr::value_type>, _Expr> > 3905 >::type 3906 operator+(const typename _Expr::value_type& __x, const _Expr& __y) 3907 { 3908 typedef typename _Expr::value_type value_type; 3909 typedef _BinaryOp<plus<value_type>, __scalar_expr<value_type>, _Expr> _Op; 3910 return __val_expr<_Op>(_Op(plus<value_type>(), 3911 __scalar_expr<value_type>(__x, __y.size()), __y)); 3912 } 3913 3914 template<class _Expr1, class _Expr2> 3915 inline _LIBCPP_INLINE_VISIBILITY 3916 typename enable_if 3917 < 3918 __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, 3919 __val_expr<_BinaryOp<minus<typename _Expr1::value_type>, _Expr1, _Expr2> > 3920 >::type 3921 operator-(const _Expr1& __x, const _Expr2& __y) 3922 { 3923 typedef typename _Expr1::value_type value_type; 3924 typedef _BinaryOp<minus<value_type>, _Expr1, _Expr2> _Op; 3925 return __val_expr<_Op>(_Op(minus<value_type>(), __x, __y)); 3926 } 3927 3928 template<class _Expr> 3929 inline _LIBCPP_INLINE_VISIBILITY 3930 typename enable_if 3931 < 3932 __is_val_expr<_Expr>::value, 3933 __val_expr<_BinaryOp<minus<typename _Expr::value_type>, 3934 _Expr, __scalar_expr<typename _Expr::value_type> > > 3935 >::type 3936 operator-(const _Expr& __x, const typename _Expr::value_type& __y) 3937 { 3938 typedef typename _Expr::value_type value_type; 3939 typedef _BinaryOp<minus<value_type>, _Expr, __scalar_expr<value_type> > _Op; 3940 return __val_expr<_Op>(_Op(minus<value_type>(), 3941 __x, __scalar_expr<value_type>(__y, __x.size()))); 3942 } 3943 3944 template<class _Expr> 3945 inline _LIBCPP_INLINE_VISIBILITY 3946 typename enable_if 3947 < 3948 __is_val_expr<_Expr>::value, 3949 __val_expr<_BinaryOp<minus<typename _Expr::value_type>, 3950 __scalar_expr<typename _Expr::value_type>, _Expr> > 3951 >::type 3952 operator-(const typename _Expr::value_type& __x, const _Expr& __y) 3953 { 3954 typedef typename _Expr::value_type value_type; 3955 typedef _BinaryOp<minus<value_type>, __scalar_expr<value_type>, _Expr> _Op; 3956 return __val_expr<_Op>(_Op(minus<value_type>(), 3957 __scalar_expr<value_type>(__x, __y.size()), __y)); 3958 } 3959 3960 template<class _Expr1, class _Expr2> 3961 inline _LIBCPP_INLINE_VISIBILITY 3962 typename enable_if 3963 < 3964 __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, 3965 __val_expr<_BinaryOp<bit_xor<typename _Expr1::value_type>, _Expr1, _Expr2> > 3966 >::type 3967 operator^(const _Expr1& __x, const _Expr2& __y) 3968 { 3969 typedef typename _Expr1::value_type value_type; 3970 typedef _BinaryOp<bit_xor<value_type>, _Expr1, _Expr2> _Op; 3971 return __val_expr<_Op>(_Op(bit_xor<value_type>(), __x, __y)); 3972 } 3973 3974 template<class _Expr> 3975 inline _LIBCPP_INLINE_VISIBILITY 3976 typename enable_if 3977 < 3978 __is_val_expr<_Expr>::value, 3979 __val_expr<_BinaryOp<bit_xor<typename _Expr::value_type>, 3980 _Expr, __scalar_expr<typename _Expr::value_type> > > 3981 >::type 3982 operator^(const _Expr& __x, const typename _Expr::value_type& __y) 3983 { 3984 typedef typename _Expr::value_type value_type; 3985 typedef _BinaryOp<bit_xor<value_type>, _Expr, __scalar_expr<value_type> > _Op; 3986 return __val_expr<_Op>(_Op(bit_xor<value_type>(), 3987 __x, __scalar_expr<value_type>(__y, __x.size()))); 3988 } 3989 3990 template<class _Expr> 3991 inline _LIBCPP_INLINE_VISIBILITY 3992 typename enable_if 3993 < 3994 __is_val_expr<_Expr>::value, 3995 __val_expr<_BinaryOp<bit_xor<typename _Expr::value_type>, 3996 __scalar_expr<typename _Expr::value_type>, _Expr> > 3997 >::type 3998 operator^(const typename _Expr::value_type& __x, const _Expr& __y) 3999 { 4000 typedef typename _Expr::value_type value_type; 4001 typedef _BinaryOp<bit_xor<value_type>, __scalar_expr<value_type>, _Expr> _Op; 4002 return __val_expr<_Op>(_Op(bit_xor<value_type>(), 4003 __scalar_expr<value_type>(__x, __y.size()), __y)); 4004 } 4005 4006 template<class _Expr1, class _Expr2> 4007 inline _LIBCPP_INLINE_VISIBILITY 4008 typename enable_if 4009 < 4010 __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, 4011 __val_expr<_BinaryOp<bit_and<typename _Expr1::value_type>, _Expr1, _Expr2> > 4012 >::type 4013 operator&(const _Expr1& __x, const _Expr2& __y) 4014 { 4015 typedef typename _Expr1::value_type value_type; 4016 typedef _BinaryOp<bit_and<value_type>, _Expr1, _Expr2> _Op; 4017 return __val_expr<_Op>(_Op(bit_and<value_type>(), __x, __y)); 4018 } 4019 4020 template<class _Expr> 4021 inline _LIBCPP_INLINE_VISIBILITY 4022 typename enable_if 4023 < 4024 __is_val_expr<_Expr>::value, 4025 __val_expr<_BinaryOp<bit_and<typename _Expr::value_type>, 4026 _Expr, __scalar_expr<typename _Expr::value_type> > > 4027 >::type 4028 operator&(const _Expr& __x, const typename _Expr::value_type& __y) 4029 { 4030 typedef typename _Expr::value_type value_type; 4031 typedef _BinaryOp<bit_and<value_type>, _Expr, __scalar_expr<value_type> > _Op; 4032 return __val_expr<_Op>(_Op(bit_and<value_type>(), 4033 __x, __scalar_expr<value_type>(__y, __x.size()))); 4034 } 4035 4036 template<class _Expr> 4037 inline _LIBCPP_INLINE_VISIBILITY 4038 typename enable_if 4039 < 4040 __is_val_expr<_Expr>::value, 4041 __val_expr<_BinaryOp<bit_and<typename _Expr::value_type>, 4042 __scalar_expr<typename _Expr::value_type>, _Expr> > 4043 >::type 4044 operator&(const typename _Expr::value_type& __x, const _Expr& __y) 4045 { 4046 typedef typename _Expr::value_type value_type; 4047 typedef _BinaryOp<bit_and<value_type>, __scalar_expr<value_type>, _Expr> _Op; 4048 return __val_expr<_Op>(_Op(bit_and<value_type>(), 4049 __scalar_expr<value_type>(__x, __y.size()), __y)); 4050 } 4051 4052 template<class _Expr1, class _Expr2> 4053 inline _LIBCPP_INLINE_VISIBILITY 4054 typename enable_if 4055 < 4056 __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, 4057 __val_expr<_BinaryOp<bit_or<typename _Expr1::value_type>, _Expr1, _Expr2> > 4058 >::type 4059 operator|(const _Expr1& __x, const _Expr2& __y) 4060 { 4061 typedef typename _Expr1::value_type value_type; 4062 typedef _BinaryOp<bit_or<value_type>, _Expr1, _Expr2> _Op; 4063 return __val_expr<_Op>(_Op(bit_or<value_type>(), __x, __y)); 4064 } 4065 4066 template<class _Expr> 4067 inline _LIBCPP_INLINE_VISIBILITY 4068 typename enable_if 4069 < 4070 __is_val_expr<_Expr>::value, 4071 __val_expr<_BinaryOp<bit_or<typename _Expr::value_type>, 4072 _Expr, __scalar_expr<typename _Expr::value_type> > > 4073 >::type 4074 operator|(const _Expr& __x, const typename _Expr::value_type& __y) 4075 { 4076 typedef typename _Expr::value_type value_type; 4077 typedef _BinaryOp<bit_or<value_type>, _Expr, __scalar_expr<value_type> > _Op; 4078 return __val_expr<_Op>(_Op(bit_or<value_type>(), 4079 __x, __scalar_expr<value_type>(__y, __x.size()))); 4080 } 4081 4082 template<class _Expr> 4083 inline _LIBCPP_INLINE_VISIBILITY 4084 typename enable_if 4085 < 4086 __is_val_expr<_Expr>::value, 4087 __val_expr<_BinaryOp<bit_or<typename _Expr::value_type>, 4088 __scalar_expr<typename _Expr::value_type>, _Expr> > 4089 >::type 4090 operator|(const typename _Expr::value_type& __x, const _Expr& __y) 4091 { 4092 typedef typename _Expr::value_type value_type; 4093 typedef _BinaryOp<bit_or<value_type>, __scalar_expr<value_type>, _Expr> _Op; 4094 return __val_expr<_Op>(_Op(bit_or<value_type>(), 4095 __scalar_expr<value_type>(__x, __y.size()), __y)); 4096 } 4097 4098 template<class _Expr1, class _Expr2> 4099 inline _LIBCPP_INLINE_VISIBILITY 4100 typename enable_if 4101 < 4102 __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, 4103 __val_expr<_BinaryOp<__bit_shift_left<typename _Expr1::value_type>, _Expr1, _Expr2> > 4104 >::type 4105 operator<<(const _Expr1& __x, const _Expr2& __y) 4106 { 4107 typedef typename _Expr1::value_type value_type; 4108 typedef _BinaryOp<__bit_shift_left<value_type>, _Expr1, _Expr2> _Op; 4109 return __val_expr<_Op>(_Op(__bit_shift_left<value_type>(), __x, __y)); 4110 } 4111 4112 template<class _Expr> 4113 inline _LIBCPP_INLINE_VISIBILITY 4114 typename enable_if 4115 < 4116 __is_val_expr<_Expr>::value, 4117 __val_expr<_BinaryOp<__bit_shift_left<typename _Expr::value_type>, 4118 _Expr, __scalar_expr<typename _Expr::value_type> > > 4119 >::type 4120 operator<<(const _Expr& __x, const typename _Expr::value_type& __y) 4121 { 4122 typedef typename _Expr::value_type value_type; 4123 typedef _BinaryOp<__bit_shift_left<value_type>, _Expr, __scalar_expr<value_type> > _Op; 4124 return __val_expr<_Op>(_Op(__bit_shift_left<value_type>(), 4125 __x, __scalar_expr<value_type>(__y, __x.size()))); 4126 } 4127 4128 template<class _Expr> 4129 inline _LIBCPP_INLINE_VISIBILITY 4130 typename enable_if 4131 < 4132 __is_val_expr<_Expr>::value, 4133 __val_expr<_BinaryOp<__bit_shift_left<typename _Expr::value_type>, 4134 __scalar_expr<typename _Expr::value_type>, _Expr> > 4135 >::type 4136 operator<<(const typename _Expr::value_type& __x, const _Expr& __y) 4137 { 4138 typedef typename _Expr::value_type value_type; 4139 typedef _BinaryOp<__bit_shift_left<value_type>, __scalar_expr<value_type>, _Expr> _Op; 4140 return __val_expr<_Op>(_Op(__bit_shift_left<value_type>(), 4141 __scalar_expr<value_type>(__x, __y.size()), __y)); 4142 } 4143 4144 template<class _Expr1, class _Expr2> 4145 inline _LIBCPP_INLINE_VISIBILITY 4146 typename enable_if 4147 < 4148 __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, 4149 __val_expr<_BinaryOp<__bit_shift_right<typename _Expr1::value_type>, _Expr1, _Expr2> > 4150 >::type 4151 operator>>(const _Expr1& __x, const _Expr2& __y) 4152 { 4153 typedef typename _Expr1::value_type value_type; 4154 typedef _BinaryOp<__bit_shift_right<value_type>, _Expr1, _Expr2> _Op; 4155 return __val_expr<_Op>(_Op(__bit_shift_right<value_type>(), __x, __y)); 4156 } 4157 4158 template<class _Expr> 4159 inline _LIBCPP_INLINE_VISIBILITY 4160 typename enable_if 4161 < 4162 __is_val_expr<_Expr>::value, 4163 __val_expr<_BinaryOp<__bit_shift_right<typename _Expr::value_type>, 4164 _Expr, __scalar_expr<typename _Expr::value_type> > > 4165 >::type 4166 operator>>(const _Expr& __x, const typename _Expr::value_type& __y) 4167 { 4168 typedef typename _Expr::value_type value_type; 4169 typedef _BinaryOp<__bit_shift_right<value_type>, _Expr, __scalar_expr<value_type> > _Op; 4170 return __val_expr<_Op>(_Op(__bit_shift_right<value_type>(), 4171 __x, __scalar_expr<value_type>(__y, __x.size()))); 4172 } 4173 4174 template<class _Expr> 4175 inline _LIBCPP_INLINE_VISIBILITY 4176 typename enable_if 4177 < 4178 __is_val_expr<_Expr>::value, 4179 __val_expr<_BinaryOp<__bit_shift_right<typename _Expr::value_type>, 4180 __scalar_expr<typename _Expr::value_type>, _Expr> > 4181 >::type 4182 operator>>(const typename _Expr::value_type& __x, const _Expr& __y) 4183 { 4184 typedef typename _Expr::value_type value_type; 4185 typedef _BinaryOp<__bit_shift_right<value_type>, __scalar_expr<value_type>, _Expr> _Op; 4186 return __val_expr<_Op>(_Op(__bit_shift_right<value_type>(), 4187 __scalar_expr<value_type>(__x, __y.size()), __y)); 4188 } 4189 4190 template<class _Expr1, class _Expr2> 4191 inline _LIBCPP_INLINE_VISIBILITY 4192 typename enable_if 4193 < 4194 __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, 4195 __val_expr<_BinaryOp<logical_and<typename _Expr1::value_type>, _Expr1, _Expr2> > 4196 >::type 4197 operator&&(const _Expr1& __x, const _Expr2& __y) 4198 { 4199 typedef typename _Expr1::value_type value_type; 4200 typedef _BinaryOp<logical_and<value_type>, _Expr1, _Expr2> _Op; 4201 return __val_expr<_Op>(_Op(logical_and<value_type>(), __x, __y)); 4202 } 4203 4204 template<class _Expr> 4205 inline _LIBCPP_INLINE_VISIBILITY 4206 typename enable_if 4207 < 4208 __is_val_expr<_Expr>::value, 4209 __val_expr<_BinaryOp<logical_and<typename _Expr::value_type>, 4210 _Expr, __scalar_expr<typename _Expr::value_type> > > 4211 >::type 4212 operator&&(const _Expr& __x, const typename _Expr::value_type& __y) 4213 { 4214 typedef typename _Expr::value_type value_type; 4215 typedef _BinaryOp<logical_and<value_type>, _Expr, __scalar_expr<value_type> > _Op; 4216 return __val_expr<_Op>(_Op(logical_and<value_type>(), 4217 __x, __scalar_expr<value_type>(__y, __x.size()))); 4218 } 4219 4220 template<class _Expr> 4221 inline _LIBCPP_INLINE_VISIBILITY 4222 typename enable_if 4223 < 4224 __is_val_expr<_Expr>::value, 4225 __val_expr<_BinaryOp<logical_and<typename _Expr::value_type>, 4226 __scalar_expr<typename _Expr::value_type>, _Expr> > 4227 >::type 4228 operator&&(const typename _Expr::value_type& __x, const _Expr& __y) 4229 { 4230 typedef typename _Expr::value_type value_type; 4231 typedef _BinaryOp<logical_and<value_type>, __scalar_expr<value_type>, _Expr> _Op; 4232 return __val_expr<_Op>(_Op(logical_and<value_type>(), 4233 __scalar_expr<value_type>(__x, __y.size()), __y)); 4234 } 4235 4236 template<class _Expr1, class _Expr2> 4237 inline _LIBCPP_INLINE_VISIBILITY 4238 typename enable_if 4239 < 4240 __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, 4241 __val_expr<_BinaryOp<logical_or<typename _Expr1::value_type>, _Expr1, _Expr2> > 4242 >::type 4243 operator||(const _Expr1& __x, const _Expr2& __y) 4244 { 4245 typedef typename _Expr1::value_type value_type; 4246 typedef _BinaryOp<logical_or<value_type>, _Expr1, _Expr2> _Op; 4247 return __val_expr<_Op>(_Op(logical_or<value_type>(), __x, __y)); 4248 } 4249 4250 template<class _Expr> 4251 inline _LIBCPP_INLINE_VISIBILITY 4252 typename enable_if 4253 < 4254 __is_val_expr<_Expr>::value, 4255 __val_expr<_BinaryOp<logical_or<typename _Expr::value_type>, 4256 _Expr, __scalar_expr<typename _Expr::value_type> > > 4257 >::type 4258 operator||(const _Expr& __x, const typename _Expr::value_type& __y) 4259 { 4260 typedef typename _Expr::value_type value_type; 4261 typedef _BinaryOp<logical_or<value_type>, _Expr, __scalar_expr<value_type> > _Op; 4262 return __val_expr<_Op>(_Op(logical_or<value_type>(), 4263 __x, __scalar_expr<value_type>(__y, __x.size()))); 4264 } 4265 4266 template<class _Expr> 4267 inline _LIBCPP_INLINE_VISIBILITY 4268 typename enable_if 4269 < 4270 __is_val_expr<_Expr>::value, 4271 __val_expr<_BinaryOp<logical_or<typename _Expr::value_type>, 4272 __scalar_expr<typename _Expr::value_type>, _Expr> > 4273 >::type 4274 operator||(const typename _Expr::value_type& __x, const _Expr& __y) 4275 { 4276 typedef typename _Expr::value_type value_type; 4277 typedef _BinaryOp<logical_or<value_type>, __scalar_expr<value_type>, _Expr> _Op; 4278 return __val_expr<_Op>(_Op(logical_or<value_type>(), 4279 __scalar_expr<value_type>(__x, __y.size()), __y)); 4280 } 4281 4282 template<class _Expr1, class _Expr2> 4283 inline _LIBCPP_INLINE_VISIBILITY 4284 typename enable_if 4285 < 4286 __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, 4287 __val_expr<_BinaryOp<equal_to<typename _Expr1::value_type>, _Expr1, _Expr2> > 4288 >::type 4289 operator==(const _Expr1& __x, const _Expr2& __y) 4290 { 4291 typedef typename _Expr1::value_type value_type; 4292 typedef _BinaryOp<equal_to<value_type>, _Expr1, _Expr2> _Op; 4293 return __val_expr<_Op>(_Op(equal_to<value_type>(), __x, __y)); 4294 } 4295 4296 template<class _Expr> 4297 inline _LIBCPP_INLINE_VISIBILITY 4298 typename enable_if 4299 < 4300 __is_val_expr<_Expr>::value, 4301 __val_expr<_BinaryOp<equal_to<typename _Expr::value_type>, 4302 _Expr, __scalar_expr<typename _Expr::value_type> > > 4303 >::type 4304 operator==(const _Expr& __x, const typename _Expr::value_type& __y) 4305 { 4306 typedef typename _Expr::value_type value_type; 4307 typedef _BinaryOp<equal_to<value_type>, _Expr, __scalar_expr<value_type> > _Op; 4308 return __val_expr<_Op>(_Op(equal_to<value_type>(), 4309 __x, __scalar_expr<value_type>(__y, __x.size()))); 4310 } 4311 4312 template<class _Expr> 4313 inline _LIBCPP_INLINE_VISIBILITY 4314 typename enable_if 4315 < 4316 __is_val_expr<_Expr>::value, 4317 __val_expr<_BinaryOp<equal_to<typename _Expr::value_type>, 4318 __scalar_expr<typename _Expr::value_type>, _Expr> > 4319 >::type 4320 operator==(const typename _Expr::value_type& __x, const _Expr& __y) 4321 { 4322 typedef typename _Expr::value_type value_type; 4323 typedef _BinaryOp<equal_to<value_type>, __scalar_expr<value_type>, _Expr> _Op; 4324 return __val_expr<_Op>(_Op(equal_to<value_type>(), 4325 __scalar_expr<value_type>(__x, __y.size()), __y)); 4326 } 4327 4328 template<class _Expr1, class _Expr2> 4329 inline _LIBCPP_INLINE_VISIBILITY 4330 typename enable_if 4331 < 4332 __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, 4333 __val_expr<_BinaryOp<not_equal_to<typename _Expr1::value_type>, _Expr1, _Expr2> > 4334 >::type 4335 operator!=(const _Expr1& __x, const _Expr2& __y) 4336 { 4337 typedef typename _Expr1::value_type value_type; 4338 typedef _BinaryOp<not_equal_to<value_type>, _Expr1, _Expr2> _Op; 4339 return __val_expr<_Op>(_Op(not_equal_to<value_type>(), __x, __y)); 4340 } 4341 4342 template<class _Expr> 4343 inline _LIBCPP_INLINE_VISIBILITY 4344 typename enable_if 4345 < 4346 __is_val_expr<_Expr>::value, 4347 __val_expr<_BinaryOp<not_equal_to<typename _Expr::value_type>, 4348 _Expr, __scalar_expr<typename _Expr::value_type> > > 4349 >::type 4350 operator!=(const _Expr& __x, const typename _Expr::value_type& __y) 4351 { 4352 typedef typename _Expr::value_type value_type; 4353 typedef _BinaryOp<not_equal_to<value_type>, _Expr, __scalar_expr<value_type> > _Op; 4354 return __val_expr<_Op>(_Op(not_equal_to<value_type>(), 4355 __x, __scalar_expr<value_type>(__y, __x.size()))); 4356 } 4357 4358 template<class _Expr> 4359 inline _LIBCPP_INLINE_VISIBILITY 4360 typename enable_if 4361 < 4362 __is_val_expr<_Expr>::value, 4363 __val_expr<_BinaryOp<not_equal_to<typename _Expr::value_type>, 4364 __scalar_expr<typename _Expr::value_type>, _Expr> > 4365 >::type 4366 operator!=(const typename _Expr::value_type& __x, const _Expr& __y) 4367 { 4368 typedef typename _Expr::value_type value_type; 4369 typedef _BinaryOp<not_equal_to<value_type>, __scalar_expr<value_type>, _Expr> _Op; 4370 return __val_expr<_Op>(_Op(not_equal_to<value_type>(), 4371 __scalar_expr<value_type>(__x, __y.size()), __y)); 4372 } 4373 4374 template<class _Expr1, class _Expr2> 4375 inline _LIBCPP_INLINE_VISIBILITY 4376 typename enable_if 4377 < 4378 __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, 4379 __val_expr<_BinaryOp<less<typename _Expr1::value_type>, _Expr1, _Expr2> > 4380 >::type 4381 operator<(const _Expr1& __x, const _Expr2& __y) 4382 { 4383 typedef typename _Expr1::value_type value_type; 4384 typedef _BinaryOp<less<value_type>, _Expr1, _Expr2> _Op; 4385 return __val_expr<_Op>(_Op(less<value_type>(), __x, __y)); 4386 } 4387 4388 template<class _Expr> 4389 inline _LIBCPP_INLINE_VISIBILITY 4390 typename enable_if 4391 < 4392 __is_val_expr<_Expr>::value, 4393 __val_expr<_BinaryOp<less<typename _Expr::value_type>, 4394 _Expr, __scalar_expr<typename _Expr::value_type> > > 4395 >::type 4396 operator<(const _Expr& __x, const typename _Expr::value_type& __y) 4397 { 4398 typedef typename _Expr::value_type value_type; 4399 typedef _BinaryOp<less<value_type>, _Expr, __scalar_expr<value_type> > _Op; 4400 return __val_expr<_Op>(_Op(less<value_type>(), 4401 __x, __scalar_expr<value_type>(__y, __x.size()))); 4402 } 4403 4404 template<class _Expr> 4405 inline _LIBCPP_INLINE_VISIBILITY 4406 typename enable_if 4407 < 4408 __is_val_expr<_Expr>::value, 4409 __val_expr<_BinaryOp<less<typename _Expr::value_type>, 4410 __scalar_expr<typename _Expr::value_type>, _Expr> > 4411 >::type 4412 operator<(const typename _Expr::value_type& __x, const _Expr& __y) 4413 { 4414 typedef typename _Expr::value_type value_type; 4415 typedef _BinaryOp<less<value_type>, __scalar_expr<value_type>, _Expr> _Op; 4416 return __val_expr<_Op>(_Op(less<value_type>(), 4417 __scalar_expr<value_type>(__x, __y.size()), __y)); 4418 } 4419 4420 template<class _Expr1, class _Expr2> 4421 inline _LIBCPP_INLINE_VISIBILITY 4422 typename enable_if 4423 < 4424 __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, 4425 __val_expr<_BinaryOp<greater<typename _Expr1::value_type>, _Expr1, _Expr2> > 4426 >::type 4427 operator>(const _Expr1& __x, const _Expr2& __y) 4428 { 4429 typedef typename _Expr1::value_type value_type; 4430 typedef _BinaryOp<greater<value_type>, _Expr1, _Expr2> _Op; 4431 return __val_expr<_Op>(_Op(greater<value_type>(), __x, __y)); 4432 } 4433 4434 template<class _Expr> 4435 inline _LIBCPP_INLINE_VISIBILITY 4436 typename enable_if 4437 < 4438 __is_val_expr<_Expr>::value, 4439 __val_expr<_BinaryOp<greater<typename _Expr::value_type>, 4440 _Expr, __scalar_expr<typename _Expr::value_type> > > 4441 >::type 4442 operator>(const _Expr& __x, const typename _Expr::value_type& __y) 4443 { 4444 typedef typename _Expr::value_type value_type; 4445 typedef _BinaryOp<greater<value_type>, _Expr, __scalar_expr<value_type> > _Op; 4446 return __val_expr<_Op>(_Op(greater<value_type>(), 4447 __x, __scalar_expr<value_type>(__y, __x.size()))); 4448 } 4449 4450 template<class _Expr> 4451 inline _LIBCPP_INLINE_VISIBILITY 4452 typename enable_if 4453 < 4454 __is_val_expr<_Expr>::value, 4455 __val_expr<_BinaryOp<greater<typename _Expr::value_type>, 4456 __scalar_expr<typename _Expr::value_type>, _Expr> > 4457 >::type 4458 operator>(const typename _Expr::value_type& __x, const _Expr& __y) 4459 { 4460 typedef typename _Expr::value_type value_type; 4461 typedef _BinaryOp<greater<value_type>, __scalar_expr<value_type>, _Expr> _Op; 4462 return __val_expr<_Op>(_Op(greater<value_type>(), 4463 __scalar_expr<value_type>(__x, __y.size()), __y)); 4464 } 4465 4466 template<class _Expr1, class _Expr2> 4467 inline _LIBCPP_INLINE_VISIBILITY 4468 typename enable_if 4469 < 4470 __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, 4471 __val_expr<_BinaryOp<less_equal<typename _Expr1::value_type>, _Expr1, _Expr2> > 4472 >::type 4473 operator<=(const _Expr1& __x, const _Expr2& __y) 4474 { 4475 typedef typename _Expr1::value_type value_type; 4476 typedef _BinaryOp<less_equal<value_type>, _Expr1, _Expr2> _Op; 4477 return __val_expr<_Op>(_Op(less_equal<value_type>(), __x, __y)); 4478 } 4479 4480 template<class _Expr> 4481 inline _LIBCPP_INLINE_VISIBILITY 4482 typename enable_if 4483 < 4484 __is_val_expr<_Expr>::value, 4485 __val_expr<_BinaryOp<less_equal<typename _Expr::value_type>, 4486 _Expr, __scalar_expr<typename _Expr::value_type> > > 4487 >::type 4488 operator<=(const _Expr& __x, const typename _Expr::value_type& __y) 4489 { 4490 typedef typename _Expr::value_type value_type; 4491 typedef _BinaryOp<less_equal<value_type>, _Expr, __scalar_expr<value_type> > _Op; 4492 return __val_expr<_Op>(_Op(less_equal<value_type>(), 4493 __x, __scalar_expr<value_type>(__y, __x.size()))); 4494 } 4495 4496 template<class _Expr> 4497 inline _LIBCPP_INLINE_VISIBILITY 4498 typename enable_if 4499 < 4500 __is_val_expr<_Expr>::value, 4501 __val_expr<_BinaryOp<less_equal<typename _Expr::value_type>, 4502 __scalar_expr<typename _Expr::value_type>, _Expr> > 4503 >::type 4504 operator<=(const typename _Expr::value_type& __x, const _Expr& __y) 4505 { 4506 typedef typename _Expr::value_type value_type; 4507 typedef _BinaryOp<less_equal<value_type>, __scalar_expr<value_type>, _Expr> _Op; 4508 return __val_expr<_Op>(_Op(less_equal<value_type>(), 4509 __scalar_expr<value_type>(__x, __y.size()), __y)); 4510 } 4511 4512 template<class _Expr1, class _Expr2> 4513 inline _LIBCPP_INLINE_VISIBILITY 4514 typename enable_if 4515 < 4516 __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, 4517 __val_expr<_BinaryOp<greater_equal<typename _Expr1::value_type>, _Expr1, _Expr2> > 4518 >::type 4519 operator>=(const _Expr1& __x, const _Expr2& __y) 4520 { 4521 typedef typename _Expr1::value_type value_type; 4522 typedef _BinaryOp<greater_equal<value_type>, _Expr1, _Expr2> _Op; 4523 return __val_expr<_Op>(_Op(greater_equal<value_type>(), __x, __y)); 4524 } 4525 4526 template<class _Expr> 4527 inline _LIBCPP_INLINE_VISIBILITY 4528 typename enable_if 4529 < 4530 __is_val_expr<_Expr>::value, 4531 __val_expr<_BinaryOp<greater_equal<typename _Expr::value_type>, 4532 _Expr, __scalar_expr<typename _Expr::value_type> > > 4533 >::type 4534 operator>=(const _Expr& __x, const typename _Expr::value_type& __y) 4535 { 4536 typedef typename _Expr::value_type value_type; 4537 typedef _BinaryOp<greater_equal<value_type>, _Expr, __scalar_expr<value_type> > _Op; 4538 return __val_expr<_Op>(_Op(greater_equal<value_type>(), 4539 __x, __scalar_expr<value_type>(__y, __x.size()))); 4540 } 4541 4542 template<class _Expr> 4543 inline _LIBCPP_INLINE_VISIBILITY 4544 typename enable_if 4545 < 4546 __is_val_expr<_Expr>::value, 4547 __val_expr<_BinaryOp<greater_equal<typename _Expr::value_type>, 4548 __scalar_expr<typename _Expr::value_type>, _Expr> > 4549 >::type 4550 operator>=(const typename _Expr::value_type& __x, const _Expr& __y) 4551 { 4552 typedef typename _Expr::value_type value_type; 4553 typedef _BinaryOp<greater_equal<value_type>, __scalar_expr<value_type>, _Expr> _Op; 4554 return __val_expr<_Op>(_Op(greater_equal<value_type>(), 4555 __scalar_expr<value_type>(__x, __y.size()), __y)); 4556 } 4557 4558 template<class _Expr> 4559 inline _LIBCPP_INLINE_VISIBILITY 4560 typename enable_if 4561 < 4562 __is_val_expr<_Expr>::value, 4563 __val_expr<_UnaryOp<__abs_expr<typename _Expr::value_type>, _Expr> > 4564 >::type 4565 abs(const _Expr& __x) 4566 { 4567 typedef typename _Expr::value_type value_type; 4568 typedef _UnaryOp<__abs_expr<value_type>, _Expr> _Op; 4569 return __val_expr<_Op>(_Op(__abs_expr<value_type>(), __x)); 4570 } 4571 4572 template<class _Expr> 4573 inline _LIBCPP_INLINE_VISIBILITY 4574 typename enable_if 4575 < 4576 __is_val_expr<_Expr>::value, 4577 __val_expr<_UnaryOp<__acos_expr<typename _Expr::value_type>, _Expr> > 4578 >::type 4579 acos(const _Expr& __x) 4580 { 4581 typedef typename _Expr::value_type value_type; 4582 typedef _UnaryOp<__acos_expr<value_type>, _Expr> _Op; 4583 return __val_expr<_Op>(_Op(__acos_expr<value_type>(), __x)); 4584 } 4585 4586 template<class _Expr> 4587 inline _LIBCPP_INLINE_VISIBILITY 4588 typename enable_if 4589 < 4590 __is_val_expr<_Expr>::value, 4591 __val_expr<_UnaryOp<__asin_expr<typename _Expr::value_type>, _Expr> > 4592 >::type 4593 asin(const _Expr& __x) 4594 { 4595 typedef typename _Expr::value_type value_type; 4596 typedef _UnaryOp<__asin_expr<value_type>, _Expr> _Op; 4597 return __val_expr<_Op>(_Op(__asin_expr<value_type>(), __x)); 4598 } 4599 4600 template<class _Expr> 4601 inline _LIBCPP_INLINE_VISIBILITY 4602 typename enable_if 4603 < 4604 __is_val_expr<_Expr>::value, 4605 __val_expr<_UnaryOp<__atan_expr<typename _Expr::value_type>, _Expr> > 4606 >::type 4607 atan(const _Expr& __x) 4608 { 4609 typedef typename _Expr::value_type value_type; 4610 typedef _UnaryOp<__atan_expr<value_type>, _Expr> _Op; 4611 return __val_expr<_Op>(_Op(__atan_expr<value_type>(), __x)); 4612 } 4613 4614 template<class _Expr1, class _Expr2> 4615 inline _LIBCPP_INLINE_VISIBILITY 4616 typename enable_if 4617 < 4618 __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, 4619 __val_expr<_BinaryOp<__atan2_expr<typename _Expr1::value_type>, _Expr1, _Expr2> > 4620 >::type 4621 atan2(const _Expr1& __x, const _Expr2& __y) 4622 { 4623 typedef typename _Expr1::value_type value_type; 4624 typedef _BinaryOp<__atan2_expr<value_type>, _Expr1, _Expr2> _Op; 4625 return __val_expr<_Op>(_Op(__atan2_expr<value_type>(), __x, __y)); 4626 } 4627 4628 template<class _Expr> 4629 inline _LIBCPP_INLINE_VISIBILITY 4630 typename enable_if 4631 < 4632 __is_val_expr<_Expr>::value, 4633 __val_expr<_BinaryOp<__atan2_expr<typename _Expr::value_type>, 4634 _Expr, __scalar_expr<typename _Expr::value_type> > > 4635 >::type 4636 atan2(const _Expr& __x, const typename _Expr::value_type& __y) 4637 { 4638 typedef typename _Expr::value_type value_type; 4639 typedef _BinaryOp<__atan2_expr<value_type>, _Expr, __scalar_expr<value_type> > _Op; 4640 return __val_expr<_Op>(_Op(__atan2_expr<value_type>(), 4641 __x, __scalar_expr<value_type>(__y, __x.size()))); 4642 } 4643 4644 template<class _Expr> 4645 inline _LIBCPP_INLINE_VISIBILITY 4646 typename enable_if 4647 < 4648 __is_val_expr<_Expr>::value, 4649 __val_expr<_BinaryOp<__atan2_expr<typename _Expr::value_type>, 4650 __scalar_expr<typename _Expr::value_type>, _Expr> > 4651 >::type 4652 atan2(const typename _Expr::value_type& __x, const _Expr& __y) 4653 { 4654 typedef typename _Expr::value_type value_type; 4655 typedef _BinaryOp<__atan2_expr<value_type>, __scalar_expr<value_type>, _Expr> _Op; 4656 return __val_expr<_Op>(_Op(__atan2_expr<value_type>(), 4657 __scalar_expr<value_type>(__x, __y.size()), __y)); 4658 } 4659 4660 template<class _Expr> 4661 inline _LIBCPP_INLINE_VISIBILITY 4662 typename enable_if 4663 < 4664 __is_val_expr<_Expr>::value, 4665 __val_expr<_UnaryOp<__cos_expr<typename _Expr::value_type>, _Expr> > 4666 >::type 4667 cos(const _Expr& __x) 4668 { 4669 typedef typename _Expr::value_type value_type; 4670 typedef _UnaryOp<__cos_expr<value_type>, _Expr> _Op; 4671 return __val_expr<_Op>(_Op(__cos_expr<value_type>(), __x)); 4672 } 4673 4674 template<class _Expr> 4675 inline _LIBCPP_INLINE_VISIBILITY 4676 typename enable_if 4677 < 4678 __is_val_expr<_Expr>::value, 4679 __val_expr<_UnaryOp<__cosh_expr<typename _Expr::value_type>, _Expr> > 4680 >::type 4681 cosh(const _Expr& __x) 4682 { 4683 typedef typename _Expr::value_type value_type; 4684 typedef _UnaryOp<__cosh_expr<value_type>, _Expr> _Op; 4685 return __val_expr<_Op>(_Op(__cosh_expr<value_type>(), __x)); 4686 } 4687 4688 template<class _Expr> 4689 inline _LIBCPP_INLINE_VISIBILITY 4690 typename enable_if 4691 < 4692 __is_val_expr<_Expr>::value, 4693 __val_expr<_UnaryOp<__exp_expr<typename _Expr::value_type>, _Expr> > 4694 >::type 4695 exp(const _Expr& __x) 4696 { 4697 typedef typename _Expr::value_type value_type; 4698 typedef _UnaryOp<__exp_expr<value_type>, _Expr> _Op; 4699 return __val_expr<_Op>(_Op(__exp_expr<value_type>(), __x)); 4700 } 4701 4702 template<class _Expr> 4703 inline _LIBCPP_INLINE_VISIBILITY 4704 typename enable_if 4705 < 4706 __is_val_expr<_Expr>::value, 4707 __val_expr<_UnaryOp<__log_expr<typename _Expr::value_type>, _Expr> > 4708 >::type 4709 log(const _Expr& __x) 4710 { 4711 typedef typename _Expr::value_type value_type; 4712 typedef _UnaryOp<__log_expr<value_type>, _Expr> _Op; 4713 return __val_expr<_Op>(_Op(__log_expr<value_type>(), __x)); 4714 } 4715 4716 template<class _Expr> 4717 inline _LIBCPP_INLINE_VISIBILITY 4718 typename enable_if 4719 < 4720 __is_val_expr<_Expr>::value, 4721 __val_expr<_UnaryOp<__log10_expr<typename _Expr::value_type>, _Expr> > 4722 >::type 4723 log10(const _Expr& __x) 4724 { 4725 typedef typename _Expr::value_type value_type; 4726 typedef _UnaryOp<__log10_expr<value_type>, _Expr> _Op; 4727 return __val_expr<_Op>(_Op(__log10_expr<value_type>(), __x)); 4728 } 4729 4730 template<class _Expr1, class _Expr2> 4731 inline _LIBCPP_INLINE_VISIBILITY 4732 typename enable_if 4733 < 4734 __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, 4735 __val_expr<_BinaryOp<__pow_expr<typename _Expr1::value_type>, _Expr1, _Expr2> > 4736 >::type 4737 pow(const _Expr1& __x, const _Expr2& __y) 4738 { 4739 typedef typename _Expr1::value_type value_type; 4740 typedef _BinaryOp<__pow_expr<value_type>, _Expr1, _Expr2> _Op; 4741 return __val_expr<_Op>(_Op(__pow_expr<value_type>(), __x, __y)); 4742 } 4743 4744 template<class _Expr> 4745 inline _LIBCPP_INLINE_VISIBILITY 4746 typename enable_if 4747 < 4748 __is_val_expr<_Expr>::value, 4749 __val_expr<_BinaryOp<__pow_expr<typename _Expr::value_type>, 4750 _Expr, __scalar_expr<typename _Expr::value_type> > > 4751 >::type 4752 pow(const _Expr& __x, const typename _Expr::value_type& __y) 4753 { 4754 typedef typename _Expr::value_type value_type; 4755 typedef _BinaryOp<__pow_expr<value_type>, _Expr, __scalar_expr<value_type> > _Op; 4756 return __val_expr<_Op>(_Op(__pow_expr<value_type>(), 4757 __x, __scalar_expr<value_type>(__y, __x.size()))); 4758 } 4759 4760 template<class _Expr> 4761 inline _LIBCPP_INLINE_VISIBILITY 4762 typename enable_if 4763 < 4764 __is_val_expr<_Expr>::value, 4765 __val_expr<_BinaryOp<__pow_expr<typename _Expr::value_type>, 4766 __scalar_expr<typename _Expr::value_type>, _Expr> > 4767 >::type 4768 pow(const typename _Expr::value_type& __x, const _Expr& __y) 4769 { 4770 typedef typename _Expr::value_type value_type; 4771 typedef _BinaryOp<__pow_expr<value_type>, __scalar_expr<value_type>, _Expr> _Op; 4772 return __val_expr<_Op>(_Op(__pow_expr<value_type>(), 4773 __scalar_expr<value_type>(__x, __y.size()), __y)); 4774 } 4775 4776 template<class _Expr> 4777 inline _LIBCPP_INLINE_VISIBILITY 4778 typename enable_if 4779 < 4780 __is_val_expr<_Expr>::value, 4781 __val_expr<_UnaryOp<__sin_expr<typename _Expr::value_type>, _Expr> > 4782 >::type 4783 sin(const _Expr& __x) 4784 { 4785 typedef typename _Expr::value_type value_type; 4786 typedef _UnaryOp<__sin_expr<value_type>, _Expr> _Op; 4787 return __val_expr<_Op>(_Op(__sin_expr<value_type>(), __x)); 4788 } 4789 4790 template<class _Expr> 4791 inline _LIBCPP_INLINE_VISIBILITY 4792 typename enable_if 4793 < 4794 __is_val_expr<_Expr>::value, 4795 __val_expr<_UnaryOp<__sinh_expr<typename _Expr::value_type>, _Expr> > 4796 >::type 4797 sinh(const _Expr& __x) 4798 { 4799 typedef typename _Expr::value_type value_type; 4800 typedef _UnaryOp<__sinh_expr<value_type>, _Expr> _Op; 4801 return __val_expr<_Op>(_Op(__sinh_expr<value_type>(), __x)); 4802 } 4803 4804 template<class _Expr> 4805 inline _LIBCPP_INLINE_VISIBILITY 4806 typename enable_if 4807 < 4808 __is_val_expr<_Expr>::value, 4809 __val_expr<_UnaryOp<__sqrt_expr<typename _Expr::value_type>, _Expr> > 4810 >::type 4811 sqrt(const _Expr& __x) 4812 { 4813 typedef typename _Expr::value_type value_type; 4814 typedef _UnaryOp<__sqrt_expr<value_type>, _Expr> _Op; 4815 return __val_expr<_Op>(_Op(__sqrt_expr<value_type>(), __x)); 4816 } 4817 4818 template<class _Expr> 4819 inline _LIBCPP_INLINE_VISIBILITY 4820 typename enable_if 4821 < 4822 __is_val_expr<_Expr>::value, 4823 __val_expr<_UnaryOp<__tan_expr<typename _Expr::value_type>, _Expr> > 4824 >::type 4825 tan(const _Expr& __x) 4826 { 4827 typedef typename _Expr::value_type value_type; 4828 typedef _UnaryOp<__tan_expr<value_type>, _Expr> _Op; 4829 return __val_expr<_Op>(_Op(__tan_expr<value_type>(), __x)); 4830 } 4831 4832 template<class _Expr> 4833 inline _LIBCPP_INLINE_VISIBILITY 4834 typename enable_if 4835 < 4836 __is_val_expr<_Expr>::value, 4837 __val_expr<_UnaryOp<__tanh_expr<typename _Expr::value_type>, _Expr> > 4838 >::type 4839 tanh(const _Expr& __x) 4840 { 4841 typedef typename _Expr::value_type value_type; 4842 typedef _UnaryOp<__tanh_expr<value_type>, _Expr> _Op; 4843 return __val_expr<_Op>(_Op(__tanh_expr<value_type>(), __x)); 4844 } 4845 4846 template <class _Tp> 4847 inline _LIBCPP_INLINE_VISIBILITY 4848 _Tp* 4849 begin(valarray<_Tp>& __v) 4850 { 4851 return __v.__begin_; 4852 } 4853 4854 template <class _Tp> 4855 inline _LIBCPP_INLINE_VISIBILITY 4856 const _Tp* 4857 begin(const valarray<_Tp>& __v) 4858 { 4859 return __v.__begin_; 4860 } 4861 4862 template <class _Tp> 4863 inline _LIBCPP_INLINE_VISIBILITY 4864 _Tp* 4865 end(valarray<_Tp>& __v) 4866 { 4867 return __v.__end_; 4868 } 4869 4870 template <class _Tp> 4871 inline _LIBCPP_INLINE_VISIBILITY 4872 const _Tp* 4873 end(const valarray<_Tp>& __v) 4874 { 4875 return __v.__end_; 4876 } 4877 4878 _LIBCPP_END_NAMESPACE_STD 4879 4880 #endif // _LIBCPP_VALARRAY 4881
