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 friend bool operator==(const slice& x, const slice& y); // since C++20 121}; 122 123template <class T> 124class slice_array 125{ 126public: 127 typedef T value_type; 128 129 const slice_array& operator=(const slice_array& sa) 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 void operator<<=(const valarray<value_type>& v) const; 140 void operator>>=(const valarray<value_type>& v) const; 141 142 void operator=(const value_type& x) const; 143 void operator=(const valarray<T>& val_arr) const; 144 145 slice_array() = delete; 146}; 147 148class gslice 149{ 150public: 151 gslice(); 152 gslice(size_t start, const valarray<size_t>& size, 153 const valarray<size_t>& stride); 154 155 size_t start() const; 156 valarray<size_t> size() const; 157 valarray<size_t> stride() const; 158}; 159 160template <class T> 161class gslice_array 162{ 163public: 164 typedef T value_type; 165 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 void operator<<=(const valarray<value_type>& v) const; 176 void operator>>=(const valarray<value_type>& v) const; 177 178 gslice_array(const gslice_array& ga); 179 ~gslice_array(); 180 const gslice_array& operator=(const gslice_array& ga) const; 181 void operator=(const value_type& x) const; 182 183 gslice_array() = delete; 184}; 185 186template <class T> 187class mask_array 188{ 189public: 190 typedef T value_type; 191 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 void operator<<=(const valarray<value_type>& v) const; 202 void operator>>=(const valarray<value_type>& v) const; 203 204 mask_array(const mask_array& ma); 205 ~mask_array(); 206 const mask_array& operator=(const mask_array& ma) const; 207 void operator=(const value_type& x) const; 208 209 mask_array() = delete; 210}; 211 212template <class T> 213class indirect_array 214{ 215public: 216 typedef T value_type; 217 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 void operator<<=(const valarray<value_type>& v) const; 228 void operator>>=(const valarray<value_type>& v) const; 229 230 indirect_array(const indirect_array& ia); 231 ~indirect_array(); 232 const indirect_array& operator=(const indirect_array& ia) const; 233 void operator=(const value_type& x) const; 234 235 indirect_array() = delete; 236}; 237 238template<class T> void swap(valarray<T>& x, valarray<T>& y) noexcept; 239 240template<class T> valarray<T> operator* (const valarray<T>& x, const valarray<T>& y); 241template<class T> valarray<T> operator* (const valarray<T>& x, const T& y); 242template<class T> valarray<T> operator* (const T& x, const valarray<T>& y); 243 244template<class T> valarray<T> operator/ (const valarray<T>& x, const valarray<T>& y); 245template<class T> valarray<T> operator/ (const valarray<T>& x, const T& y); 246template<class T> valarray<T> operator/ (const T& x, const valarray<T>& y); 247 248template<class T> valarray<T> operator% (const valarray<T>& x, const valarray<T>& y); 249template<class T> valarray<T> operator% (const valarray<T>& x, const T& y); 250template<class T> valarray<T> operator% (const T& x, const valarray<T>& y); 251 252template<class T> valarray<T> operator+ (const valarray<T>& x, const valarray<T>& y); 253template<class T> valarray<T> operator+ (const valarray<T>& x, const T& y); 254template<class T> valarray<T> operator+ (const T& x, const valarray<T>& y); 255 256template<class T> valarray<T> operator- (const valarray<T>& x, const valarray<T>& y); 257template<class T> valarray<T> operator- (const valarray<T>& x, const T& y); 258template<class T> valarray<T> operator- (const T& x, const valarray<T>& y); 259 260template<class T> valarray<T> operator^ (const valarray<T>& x, const valarray<T>& y); 261template<class T> valarray<T> operator^ (const valarray<T>& x, const T& y); 262template<class T> valarray<T> operator^ (const T& x, const valarray<T>& y); 263 264template<class T> valarray<T> operator& (const valarray<T>& x, const valarray<T>& y); 265template<class T> valarray<T> operator& (const valarray<T>& x, const T& y); 266template<class T> valarray<T> operator& (const T& x, const valarray<T>& y); 267 268template<class T> valarray<T> operator| (const valarray<T>& x, const valarray<T>& y); 269template<class T> valarray<T> operator| (const valarray<T>& x, const T& y); 270template<class T> valarray<T> operator| (const T& x, const valarray<T>& y); 271 272template<class T> valarray<T> operator<<(const valarray<T>& x, const valarray<T>& y); 273template<class T> valarray<T> operator<<(const valarray<T>& x, const T& y); 274template<class T> valarray<T> operator<<(const T& x, const valarray<T>& y); 275 276template<class T> valarray<T> operator>>(const valarray<T>& x, const valarray<T>& y); 277template<class T> valarray<T> operator>>(const valarray<T>& x, const T& y); 278template<class T> valarray<T> operator>>(const T& x, const valarray<T>& y); 279 280template<class T> valarray<bool> operator&&(const valarray<T>& x, const valarray<T>& y); 281template<class T> valarray<bool> operator&&(const valarray<T>& x, const T& y); 282template<class T> valarray<bool> operator&&(const T& x, const valarray<T>& y); 283 284template<class T> valarray<bool> operator||(const valarray<T>& x, const valarray<T>& y); 285template<class T> valarray<bool> operator||(const valarray<T>& x, const T& y); 286template<class T> valarray<bool> operator||(const T& x, const valarray<T>& y); 287 288template<class T> valarray<bool> operator==(const valarray<T>& x, const valarray<T>& y); 289template<class T> valarray<bool> operator==(const valarray<T>& x, const T& y); 290template<class T> valarray<bool> operator==(const T& x, const valarray<T>& y); 291 292template<class T> valarray<bool> operator!=(const valarray<T>& x, const valarray<T>& y); 293template<class T> valarray<bool> operator!=(const valarray<T>& x, const T& y); 294template<class T> valarray<bool> operator!=(const T& x, const valarray<T>& y); 295 296template<class T> valarray<bool> operator< (const valarray<T>& x, const valarray<T>& y); 297template<class T> valarray<bool> operator< (const valarray<T>& x, const T& y); 298template<class T> valarray<bool> operator< (const T& x, const valarray<T>& y); 299 300template<class T> valarray<bool> operator> (const valarray<T>& x, const valarray<T>& y); 301template<class T> valarray<bool> operator> (const valarray<T>& x, const T& y); 302template<class T> valarray<bool> operator> (const T& x, const valarray<T>& y); 303 304template<class T> valarray<bool> operator<=(const valarray<T>& x, const valarray<T>& y); 305template<class T> valarray<bool> operator<=(const valarray<T>& x, const T& y); 306template<class T> valarray<bool> operator<=(const T& x, const valarray<T>& y); 307 308template<class T> valarray<bool> operator>=(const valarray<T>& x, const valarray<T>& y); 309template<class T> valarray<bool> operator>=(const valarray<T>& x, const T& y); 310template<class T> valarray<bool> operator>=(const T& x, const valarray<T>& y); 311 312template<class T> valarray<T> abs (const valarray<T>& x); 313template<class T> valarray<T> acos (const valarray<T>& x); 314template<class T> valarray<T> asin (const valarray<T>& x); 315template<class T> valarray<T> atan (const valarray<T>& x); 316 317template<class T> valarray<T> atan2(const valarray<T>& x, const valarray<T>& y); 318template<class T> valarray<T> atan2(const valarray<T>& x, const T& y); 319template<class T> valarray<T> atan2(const T& x, const valarray<T>& y); 320 321template<class T> valarray<T> cos (const valarray<T>& x); 322template<class T> valarray<T> cosh (const valarray<T>& x); 323template<class T> valarray<T> exp (const valarray<T>& x); 324template<class T> valarray<T> log (const valarray<T>& x); 325template<class T> valarray<T> log10(const valarray<T>& x); 326 327template<class T> valarray<T> pow(const valarray<T>& x, const valarray<T>& y); 328template<class T> valarray<T> pow(const valarray<T>& x, const T& y); 329template<class T> valarray<T> pow(const T& x, const valarray<T>& y); 330 331template<class T> valarray<T> sin (const valarray<T>& x); 332template<class T> valarray<T> sinh (const valarray<T>& x); 333template<class T> valarray<T> sqrt (const valarray<T>& x); 334template<class T> valarray<T> tan (const valarray<T>& x); 335template<class T> valarray<T> tanh (const valarray<T>& x); 336 337template <class T> unspecified1 begin(valarray<T>& v); 338template <class T> unspecified2 begin(const valarray<T>& v); 339template <class T> unspecified1 end(valarray<T>& v); 340template <class T> unspecified2 end(const valarray<T>& v); 341 342} // std 343 344*/ 345 346#include <__algorithm/copy.h> 347#include <__algorithm/count.h> 348#include <__algorithm/fill.h> 349#include <__algorithm/max_element.h> 350#include <__algorithm/min.h> 351#include <__algorithm/min_element.h> 352#include <__algorithm/unwrap_iter.h> 353#include <__assert> 354#include <__config> 355#include <__functional/operations.h> 356#include <__memory/addressof.h> 357#include <__memory/allocator.h> 358#include <__memory/uninitialized_algorithms.h> 359#include <__type_traits/decay.h> 360#include <__type_traits/remove_reference.h> 361#include <__utility/move.h> 362#include <__utility/swap.h> 363#include <cmath> 364#include <cstddef> 365#include <new> 366#include <version> 367 368// standard-mandated includes 369 370// [valarray.syn] 371#include <initializer_list> 372 373#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) 374# pragma GCC system_header 375#endif 376 377_LIBCPP_PUSH_MACROS 378#include <__undef_macros> 379 380_LIBCPP_BEGIN_NAMESPACE_STD 381 382template <class _Tp> 383class _LIBCPP_TEMPLATE_VIS valarray; 384 385class _LIBCPP_TEMPLATE_VIS slice { 386 size_t __start_; 387 size_t __size_; 388 size_t __stride_; 389 390public: 391 _LIBCPP_HIDE_FROM_ABI slice() : __start_(0), __size_(0), __stride_(0) {} 392 393 _LIBCPP_HIDE_FROM_ABI slice(size_t __start, size_t __size, size_t __stride) 394 : __start_(__start), __size_(__size), __stride_(__stride) {} 395 396 _LIBCPP_HIDE_FROM_ABI size_t start() const { return __start_; } 397 _LIBCPP_HIDE_FROM_ABI size_t size() const { return __size_; } 398 _LIBCPP_HIDE_FROM_ABI size_t stride() const { return __stride_; } 399 400#if _LIBCPP_STD_VER >= 20 401 402 _LIBCPP_HIDE_FROM_ABI friend bool operator==(const slice& __x, const slice& __y) { 403 return __x.start() == __y.start() && __x.size() == __y.size() && __x.stride() == __y.stride(); 404 } 405 406#endif 407}; 408 409template <class _Tp> 410class _LIBCPP_TEMPLATE_VIS slice_array; 411class _LIBCPP_EXPORTED_FROM_ABI gslice; 412template <class _Tp> 413class _LIBCPP_TEMPLATE_VIS gslice_array; 414template <class _Tp> 415class _LIBCPP_TEMPLATE_VIS mask_array; 416template <class _Tp> 417class _LIBCPP_TEMPLATE_VIS indirect_array; 418 419template <class _Tp> 420_LIBCPP_HIDE_FROM_ABI _Tp* begin(valarray<_Tp>& __v); 421 422template <class _Tp> 423_LIBCPP_HIDE_FROM_ABI const _Tp* begin(const valarray<_Tp>& __v); 424 425template <class _Tp> 426_LIBCPP_HIDE_FROM_ABI _Tp* end(valarray<_Tp>& __v); 427 428template <class _Tp> 429_LIBCPP_HIDE_FROM_ABI const _Tp* end(const valarray<_Tp>& __v); 430 431template <class _Op, class _A0> 432struct _UnaryOp { 433 typedef typename _Op::__result_type __result_type; 434 using value_type = __decay_t<__result_type>; 435 436 _Op __op_; 437 _A0 __a0_; 438 439 _LIBCPP_HIDE_FROM_ABI _UnaryOp(const _Op& __op, const _A0& __a0) : __op_(__op), __a0_(__a0) {} 440 441 _LIBCPP_HIDE_FROM_ABI __result_type operator[](size_t __i) const { return __op_(__a0_[__i]); } 442 443 _LIBCPP_HIDE_FROM_ABI size_t size() const { return __a0_.size(); } 444}; 445 446template <class _Op, class _A0, class _A1> 447struct _BinaryOp { 448 typedef typename _Op::__result_type __result_type; 449 using value_type = __decay_t<__result_type>; 450 451 _Op __op_; 452 _A0 __a0_; 453 _A1 __a1_; 454 455 _LIBCPP_HIDE_FROM_ABI _BinaryOp(const _Op& __op, const _A0& __a0, const _A1& __a1) 456 : __op_(__op), __a0_(__a0), __a1_(__a1) {} 457 458 _LIBCPP_HIDE_FROM_ABI __result_type operator[](size_t __i) const { return __op_(__a0_[__i], __a1_[__i]); } 459 460 _LIBCPP_HIDE_FROM_ABI size_t size() const { return __a0_.size(); } 461}; 462 463template <class _Tp> 464class __scalar_expr { 465public: 466 typedef _Tp value_type; 467 typedef const _Tp& __result_type; 468 469private: 470 const value_type& __t_; 471 size_t __s_; 472 473public: 474 _LIBCPP_HIDE_FROM_ABI explicit __scalar_expr(const value_type& __t, size_t __s) : __t_(__t), __s_(__s) {} 475 476 _LIBCPP_HIDE_FROM_ABI __result_type operator[](size_t) const { return __t_; } 477 478 _LIBCPP_HIDE_FROM_ABI size_t size() const { return __s_; } 479}; 480 481template <class _Tp> 482struct __unary_plus { 483 typedef _Tp __result_type; 484 _LIBCPP_HIDE_FROM_ABI _Tp operator()(const _Tp& __x) const { return +__x; } 485}; 486 487template <class _Tp> 488struct __bit_not { 489 typedef _Tp __result_type; 490 _LIBCPP_HIDE_FROM_ABI _Tp operator()(const _Tp& __x) const { return ~__x; } 491}; 492 493template <class _Tp> 494struct __bit_shift_left { 495 typedef _Tp __result_type; 496 _LIBCPP_HIDE_FROM_ABI _Tp operator()(const _Tp& __x, const _Tp& __y) const { return __x << __y; } 497}; 498 499template <class _Tp> 500struct __bit_shift_right { 501 typedef _Tp __result_type; 502 _LIBCPP_HIDE_FROM_ABI _Tp operator()(const _Tp& __x, const _Tp& __y) const { return __x >> __y; } 503}; 504 505template <class _Tp, class _Fp> 506struct __apply_expr { 507private: 508 _Fp __f_; 509 510public: 511 typedef _Tp __result_type; 512 513 _LIBCPP_HIDE_FROM_ABI explicit __apply_expr(_Fp __f) : __f_(__f) {} 514 515 _LIBCPP_HIDE_FROM_ABI _Tp operator()(const _Tp& __x) const { return __f_(__x); } 516}; 517 518template <class _Tp> 519struct __abs_expr { 520 typedef _Tp __result_type; 521 _LIBCPP_HIDE_FROM_ABI _Tp operator()(const _Tp& __x) const { return std::abs(__x); } 522}; 523 524template <class _Tp> 525struct __acos_expr { 526 typedef _Tp __result_type; 527 _LIBCPP_HIDE_FROM_ABI _Tp operator()(const _Tp& __x) const { return std::acos(__x); } 528}; 529 530template <class _Tp> 531struct __asin_expr { 532 typedef _Tp __result_type; 533 _LIBCPP_HIDE_FROM_ABI _Tp operator()(const _Tp& __x) const { return std::asin(__x); } 534}; 535 536template <class _Tp> 537struct __atan_expr { 538 typedef _Tp __result_type; 539 _LIBCPP_HIDE_FROM_ABI _Tp operator()(const _Tp& __x) const { return std::atan(__x); } 540}; 541 542template <class _Tp> 543struct __atan2_expr { 544 typedef _Tp __result_type; 545 _LIBCPP_HIDE_FROM_ABI _Tp operator()(const _Tp& __x, const _Tp& __y) const { return std::atan2(__x, __y); } 546}; 547 548template <class _Tp> 549struct __cos_expr { 550 typedef _Tp __result_type; 551 _LIBCPP_HIDE_FROM_ABI _Tp operator()(const _Tp& __x) const { return std::cos(__x); } 552}; 553 554template <class _Tp> 555struct __cosh_expr { 556 typedef _Tp __result_type; 557 _LIBCPP_HIDE_FROM_ABI _Tp operator()(const _Tp& __x) const { return std::cosh(__x); } 558}; 559 560template <class _Tp> 561struct __exp_expr { 562 typedef _Tp __result_type; 563 _LIBCPP_HIDE_FROM_ABI _Tp operator()(const _Tp& __x) const { return std::exp(__x); } 564}; 565 566template <class _Tp> 567struct __log_expr { 568 typedef _Tp __result_type; 569 _LIBCPP_HIDE_FROM_ABI _Tp operator()(const _Tp& __x) const { return std::log(__x); } 570}; 571 572template <class _Tp> 573struct __log10_expr { 574 typedef _Tp __result_type; 575 _LIBCPP_HIDE_FROM_ABI _Tp operator()(const _Tp& __x) const { return std::log10(__x); } 576}; 577 578template <class _Tp> 579struct __pow_expr { 580 typedef _Tp __result_type; 581 _LIBCPP_HIDE_FROM_ABI _Tp operator()(const _Tp& __x, const _Tp& __y) const { return std::pow(__x, __y); } 582}; 583 584template <class _Tp> 585struct __sin_expr { 586 typedef _Tp __result_type; 587 _LIBCPP_HIDE_FROM_ABI _Tp operator()(const _Tp& __x) const { return std::sin(__x); } 588}; 589 590template <class _Tp> 591struct __sinh_expr { 592 typedef _Tp __result_type; 593 _LIBCPP_HIDE_FROM_ABI _Tp operator()(const _Tp& __x) const { return std::sinh(__x); } 594}; 595 596template <class _Tp> 597struct __sqrt_expr { 598 typedef _Tp __result_type; 599 _LIBCPP_HIDE_FROM_ABI _Tp operator()(const _Tp& __x) const { return std::sqrt(__x); } 600}; 601 602template <class _Tp> 603struct __tan_expr { 604 typedef _Tp __result_type; 605 _LIBCPP_HIDE_FROM_ABI _Tp operator()(const _Tp& __x) const { return std::tan(__x); } 606}; 607 608template <class _Tp> 609struct __tanh_expr { 610 typedef _Tp __result_type; 611 _LIBCPP_HIDE_FROM_ABI _Tp operator()(const _Tp& __x) const { return std::tanh(__x); } 612}; 613 614template <class _ValExpr> 615class __slice_expr { 616 typedef __libcpp_remove_reference_t<_ValExpr> _RmExpr; 617 618public: 619 typedef typename _RmExpr::value_type value_type; 620 typedef value_type __result_type; 621 622private: 623 _ValExpr __expr_; 624 size_t __start_; 625 size_t __size_; 626 size_t __stride_; 627 628 _LIBCPP_HIDE_FROM_ABI __slice_expr(const slice& __sl, const _RmExpr& __e) 629 : __expr_(__e), __start_(__sl.start()), __size_(__sl.size()), __stride_(__sl.stride()) {} 630 631public: 632 _LIBCPP_HIDE_FROM_ABI __result_type operator[](size_t __i) const { return __expr_[__start_ + __i * __stride_]; } 633 634 _LIBCPP_HIDE_FROM_ABI size_t size() const { return __size_; } 635 636 template <class> 637 friend class __val_expr; 638 template <class> 639 friend class _LIBCPP_TEMPLATE_VIS valarray; 640}; 641 642template <class _ValExpr> 643class __mask_expr; 644 645template <class _ValExpr> 646class __indirect_expr; 647 648template <class _ValExpr> 649class __shift_expr { 650 typedef __libcpp_remove_reference_t<_ValExpr> _RmExpr; 651 652public: 653 typedef typename _RmExpr::value_type value_type; 654 typedef value_type __result_type; 655 656private: 657 _ValExpr __expr_; 658 size_t __size_; 659 ptrdiff_t __ul_; 660 ptrdiff_t __sn_; 661 ptrdiff_t __n_; 662 static const ptrdiff_t _Np = static_cast<ptrdiff_t>(sizeof(ptrdiff_t) * __CHAR_BIT__ - 1); 663 664 _LIBCPP_HIDE_FROM_ABI __shift_expr(int __n, const _RmExpr& __e) : __expr_(__e), __size_(__e.size()), __n_(__n) { 665 ptrdiff_t __neg_n = static_cast<ptrdiff_t>(__n_ >> _Np); 666 __sn_ = __neg_n | static_cast<ptrdiff_t>(static_cast<size_t>(-__n_) >> _Np); 667 __ul_ = ((__size_ - __n_) & ~__neg_n) | ((__n_ + 1) & __neg_n); 668 } 669 670public: 671 _LIBCPP_HIDE_FROM_ABI __result_type operator[](size_t __j) const { 672 ptrdiff_t __i = static_cast<ptrdiff_t>(__j); 673 ptrdiff_t __m = (__sn_ * __i - __ul_) >> _Np; 674 return (__expr_[(__i + __n_) & __m] & __m) | (value_type() & ~__m); 675 } 676 677 _LIBCPP_HIDE_FROM_ABI size_t size() const { return __size_; } 678 679 template <class> 680 friend class __val_expr; 681}; 682 683template <class _ValExpr> 684class __cshift_expr { 685 typedef __libcpp_remove_reference_t<_ValExpr> _RmExpr; 686 687public: 688 typedef typename _RmExpr::value_type value_type; 689 typedef value_type __result_type; 690 691private: 692 _ValExpr __expr_; 693 size_t __size_; 694 size_t __m_; 695 size_t __o1_; 696 size_t __o2_; 697 698 _LIBCPP_HIDE_FROM_ABI __cshift_expr(int __n, const _RmExpr& __e) : __expr_(__e), __size_(__e.size()) { 699 __n %= static_cast<int>(__size_); 700 if (__n >= 0) { 701 __m_ = __size_ - __n; 702 __o1_ = __n; 703 __o2_ = __n - __size_; 704 } else { 705 __m_ = -__n; 706 __o1_ = __n + __size_; 707 __o2_ = __n; 708 } 709 } 710 711public: 712 _LIBCPP_HIDE_FROM_ABI __result_type operator[](size_t __i) const { 713 if (__i < __m_) 714 return __expr_[__i + __o1_]; 715 return __expr_[__i + __o2_]; 716 } 717 718 _LIBCPP_HIDE_FROM_ABI size_t size() const { return __size_; } 719 720 template <class> 721 friend class __val_expr; 722}; 723 724template <class _ValExpr> 725class __val_expr; 726 727template <class _ValExpr> 728struct __is_val_expr : false_type {}; 729 730template <class _ValExpr> 731struct __is_val_expr<__val_expr<_ValExpr> > : true_type {}; 732 733template <class _Tp> 734struct __is_val_expr<valarray<_Tp> > : true_type {}; 735 736template <class _Tp> 737struct __is_val_expr<slice_array<_Tp> > : true_type {}; 738 739template <class _Tp> 740struct __is_val_expr<gslice_array<_Tp> > : true_type {}; 741 742template <class _Tp> 743struct __is_val_expr<mask_array<_Tp> > : true_type {}; 744 745template <class _Tp> 746struct __is_val_expr<indirect_array<_Tp> > : true_type {}; 747 748// The functions using a __val_expr access the elements by their index. 749// valarray and the libc++ lazy proxies have an operator[]. The 750// Standard proxy array's don't have this operator, instead they have a 751// implementation specific accessor 752// __get(size_t) 753// 754// The functions use the non-member function 755// __get(__val_expr, size_t) 756// 757// If the __val_expr is a specialization of __val_expr_use_member_functions it 758// uses the __val_expr's member function 759// __get(size_t) 760// else it uses the __val_expr's member function 761// operator[](size_t) 762template <class _ValExpr> 763struct __val_expr_use_member_functions; 764 765template <class> 766struct __val_expr_use_member_functions : false_type {}; 767 768template <class _Tp> 769struct __val_expr_use_member_functions<slice_array<_Tp> > : true_type {}; 770 771template <class _Tp> 772struct __val_expr_use_member_functions<gslice_array<_Tp> > : true_type {}; 773 774template <class _Tp> 775struct __val_expr_use_member_functions<mask_array<_Tp> > : true_type {}; 776 777template <class _Tp> 778struct __val_expr_use_member_functions<indirect_array<_Tp> > : true_type {}; 779 780template <class _Tp> 781class _LIBCPP_TEMPLATE_VIS valarray { 782public: 783 typedef _Tp value_type; 784 typedef _Tp __result_type; 785 786private: 787 value_type* __begin_; 788 value_type* __end_; 789 790public: 791 // construct/destroy: 792 _LIBCPP_HIDE_FROM_ABI valarray() : __begin_(nullptr), __end_(nullptr) {} 793 inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 explicit valarray(size_t __n); 794 _LIBCPP_HIDE_FROM_ABI valarray(const value_type& __x, size_t __n); 795 valarray(const value_type* __p, size_t __n); 796 valarray(const valarray& __v); 797#ifndef _LIBCPP_CXX03_LANG 798 _LIBCPP_HIDE_FROM_ABI valarray(valarray&& __v) _NOEXCEPT; 799 valarray(initializer_list<value_type> __il); 800#endif // _LIBCPP_CXX03_LANG 801 valarray(const slice_array<value_type>& __sa); 802 valarray(const gslice_array<value_type>& __ga); 803 valarray(const mask_array<value_type>& __ma); 804 valarray(const indirect_array<value_type>& __ia); 805 inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 ~valarray(); 806 807 // assignment: 808 valarray& operator=(const valarray& __v); 809#ifndef _LIBCPP_CXX03_LANG 810 _LIBCPP_HIDE_FROM_ABI valarray& operator=(valarray&& __v) _NOEXCEPT; 811 _LIBCPP_HIDE_FROM_ABI valarray& operator=(initializer_list<value_type>); 812#endif // _LIBCPP_CXX03_LANG 813 _LIBCPP_HIDE_FROM_ABI valarray& operator=(const value_type& __x); 814 _LIBCPP_HIDE_FROM_ABI valarray& operator=(const slice_array<value_type>& __sa); 815 _LIBCPP_HIDE_FROM_ABI valarray& operator=(const gslice_array<value_type>& __ga); 816 _LIBCPP_HIDE_FROM_ABI valarray& operator=(const mask_array<value_type>& __ma); 817 _LIBCPP_HIDE_FROM_ABI valarray& operator=(const indirect_array<value_type>& __ia); 818 template <class _ValExpr> 819 _LIBCPP_HIDE_FROM_ABI valarray& operator=(const __val_expr<_ValExpr>& __v); 820 821 // element access: 822 _LIBCPP_HIDE_FROM_ABI const value_type& operator[](size_t __i) const { return __begin_[__i]; } 823 824 _LIBCPP_HIDE_FROM_ABI value_type& operator[](size_t __i) { return __begin_[__i]; } 825 826 // subset operations: 827 _LIBCPP_HIDE_FROM_ABI __val_expr<__slice_expr<const valarray&> > operator[](slice __s) const; 828 _LIBCPP_HIDE_FROM_ABI slice_array<value_type> operator[](slice __s); 829 _LIBCPP_HIDE_FROM_ABI __val_expr<__indirect_expr<const valarray&> > operator[](const gslice& __gs) const; 830 _LIBCPP_HIDE_FROM_ABI gslice_array<value_type> operator[](const gslice& __gs); 831#ifndef _LIBCPP_CXX03_LANG 832 _LIBCPP_HIDE_FROM_ABI __val_expr<__indirect_expr<const valarray&> > operator[](gslice&& __gs) const; 833 _LIBCPP_HIDE_FROM_ABI gslice_array<value_type> operator[](gslice&& __gs); 834#endif // _LIBCPP_CXX03_LANG 835 _LIBCPP_HIDE_FROM_ABI __val_expr<__mask_expr<const valarray&> > operator[](const valarray<bool>& __vb) const; 836 _LIBCPP_HIDE_FROM_ABI mask_array<value_type> operator[](const valarray<bool>& __vb); 837#ifndef _LIBCPP_CXX03_LANG 838 _LIBCPP_HIDE_FROM_ABI __val_expr<__mask_expr<const valarray&> > operator[](valarray<bool>&& __vb) const; 839 _LIBCPP_HIDE_FROM_ABI mask_array<value_type> operator[](valarray<bool>&& __vb); 840#endif // _LIBCPP_CXX03_LANG 841 _LIBCPP_HIDE_FROM_ABI __val_expr<__indirect_expr<const valarray&> > operator[](const valarray<size_t>& __vs) const; 842 _LIBCPP_HIDE_FROM_ABI indirect_array<value_type> operator[](const valarray<size_t>& __vs); 843#ifndef _LIBCPP_CXX03_LANG 844 _LIBCPP_HIDE_FROM_ABI __val_expr<__indirect_expr<const valarray&> > operator[](valarray<size_t>&& __vs) const; 845 _LIBCPP_HIDE_FROM_ABI indirect_array<value_type> operator[](valarray<size_t>&& __vs); 846#endif // _LIBCPP_CXX03_LANG 847 848 // unary operators: 849 _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__unary_plus<_Tp>, const valarray&> > operator+() const; 850 _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<negate<_Tp>, const valarray&> > operator-() const; 851 _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__bit_not<_Tp>, const valarray&> > operator~() const; 852 _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<logical_not<_Tp>, const valarray&> > operator!() const; 853 854 // computed assignment: 855 _LIBCPP_HIDE_FROM_ABI valarray& operator*=(const value_type& __x); 856 _LIBCPP_HIDE_FROM_ABI valarray& operator/=(const value_type& __x); 857 _LIBCPP_HIDE_FROM_ABI valarray& operator%=(const value_type& __x); 858 _LIBCPP_HIDE_FROM_ABI valarray& operator+=(const value_type& __x); 859 _LIBCPP_HIDE_FROM_ABI valarray& operator-=(const value_type& __x); 860 _LIBCPP_HIDE_FROM_ABI valarray& operator^=(const value_type& __x); 861 _LIBCPP_HIDE_FROM_ABI valarray& operator&=(const value_type& __x); 862 _LIBCPP_HIDE_FROM_ABI valarray& operator|=(const value_type& __x); 863 _LIBCPP_HIDE_FROM_ABI valarray& operator<<=(const value_type& __x); 864 _LIBCPP_HIDE_FROM_ABI valarray& operator>>=(const value_type& __x); 865 866 template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 867 _LIBCPP_HIDE_FROM_ABI valarray& operator*=(const _Expr& __v); 868 869 template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 870 _LIBCPP_HIDE_FROM_ABI valarray& operator/=(const _Expr& __v); 871 872 template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 873 _LIBCPP_HIDE_FROM_ABI valarray& operator%=(const _Expr& __v); 874 875 template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 876 _LIBCPP_HIDE_FROM_ABI valarray& operator+=(const _Expr& __v); 877 878 template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 879 _LIBCPP_HIDE_FROM_ABI valarray& operator-=(const _Expr& __v); 880 881 template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 882 _LIBCPP_HIDE_FROM_ABI valarray& operator^=(const _Expr& __v); 883 884 template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 885 _LIBCPP_HIDE_FROM_ABI valarray& operator|=(const _Expr& __v); 886 887 template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 888 _LIBCPP_HIDE_FROM_ABI valarray& operator&=(const _Expr& __v); 889 890 template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 891 _LIBCPP_HIDE_FROM_ABI valarray& operator<<=(const _Expr& __v); 892 893 template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 894 _LIBCPP_HIDE_FROM_ABI valarray& operator>>=(const _Expr& __v); 895 896 // member functions: 897 _LIBCPP_HIDE_FROM_ABI void swap(valarray& __v) _NOEXCEPT; 898 899 _LIBCPP_HIDE_FROM_ABI size_t size() const { return static_cast<size_t>(__end_ - __begin_); } 900 901 _LIBCPP_HIDE_FROM_ABI value_type sum() const; 902 _LIBCPP_HIDE_FROM_ABI value_type min() const; 903 _LIBCPP_HIDE_FROM_ABI value_type max() const; 904 905 valarray shift(int __i) const; 906 valarray cshift(int __i) const; 907 valarray apply(value_type __f(value_type)) const; 908 valarray apply(value_type __f(const value_type&)) const; 909 void resize(size_t __n, value_type __x = value_type()); 910 911private: 912 template <class> 913 friend class _LIBCPP_TEMPLATE_VIS valarray; 914 template <class> 915 friend class _LIBCPP_TEMPLATE_VIS slice_array; 916 template <class> 917 friend class _LIBCPP_TEMPLATE_VIS gslice_array; 918 template <class> 919 friend class _LIBCPP_TEMPLATE_VIS mask_array; 920 template <class> 921 friend class __mask_expr; 922 template <class> 923 friend class _LIBCPP_TEMPLATE_VIS indirect_array; 924 template <class> 925 friend class __indirect_expr; 926 template <class> 927 friend class __val_expr; 928 929 template <class _Up> 930 friend _Up* begin(valarray<_Up>& __v); 931 932 template <class _Up> 933 friend const _Up* begin(const valarray<_Up>& __v); 934 935 template <class _Up> 936 friend _Up* end(valarray<_Up>& __v); 937 938 template <class _Up> 939 friend const _Up* end(const valarray<_Up>& __v); 940 941 _LIBCPP_HIDE_FROM_ABI void __clear(size_t __capacity); 942 valarray& __assign_range(const value_type* __f, const value_type* __l); 943}; 944 945#if _LIBCPP_STD_VER >= 17 946template <class _Tp, size_t _Size> 947valarray(const _Tp (&)[_Size], size_t) -> valarray<_Tp>; 948#endif 949 950template <class _Expr, 951 __enable_if_t<__is_val_expr<_Expr>::value && __val_expr_use_member_functions<_Expr>::value, int> = 0> 952_LIBCPP_HIDE_FROM_ABI typename _Expr::value_type __get(const _Expr& __v, size_t __i) { 953 return __v.__get(__i); 954} 955 956template <class _Expr, 957 __enable_if_t<__is_val_expr<_Expr>::value && !__val_expr_use_member_functions<_Expr>::value, int> = 0> 958_LIBCPP_HIDE_FROM_ABI typename _Expr::value_type __get(const _Expr& __v, size_t __i) { 959 return __v[__i]; 960} 961 962extern template _LIBCPP_EXPORTED_FROM_ABI void valarray<size_t>::resize(size_t, size_t); 963 964template <class _Op, class _Tp> 965struct _UnaryOp<_Op, valarray<_Tp> > { 966 typedef typename _Op::__result_type __result_type; 967 using value_type = __decay_t<__result_type>; 968 969 _Op __op_; 970 const valarray<_Tp>& __a0_; 971 972 _LIBCPP_HIDE_FROM_ABI _UnaryOp(const _Op& __op, const valarray<_Tp>& __a0) : __op_(__op), __a0_(__a0) {} 973 974 _LIBCPP_HIDE_FROM_ABI __result_type operator[](size_t __i) const { return __op_(__a0_[__i]); } 975 976 _LIBCPP_HIDE_FROM_ABI size_t size() const { return __a0_.size(); } 977}; 978 979template <class _Op, class _Tp, class _A1> 980struct _BinaryOp<_Op, valarray<_Tp>, _A1> { 981 typedef typename _Op::__result_type __result_type; 982 using value_type = __decay_t<__result_type>; 983 984 _Op __op_; 985 const valarray<_Tp>& __a0_; 986 _A1 __a1_; 987 988 _LIBCPP_HIDE_FROM_ABI _BinaryOp(const _Op& __op, const valarray<_Tp>& __a0, const _A1& __a1) 989 : __op_(__op), __a0_(__a0), __a1_(__a1) {} 990 991 _LIBCPP_HIDE_FROM_ABI __result_type operator[](size_t __i) const { return __op_(__a0_[__i], __a1_[__i]); } 992 993 _LIBCPP_HIDE_FROM_ABI size_t size() const { return __a0_.size(); } 994}; 995 996template <class _Op, class _A0, class _Tp> 997struct _BinaryOp<_Op, _A0, valarray<_Tp> > { 998 typedef typename _Op::__result_type __result_type; 999 using value_type = __decay_t<__result_type>; 1000 1001 _Op __op_; 1002 _A0 __a0_; 1003 const valarray<_Tp>& __a1_; 1004 1005 _LIBCPP_HIDE_FROM_ABI _BinaryOp(const _Op& __op, const _A0& __a0, const valarray<_Tp>& __a1) 1006 : __op_(__op), __a0_(__a0), __a1_(__a1) {} 1007 1008 _LIBCPP_HIDE_FROM_ABI __result_type operator[](size_t __i) const { return __op_(__a0_[__i], __a1_[__i]); } 1009 1010 _LIBCPP_HIDE_FROM_ABI size_t size() const { return __a0_.size(); } 1011}; 1012 1013template <class _Op, class _Tp> 1014struct _BinaryOp<_Op, valarray<_Tp>, valarray<_Tp> > { 1015 typedef typename _Op::__result_type __result_type; 1016 using value_type = __decay_t<__result_type>; 1017 1018 _Op __op_; 1019 const valarray<_Tp>& __a0_; 1020 const valarray<_Tp>& __a1_; 1021 1022 _LIBCPP_HIDE_FROM_ABI _BinaryOp(const _Op& __op, const valarray<_Tp>& __a0, const valarray<_Tp>& __a1) 1023 : __op_(__op), __a0_(__a0), __a1_(__a1) {} 1024 1025 _LIBCPP_HIDE_FROM_ABI __result_type operator[](size_t __i) const { return __op_(__a0_[__i], __a1_[__i]); } 1026 1027 _LIBCPP_HIDE_FROM_ABI size_t size() const { return __a0_.size(); } 1028}; 1029 1030// slice_array 1031 1032template <class _Tp> 1033class _LIBCPP_TEMPLATE_VIS slice_array { 1034public: 1035 typedef _Tp value_type; 1036 1037private: 1038 value_type* __vp_; 1039 size_t __size_; 1040 size_t __stride_; 1041 1042public: 1043 template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 1044 void _LIBCPP_HIDE_FROM_ABI operator=(const _Expr& __v) const; 1045 1046 template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 1047 void _LIBCPP_HIDE_FROM_ABI operator*=(const _Expr& __v) const; 1048 1049 template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 1050 void _LIBCPP_HIDE_FROM_ABI operator/=(const _Expr& __v) const; 1051 1052 template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 1053 void _LIBCPP_HIDE_FROM_ABI operator%=(const _Expr& __v) const; 1054 1055 template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 1056 void _LIBCPP_HIDE_FROM_ABI operator+=(const _Expr& __v) const; 1057 1058 template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 1059 void _LIBCPP_HIDE_FROM_ABI operator-=(const _Expr& __v) const; 1060 1061 template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 1062 void _LIBCPP_HIDE_FROM_ABI operator^=(const _Expr& __v) const; 1063 1064 template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 1065 void _LIBCPP_HIDE_FROM_ABI operator&=(const _Expr& __v) const; 1066 1067 template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 1068 void _LIBCPP_HIDE_FROM_ABI operator|=(const _Expr& __v) const; 1069 1070 template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 1071 void _LIBCPP_HIDE_FROM_ABI operator<<=(const _Expr& __v) const; 1072 1073 template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 1074 void _LIBCPP_HIDE_FROM_ABI operator>>=(const _Expr& __v) const; 1075 1076 slice_array(slice_array const&) = default; 1077 1078 _LIBCPP_HIDE_FROM_ABI const slice_array& operator=(const slice_array& __sa) const; 1079 1080 _LIBCPP_HIDE_FROM_ABI void operator=(const value_type& __x) const; 1081 1082 _LIBCPP_HIDE_FROM_ABI void operator=(const valarray<value_type>& __va) const; 1083 1084 // Behaves like __val_expr::operator[], which returns by value. 1085 _LIBCPP_HIDE_FROM_ABI value_type __get(size_t __i) const { 1086 _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(__i < __size_, "slice_array.__get() index out of bounds"); 1087 return __vp_[__i * __stride_]; 1088 } 1089 1090private: 1091 _LIBCPP_HIDE_FROM_ABI slice_array(const slice& __sl, const valarray<value_type>& __v) 1092 : __vp_(const_cast<value_type*>(__v.__begin_ + __sl.start())), __size_(__sl.size()), __stride_(__sl.stride()) {} 1093 1094 template <class> 1095 friend class valarray; 1096}; 1097 1098template <class _Tp> 1099inline const slice_array<_Tp>& slice_array<_Tp>::operator=(const slice_array& __sa) const { 1100 value_type* __t = __vp_; 1101 const value_type* __s = __sa.__vp_; 1102 for (size_t __n = __size_; __n; --__n, __t += __stride_, __s += __sa.__stride_) 1103 *__t = *__s; 1104 return *this; 1105} 1106 1107template <class _Tp> 1108template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> > 1109inline void slice_array<_Tp>::operator=(const _Expr& __v) const { 1110 value_type* __t = __vp_; 1111 for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_) 1112 *__t = __v[__i]; 1113} 1114 1115template <class _Tp> 1116inline void slice_array<_Tp>::operator=(const valarray<value_type>& __va) const { 1117 value_type* __t = __vp_; 1118 for (size_t __i = 0; __i < __va.size(); ++__i, __t += __stride_) 1119 *__t = __va[__i]; 1120} 1121 1122template <class _Tp> 1123template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> > 1124inline void slice_array<_Tp>::operator*=(const _Expr& __v) const { 1125 value_type* __t = __vp_; 1126 for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_) 1127 *__t *= __v[__i]; 1128} 1129 1130template <class _Tp> 1131template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> > 1132inline void slice_array<_Tp>::operator/=(const _Expr& __v) const { 1133 value_type* __t = __vp_; 1134 for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_) 1135 *__t /= __v[__i]; 1136} 1137 1138template <class _Tp> 1139template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> > 1140inline void slice_array<_Tp>::operator%=(const _Expr& __v) const { 1141 value_type* __t = __vp_; 1142 for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_) 1143 *__t %= __v[__i]; 1144} 1145 1146template <class _Tp> 1147template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> > 1148inline void slice_array<_Tp>::operator+=(const _Expr& __v) const { 1149 value_type* __t = __vp_; 1150 for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_) 1151 *__t += __v[__i]; 1152} 1153 1154template <class _Tp> 1155template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> > 1156inline void slice_array<_Tp>::operator-=(const _Expr& __v) const { 1157 value_type* __t = __vp_; 1158 for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_) 1159 *__t -= __v[__i]; 1160} 1161 1162template <class _Tp> 1163template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> > 1164inline void slice_array<_Tp>::operator^=(const _Expr& __v) const { 1165 value_type* __t = __vp_; 1166 for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_) 1167 *__t ^= __v[__i]; 1168} 1169 1170template <class _Tp> 1171template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> > 1172inline void slice_array<_Tp>::operator&=(const _Expr& __v) const { 1173 value_type* __t = __vp_; 1174 for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_) 1175 *__t &= __v[__i]; 1176} 1177 1178template <class _Tp> 1179template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> > 1180inline void slice_array<_Tp>::operator|=(const _Expr& __v) const { 1181 value_type* __t = __vp_; 1182 for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_) 1183 *__t |= __v[__i]; 1184} 1185 1186template <class _Tp> 1187template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> > 1188inline void slice_array<_Tp>::operator<<=(const _Expr& __v) const { 1189 value_type* __t = __vp_; 1190 for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_) 1191 *__t <<= __v[__i]; 1192} 1193 1194template <class _Tp> 1195template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> > 1196inline void slice_array<_Tp>::operator>>=(const _Expr& __v) const { 1197 value_type* __t = __vp_; 1198 for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_) 1199 *__t >>= __v[__i]; 1200} 1201 1202template <class _Tp> 1203inline void slice_array<_Tp>::operator=(const value_type& __x) const { 1204 value_type* __t = __vp_; 1205 for (size_t __n = __size_; __n; --__n, __t += __stride_) 1206 *__t = __x; 1207} 1208 1209// gslice 1210 1211class _LIBCPP_EXPORTED_FROM_ABI gslice { 1212 valarray<size_t> __size_; 1213 valarray<size_t> __stride_; 1214 valarray<size_t> __1d_; 1215 1216public: 1217 _LIBCPP_HIDE_FROM_ABI gslice() {} 1218 1219 _LIBCPP_HIDE_FROM_ABI gslice(size_t __start, const valarray<size_t>& __size, const valarray<size_t>& __stride) 1220 : __size_(__size), __stride_(__stride) { 1221 __init(__start); 1222 } 1223 1224#ifndef _LIBCPP_CXX03_LANG 1225 1226 _LIBCPP_HIDE_FROM_ABI gslice(size_t __start, const valarray<size_t>& __size, valarray<size_t>&& __stride) 1227 : __size_(__size), __stride_(std::move(__stride)) { 1228 __init(__start); 1229 } 1230 1231 _LIBCPP_HIDE_FROM_ABI gslice(size_t __start, valarray<size_t>&& __size, const valarray<size_t>& __stride) 1232 : __size_(std::move(__size)), __stride_(__stride) { 1233 __init(__start); 1234 } 1235 1236 _LIBCPP_HIDE_FROM_ABI gslice(size_t __start, valarray<size_t>&& __size, valarray<size_t>&& __stride) 1237 : __size_(std::move(__size)), __stride_(std::move(__stride)) { 1238 __init(__start); 1239 } 1240 1241#endif // _LIBCPP_CXX03_LANG 1242 1243 _LIBCPP_HIDE_FROM_ABI size_t start() const { return __1d_.size() ? __1d_[0] : 0; } 1244 1245 _LIBCPP_HIDE_FROM_ABI valarray<size_t> size() const { return __size_; } 1246 1247 _LIBCPP_HIDE_FROM_ABI valarray<size_t> stride() const { return __stride_; } 1248 1249private: 1250 void __init(size_t __start); 1251 1252 template <class> 1253 friend class gslice_array; 1254 template <class> 1255 friend class valarray; 1256 template <class> 1257 friend class __val_expr; 1258}; 1259 1260// gslice_array 1261 1262template <class _Tp> 1263class _LIBCPP_TEMPLATE_VIS gslice_array { 1264public: 1265 typedef _Tp value_type; 1266 1267private: 1268 value_type* __vp_; 1269 valarray<size_t> __1d_; 1270 1271public: 1272 template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 1273 void _LIBCPP_HIDE_FROM_ABI operator=(const _Expr& __v) const; 1274 1275 template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 1276 void _LIBCPP_HIDE_FROM_ABI operator*=(const _Expr& __v) const; 1277 1278 template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 1279 void _LIBCPP_HIDE_FROM_ABI operator/=(const _Expr& __v) const; 1280 1281 template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 1282 void _LIBCPP_HIDE_FROM_ABI operator%=(const _Expr& __v) const; 1283 1284 template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 1285 void _LIBCPP_HIDE_FROM_ABI operator+=(const _Expr& __v) const; 1286 1287 template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 1288 void _LIBCPP_HIDE_FROM_ABI operator-=(const _Expr& __v) const; 1289 1290 template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 1291 void _LIBCPP_HIDE_FROM_ABI operator^=(const _Expr& __v) const; 1292 1293 template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 1294 void _LIBCPP_HIDE_FROM_ABI operator&=(const _Expr& __v) const; 1295 1296 template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 1297 void _LIBCPP_HIDE_FROM_ABI operator|=(const _Expr& __v) const; 1298 1299 template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 1300 void _LIBCPP_HIDE_FROM_ABI operator<<=(const _Expr& __v) const; 1301 1302 template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 1303 void _LIBCPP_HIDE_FROM_ABI operator>>=(const _Expr& __v) const; 1304 1305 _LIBCPP_HIDE_FROM_ABI const gslice_array& operator=(const gslice_array& __ga) const; 1306 1307 _LIBCPP_HIDE_FROM_ABI void operator=(const value_type& __x) const; 1308 1309 gslice_array(const gslice_array&) = default; 1310 1311 // Behaves like __val_expr::operator[], which returns by value. 1312 _LIBCPP_HIDE_FROM_ABI value_type __get(size_t __i) const { 1313 _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(__i < __1d_.size(), "gslice_array.__get() index out of bounds"); 1314 return __vp_[__1d_[__i]]; 1315 } 1316 1317private: 1318 gslice_array(const gslice& __gs, const valarray<value_type>& __v) 1319 : __vp_(const_cast<value_type*>(__v.__begin_)), __1d_(__gs.__1d_) {} 1320 1321#ifndef _LIBCPP_CXX03_LANG 1322 gslice_array(gslice&& __gs, const valarray<value_type>& __v) 1323 : __vp_(const_cast<value_type*>(__v.__begin_)), __1d_(std::move(__gs.__1d_)) {} 1324#endif // _LIBCPP_CXX03_LANG 1325 1326 template <class> 1327 friend class valarray; 1328}; 1329 1330template <class _Tp> 1331template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> > 1332inline void gslice_array<_Tp>::operator=(const _Expr& __v) const { 1333 typedef const size_t* _Ip; 1334 size_t __j = 0; 1335 for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j) 1336 __vp_[*__i] = __v[__j]; 1337} 1338 1339template <class _Tp> 1340template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> > 1341inline void gslice_array<_Tp>::operator*=(const _Expr& __v) const { 1342 typedef const size_t* _Ip; 1343 size_t __j = 0; 1344 for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j) 1345 __vp_[*__i] *= __v[__j]; 1346} 1347 1348template <class _Tp> 1349template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> > 1350inline void gslice_array<_Tp>::operator/=(const _Expr& __v) const { 1351 typedef const size_t* _Ip; 1352 size_t __j = 0; 1353 for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j) 1354 __vp_[*__i] /= __v[__j]; 1355} 1356 1357template <class _Tp> 1358template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> > 1359inline void gslice_array<_Tp>::operator%=(const _Expr& __v) const { 1360 typedef const size_t* _Ip; 1361 size_t __j = 0; 1362 for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j) 1363 __vp_[*__i] %= __v[__j]; 1364} 1365 1366template <class _Tp> 1367template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> > 1368inline void gslice_array<_Tp>::operator+=(const _Expr& __v) const { 1369 typedef const size_t* _Ip; 1370 size_t __j = 0; 1371 for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j) 1372 __vp_[*__i] += __v[__j]; 1373} 1374 1375template <class _Tp> 1376template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> > 1377inline void gslice_array<_Tp>::operator-=(const _Expr& __v) const { 1378 typedef const size_t* _Ip; 1379 size_t __j = 0; 1380 for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j) 1381 __vp_[*__i] -= __v[__j]; 1382} 1383 1384template <class _Tp> 1385template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> > 1386inline void gslice_array<_Tp>::operator^=(const _Expr& __v) const { 1387 typedef const size_t* _Ip; 1388 size_t __j = 0; 1389 for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j) 1390 __vp_[*__i] ^= __v[__j]; 1391} 1392 1393template <class _Tp> 1394template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> > 1395inline void gslice_array<_Tp>::operator&=(const _Expr& __v) const { 1396 typedef const size_t* _Ip; 1397 size_t __j = 0; 1398 for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j) 1399 __vp_[*__i] &= __v[__j]; 1400} 1401 1402template <class _Tp> 1403template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> > 1404inline void gslice_array<_Tp>::operator|=(const _Expr& __v) const { 1405 typedef const size_t* _Ip; 1406 size_t __j = 0; 1407 for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j) 1408 __vp_[*__i] |= __v[__j]; 1409} 1410 1411template <class _Tp> 1412template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> > 1413inline void gslice_array<_Tp>::operator<<=(const _Expr& __v) const { 1414 typedef const size_t* _Ip; 1415 size_t __j = 0; 1416 for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j) 1417 __vp_[*__i] <<= __v[__j]; 1418} 1419 1420template <class _Tp> 1421template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> > 1422inline void gslice_array<_Tp>::operator>>=(const _Expr& __v) const { 1423 typedef const size_t* _Ip; 1424 size_t __j = 0; 1425 for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j) 1426 __vp_[*__i] >>= __v[__j]; 1427} 1428 1429template <class _Tp> 1430inline const gslice_array<_Tp>& gslice_array<_Tp>::operator=(const gslice_array& __ga) const { 1431 typedef const size_t* _Ip; 1432 const value_type* __s = __ga.__vp_; 1433 for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_, __j = __ga.__1d_.__begin_; __i != __e; ++__i, ++__j) 1434 __vp_[*__i] = __s[*__j]; 1435 return *this; 1436} 1437 1438template <class _Tp> 1439inline void gslice_array<_Tp>::operator=(const value_type& __x) const { 1440 typedef const size_t* _Ip; 1441 for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i) 1442 __vp_[*__i] = __x; 1443} 1444 1445// mask_array 1446 1447template <class _Tp> 1448class _LIBCPP_TEMPLATE_VIS mask_array { 1449public: 1450 typedef _Tp value_type; 1451 1452private: 1453 value_type* __vp_; 1454 valarray<size_t> __1d_; 1455 1456public: 1457 template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 1458 void _LIBCPP_HIDE_FROM_ABI operator=(const _Expr& __v) const; 1459 1460 template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 1461 void _LIBCPP_HIDE_FROM_ABI operator*=(const _Expr& __v) const; 1462 1463 template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 1464 void _LIBCPP_HIDE_FROM_ABI operator/=(const _Expr& __v) const; 1465 1466 template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 1467 void _LIBCPP_HIDE_FROM_ABI operator%=(const _Expr& __v) const; 1468 1469 template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 1470 void _LIBCPP_HIDE_FROM_ABI operator+=(const _Expr& __v) const; 1471 1472 template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 1473 void _LIBCPP_HIDE_FROM_ABI operator-=(const _Expr& __v) const; 1474 1475 template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 1476 void _LIBCPP_HIDE_FROM_ABI operator^=(const _Expr& __v) const; 1477 1478 template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 1479 void _LIBCPP_HIDE_FROM_ABI operator&=(const _Expr& __v) const; 1480 1481 template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 1482 void _LIBCPP_HIDE_FROM_ABI operator|=(const _Expr& __v) const; 1483 1484 template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 1485 void _LIBCPP_HIDE_FROM_ABI operator<<=(const _Expr& __v) const; 1486 1487 template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 1488 void _LIBCPP_HIDE_FROM_ABI operator>>=(const _Expr& __v) const; 1489 1490 mask_array(const mask_array&) = default; 1491 1492 _LIBCPP_HIDE_FROM_ABI const mask_array& operator=(const mask_array& __ma) const; 1493 1494 _LIBCPP_HIDE_FROM_ABI void operator=(const value_type& __x) const; 1495 1496 // Behaves like __val_expr::operator[], which returns by value. 1497 _LIBCPP_HIDE_FROM_ABI value_type __get(size_t __i) const { 1498 _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(__i < __1d_.size(), "mask_array.__get() index out of bounds"); 1499 return __vp_[__1d_[__i]]; 1500 } 1501 1502private: 1503 _LIBCPP_HIDE_FROM_ABI mask_array(const valarray<bool>& __vb, const valarray<value_type>& __v) 1504 : __vp_(const_cast<value_type*>(__v.__begin_)), 1505 __1d_(static_cast<size_t>(count(__vb.__begin_, __vb.__end_, true))) { 1506 size_t __j = 0; 1507 for (size_t __i = 0; __i < __vb.size(); ++__i) 1508 if (__vb[__i]) 1509 __1d_[__j++] = __i; 1510 } 1511 1512 template <class> 1513 friend class valarray; 1514}; 1515 1516template <class _Tp> 1517template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> > 1518inline void mask_array<_Tp>::operator=(const _Expr& __v) const { 1519 size_t __n = __1d_.size(); 1520 for (size_t __i = 0; __i < __n; ++__i) 1521 __vp_[__1d_[__i]] = __v[__i]; 1522} 1523 1524template <class _Tp> 1525template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> > 1526inline void mask_array<_Tp>::operator*=(const _Expr& __v) const { 1527 size_t __n = __1d_.size(); 1528 for (size_t __i = 0; __i < __n; ++__i) 1529 __vp_[__1d_[__i]] *= __v[__i]; 1530} 1531 1532template <class _Tp> 1533template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> > 1534inline void mask_array<_Tp>::operator/=(const _Expr& __v) const { 1535 size_t __n = __1d_.size(); 1536 for (size_t __i = 0; __i < __n; ++__i) 1537 __vp_[__1d_[__i]] /= __v[__i]; 1538} 1539 1540template <class _Tp> 1541template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> > 1542inline void mask_array<_Tp>::operator%=(const _Expr& __v) const { 1543 size_t __n = __1d_.size(); 1544 for (size_t __i = 0; __i < __n; ++__i) 1545 __vp_[__1d_[__i]] %= __v[__i]; 1546} 1547 1548template <class _Tp> 1549template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> > 1550inline void mask_array<_Tp>::operator+=(const _Expr& __v) const { 1551 size_t __n = __1d_.size(); 1552 for (size_t __i = 0; __i < __n; ++__i) 1553 __vp_[__1d_[__i]] += __v[__i]; 1554} 1555 1556template <class _Tp> 1557template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> > 1558inline void mask_array<_Tp>::operator-=(const _Expr& __v) const { 1559 size_t __n = __1d_.size(); 1560 for (size_t __i = 0; __i < __n; ++__i) 1561 __vp_[__1d_[__i]] -= __v[__i]; 1562} 1563 1564template <class _Tp> 1565template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> > 1566inline void mask_array<_Tp>::operator^=(const _Expr& __v) const { 1567 size_t __n = __1d_.size(); 1568 for (size_t __i = 0; __i < __n; ++__i) 1569 __vp_[__1d_[__i]] ^= __v[__i]; 1570} 1571 1572template <class _Tp> 1573template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> > 1574inline void mask_array<_Tp>::operator&=(const _Expr& __v) const { 1575 size_t __n = __1d_.size(); 1576 for (size_t __i = 0; __i < __n; ++__i) 1577 __vp_[__1d_[__i]] &= __v[__i]; 1578} 1579 1580template <class _Tp> 1581template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> > 1582inline void mask_array<_Tp>::operator|=(const _Expr& __v) const { 1583 size_t __n = __1d_.size(); 1584 for (size_t __i = 0; __i < __n; ++__i) 1585 __vp_[__1d_[__i]] |= __v[__i]; 1586} 1587 1588template <class _Tp> 1589template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> > 1590inline void mask_array<_Tp>::operator<<=(const _Expr& __v) const { 1591 size_t __n = __1d_.size(); 1592 for (size_t __i = 0; __i < __n; ++__i) 1593 __vp_[__1d_[__i]] <<= __v[__i]; 1594} 1595 1596template <class _Tp> 1597template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> > 1598inline void mask_array<_Tp>::operator>>=(const _Expr& __v) const { 1599 size_t __n = __1d_.size(); 1600 for (size_t __i = 0; __i < __n; ++__i) 1601 __vp_[__1d_[__i]] >>= __v[__i]; 1602} 1603 1604template <class _Tp> 1605inline const mask_array<_Tp>& mask_array<_Tp>::operator=(const mask_array& __ma) const { 1606 size_t __n = __1d_.size(); 1607 for (size_t __i = 0; __i < __n; ++__i) 1608 __vp_[__1d_[__i]] = __ma.__vp_[__1d_[__i]]; 1609 return *this; 1610} 1611 1612template <class _Tp> 1613inline void mask_array<_Tp>::operator=(const value_type& __x) const { 1614 size_t __n = __1d_.size(); 1615 for (size_t __i = 0; __i < __n; ++__i) 1616 __vp_[__1d_[__i]] = __x; 1617} 1618 1619template <class _ValExpr> 1620class __mask_expr { 1621 typedef __libcpp_remove_reference_t<_ValExpr> _RmExpr; 1622 1623public: 1624 typedef typename _RmExpr::value_type value_type; 1625 typedef value_type __result_type; 1626 1627private: 1628 _ValExpr __expr_; 1629 valarray<size_t> __1d_; 1630 1631 _LIBCPP_HIDE_FROM_ABI __mask_expr(const valarray<bool>& __vb, const _RmExpr& __e) 1632 : __expr_(__e), __1d_(static_cast<size_t>(count(__vb.__begin_, __vb.__end_, true))) { 1633 size_t __j = 0; 1634 for (size_t __i = 0; __i < __vb.size(); ++__i) 1635 if (__vb[__i]) 1636 __1d_[__j++] = __i; 1637 } 1638 1639public: 1640 _LIBCPP_HIDE_FROM_ABI __result_type operator[](size_t __i) const { return __expr_[__1d_[__i]]; } 1641 1642 _LIBCPP_HIDE_FROM_ABI size_t size() const { return __1d_.size(); } 1643 1644 template <class> 1645 friend class __val_expr; 1646 template <class> 1647 friend class valarray; 1648}; 1649 1650// indirect_array 1651 1652template <class _Tp> 1653class _LIBCPP_TEMPLATE_VIS indirect_array { 1654public: 1655 typedef _Tp value_type; 1656 1657private: 1658 value_type* __vp_; 1659 valarray<size_t> __1d_; 1660 1661public: 1662 template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 1663 void _LIBCPP_HIDE_FROM_ABI operator=(const _Expr& __v) const; 1664 1665 template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 1666 void _LIBCPP_HIDE_FROM_ABI operator*=(const _Expr& __v) const; 1667 1668 template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 1669 void _LIBCPP_HIDE_FROM_ABI operator/=(const _Expr& __v) const; 1670 1671 template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 1672 void _LIBCPP_HIDE_FROM_ABI operator%=(const _Expr& __v) const; 1673 1674 template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 1675 void _LIBCPP_HIDE_FROM_ABI operator+=(const _Expr& __v) const; 1676 1677 template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 1678 void _LIBCPP_HIDE_FROM_ABI operator-=(const _Expr& __v) const; 1679 1680 template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 1681 void _LIBCPP_HIDE_FROM_ABI operator^=(const _Expr& __v) const; 1682 1683 template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 1684 void _LIBCPP_HIDE_FROM_ABI operator&=(const _Expr& __v) const; 1685 1686 template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 1687 void _LIBCPP_HIDE_FROM_ABI operator|=(const _Expr& __v) const; 1688 1689 template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 1690 void _LIBCPP_HIDE_FROM_ABI operator<<=(const _Expr& __v) const; 1691 1692 template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 1693 void _LIBCPP_HIDE_FROM_ABI operator>>=(const _Expr& __v) const; 1694 1695 indirect_array(const indirect_array&) = default; 1696 1697 _LIBCPP_HIDE_FROM_ABI const indirect_array& operator=(const indirect_array& __ia) const; 1698 1699 _LIBCPP_HIDE_FROM_ABI void operator=(const value_type& __x) const; 1700 1701 // Behaves like __val_expr::operator[], which returns by value. 1702 _LIBCPP_HIDE_FROM_ABI value_type __get(size_t __i) const { 1703 _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(__i < __1d_.size(), "indirect_array.__get() index out of bounds"); 1704 return __vp_[__1d_[__i]]; 1705 } 1706 1707private: 1708 _LIBCPP_HIDE_FROM_ABI indirect_array(const valarray<size_t>& __ia, const valarray<value_type>& __v) 1709 : __vp_(const_cast<value_type*>(__v.__begin_)), __1d_(__ia) {} 1710 1711#ifndef _LIBCPP_CXX03_LANG 1712 1713 _LIBCPP_HIDE_FROM_ABI indirect_array(valarray<size_t>&& __ia, const valarray<value_type>& __v) 1714 : __vp_(const_cast<value_type*>(__v.__begin_)), __1d_(std::move(__ia)) {} 1715 1716#endif // _LIBCPP_CXX03_LANG 1717 1718 template <class> 1719 friend class valarray; 1720}; 1721 1722template <class _Tp> 1723template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> > 1724inline void indirect_array<_Tp>::operator=(const _Expr& __v) const { 1725 size_t __n = __1d_.size(); 1726 for (size_t __i = 0; __i < __n; ++__i) 1727 __vp_[__1d_[__i]] = __v[__i]; 1728} 1729 1730template <class _Tp> 1731template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> > 1732inline void indirect_array<_Tp>::operator*=(const _Expr& __v) const { 1733 size_t __n = __1d_.size(); 1734 for (size_t __i = 0; __i < __n; ++__i) 1735 __vp_[__1d_[__i]] *= __v[__i]; 1736} 1737 1738template <class _Tp> 1739template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> > 1740inline void indirect_array<_Tp>::operator/=(const _Expr& __v) const { 1741 size_t __n = __1d_.size(); 1742 for (size_t __i = 0; __i < __n; ++__i) 1743 __vp_[__1d_[__i]] /= __v[__i]; 1744} 1745 1746template <class _Tp> 1747template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> > 1748inline void indirect_array<_Tp>::operator%=(const _Expr& __v) const { 1749 size_t __n = __1d_.size(); 1750 for (size_t __i = 0; __i < __n; ++__i) 1751 __vp_[__1d_[__i]] %= __v[__i]; 1752} 1753 1754template <class _Tp> 1755template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> > 1756inline void indirect_array<_Tp>::operator+=(const _Expr& __v) const { 1757 size_t __n = __1d_.size(); 1758 for (size_t __i = 0; __i < __n; ++__i) 1759 __vp_[__1d_[__i]] += __v[__i]; 1760} 1761 1762template <class _Tp> 1763template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> > 1764inline void indirect_array<_Tp>::operator-=(const _Expr& __v) const { 1765 size_t __n = __1d_.size(); 1766 for (size_t __i = 0; __i < __n; ++__i) 1767 __vp_[__1d_[__i]] -= __v[__i]; 1768} 1769 1770template <class _Tp> 1771template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> > 1772inline void indirect_array<_Tp>::operator^=(const _Expr& __v) const { 1773 size_t __n = __1d_.size(); 1774 for (size_t __i = 0; __i < __n; ++__i) 1775 __vp_[__1d_[__i]] ^= __v[__i]; 1776} 1777 1778template <class _Tp> 1779template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> > 1780inline void indirect_array<_Tp>::operator&=(const _Expr& __v) const { 1781 size_t __n = __1d_.size(); 1782 for (size_t __i = 0; __i < __n; ++__i) 1783 __vp_[__1d_[__i]] &= __v[__i]; 1784} 1785 1786template <class _Tp> 1787template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> > 1788inline void indirect_array<_Tp>::operator|=(const _Expr& __v) const { 1789 size_t __n = __1d_.size(); 1790 for (size_t __i = 0; __i < __n; ++__i) 1791 __vp_[__1d_[__i]] |= __v[__i]; 1792} 1793 1794template <class _Tp> 1795template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> > 1796inline void indirect_array<_Tp>::operator<<=(const _Expr& __v) const { 1797 size_t __n = __1d_.size(); 1798 for (size_t __i = 0; __i < __n; ++__i) 1799 __vp_[__1d_[__i]] <<= __v[__i]; 1800} 1801 1802template <class _Tp> 1803template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> > 1804inline void indirect_array<_Tp>::operator>>=(const _Expr& __v) const { 1805 size_t __n = __1d_.size(); 1806 for (size_t __i = 0; __i < __n; ++__i) 1807 __vp_[__1d_[__i]] >>= __v[__i]; 1808} 1809 1810template <class _Tp> 1811inline const indirect_array<_Tp>& indirect_array<_Tp>::operator=(const indirect_array& __ia) const { 1812 typedef const size_t* _Ip; 1813 const value_type* __s = __ia.__vp_; 1814 for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_, __j = __ia.__1d_.__begin_; __i != __e; ++__i, ++__j) 1815 __vp_[*__i] = __s[*__j]; 1816 return *this; 1817} 1818 1819template <class _Tp> 1820inline void indirect_array<_Tp>::operator=(const value_type& __x) const { 1821 typedef const size_t* _Ip; 1822 for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i) 1823 __vp_[*__i] = __x; 1824} 1825 1826template <class _ValExpr> 1827class __indirect_expr { 1828 typedef __libcpp_remove_reference_t<_ValExpr> _RmExpr; 1829 1830public: 1831 typedef typename _RmExpr::value_type value_type; 1832 typedef value_type __result_type; 1833 1834private: 1835 _ValExpr __expr_; 1836 valarray<size_t> __1d_; 1837 1838 _LIBCPP_HIDE_FROM_ABI __indirect_expr(const valarray<size_t>& __ia, const _RmExpr& __e) : __expr_(__e), __1d_(__ia) {} 1839 1840#ifndef _LIBCPP_CXX03_LANG 1841 1842 _LIBCPP_HIDE_FROM_ABI __indirect_expr(valarray<size_t>&& __ia, const _RmExpr& __e) 1843 : __expr_(__e), __1d_(std::move(__ia)) {} 1844 1845#endif // _LIBCPP_CXX03_LANG 1846 1847public: 1848 _LIBCPP_HIDE_FROM_ABI __result_type operator[](size_t __i) const { return __expr_[__1d_[__i]]; } 1849 1850 _LIBCPP_HIDE_FROM_ABI size_t size() const { return __1d_.size(); } 1851 1852 template <class> 1853 friend class __val_expr; 1854 template <class> 1855 friend class _LIBCPP_TEMPLATE_VIS valarray; 1856}; 1857 1858template <class _ValExpr> 1859class __val_expr { 1860 typedef __libcpp_remove_reference_t<_ValExpr> _RmExpr; 1861 1862 _ValExpr __expr_; 1863 1864public: 1865 typedef typename _RmExpr::value_type value_type; 1866 typedef typename _RmExpr::__result_type __result_type; 1867 1868 _LIBCPP_HIDE_FROM_ABI explicit __val_expr(const _RmExpr& __e) : __expr_(__e) {} 1869 1870 _LIBCPP_HIDE_FROM_ABI __result_type operator[](size_t __i) const { return __expr_[__i]; } 1871 1872 _LIBCPP_HIDE_FROM_ABI __val_expr<__slice_expr<_ValExpr> > operator[](slice __s) const { 1873 typedef __slice_expr<_ValExpr> _NewExpr; 1874 return __val_expr< _NewExpr >(_NewExpr(__s, __expr_)); 1875 } 1876 1877 _LIBCPP_HIDE_FROM_ABI __val_expr<__indirect_expr<_ValExpr> > operator[](const gslice& __gs) const { 1878 typedef __indirect_expr<_ValExpr> _NewExpr; 1879 return __val_expr<_NewExpr >(_NewExpr(__gs.__1d_, __expr_)); 1880 } 1881 1882 _LIBCPP_HIDE_FROM_ABI __val_expr<__mask_expr<_ValExpr> > operator[](const valarray<bool>& __vb) const { 1883 typedef __mask_expr<_ValExpr> _NewExpr; 1884 return __val_expr< _NewExpr >(_NewExpr(__vb, __expr_)); 1885 } 1886 1887 _LIBCPP_HIDE_FROM_ABI __val_expr<__indirect_expr<_ValExpr> > operator[](const valarray<size_t>& __vs) const { 1888 typedef __indirect_expr<_ValExpr> _NewExpr; 1889 return __val_expr< _NewExpr >(_NewExpr(__vs, __expr_)); 1890 } 1891 1892 _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__unary_plus<value_type>, _ValExpr> > operator+() const { 1893 typedef _UnaryOp<__unary_plus<value_type>, _ValExpr> _NewExpr; 1894 return __val_expr<_NewExpr>(_NewExpr(__unary_plus<value_type>(), __expr_)); 1895 } 1896 1897 _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<negate<value_type>, _ValExpr> > operator-() const { 1898 typedef _UnaryOp<negate<value_type>, _ValExpr> _NewExpr; 1899 return __val_expr<_NewExpr>(_NewExpr(negate<value_type>(), __expr_)); 1900 } 1901 1902 _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__bit_not<value_type>, _ValExpr> > operator~() const { 1903 typedef _UnaryOp<__bit_not<value_type>, _ValExpr> _NewExpr; 1904 return __val_expr<_NewExpr>(_NewExpr(__bit_not<value_type>(), __expr_)); 1905 } 1906 1907 _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<logical_not<value_type>, _ValExpr> > operator!() const { 1908 typedef _UnaryOp<logical_not<value_type>, _ValExpr> _NewExpr; 1909 return __val_expr<_NewExpr>(_NewExpr(logical_not<value_type>(), __expr_)); 1910 } 1911 1912 operator valarray<__result_type>() const; 1913 1914 _LIBCPP_HIDE_FROM_ABI size_t size() const { return __expr_.size(); } 1915 1916 _LIBCPP_HIDE_FROM_ABI __result_type sum() const { 1917 size_t __n = __expr_.size(); 1918 __result_type __r = __n ? __expr_[0] : __result_type(); 1919 for (size_t __i = 1; __i < __n; ++__i) 1920 __r += __expr_[__i]; 1921 return __r; 1922 } 1923 1924 _LIBCPP_HIDE_FROM_ABI __result_type min() const { 1925 size_t __n = size(); 1926 __result_type __r = __n ? (*this)[0] : __result_type(); 1927 for (size_t __i = 1; __i < __n; ++__i) { 1928 __result_type __x = __expr_[__i]; 1929 if (__x < __r) 1930 __r = __x; 1931 } 1932 return __r; 1933 } 1934 1935 _LIBCPP_HIDE_FROM_ABI __result_type max() const { 1936 size_t __n = size(); 1937 __result_type __r = __n ? (*this)[0] : __result_type(); 1938 for (size_t __i = 1; __i < __n; ++__i) { 1939 __result_type __x = __expr_[__i]; 1940 if (__r < __x) 1941 __r = __x; 1942 } 1943 return __r; 1944 } 1945 1946 _LIBCPP_HIDE_FROM_ABI __val_expr<__shift_expr<_ValExpr> > shift(int __i) const { 1947 return __val_expr<__shift_expr<_ValExpr> >(__shift_expr<_ValExpr>(__i, __expr_)); 1948 } 1949 1950 _LIBCPP_HIDE_FROM_ABI __val_expr<__cshift_expr<_ValExpr> > cshift(int __i) const { 1951 return __val_expr<__cshift_expr<_ValExpr> >(__cshift_expr<_ValExpr>(__i, __expr_)); 1952 } 1953 1954 _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__apply_expr<value_type, value_type (*)(value_type)>, _ValExpr> > 1955 apply(value_type __f(value_type)) const { 1956 typedef __apply_expr<value_type, value_type (*)(value_type)> _Op; 1957 typedef _UnaryOp<_Op, _ValExpr> _NewExpr; 1958 return __val_expr<_NewExpr>(_NewExpr(_Op(__f), __expr_)); 1959 } 1960 1961 _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__apply_expr<value_type, value_type (*)(const value_type&)>, _ValExpr> > 1962 apply(value_type __f(const value_type&)) const { 1963 typedef __apply_expr<value_type, value_type (*)(const value_type&)> _Op; 1964 typedef _UnaryOp<_Op, _ValExpr> _NewExpr; 1965 return __val_expr<_NewExpr>(_NewExpr(_Op(__f), __expr_)); 1966 } 1967}; 1968 1969template <class _ValExpr> 1970__val_expr<_ValExpr>::operator valarray<__val_expr::__result_type>() const { 1971 valarray<__result_type> __r; 1972 size_t __n = __expr_.size(); 1973 if (__n) { 1974 __r.__begin_ = __r.__end_ = allocator<__result_type>().allocate(__n); 1975 for (size_t __i = 0; __i != __n; ++__r.__end_, ++__i) 1976 ::new ((void*)__r.__end_) __result_type(__expr_[__i]); 1977 } 1978 return __r; 1979} 1980 1981// valarray 1982 1983template <class _Tp> 1984inline valarray<_Tp>::valarray(size_t __n) : __begin_(nullptr), __end_(nullptr) { 1985 if (__n) { 1986 __begin_ = __end_ = allocator<value_type>().allocate(__n); 1987#ifndef _LIBCPP_HAS_NO_EXCEPTIONS 1988 try { 1989#endif // _LIBCPP_HAS_NO_EXCEPTIONS 1990 for (size_t __n_left = __n; __n_left; --__n_left, ++__end_) 1991 ::new ((void*)__end_) value_type(); 1992#ifndef _LIBCPP_HAS_NO_EXCEPTIONS 1993 } catch (...) { 1994 __clear(__n); 1995 throw; 1996 } 1997#endif // _LIBCPP_HAS_NO_EXCEPTIONS 1998 } 1999} 2000 2001template <class _Tp> 2002inline valarray<_Tp>::valarray(const value_type& __x, size_t __n) : __begin_(nullptr), __end_(nullptr) { 2003 resize(__n, __x); 2004} 2005 2006template <class _Tp> 2007valarray<_Tp>::valarray(const value_type* __p, size_t __n) : __begin_(nullptr), __end_(nullptr) { 2008 if (__n) { 2009 __begin_ = __end_ = allocator<value_type>().allocate(__n); 2010#ifndef _LIBCPP_HAS_NO_EXCEPTIONS 2011 try { 2012#endif // _LIBCPP_HAS_NO_EXCEPTIONS 2013 for (size_t __n_left = __n; __n_left; ++__end_, ++__p, --__n_left) 2014 ::new ((void*)__end_) value_type(*__p); 2015#ifndef _LIBCPP_HAS_NO_EXCEPTIONS 2016 } catch (...) { 2017 __clear(__n); 2018 throw; 2019 } 2020#endif // _LIBCPP_HAS_NO_EXCEPTIONS 2021 } 2022} 2023 2024template <class _Tp> 2025valarray<_Tp>::valarray(const valarray& __v) : __begin_(nullptr), __end_(nullptr) { 2026 if (__v.size()) { 2027 __begin_ = __end_ = allocator<value_type>().allocate(__v.size()); 2028#ifndef _LIBCPP_HAS_NO_EXCEPTIONS 2029 try { 2030#endif // _LIBCPP_HAS_NO_EXCEPTIONS 2031 for (value_type* __p = __v.__begin_; __p != __v.__end_; ++__end_, ++__p) 2032 ::new ((void*)__end_) value_type(*__p); 2033#ifndef _LIBCPP_HAS_NO_EXCEPTIONS 2034 } catch (...) { 2035 __clear(__v.size()); 2036 throw; 2037 } 2038#endif // _LIBCPP_HAS_NO_EXCEPTIONS 2039 } 2040} 2041 2042#ifndef _LIBCPP_CXX03_LANG 2043 2044template <class _Tp> 2045inline valarray<_Tp>::valarray(valarray&& __v) _NOEXCEPT : __begin_(__v.__begin_), __end_(__v.__end_) { 2046 __v.__begin_ = __v.__end_ = nullptr; 2047} 2048 2049template <class _Tp> 2050valarray<_Tp>::valarray(initializer_list<value_type> __il) : __begin_(nullptr), __end_(nullptr) { 2051 const size_t __n = __il.size(); 2052 if (__n) { 2053 __begin_ = __end_ = allocator<value_type>().allocate(__n); 2054# ifndef _LIBCPP_HAS_NO_EXCEPTIONS 2055 try { 2056# endif // _LIBCPP_HAS_NO_EXCEPTIONS 2057 size_t __n_left = __n; 2058 for (const value_type* __p = __il.begin(); __n_left; ++__end_, ++__p, --__n_left) 2059 ::new ((void*)__end_) value_type(*__p); 2060# ifndef _LIBCPP_HAS_NO_EXCEPTIONS 2061 } catch (...) { 2062 __clear(__n); 2063 throw; 2064 } 2065# endif // _LIBCPP_HAS_NO_EXCEPTIONS 2066 } 2067} 2068 2069#endif // _LIBCPP_CXX03_LANG 2070 2071template <class _Tp> 2072valarray<_Tp>::valarray(const slice_array<value_type>& __sa) : __begin_(nullptr), __end_(nullptr) { 2073 const size_t __n = __sa.__size_; 2074 if (__n) { 2075 __begin_ = __end_ = allocator<value_type>().allocate(__n); 2076#ifndef _LIBCPP_HAS_NO_EXCEPTIONS 2077 try { 2078#endif // _LIBCPP_HAS_NO_EXCEPTIONS 2079 size_t __n_left = __n; 2080 for (const value_type* __p = __sa.__vp_; __n_left; ++__end_, __p += __sa.__stride_, --__n_left) 2081 ::new ((void*)__end_) value_type(*__p); 2082#ifndef _LIBCPP_HAS_NO_EXCEPTIONS 2083 } catch (...) { 2084 __clear(__n); 2085 throw; 2086 } 2087#endif // _LIBCPP_HAS_NO_EXCEPTIONS 2088 } 2089} 2090 2091template <class _Tp> 2092valarray<_Tp>::valarray(const gslice_array<value_type>& __ga) : __begin_(nullptr), __end_(nullptr) { 2093 const size_t __n = __ga.__1d_.size(); 2094 if (__n) { 2095 __begin_ = __end_ = allocator<value_type>().allocate(__n); 2096#ifndef _LIBCPP_HAS_NO_EXCEPTIONS 2097 try { 2098#endif // _LIBCPP_HAS_NO_EXCEPTIONS 2099 typedef const size_t* _Ip; 2100 const value_type* __s = __ga.__vp_; 2101 for (_Ip __i = __ga.__1d_.__begin_, __e = __ga.__1d_.__end_; __i != __e; ++__i, ++__end_) 2102 ::new ((void*)__end_) value_type(__s[*__i]); 2103#ifndef _LIBCPP_HAS_NO_EXCEPTIONS 2104 } catch (...) { 2105 __clear(__n); 2106 throw; 2107 } 2108#endif // _LIBCPP_HAS_NO_EXCEPTIONS 2109 } 2110} 2111 2112template <class _Tp> 2113valarray<_Tp>::valarray(const mask_array<value_type>& __ma) : __begin_(nullptr), __end_(nullptr) { 2114 const size_t __n = __ma.__1d_.size(); 2115 if (__n) { 2116 __begin_ = __end_ = allocator<value_type>().allocate(__n); 2117#ifndef _LIBCPP_HAS_NO_EXCEPTIONS 2118 try { 2119#endif // _LIBCPP_HAS_NO_EXCEPTIONS 2120 typedef const size_t* _Ip; 2121 const value_type* __s = __ma.__vp_; 2122 for (_Ip __i = __ma.__1d_.__begin_, __e = __ma.__1d_.__end_; __i != __e; ++__i, ++__end_) 2123 ::new ((void*)__end_) value_type(__s[*__i]); 2124#ifndef _LIBCPP_HAS_NO_EXCEPTIONS 2125 } catch (...) { 2126 __clear(__n); 2127 throw; 2128 } 2129#endif // _LIBCPP_HAS_NO_EXCEPTIONS 2130 } 2131} 2132 2133template <class _Tp> 2134valarray<_Tp>::valarray(const indirect_array<value_type>& __ia) : __begin_(nullptr), __end_(nullptr) { 2135 const size_t __n = __ia.__1d_.size(); 2136 if (__n) { 2137 __begin_ = __end_ = allocator<value_type>().allocate(__n); 2138#ifndef _LIBCPP_HAS_NO_EXCEPTIONS 2139 try { 2140#endif // _LIBCPP_HAS_NO_EXCEPTIONS 2141 typedef const size_t* _Ip; 2142 const value_type* __s = __ia.__vp_; 2143 for (_Ip __i = __ia.__1d_.__begin_, __e = __ia.__1d_.__end_; __i != __e; ++__i, ++__end_) 2144 ::new ((void*)__end_) value_type(__s[*__i]); 2145#ifndef _LIBCPP_HAS_NO_EXCEPTIONS 2146 } catch (...) { 2147 __clear(__n); 2148 throw; 2149 } 2150#endif // _LIBCPP_HAS_NO_EXCEPTIONS 2151 } 2152} 2153 2154template <class _Tp> 2155inline valarray<_Tp>::~valarray() { 2156 __clear(size()); 2157} 2158 2159template <class _Tp> 2160valarray<_Tp>& valarray<_Tp>::__assign_range(const value_type* __f, const value_type* __l) { 2161 size_t __n = __l - __f; 2162 if (size() != __n) { 2163 __clear(size()); 2164 __begin_ = allocator<value_type>().allocate(__n); 2165 __end_ = __begin_ + __n; 2166 std::uninitialized_copy(__f, __l, __begin_); 2167 } else { 2168 std::copy(__f, __l, __begin_); 2169 } 2170 return *this; 2171} 2172 2173template <class _Tp> 2174valarray<_Tp>& valarray<_Tp>::operator=(const valarray& __v) { 2175 if (this != std::addressof(__v)) 2176 return __assign_range(__v.__begin_, __v.__end_); 2177 return *this; 2178} 2179 2180#ifndef _LIBCPP_CXX03_LANG 2181 2182template <class _Tp> 2183inline valarray<_Tp>& valarray<_Tp>::operator=(valarray&& __v) _NOEXCEPT { 2184 __clear(size()); 2185 __begin_ = __v.__begin_; 2186 __end_ = __v.__end_; 2187 __v.__begin_ = nullptr; 2188 __v.__end_ = nullptr; 2189 return *this; 2190} 2191 2192template <class _Tp> 2193inline valarray<_Tp>& valarray<_Tp>::operator=(initializer_list<value_type> __il) { 2194 return __assign_range(__il.begin(), __il.end()); 2195} 2196 2197#endif // _LIBCPP_CXX03_LANG 2198 2199template <class _Tp> 2200inline valarray<_Tp>& valarray<_Tp>::operator=(const value_type& __x) { 2201 std::fill(__begin_, __end_, __x); 2202 return *this; 2203} 2204 2205template <class _Tp> 2206inline valarray<_Tp>& valarray<_Tp>::operator=(const slice_array<value_type>& __sa) { 2207 value_type* __t = __begin_; 2208 const value_type* __s = __sa.__vp_; 2209 for (size_t __n = __sa.__size_; __n; --__n, __s += __sa.__stride_, ++__t) 2210 *__t = *__s; 2211 return *this; 2212} 2213 2214template <class _Tp> 2215inline valarray<_Tp>& valarray<_Tp>::operator=(const gslice_array<value_type>& __ga) { 2216 typedef const size_t* _Ip; 2217 value_type* __t = __begin_; 2218 const value_type* __s = __ga.__vp_; 2219 for (_Ip __i = __ga.__1d_.__begin_, __e = __ga.__1d_.__end_; __i != __e; ++__i, ++__t) 2220 *__t = __s[*__i]; 2221 return *this; 2222} 2223 2224template <class _Tp> 2225inline valarray<_Tp>& valarray<_Tp>::operator=(const mask_array<value_type>& __ma) { 2226 typedef const size_t* _Ip; 2227 value_type* __t = __begin_; 2228 const value_type* __s = __ma.__vp_; 2229 for (_Ip __i = __ma.__1d_.__begin_, __e = __ma.__1d_.__end_; __i != __e; ++__i, ++__t) 2230 *__t = __s[*__i]; 2231 return *this; 2232} 2233 2234template <class _Tp> 2235inline valarray<_Tp>& valarray<_Tp>::operator=(const indirect_array<value_type>& __ia) { 2236 typedef const size_t* _Ip; 2237 value_type* __t = __begin_; 2238 const value_type* __s = __ia.__vp_; 2239 for (_Ip __i = __ia.__1d_.__begin_, __e = __ia.__1d_.__end_; __i != __e; ++__i, ++__t) 2240 *__t = __s[*__i]; 2241 return *this; 2242} 2243 2244template <class _Tp> 2245template <class _ValExpr> 2246inline valarray<_Tp>& valarray<_Tp>::operator=(const __val_expr<_ValExpr>& __v) { 2247 size_t __n = __v.size(); 2248 if (size() != __n) 2249 resize(__n); 2250 value_type* __t = __begin_; 2251 for (size_t __i = 0; __i != __n; ++__t, ++__i) 2252 *__t = __result_type(__v[__i]); 2253 return *this; 2254} 2255 2256template <class _Tp> 2257inline __val_expr<__slice_expr<const valarray<_Tp>&> > valarray<_Tp>::operator[](slice __s) const { 2258 return __val_expr<__slice_expr<const valarray&> >(__slice_expr<const valarray&>(__s, *this)); 2259} 2260 2261template <class _Tp> 2262inline slice_array<_Tp> valarray<_Tp>::operator[](slice __s) { 2263 return slice_array<value_type>(__s, *this); 2264} 2265 2266template <class _Tp> 2267inline __val_expr<__indirect_expr<const valarray<_Tp>&> > valarray<_Tp>::operator[](const gslice& __gs) const { 2268 return __val_expr<__indirect_expr<const valarray&> >(__indirect_expr<const valarray&>(__gs.__1d_, *this)); 2269} 2270 2271template <class _Tp> 2272inline gslice_array<_Tp> valarray<_Tp>::operator[](const gslice& __gs) { 2273 return gslice_array<value_type>(__gs, *this); 2274} 2275 2276#ifndef _LIBCPP_CXX03_LANG 2277 2278template <class _Tp> 2279inline __val_expr<__indirect_expr<const valarray<_Tp>&> > valarray<_Tp>::operator[](gslice&& __gs) const { 2280 return __val_expr<__indirect_expr<const valarray&> >(__indirect_expr<const valarray&>(std::move(__gs.__1d_), *this)); 2281} 2282 2283template <class _Tp> 2284inline gslice_array<_Tp> valarray<_Tp>::operator[](gslice&& __gs) { 2285 return gslice_array<value_type>(std::move(__gs), *this); 2286} 2287 2288#endif // _LIBCPP_CXX03_LANG 2289 2290template <class _Tp> 2291inline __val_expr<__mask_expr<const valarray<_Tp>&> > valarray<_Tp>::operator[](const valarray<bool>& __vb) const { 2292 return __val_expr<__mask_expr<const valarray&> >(__mask_expr<const valarray&>(__vb, *this)); 2293} 2294 2295template <class _Tp> 2296inline mask_array<_Tp> valarray<_Tp>::operator[](const valarray<bool>& __vb) { 2297 return mask_array<value_type>(__vb, *this); 2298} 2299 2300#ifndef _LIBCPP_CXX03_LANG 2301 2302template <class _Tp> 2303inline __val_expr<__mask_expr<const valarray<_Tp>&> > valarray<_Tp>::operator[](valarray<bool>&& __vb) const { 2304 return __val_expr<__mask_expr<const valarray&> >(__mask_expr<const valarray&>(std::move(__vb), *this)); 2305} 2306 2307template <class _Tp> 2308inline mask_array<_Tp> valarray<_Tp>::operator[](valarray<bool>&& __vb) { 2309 return mask_array<value_type>(std::move(__vb), *this); 2310} 2311 2312#endif // _LIBCPP_CXX03_LANG 2313 2314template <class _Tp> 2315inline __val_expr<__indirect_expr<const valarray<_Tp>&> > 2316valarray<_Tp>::operator[](const valarray<size_t>& __vs) const { 2317 return __val_expr<__indirect_expr<const valarray&> >(__indirect_expr<const valarray&>(__vs, *this)); 2318} 2319 2320template <class _Tp> 2321inline indirect_array<_Tp> valarray<_Tp>::operator[](const valarray<size_t>& __vs) { 2322 return indirect_array<value_type>(__vs, *this); 2323} 2324 2325#ifndef _LIBCPP_CXX03_LANG 2326 2327template <class _Tp> 2328inline __val_expr<__indirect_expr<const valarray<_Tp>&> > valarray<_Tp>::operator[](valarray<size_t>&& __vs) const { 2329 return __val_expr<__indirect_expr<const valarray&> >(__indirect_expr<const valarray&>(std::move(__vs), *this)); 2330} 2331 2332template <class _Tp> 2333inline indirect_array<_Tp> valarray<_Tp>::operator[](valarray<size_t>&& __vs) { 2334 return indirect_array<value_type>(std::move(__vs), *this); 2335} 2336 2337#endif // _LIBCPP_CXX03_LANG 2338 2339template <class _Tp> 2340inline __val_expr<_UnaryOp<__unary_plus<_Tp>, const valarray<_Tp>&> > valarray<_Tp>::operator+() const { 2341 using _Op = _UnaryOp<__unary_plus<_Tp>, const valarray<_Tp>&>; 2342 return __val_expr<_Op>(_Op(__unary_plus<_Tp>(), *this)); 2343} 2344 2345template <class _Tp> 2346inline __val_expr<_UnaryOp<negate<_Tp>, const valarray<_Tp>&> > valarray<_Tp>::operator-() const { 2347 using _Op = _UnaryOp<negate<_Tp>, const valarray<_Tp>&>; 2348 return __val_expr<_Op>(_Op(negate<_Tp>(), *this)); 2349} 2350 2351template <class _Tp> 2352inline __val_expr<_UnaryOp<__bit_not<_Tp>, const valarray<_Tp>&> > valarray<_Tp>::operator~() const { 2353 using _Op = _UnaryOp<__bit_not<_Tp>, const valarray<_Tp>&>; 2354 return __val_expr<_Op>(_Op(__bit_not<_Tp>(), *this)); 2355} 2356 2357template <class _Tp> 2358inline __val_expr<_UnaryOp<logical_not<_Tp>, const valarray<_Tp>&> > valarray<_Tp>::operator!() const { 2359 using _Op = _UnaryOp<logical_not<_Tp>, const valarray<_Tp>&>; 2360 return __val_expr<_Op>(_Op(logical_not<_Tp>(), *this)); 2361} 2362 2363template <class _Tp> 2364inline valarray<_Tp>& valarray<_Tp>::operator*=(const value_type& __x) { 2365 for (value_type* __p = __begin_; __p != __end_; ++__p) 2366 *__p *= __x; 2367 return *this; 2368} 2369 2370template <class _Tp> 2371inline valarray<_Tp>& valarray<_Tp>::operator/=(const value_type& __x) { 2372 for (value_type* __p = __begin_; __p != __end_; ++__p) 2373 *__p /= __x; 2374 return *this; 2375} 2376 2377template <class _Tp> 2378inline valarray<_Tp>& valarray<_Tp>::operator%=(const value_type& __x) { 2379 for (value_type* __p = __begin_; __p != __end_; ++__p) 2380 *__p %= __x; 2381 return *this; 2382} 2383 2384template <class _Tp> 2385inline valarray<_Tp>& valarray<_Tp>::operator+=(const value_type& __x) { 2386 for (value_type* __p = __begin_; __p != __end_; ++__p) 2387 *__p += __x; 2388 return *this; 2389} 2390 2391template <class _Tp> 2392inline valarray<_Tp>& valarray<_Tp>::operator-=(const value_type& __x) { 2393 for (value_type* __p = __begin_; __p != __end_; ++__p) 2394 *__p -= __x; 2395 return *this; 2396} 2397 2398template <class _Tp> 2399inline valarray<_Tp>& valarray<_Tp>::operator^=(const value_type& __x) { 2400 for (value_type* __p = __begin_; __p != __end_; ++__p) 2401 *__p ^= __x; 2402 return *this; 2403} 2404 2405template <class _Tp> 2406inline valarray<_Tp>& valarray<_Tp>::operator&=(const value_type& __x) { 2407 for (value_type* __p = __begin_; __p != __end_; ++__p) 2408 *__p &= __x; 2409 return *this; 2410} 2411 2412template <class _Tp> 2413inline valarray<_Tp>& valarray<_Tp>::operator|=(const value_type& __x) { 2414 for (value_type* __p = __begin_; __p != __end_; ++__p) 2415 *__p |= __x; 2416 return *this; 2417} 2418 2419template <class _Tp> 2420inline valarray<_Tp>& valarray<_Tp>::operator<<=(const value_type& __x) { 2421 for (value_type* __p = __begin_; __p != __end_; ++__p) 2422 *__p <<= __x; 2423 return *this; 2424} 2425 2426template <class _Tp> 2427inline valarray<_Tp>& valarray<_Tp>::operator>>=(const value_type& __x) { 2428 for (value_type* __p = __begin_; __p != __end_; ++__p) 2429 *__p >>= __x; 2430 return *this; 2431} 2432 2433template <class _Tp> 2434template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> > 2435inline valarray<_Tp>& valarray<_Tp>::operator*=(const _Expr& __v) { 2436 size_t __i = 0; 2437 for (value_type* __t = __begin_; __t != __end_; ++__t, ++__i) 2438 *__t *= std::__get(__v, __i); 2439 return *this; 2440} 2441 2442template <class _Tp> 2443template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> > 2444inline valarray<_Tp>& valarray<_Tp>::operator/=(const _Expr& __v) { 2445 size_t __i = 0; 2446 for (value_type* __t = __begin_; __t != __end_; ++__t, ++__i) 2447 *__t /= std::__get(__v, __i); 2448 return *this; 2449} 2450 2451template <class _Tp> 2452template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> > 2453inline valarray<_Tp>& valarray<_Tp>::operator%=(const _Expr& __v) { 2454 size_t __i = 0; 2455 for (value_type* __t = __begin_; __t != __end_; ++__t, ++__i) 2456 *__t %= std::__get(__v, __i); 2457 return *this; 2458} 2459 2460template <class _Tp> 2461template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> > 2462inline valarray<_Tp>& valarray<_Tp>::operator+=(const _Expr& __v) { 2463 size_t __i = 0; 2464 for (value_type* __t = __begin_; __t != __end_; ++__t, ++__i) 2465 *__t += std::__get(__v, __i); 2466 return *this; 2467} 2468 2469template <class _Tp> 2470template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> > 2471inline valarray<_Tp>& valarray<_Tp>::operator-=(const _Expr& __v) { 2472 size_t __i = 0; 2473 for (value_type* __t = __begin_; __t != __end_; ++__t, ++__i) 2474 *__t -= std::__get(__v, __i); 2475 return *this; 2476} 2477 2478template <class _Tp> 2479template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> > 2480inline valarray<_Tp>& valarray<_Tp>::operator^=(const _Expr& __v) { 2481 size_t __i = 0; 2482 for (value_type* __t = __begin_; __t != __end_; ++__t, ++__i) 2483 *__t ^= std::__get(__v, __i); 2484 return *this; 2485} 2486 2487template <class _Tp> 2488template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> > 2489inline valarray<_Tp>& valarray<_Tp>::operator|=(const _Expr& __v) { 2490 size_t __i = 0; 2491 for (value_type* __t = __begin_; __t != __end_; ++__t, ++__i) 2492 *__t |= std::__get(__v, __i); 2493 return *this; 2494} 2495 2496template <class _Tp> 2497template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> > 2498inline valarray<_Tp>& valarray<_Tp>::operator&=(const _Expr& __v) { 2499 size_t __i = 0; 2500 for (value_type* __t = __begin_; __t != __end_; ++__t, ++__i) 2501 *__t &= std::__get(__v, __i); 2502 return *this; 2503} 2504 2505template <class _Tp> 2506template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> > 2507inline valarray<_Tp>& valarray<_Tp>::operator<<=(const _Expr& __v) { 2508 size_t __i = 0; 2509 for (value_type* __t = __begin_; __t != __end_; ++__t, ++__i) 2510 *__t <<= std::__get(__v, __i); 2511 return *this; 2512} 2513 2514template <class _Tp> 2515template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> > 2516inline valarray<_Tp>& valarray<_Tp>::operator>>=(const _Expr& __v) { 2517 size_t __i = 0; 2518 for (value_type* __t = __begin_; __t != __end_; ++__t, ++__i) 2519 *__t >>= std::__get(__v, __i); 2520 return *this; 2521} 2522 2523template <class _Tp> 2524inline void valarray<_Tp>::swap(valarray& __v) _NOEXCEPT { 2525 std::swap(__begin_, __v.__begin_); 2526 std::swap(__end_, __v.__end_); 2527} 2528 2529template <class _Tp> 2530inline _Tp valarray<_Tp>::sum() const { 2531 if (__begin_ == __end_) 2532 return value_type(); 2533 const value_type* __p = __begin_; 2534 _Tp __r = *__p; 2535 for (++__p; __p != __end_; ++__p) 2536 __r += *__p; 2537 return __r; 2538} 2539 2540template <class _Tp> 2541inline _Tp valarray<_Tp>::min() const { 2542 if (__begin_ == __end_) 2543 return value_type(); 2544 return *std::min_element(__begin_, __end_); 2545} 2546 2547template <class _Tp> 2548inline _Tp valarray<_Tp>::max() const { 2549 if (__begin_ == __end_) 2550 return value_type(); 2551 return *std::max_element(__begin_, __end_); 2552} 2553 2554template <class _Tp> 2555valarray<_Tp> valarray<_Tp>::shift(int __i) const { 2556 valarray<value_type> __r; 2557 size_t __n = size(); 2558 if (__n) { 2559 __r.__begin_ = __r.__end_ = allocator<value_type>().allocate(__n); 2560 const value_type* __sb; 2561 value_type* __tb; 2562 value_type* __te; 2563 if (__i >= 0) { 2564 __i = std::min(__i, static_cast<int>(__n)); 2565 __sb = __begin_ + __i; 2566 __tb = __r.__begin_; 2567 __te = __r.__begin_ + (__n - __i); 2568 } else { 2569 __i = std::min(-__i, static_cast<int>(__n)); 2570 __sb = __begin_; 2571 __tb = __r.__begin_ + __i; 2572 __te = __r.__begin_ + __n; 2573 } 2574 for (; __r.__end_ != __tb; ++__r.__end_) 2575 ::new ((void*)__r.__end_) value_type(); 2576 for (; __r.__end_ != __te; ++__r.__end_, ++__sb) 2577 ::new ((void*)__r.__end_) value_type(*__sb); 2578 for (__te = __r.__begin_ + __n; __r.__end_ != __te; ++__r.__end_) 2579 ::new ((void*)__r.__end_) value_type(); 2580 } 2581 return __r; 2582} 2583 2584template <class _Tp> 2585valarray<_Tp> valarray<_Tp>::cshift(int __i) const { 2586 valarray<value_type> __r; 2587 size_t __n = size(); 2588 if (__n) { 2589 __r.__begin_ = __r.__end_ = allocator<value_type>().allocate(__n); 2590 __i %= static_cast<int>(__n); 2591 const value_type* __m = __i >= 0 ? __begin_ + __i : __end_ + __i; 2592 for (const value_type* __s = __m; __s != __end_; ++__r.__end_, ++__s) 2593 ::new ((void*)__r.__end_) value_type(*__s); 2594 for (const value_type* __s = __begin_; __s != __m; ++__r.__end_, ++__s) 2595 ::new ((void*)__r.__end_) value_type(*__s); 2596 } 2597 return __r; 2598} 2599 2600template <class _Tp> 2601valarray<_Tp> valarray<_Tp>::apply(value_type __f(value_type)) const { 2602 valarray<value_type> __r; 2603 size_t __n = size(); 2604 if (__n) { 2605 __r.__begin_ = __r.__end_ = allocator<value_type>().allocate(__n); 2606 for (const value_type* __p = __begin_; __n; ++__r.__end_, ++__p, --__n) 2607 ::new ((void*)__r.__end_) value_type(__f(*__p)); 2608 } 2609 return __r; 2610} 2611 2612template <class _Tp> 2613valarray<_Tp> valarray<_Tp>::apply(value_type __f(const value_type&)) const { 2614 valarray<value_type> __r; 2615 size_t __n = size(); 2616 if (__n) { 2617 __r.__begin_ = __r.__end_ = allocator<value_type>().allocate(__n); 2618 for (const value_type* __p = __begin_; __n; ++__r.__end_, ++__p, --__n) 2619 ::new ((void*)__r.__end_) value_type(__f(*__p)); 2620 } 2621 return __r; 2622} 2623 2624template <class _Tp> 2625inline void valarray<_Tp>::__clear(size_t __capacity) { 2626 if (__begin_ != nullptr) { 2627 while (__end_ != __begin_) 2628 (--__end_)->~value_type(); 2629 allocator<value_type>().deallocate(__begin_, __capacity); 2630 __begin_ = __end_ = nullptr; 2631 } 2632} 2633 2634template <class _Tp> 2635void valarray<_Tp>::resize(size_t __n, value_type __x) { 2636 __clear(size()); 2637 if (__n) { 2638 __begin_ = __end_ = allocator<value_type>().allocate(__n); 2639#ifndef _LIBCPP_HAS_NO_EXCEPTIONS 2640 try { 2641#endif // _LIBCPP_HAS_NO_EXCEPTIONS 2642 for (size_t __n_left = __n; __n_left; --__n_left, ++__end_) 2643 ::new ((void*)__end_) value_type(__x); 2644#ifndef _LIBCPP_HAS_NO_EXCEPTIONS 2645 } catch (...) { 2646 __clear(__n); 2647 throw; 2648 } 2649#endif // _LIBCPP_HAS_NO_EXCEPTIONS 2650 } 2651} 2652 2653template <class _Tp> 2654inline _LIBCPP_HIDE_FROM_ABI void swap(valarray<_Tp>& __x, valarray<_Tp>& __y) _NOEXCEPT { 2655 __x.swap(__y); 2656} 2657 2658template <class _Expr1, 2659 class _Expr2, 2660 __enable_if_t<__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, int> = 0> 2661inline _LIBCPP_HIDE_FROM_ABI __val_expr<_BinaryOp<multiplies<typename _Expr1::value_type>, _Expr1, _Expr2> > 2662operator*(const _Expr1& __x, const _Expr2& __y) { 2663 typedef typename _Expr1::value_type value_type; 2664 typedef _BinaryOp<multiplies<value_type>, _Expr1, _Expr2> _Op; 2665 return __val_expr<_Op>(_Op(multiplies<value_type>(), __x, __y)); 2666} 2667 2668template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 2669inline _LIBCPP_HIDE_FROM_ABI 2670__val_expr<_BinaryOp<multiplies<typename _Expr::value_type>, _Expr, __scalar_expr<typename _Expr::value_type> > > 2671operator*(const _Expr& __x, const typename _Expr::value_type& __y) { 2672 typedef typename _Expr::value_type value_type; 2673 typedef _BinaryOp<multiplies<value_type>, _Expr, __scalar_expr<value_type> > _Op; 2674 return __val_expr<_Op>(_Op(multiplies<value_type>(), __x, __scalar_expr<value_type>(__y, __x.size()))); 2675} 2676 2677template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 2678inline _LIBCPP_HIDE_FROM_ABI 2679__val_expr<_BinaryOp<multiplies<typename _Expr::value_type>, __scalar_expr<typename _Expr::value_type>, _Expr> > 2680operator*(const typename _Expr::value_type& __x, const _Expr& __y) { 2681 typedef typename _Expr::value_type value_type; 2682 typedef _BinaryOp<multiplies<value_type>, __scalar_expr<value_type>, _Expr> _Op; 2683 return __val_expr<_Op>(_Op(multiplies<value_type>(), __scalar_expr<value_type>(__x, __y.size()), __y)); 2684} 2685 2686template <class _Expr1, 2687 class _Expr2, 2688 __enable_if_t<__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, int> = 0> 2689inline _LIBCPP_HIDE_FROM_ABI __val_expr<_BinaryOp<divides<typename _Expr1::value_type>, _Expr1, _Expr2> > 2690operator/(const _Expr1& __x, const _Expr2& __y) { 2691 typedef typename _Expr1::value_type value_type; 2692 typedef _BinaryOp<divides<value_type>, _Expr1, _Expr2> _Op; 2693 return __val_expr<_Op>(_Op(divides<value_type>(), __x, __y)); 2694} 2695 2696template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 2697inline _LIBCPP_HIDE_FROM_ABI 2698__val_expr<_BinaryOp<divides<typename _Expr::value_type>, _Expr, __scalar_expr<typename _Expr::value_type> > > 2699operator/(const _Expr& __x, const typename _Expr::value_type& __y) { 2700 typedef typename _Expr::value_type value_type; 2701 typedef _BinaryOp<divides<value_type>, _Expr, __scalar_expr<value_type> > _Op; 2702 return __val_expr<_Op>(_Op(divides<value_type>(), __x, __scalar_expr<value_type>(__y, __x.size()))); 2703} 2704 2705template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 2706inline _LIBCPP_HIDE_FROM_ABI 2707__val_expr<_BinaryOp<divides<typename _Expr::value_type>, __scalar_expr<typename _Expr::value_type>, _Expr> > 2708operator/(const typename _Expr::value_type& __x, const _Expr& __y) { 2709 typedef typename _Expr::value_type value_type; 2710 typedef _BinaryOp<divides<value_type>, __scalar_expr<value_type>, _Expr> _Op; 2711 return __val_expr<_Op>(_Op(divides<value_type>(), __scalar_expr<value_type>(__x, __y.size()), __y)); 2712} 2713 2714template <class _Expr1, 2715 class _Expr2, 2716 __enable_if_t<__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, int> = 0> 2717inline _LIBCPP_HIDE_FROM_ABI __val_expr<_BinaryOp<modulus<typename _Expr1::value_type>, _Expr1, _Expr2> > 2718operator%(const _Expr1& __x, const _Expr2& __y) { 2719 typedef typename _Expr1::value_type value_type; 2720 typedef _BinaryOp<modulus<value_type>, _Expr1, _Expr2> _Op; 2721 return __val_expr<_Op>(_Op(modulus<value_type>(), __x, __y)); 2722} 2723 2724template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 2725inline _LIBCPP_HIDE_FROM_ABI 2726__val_expr<_BinaryOp<modulus<typename _Expr::value_type>, _Expr, __scalar_expr<typename _Expr::value_type> > > 2727operator%(const _Expr& __x, const typename _Expr::value_type& __y) { 2728 typedef typename _Expr::value_type value_type; 2729 typedef _BinaryOp<modulus<value_type>, _Expr, __scalar_expr<value_type> > _Op; 2730 return __val_expr<_Op>(_Op(modulus<value_type>(), __x, __scalar_expr<value_type>(__y, __x.size()))); 2731} 2732 2733template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 2734inline _LIBCPP_HIDE_FROM_ABI 2735__val_expr<_BinaryOp<modulus<typename _Expr::value_type>, __scalar_expr<typename _Expr::value_type>, _Expr> > 2736operator%(const typename _Expr::value_type& __x, const _Expr& __y) { 2737 typedef typename _Expr::value_type value_type; 2738 typedef _BinaryOp<modulus<value_type>, __scalar_expr<value_type>, _Expr> _Op; 2739 return __val_expr<_Op>(_Op(modulus<value_type>(), __scalar_expr<value_type>(__x, __y.size()), __y)); 2740} 2741 2742template <class _Expr1, 2743 class _Expr2, 2744 __enable_if_t<__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, int> = 0> 2745inline _LIBCPP_HIDE_FROM_ABI __val_expr<_BinaryOp<plus<typename _Expr1::value_type>, _Expr1, _Expr2> > 2746operator+(const _Expr1& __x, const _Expr2& __y) { 2747 typedef typename _Expr1::value_type value_type; 2748 typedef _BinaryOp<plus<value_type>, _Expr1, _Expr2> _Op; 2749 return __val_expr<_Op>(_Op(plus<value_type>(), __x, __y)); 2750} 2751 2752template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 2753inline _LIBCPP_HIDE_FROM_ABI 2754__val_expr<_BinaryOp<plus<typename _Expr::value_type>, _Expr, __scalar_expr<typename _Expr::value_type> > > 2755operator+(const _Expr& __x, const typename _Expr::value_type& __y) { 2756 typedef typename _Expr::value_type value_type; 2757 typedef _BinaryOp<plus<value_type>, _Expr, __scalar_expr<value_type> > _Op; 2758 return __val_expr<_Op>(_Op(plus<value_type>(), __x, __scalar_expr<value_type>(__y, __x.size()))); 2759} 2760 2761template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 2762inline _LIBCPP_HIDE_FROM_ABI 2763__val_expr<_BinaryOp<plus<typename _Expr::value_type>, __scalar_expr<typename _Expr::value_type>, _Expr> > 2764operator+(const typename _Expr::value_type& __x, const _Expr& __y) { 2765 typedef typename _Expr::value_type value_type; 2766 typedef _BinaryOp<plus<value_type>, __scalar_expr<value_type>, _Expr> _Op; 2767 return __val_expr<_Op>(_Op(plus<value_type>(), __scalar_expr<value_type>(__x, __y.size()), __y)); 2768} 2769 2770template <class _Expr1, 2771 class _Expr2, 2772 __enable_if_t<__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, int> = 0> 2773inline _LIBCPP_HIDE_FROM_ABI __val_expr<_BinaryOp<minus<typename _Expr1::value_type>, _Expr1, _Expr2> > 2774operator-(const _Expr1& __x, const _Expr2& __y) { 2775 typedef typename _Expr1::value_type value_type; 2776 typedef _BinaryOp<minus<value_type>, _Expr1, _Expr2> _Op; 2777 return __val_expr<_Op>(_Op(minus<value_type>(), __x, __y)); 2778} 2779 2780template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 2781inline _LIBCPP_HIDE_FROM_ABI 2782__val_expr<_BinaryOp<minus<typename _Expr::value_type>, _Expr, __scalar_expr<typename _Expr::value_type> > > 2783operator-(const _Expr& __x, const typename _Expr::value_type& __y) { 2784 typedef typename _Expr::value_type value_type; 2785 typedef _BinaryOp<minus<value_type>, _Expr, __scalar_expr<value_type> > _Op; 2786 return __val_expr<_Op>(_Op(minus<value_type>(), __x, __scalar_expr<value_type>(__y, __x.size()))); 2787} 2788 2789template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 2790inline _LIBCPP_HIDE_FROM_ABI 2791__val_expr<_BinaryOp<minus<typename _Expr::value_type>, __scalar_expr<typename _Expr::value_type>, _Expr> > 2792operator-(const typename _Expr::value_type& __x, const _Expr& __y) { 2793 typedef typename _Expr::value_type value_type; 2794 typedef _BinaryOp<minus<value_type>, __scalar_expr<value_type>, _Expr> _Op; 2795 return __val_expr<_Op>(_Op(minus<value_type>(), __scalar_expr<value_type>(__x, __y.size()), __y)); 2796} 2797 2798template <class _Expr1, 2799 class _Expr2, 2800 __enable_if_t<__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, int> = 0> 2801inline _LIBCPP_HIDE_FROM_ABI __val_expr<_BinaryOp<bit_xor<typename _Expr1::value_type>, _Expr1, _Expr2> > 2802operator^(const _Expr1& __x, const _Expr2& __y) { 2803 typedef typename _Expr1::value_type value_type; 2804 typedef _BinaryOp<bit_xor<value_type>, _Expr1, _Expr2> _Op; 2805 return __val_expr<_Op>(_Op(bit_xor<value_type>(), __x, __y)); 2806} 2807 2808template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 2809inline _LIBCPP_HIDE_FROM_ABI 2810__val_expr<_BinaryOp<bit_xor<typename _Expr::value_type>, _Expr, __scalar_expr<typename _Expr::value_type> > > 2811operator^(const _Expr& __x, const typename _Expr::value_type& __y) { 2812 typedef typename _Expr::value_type value_type; 2813 typedef _BinaryOp<bit_xor<value_type>, _Expr, __scalar_expr<value_type> > _Op; 2814 return __val_expr<_Op>(_Op(bit_xor<value_type>(), __x, __scalar_expr<value_type>(__y, __x.size()))); 2815} 2816 2817template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 2818inline _LIBCPP_HIDE_FROM_ABI 2819__val_expr<_BinaryOp<bit_xor<typename _Expr::value_type>, __scalar_expr<typename _Expr::value_type>, _Expr> > 2820operator^(const typename _Expr::value_type& __x, const _Expr& __y) { 2821 typedef typename _Expr::value_type value_type; 2822 typedef _BinaryOp<bit_xor<value_type>, __scalar_expr<value_type>, _Expr> _Op; 2823 return __val_expr<_Op>(_Op(bit_xor<value_type>(), __scalar_expr<value_type>(__x, __y.size()), __y)); 2824} 2825 2826template <class _Expr1, 2827 class _Expr2, 2828 __enable_if_t<__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, int> = 0> 2829inline _LIBCPP_HIDE_FROM_ABI __val_expr<_BinaryOp<bit_and<typename _Expr1::value_type>, _Expr1, _Expr2> > 2830operator&(const _Expr1& __x, const _Expr2& __y) { 2831 typedef typename _Expr1::value_type value_type; 2832 typedef _BinaryOp<bit_and<value_type>, _Expr1, _Expr2> _Op; 2833 return __val_expr<_Op>(_Op(bit_and<value_type>(), __x, __y)); 2834} 2835 2836template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 2837inline _LIBCPP_HIDE_FROM_ABI 2838__val_expr<_BinaryOp<bit_and<typename _Expr::value_type>, _Expr, __scalar_expr<typename _Expr::value_type> > > 2839operator&(const _Expr& __x, const typename _Expr::value_type& __y) { 2840 typedef typename _Expr::value_type value_type; 2841 typedef _BinaryOp<bit_and<value_type>, _Expr, __scalar_expr<value_type> > _Op; 2842 return __val_expr<_Op>(_Op(bit_and<value_type>(), __x, __scalar_expr<value_type>(__y, __x.size()))); 2843} 2844 2845template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 2846inline _LIBCPP_HIDE_FROM_ABI 2847__val_expr<_BinaryOp<bit_and<typename _Expr::value_type>, __scalar_expr<typename _Expr::value_type>, _Expr> > 2848operator&(const typename _Expr::value_type& __x, const _Expr& __y) { 2849 typedef typename _Expr::value_type value_type; 2850 typedef _BinaryOp<bit_and<value_type>, __scalar_expr<value_type>, _Expr> _Op; 2851 return __val_expr<_Op>(_Op(bit_and<value_type>(), __scalar_expr<value_type>(__x, __y.size()), __y)); 2852} 2853 2854template <class _Expr1, 2855 class _Expr2, 2856 __enable_if_t<__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, int> = 0> 2857inline _LIBCPP_HIDE_FROM_ABI __val_expr<_BinaryOp<bit_or<typename _Expr1::value_type>, _Expr1, _Expr2> > 2858operator|(const _Expr1& __x, const _Expr2& __y) { 2859 typedef typename _Expr1::value_type value_type; 2860 typedef _BinaryOp<bit_or<value_type>, _Expr1, _Expr2> _Op; 2861 return __val_expr<_Op>(_Op(bit_or<value_type>(), __x, __y)); 2862} 2863 2864template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 2865inline _LIBCPP_HIDE_FROM_ABI 2866__val_expr<_BinaryOp<bit_or<typename _Expr::value_type>, _Expr, __scalar_expr<typename _Expr::value_type> > > 2867operator|(const _Expr& __x, const typename _Expr::value_type& __y) { 2868 typedef typename _Expr::value_type value_type; 2869 typedef _BinaryOp<bit_or<value_type>, _Expr, __scalar_expr<value_type> > _Op; 2870 return __val_expr<_Op>(_Op(bit_or<value_type>(), __x, __scalar_expr<value_type>(__y, __x.size()))); 2871} 2872 2873template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 2874inline _LIBCPP_HIDE_FROM_ABI 2875__val_expr<_BinaryOp<bit_or<typename _Expr::value_type>, __scalar_expr<typename _Expr::value_type>, _Expr> > 2876operator|(const typename _Expr::value_type& __x, const _Expr& __y) { 2877 typedef typename _Expr::value_type value_type; 2878 typedef _BinaryOp<bit_or<value_type>, __scalar_expr<value_type>, _Expr> _Op; 2879 return __val_expr<_Op>(_Op(bit_or<value_type>(), __scalar_expr<value_type>(__x, __y.size()), __y)); 2880} 2881 2882template <class _Expr1, 2883 class _Expr2, 2884 __enable_if_t<__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, int> = 0> 2885inline _LIBCPP_HIDE_FROM_ABI __val_expr<_BinaryOp<__bit_shift_left<typename _Expr1::value_type>, _Expr1, _Expr2> > 2886operator<<(const _Expr1& __x, const _Expr2& __y) { 2887 typedef typename _Expr1::value_type value_type; 2888 typedef _BinaryOp<__bit_shift_left<value_type>, _Expr1, _Expr2> _Op; 2889 return __val_expr<_Op>(_Op(__bit_shift_left<value_type>(), __x, __y)); 2890} 2891 2892template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 2893inline _LIBCPP_HIDE_FROM_ABI 2894__val_expr< _BinaryOp<__bit_shift_left<typename _Expr::value_type>, _Expr, __scalar_expr<typename _Expr::value_type> > > 2895operator<<(const _Expr& __x, const typename _Expr::value_type& __y) { 2896 typedef typename _Expr::value_type value_type; 2897 typedef _BinaryOp<__bit_shift_left<value_type>, _Expr, __scalar_expr<value_type> > _Op; 2898 return __val_expr<_Op>(_Op(__bit_shift_left<value_type>(), __x, __scalar_expr<value_type>(__y, __x.size()))); 2899} 2900 2901template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 2902inline _LIBCPP_HIDE_FROM_ABI 2903__val_expr< _BinaryOp<__bit_shift_left<typename _Expr::value_type>, __scalar_expr<typename _Expr::value_type>, _Expr> > 2904operator<<(const typename _Expr::value_type& __x, const _Expr& __y) { 2905 typedef typename _Expr::value_type value_type; 2906 typedef _BinaryOp<__bit_shift_left<value_type>, __scalar_expr<value_type>, _Expr> _Op; 2907 return __val_expr<_Op>(_Op(__bit_shift_left<value_type>(), __scalar_expr<value_type>(__x, __y.size()), __y)); 2908} 2909 2910template <class _Expr1, 2911 class _Expr2, 2912 __enable_if_t<__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, int> = 0> 2913inline _LIBCPP_HIDE_FROM_ABI __val_expr<_BinaryOp<__bit_shift_right<typename _Expr1::value_type>, _Expr1, _Expr2> > 2914operator>>(const _Expr1& __x, const _Expr2& __y) { 2915 typedef typename _Expr1::value_type value_type; 2916 typedef _BinaryOp<__bit_shift_right<value_type>, _Expr1, _Expr2> _Op; 2917 return __val_expr<_Op>(_Op(__bit_shift_right<value_type>(), __x, __y)); 2918} 2919 2920template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 2921inline _LIBCPP_HIDE_FROM_ABI __val_expr< 2922 _BinaryOp<__bit_shift_right<typename _Expr::value_type>, _Expr, __scalar_expr<typename _Expr::value_type> > > 2923operator>>(const _Expr& __x, const typename _Expr::value_type& __y) { 2924 typedef typename _Expr::value_type value_type; 2925 typedef _BinaryOp<__bit_shift_right<value_type>, _Expr, __scalar_expr<value_type> > _Op; 2926 return __val_expr<_Op>(_Op(__bit_shift_right<value_type>(), __x, __scalar_expr<value_type>(__y, __x.size()))); 2927} 2928 2929template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 2930inline _LIBCPP_HIDE_FROM_ABI 2931__val_expr< _BinaryOp<__bit_shift_right<typename _Expr::value_type>, __scalar_expr<typename _Expr::value_type>, _Expr> > 2932operator>>(const typename _Expr::value_type& __x, const _Expr& __y) { 2933 typedef typename _Expr::value_type value_type; 2934 typedef _BinaryOp<__bit_shift_right<value_type>, __scalar_expr<value_type>, _Expr> _Op; 2935 return __val_expr<_Op>(_Op(__bit_shift_right<value_type>(), __scalar_expr<value_type>(__x, __y.size()), __y)); 2936} 2937 2938template <class _Expr1, 2939 class _Expr2, 2940 __enable_if_t<__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, int> = 0> 2941inline _LIBCPP_HIDE_FROM_ABI __val_expr<_BinaryOp<logical_and<typename _Expr1::value_type>, _Expr1, _Expr2> > 2942operator&&(const _Expr1& __x, const _Expr2& __y) { 2943 typedef typename _Expr1::value_type value_type; 2944 typedef _BinaryOp<logical_and<value_type>, _Expr1, _Expr2> _Op; 2945 return __val_expr<_Op>(_Op(logical_and<value_type>(), __x, __y)); 2946} 2947 2948template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 2949inline _LIBCPP_HIDE_FROM_ABI 2950__val_expr<_BinaryOp<logical_and<typename _Expr::value_type>, _Expr, __scalar_expr<typename _Expr::value_type> > > 2951operator&&(const _Expr& __x, const typename _Expr::value_type& __y) { 2952 typedef typename _Expr::value_type value_type; 2953 typedef _BinaryOp<logical_and<value_type>, _Expr, __scalar_expr<value_type> > _Op; 2954 return __val_expr<_Op>(_Op(logical_and<value_type>(), __x, __scalar_expr<value_type>(__y, __x.size()))); 2955} 2956 2957template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 2958inline _LIBCPP_HIDE_FROM_ABI 2959__val_expr<_BinaryOp<logical_and<typename _Expr::value_type>, __scalar_expr<typename _Expr::value_type>, _Expr> > 2960operator&&(const typename _Expr::value_type& __x, const _Expr& __y) { 2961 typedef typename _Expr::value_type value_type; 2962 typedef _BinaryOp<logical_and<value_type>, __scalar_expr<value_type>, _Expr> _Op; 2963 return __val_expr<_Op>(_Op(logical_and<value_type>(), __scalar_expr<value_type>(__x, __y.size()), __y)); 2964} 2965 2966template <class _Expr1, 2967 class _Expr2, 2968 __enable_if_t<__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, int> = 0> 2969inline _LIBCPP_HIDE_FROM_ABI __val_expr<_BinaryOp<logical_or<typename _Expr1::value_type>, _Expr1, _Expr2> > 2970operator||(const _Expr1& __x, const _Expr2& __y) { 2971 typedef typename _Expr1::value_type value_type; 2972 typedef _BinaryOp<logical_or<value_type>, _Expr1, _Expr2> _Op; 2973 return __val_expr<_Op>(_Op(logical_or<value_type>(), __x, __y)); 2974} 2975 2976template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 2977inline _LIBCPP_HIDE_FROM_ABI 2978__val_expr<_BinaryOp<logical_or<typename _Expr::value_type>, _Expr, __scalar_expr<typename _Expr::value_type> > > 2979operator||(const _Expr& __x, const typename _Expr::value_type& __y) { 2980 typedef typename _Expr::value_type value_type; 2981 typedef _BinaryOp<logical_or<value_type>, _Expr, __scalar_expr<value_type> > _Op; 2982 return __val_expr<_Op>(_Op(logical_or<value_type>(), __x, __scalar_expr<value_type>(__y, __x.size()))); 2983} 2984 2985template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 2986inline _LIBCPP_HIDE_FROM_ABI 2987__val_expr<_BinaryOp<logical_or<typename _Expr::value_type>, __scalar_expr<typename _Expr::value_type>, _Expr> > 2988operator||(const typename _Expr::value_type& __x, const _Expr& __y) { 2989 typedef typename _Expr::value_type value_type; 2990 typedef _BinaryOp<logical_or<value_type>, __scalar_expr<value_type>, _Expr> _Op; 2991 return __val_expr<_Op>(_Op(logical_or<value_type>(), __scalar_expr<value_type>(__x, __y.size()), __y)); 2992} 2993 2994template <class _Expr1, 2995 class _Expr2, 2996 __enable_if_t<__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, int> = 0> 2997inline _LIBCPP_HIDE_FROM_ABI __val_expr<_BinaryOp<equal_to<typename _Expr1::value_type>, _Expr1, _Expr2> > 2998operator==(const _Expr1& __x, const _Expr2& __y) { 2999 typedef typename _Expr1::value_type value_type; 3000 typedef _BinaryOp<equal_to<value_type>, _Expr1, _Expr2> _Op; 3001 return __val_expr<_Op>(_Op(equal_to<value_type>(), __x, __y)); 3002} 3003 3004template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 3005inline _LIBCPP_HIDE_FROM_ABI 3006__val_expr<_BinaryOp<equal_to<typename _Expr::value_type>, _Expr, __scalar_expr<typename _Expr::value_type> > > 3007operator==(const _Expr& __x, const typename _Expr::value_type& __y) { 3008 typedef typename _Expr::value_type value_type; 3009 typedef _BinaryOp<equal_to<value_type>, _Expr, __scalar_expr<value_type> > _Op; 3010 return __val_expr<_Op>(_Op(equal_to<value_type>(), __x, __scalar_expr<value_type>(__y, __x.size()))); 3011} 3012 3013template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 3014inline _LIBCPP_HIDE_FROM_ABI 3015__val_expr<_BinaryOp<equal_to<typename _Expr::value_type>, __scalar_expr<typename _Expr::value_type>, _Expr> > 3016operator==(const typename _Expr::value_type& __x, const _Expr& __y) { 3017 typedef typename _Expr::value_type value_type; 3018 typedef _BinaryOp<equal_to<value_type>, __scalar_expr<value_type>, _Expr> _Op; 3019 return __val_expr<_Op>(_Op(equal_to<value_type>(), __scalar_expr<value_type>(__x, __y.size()), __y)); 3020} 3021 3022template <class _Expr1, 3023 class _Expr2, 3024 __enable_if_t<__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, int> = 0> 3025inline _LIBCPP_HIDE_FROM_ABI __val_expr<_BinaryOp<not_equal_to<typename _Expr1::value_type>, _Expr1, _Expr2> > 3026operator!=(const _Expr1& __x, const _Expr2& __y) { 3027 typedef typename _Expr1::value_type value_type; 3028 typedef _BinaryOp<not_equal_to<value_type>, _Expr1, _Expr2> _Op; 3029 return __val_expr<_Op>(_Op(not_equal_to<value_type>(), __x, __y)); 3030} 3031 3032template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 3033inline _LIBCPP_HIDE_FROM_ABI 3034__val_expr<_BinaryOp<not_equal_to<typename _Expr::value_type>, _Expr, __scalar_expr<typename _Expr::value_type> > > 3035operator!=(const _Expr& __x, const typename _Expr::value_type& __y) { 3036 typedef typename _Expr::value_type value_type; 3037 typedef _BinaryOp<not_equal_to<value_type>, _Expr, __scalar_expr<value_type> > _Op; 3038 return __val_expr<_Op>(_Op(not_equal_to<value_type>(), __x, __scalar_expr<value_type>(__y, __x.size()))); 3039} 3040 3041template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 3042inline _LIBCPP_HIDE_FROM_ABI 3043__val_expr<_BinaryOp<not_equal_to<typename _Expr::value_type>, __scalar_expr<typename _Expr::value_type>, _Expr> > 3044operator!=(const typename _Expr::value_type& __x, const _Expr& __y) { 3045 typedef typename _Expr::value_type value_type; 3046 typedef _BinaryOp<not_equal_to<value_type>, __scalar_expr<value_type>, _Expr> _Op; 3047 return __val_expr<_Op>(_Op(not_equal_to<value_type>(), __scalar_expr<value_type>(__x, __y.size()), __y)); 3048} 3049 3050template <class _Expr1, 3051 class _Expr2, 3052 __enable_if_t<__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, int> = 0> 3053inline _LIBCPP_HIDE_FROM_ABI __val_expr<_BinaryOp<less<typename _Expr1::value_type>, _Expr1, _Expr2> > 3054operator<(const _Expr1& __x, const _Expr2& __y) { 3055 typedef typename _Expr1::value_type value_type; 3056 typedef _BinaryOp<less<value_type>, _Expr1, _Expr2> _Op; 3057 return __val_expr<_Op>(_Op(less<value_type>(), __x, __y)); 3058} 3059 3060template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 3061inline _LIBCPP_HIDE_FROM_ABI 3062__val_expr<_BinaryOp<less<typename _Expr::value_type>, _Expr, __scalar_expr<typename _Expr::value_type> > > 3063operator<(const _Expr& __x, const typename _Expr::value_type& __y) { 3064 typedef typename _Expr::value_type value_type; 3065 typedef _BinaryOp<less<value_type>, _Expr, __scalar_expr<value_type> > _Op; 3066 return __val_expr<_Op>(_Op(less<value_type>(), __x, __scalar_expr<value_type>(__y, __x.size()))); 3067} 3068 3069template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 3070inline _LIBCPP_HIDE_FROM_ABI 3071__val_expr<_BinaryOp<less<typename _Expr::value_type>, __scalar_expr<typename _Expr::value_type>, _Expr> > 3072operator<(const typename _Expr::value_type& __x, const _Expr& __y) { 3073 typedef typename _Expr::value_type value_type; 3074 typedef _BinaryOp<less<value_type>, __scalar_expr<value_type>, _Expr> _Op; 3075 return __val_expr<_Op>(_Op(less<value_type>(), __scalar_expr<value_type>(__x, __y.size()), __y)); 3076} 3077 3078template <class _Expr1, 3079 class _Expr2, 3080 __enable_if_t<__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, int> = 0> 3081inline _LIBCPP_HIDE_FROM_ABI __val_expr<_BinaryOp<greater<typename _Expr1::value_type>, _Expr1, _Expr2> > 3082operator>(const _Expr1& __x, const _Expr2& __y) { 3083 typedef typename _Expr1::value_type value_type; 3084 typedef _BinaryOp<greater<value_type>, _Expr1, _Expr2> _Op; 3085 return __val_expr<_Op>(_Op(greater<value_type>(), __x, __y)); 3086} 3087 3088template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 3089inline _LIBCPP_HIDE_FROM_ABI 3090__val_expr<_BinaryOp<greater<typename _Expr::value_type>, _Expr, __scalar_expr<typename _Expr::value_type> > > 3091operator>(const _Expr& __x, const typename _Expr::value_type& __y) { 3092 typedef typename _Expr::value_type value_type; 3093 typedef _BinaryOp<greater<value_type>, _Expr, __scalar_expr<value_type> > _Op; 3094 return __val_expr<_Op>(_Op(greater<value_type>(), __x, __scalar_expr<value_type>(__y, __x.size()))); 3095} 3096 3097template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 3098inline _LIBCPP_HIDE_FROM_ABI 3099__val_expr<_BinaryOp<greater<typename _Expr::value_type>, __scalar_expr<typename _Expr::value_type>, _Expr> > 3100operator>(const typename _Expr::value_type& __x, const _Expr& __y) { 3101 typedef typename _Expr::value_type value_type; 3102 typedef _BinaryOp<greater<value_type>, __scalar_expr<value_type>, _Expr> _Op; 3103 return __val_expr<_Op>(_Op(greater<value_type>(), __scalar_expr<value_type>(__x, __y.size()), __y)); 3104} 3105 3106template <class _Expr1, 3107 class _Expr2, 3108 __enable_if_t<__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, int> = 0> 3109inline _LIBCPP_HIDE_FROM_ABI __val_expr<_BinaryOp<less_equal<typename _Expr1::value_type>, _Expr1, _Expr2> > 3110operator<=(const _Expr1& __x, const _Expr2& __y) { 3111 typedef typename _Expr1::value_type value_type; 3112 typedef _BinaryOp<less_equal<value_type>, _Expr1, _Expr2> _Op; 3113 return __val_expr<_Op>(_Op(less_equal<value_type>(), __x, __y)); 3114} 3115 3116template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 3117inline _LIBCPP_HIDE_FROM_ABI 3118__val_expr<_BinaryOp<less_equal<typename _Expr::value_type>, _Expr, __scalar_expr<typename _Expr::value_type> > > 3119operator<=(const _Expr& __x, const typename _Expr::value_type& __y) { 3120 typedef typename _Expr::value_type value_type; 3121 typedef _BinaryOp<less_equal<value_type>, _Expr, __scalar_expr<value_type> > _Op; 3122 return __val_expr<_Op>(_Op(less_equal<value_type>(), __x, __scalar_expr<value_type>(__y, __x.size()))); 3123} 3124 3125template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 3126inline _LIBCPP_HIDE_FROM_ABI 3127__val_expr<_BinaryOp<less_equal<typename _Expr::value_type>, __scalar_expr<typename _Expr::value_type>, _Expr> > 3128operator<=(const typename _Expr::value_type& __x, const _Expr& __y) { 3129 typedef typename _Expr::value_type value_type; 3130 typedef _BinaryOp<less_equal<value_type>, __scalar_expr<value_type>, _Expr> _Op; 3131 return __val_expr<_Op>(_Op(less_equal<value_type>(), __scalar_expr<value_type>(__x, __y.size()), __y)); 3132} 3133 3134template <class _Expr1, 3135 class _Expr2, 3136 __enable_if_t<__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, int> = 0> 3137inline _LIBCPP_HIDE_FROM_ABI __val_expr<_BinaryOp<greater_equal<typename _Expr1::value_type>, _Expr1, _Expr2> > 3138operator>=(const _Expr1& __x, const _Expr2& __y) { 3139 typedef typename _Expr1::value_type value_type; 3140 typedef _BinaryOp<greater_equal<value_type>, _Expr1, _Expr2> _Op; 3141 return __val_expr<_Op>(_Op(greater_equal<value_type>(), __x, __y)); 3142} 3143 3144template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 3145inline _LIBCPP_HIDE_FROM_ABI 3146__val_expr<_BinaryOp<greater_equal<typename _Expr::value_type>, _Expr, __scalar_expr<typename _Expr::value_type> > > 3147operator>=(const _Expr& __x, const typename _Expr::value_type& __y) { 3148 typedef typename _Expr::value_type value_type; 3149 typedef _BinaryOp<greater_equal<value_type>, _Expr, __scalar_expr<value_type> > _Op; 3150 return __val_expr<_Op>(_Op(greater_equal<value_type>(), __x, __scalar_expr<value_type>(__y, __x.size()))); 3151} 3152 3153template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 3154inline _LIBCPP_HIDE_FROM_ABI 3155__val_expr<_BinaryOp<greater_equal<typename _Expr::value_type>, __scalar_expr<typename _Expr::value_type>, _Expr> > 3156operator>=(const typename _Expr::value_type& __x, const _Expr& __y) { 3157 typedef typename _Expr::value_type value_type; 3158 typedef _BinaryOp<greater_equal<value_type>, __scalar_expr<value_type>, _Expr> _Op; 3159 return __val_expr<_Op>(_Op(greater_equal<value_type>(), __scalar_expr<value_type>(__x, __y.size()), __y)); 3160} 3161 3162template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 3163inline _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__abs_expr<typename _Expr::value_type>, _Expr> > 3164abs(const _Expr& __x) { 3165 typedef typename _Expr::value_type value_type; 3166 typedef _UnaryOp<__abs_expr<value_type>, _Expr> _Op; 3167 return __val_expr<_Op>(_Op(__abs_expr<value_type>(), __x)); 3168} 3169 3170template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 3171inline _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__acos_expr<typename _Expr::value_type>, _Expr> > 3172acos(const _Expr& __x) { 3173 typedef typename _Expr::value_type value_type; 3174 typedef _UnaryOp<__acos_expr<value_type>, _Expr> _Op; 3175 return __val_expr<_Op>(_Op(__acos_expr<value_type>(), __x)); 3176} 3177 3178template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 3179inline _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__asin_expr<typename _Expr::value_type>, _Expr> > 3180asin(const _Expr& __x) { 3181 typedef typename _Expr::value_type value_type; 3182 typedef _UnaryOp<__asin_expr<value_type>, _Expr> _Op; 3183 return __val_expr<_Op>(_Op(__asin_expr<value_type>(), __x)); 3184} 3185 3186template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 3187inline _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__atan_expr<typename _Expr::value_type>, _Expr> > 3188atan(const _Expr& __x) { 3189 typedef typename _Expr::value_type value_type; 3190 typedef _UnaryOp<__atan_expr<value_type>, _Expr> _Op; 3191 return __val_expr<_Op>(_Op(__atan_expr<value_type>(), __x)); 3192} 3193 3194template <class _Expr1, 3195 class _Expr2, 3196 __enable_if_t<__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, int> = 0> 3197inline _LIBCPP_HIDE_FROM_ABI __val_expr<_BinaryOp<__atan2_expr<typename _Expr1::value_type>, _Expr1, _Expr2> > 3198atan2(const _Expr1& __x, const _Expr2& __y) { 3199 typedef typename _Expr1::value_type value_type; 3200 typedef _BinaryOp<__atan2_expr<value_type>, _Expr1, _Expr2> _Op; 3201 return __val_expr<_Op>(_Op(__atan2_expr<value_type>(), __x, __y)); 3202} 3203 3204template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 3205inline _LIBCPP_HIDE_FROM_ABI 3206__val_expr<_BinaryOp<__atan2_expr<typename _Expr::value_type>, _Expr, __scalar_expr<typename _Expr::value_type> > > 3207atan2(const _Expr& __x, const typename _Expr::value_type& __y) { 3208 typedef typename _Expr::value_type value_type; 3209 typedef _BinaryOp<__atan2_expr<value_type>, _Expr, __scalar_expr<value_type> > _Op; 3210 return __val_expr<_Op>(_Op(__atan2_expr<value_type>(), __x, __scalar_expr<value_type>(__y, __x.size()))); 3211} 3212 3213template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 3214inline _LIBCPP_HIDE_FROM_ABI 3215__val_expr<_BinaryOp<__atan2_expr<typename _Expr::value_type>, __scalar_expr<typename _Expr::value_type>, _Expr> > 3216atan2(const typename _Expr::value_type& __x, const _Expr& __y) { 3217 typedef typename _Expr::value_type value_type; 3218 typedef _BinaryOp<__atan2_expr<value_type>, __scalar_expr<value_type>, _Expr> _Op; 3219 return __val_expr<_Op>(_Op(__atan2_expr<value_type>(), __scalar_expr<value_type>(__x, __y.size()), __y)); 3220} 3221 3222template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 3223inline _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__cos_expr<typename _Expr::value_type>, _Expr> > 3224cos(const _Expr& __x) { 3225 typedef typename _Expr::value_type value_type; 3226 typedef _UnaryOp<__cos_expr<value_type>, _Expr> _Op; 3227 return __val_expr<_Op>(_Op(__cos_expr<value_type>(), __x)); 3228} 3229 3230template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 3231inline _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__cosh_expr<typename _Expr::value_type>, _Expr> > 3232cosh(const _Expr& __x) { 3233 typedef typename _Expr::value_type value_type; 3234 typedef _UnaryOp<__cosh_expr<value_type>, _Expr> _Op; 3235 return __val_expr<_Op>(_Op(__cosh_expr<value_type>(), __x)); 3236} 3237 3238template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 3239inline _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__exp_expr<typename _Expr::value_type>, _Expr> > 3240exp(const _Expr& __x) { 3241 typedef typename _Expr::value_type value_type; 3242 typedef _UnaryOp<__exp_expr<value_type>, _Expr> _Op; 3243 return __val_expr<_Op>(_Op(__exp_expr<value_type>(), __x)); 3244} 3245 3246template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 3247inline _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__log_expr<typename _Expr::value_type>, _Expr> > 3248log(const _Expr& __x) { 3249 typedef typename _Expr::value_type value_type; 3250 typedef _UnaryOp<__log_expr<value_type>, _Expr> _Op; 3251 return __val_expr<_Op>(_Op(__log_expr<value_type>(), __x)); 3252} 3253 3254template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 3255inline _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__log10_expr<typename _Expr::value_type>, _Expr> > 3256log10(const _Expr& __x) { 3257 typedef typename _Expr::value_type value_type; 3258 typedef _UnaryOp<__log10_expr<value_type>, _Expr> _Op; 3259 return __val_expr<_Op>(_Op(__log10_expr<value_type>(), __x)); 3260} 3261 3262template <class _Expr1, 3263 class _Expr2, 3264 __enable_if_t<__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, int> = 0> 3265inline _LIBCPP_HIDE_FROM_ABI __val_expr<_BinaryOp<__pow_expr<typename _Expr1::value_type>, _Expr1, _Expr2> > 3266pow(const _Expr1& __x, const _Expr2& __y) { 3267 typedef typename _Expr1::value_type value_type; 3268 typedef _BinaryOp<__pow_expr<value_type>, _Expr1, _Expr2> _Op; 3269 return __val_expr<_Op>(_Op(__pow_expr<value_type>(), __x, __y)); 3270} 3271 3272template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 3273inline _LIBCPP_HIDE_FROM_ABI 3274__val_expr<_BinaryOp<__pow_expr<typename _Expr::value_type>, _Expr, __scalar_expr<typename _Expr::value_type> > > 3275pow(const _Expr& __x, const typename _Expr::value_type& __y) { 3276 typedef typename _Expr::value_type value_type; 3277 typedef _BinaryOp<__pow_expr<value_type>, _Expr, __scalar_expr<value_type> > _Op; 3278 return __val_expr<_Op>(_Op(__pow_expr<value_type>(), __x, __scalar_expr<value_type>(__y, __x.size()))); 3279} 3280 3281template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 3282inline _LIBCPP_HIDE_FROM_ABI 3283__val_expr<_BinaryOp<__pow_expr<typename _Expr::value_type>, __scalar_expr<typename _Expr::value_type>, _Expr> > 3284pow(const typename _Expr::value_type& __x, const _Expr& __y) { 3285 typedef typename _Expr::value_type value_type; 3286 typedef _BinaryOp<__pow_expr<value_type>, __scalar_expr<value_type>, _Expr> _Op; 3287 return __val_expr<_Op>(_Op(__pow_expr<value_type>(), __scalar_expr<value_type>(__x, __y.size()), __y)); 3288} 3289 3290template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 3291inline _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__sin_expr<typename _Expr::value_type>, _Expr> > 3292sin(const _Expr& __x) { 3293 typedef typename _Expr::value_type value_type; 3294 typedef _UnaryOp<__sin_expr<value_type>, _Expr> _Op; 3295 return __val_expr<_Op>(_Op(__sin_expr<value_type>(), __x)); 3296} 3297 3298template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 3299inline _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__sinh_expr<typename _Expr::value_type>, _Expr> > 3300sinh(const _Expr& __x) { 3301 typedef typename _Expr::value_type value_type; 3302 typedef _UnaryOp<__sinh_expr<value_type>, _Expr> _Op; 3303 return __val_expr<_Op>(_Op(__sinh_expr<value_type>(), __x)); 3304} 3305 3306template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 3307inline _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__sqrt_expr<typename _Expr::value_type>, _Expr> > 3308sqrt(const _Expr& __x) { 3309 typedef typename _Expr::value_type value_type; 3310 typedef _UnaryOp<__sqrt_expr<value_type>, _Expr> _Op; 3311 return __val_expr<_Op>(_Op(__sqrt_expr<value_type>(), __x)); 3312} 3313 3314template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 3315inline _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__tan_expr<typename _Expr::value_type>, _Expr> > 3316tan(const _Expr& __x) { 3317 typedef typename _Expr::value_type value_type; 3318 typedef _UnaryOp<__tan_expr<value_type>, _Expr> _Op; 3319 return __val_expr<_Op>(_Op(__tan_expr<value_type>(), __x)); 3320} 3321 3322template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 3323inline _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__tanh_expr<typename _Expr::value_type>, _Expr> > 3324tanh(const _Expr& __x) { 3325 typedef typename _Expr::value_type value_type; 3326 typedef _UnaryOp<__tanh_expr<value_type>, _Expr> _Op; 3327 return __val_expr<_Op>(_Op(__tanh_expr<value_type>(), __x)); 3328} 3329 3330template <class _Tp> 3331inline _LIBCPP_HIDE_FROM_ABI _Tp* begin(valarray<_Tp>& __v) { 3332 return __v.__begin_; 3333} 3334 3335template <class _Tp> 3336inline _LIBCPP_HIDE_FROM_ABI const _Tp* begin(const valarray<_Tp>& __v) { 3337 return __v.__begin_; 3338} 3339 3340template <class _Tp> 3341inline _LIBCPP_HIDE_FROM_ABI _Tp* end(valarray<_Tp>& __v) { 3342 return __v.__end_; 3343} 3344 3345template <class _Tp> 3346inline _LIBCPP_HIDE_FROM_ABI const _Tp* end(const valarray<_Tp>& __v) { 3347 return __v.__end_; 3348} 3349 3350_LIBCPP_END_NAMESPACE_STD 3351 3352_LIBCPP_POP_MACROS 3353 3354#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20 3355# include <algorithm> 3356# include <concepts> 3357# include <cstdlib> 3358# include <cstring> 3359# include <functional> 3360# include <stdexcept> 3361# include <type_traits> 3362#endif 3363 3364#endif // _LIBCPP_VALARRAY 3365