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