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