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