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