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