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> // all public C++ headers provide the assertion handler 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> 737class _LIBCPP_TEMPLATE_VIS valarray { 738public: 739 typedef _Tp value_type; 740 typedef _Tp __result_type; 741 742private: 743 value_type* __begin_; 744 value_type* __end_; 745 746public: 747 // construct/destroy: 748 _LIBCPP_HIDE_FROM_ABI valarray() : __begin_(nullptr), __end_(nullptr) {} 749 inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 explicit valarray(size_t __n); 750 _LIBCPP_HIDE_FROM_ABI valarray(const value_type& __x, size_t __n); 751 valarray(const value_type* __p, size_t __n); 752 valarray(const valarray& __v); 753#ifndef _LIBCPP_CXX03_LANG 754 _LIBCPP_HIDE_FROM_ABI valarray(valarray&& __v) _NOEXCEPT; 755 valarray(initializer_list<value_type> __il); 756#endif // _LIBCPP_CXX03_LANG 757 valarray(const slice_array<value_type>& __sa); 758 valarray(const gslice_array<value_type>& __ga); 759 valarray(const mask_array<value_type>& __ma); 760 valarray(const indirect_array<value_type>& __ia); 761 inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 ~valarray(); 762 763 // assignment: 764 valarray& operator=(const valarray& __v); 765#ifndef _LIBCPP_CXX03_LANG 766 _LIBCPP_HIDE_FROM_ABI valarray& operator=(valarray&& __v) _NOEXCEPT; 767 _LIBCPP_HIDE_FROM_ABI valarray& operator=(initializer_list<value_type>); 768#endif // _LIBCPP_CXX03_LANG 769 _LIBCPP_HIDE_FROM_ABI valarray& operator=(const value_type& __x); 770 _LIBCPP_HIDE_FROM_ABI valarray& operator=(const slice_array<value_type>& __sa); 771 _LIBCPP_HIDE_FROM_ABI valarray& operator=(const gslice_array<value_type>& __ga); 772 _LIBCPP_HIDE_FROM_ABI valarray& operator=(const mask_array<value_type>& __ma); 773 _LIBCPP_HIDE_FROM_ABI valarray& operator=(const indirect_array<value_type>& __ia); 774 template <class _ValExpr> 775 _LIBCPP_HIDE_FROM_ABI valarray& operator=(const __val_expr<_ValExpr>& __v); 776 777 // element access: 778 _LIBCPP_HIDE_FROM_ABI const value_type& operator[](size_t __i) const { return __begin_[__i]; } 779 780 _LIBCPP_HIDE_FROM_ABI value_type& operator[](size_t __i) { return __begin_[__i]; } 781 782 // subset operations: 783 _LIBCPP_HIDE_FROM_ABI __val_expr<__slice_expr<const valarray&> > operator[](slice __s) const; 784 _LIBCPP_HIDE_FROM_ABI slice_array<value_type> operator[](slice __s); 785 _LIBCPP_HIDE_FROM_ABI __val_expr<__indirect_expr<const valarray&> > operator[](const gslice& __gs) const; 786 _LIBCPP_HIDE_FROM_ABI gslice_array<value_type> operator[](const gslice& __gs); 787#ifndef _LIBCPP_CXX03_LANG 788 _LIBCPP_HIDE_FROM_ABI __val_expr<__indirect_expr<const valarray&> > operator[](gslice&& __gs) const; 789 _LIBCPP_HIDE_FROM_ABI gslice_array<value_type> operator[](gslice&& __gs); 790#endif // _LIBCPP_CXX03_LANG 791 _LIBCPP_HIDE_FROM_ABI __val_expr<__mask_expr<const valarray&> > operator[](const valarray<bool>& __vb) const; 792 _LIBCPP_HIDE_FROM_ABI mask_array<value_type> operator[](const valarray<bool>& __vb); 793#ifndef _LIBCPP_CXX03_LANG 794 _LIBCPP_HIDE_FROM_ABI __val_expr<__mask_expr<const valarray&> > operator[](valarray<bool>&& __vb) const; 795 _LIBCPP_HIDE_FROM_ABI mask_array<value_type> operator[](valarray<bool>&& __vb); 796#endif // _LIBCPP_CXX03_LANG 797 _LIBCPP_HIDE_FROM_ABI __val_expr<__indirect_expr<const valarray&> > operator[](const valarray<size_t>& __vs) const; 798 _LIBCPP_HIDE_FROM_ABI indirect_array<value_type> operator[](const valarray<size_t>& __vs); 799#ifndef _LIBCPP_CXX03_LANG 800 _LIBCPP_HIDE_FROM_ABI __val_expr<__indirect_expr<const valarray&> > operator[](valarray<size_t>&& __vs) const; 801 _LIBCPP_HIDE_FROM_ABI indirect_array<value_type> operator[](valarray<size_t>&& __vs); 802#endif // _LIBCPP_CXX03_LANG 803 804 // unary operators: 805 _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__unary_plus<_Tp>, const valarray&> > operator+() const; 806 _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<negate<_Tp>, const valarray&> > operator-() const; 807 _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__bit_not<_Tp>, const valarray&> > operator~() const; 808 _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<logical_not<_Tp>, const valarray&> > operator!() const; 809 810 // computed assignment: 811 _LIBCPP_HIDE_FROM_ABI valarray& operator*=(const value_type& __x); 812 _LIBCPP_HIDE_FROM_ABI valarray& operator/=(const value_type& __x); 813 _LIBCPP_HIDE_FROM_ABI valarray& operator%=(const value_type& __x); 814 _LIBCPP_HIDE_FROM_ABI valarray& operator+=(const value_type& __x); 815 _LIBCPP_HIDE_FROM_ABI valarray& operator-=(const value_type& __x); 816 _LIBCPP_HIDE_FROM_ABI valarray& operator^=(const value_type& __x); 817 _LIBCPP_HIDE_FROM_ABI valarray& operator&=(const value_type& __x); 818 _LIBCPP_HIDE_FROM_ABI valarray& operator|=(const value_type& __x); 819 _LIBCPP_HIDE_FROM_ABI valarray& operator<<=(const value_type& __x); 820 _LIBCPP_HIDE_FROM_ABI valarray& operator>>=(const value_type& __x); 821 822 template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 823 _LIBCPP_HIDE_FROM_ABI valarray& operator*=(const _Expr& __v); 824 825 template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 826 _LIBCPP_HIDE_FROM_ABI valarray& operator/=(const _Expr& __v); 827 828 template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 829 _LIBCPP_HIDE_FROM_ABI valarray& operator%=(const _Expr& __v); 830 831 template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 832 _LIBCPP_HIDE_FROM_ABI valarray& operator+=(const _Expr& __v); 833 834 template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 835 _LIBCPP_HIDE_FROM_ABI valarray& operator-=(const _Expr& __v); 836 837 template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 838 _LIBCPP_HIDE_FROM_ABI valarray& operator^=(const _Expr& __v); 839 840 template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 841 _LIBCPP_HIDE_FROM_ABI valarray& operator|=(const _Expr& __v); 842 843 template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 844 _LIBCPP_HIDE_FROM_ABI valarray& operator&=(const _Expr& __v); 845 846 template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 847 _LIBCPP_HIDE_FROM_ABI valarray& operator<<=(const _Expr& __v); 848 849 template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 850 _LIBCPP_HIDE_FROM_ABI valarray& operator>>=(const _Expr& __v); 851 852 // member functions: 853 _LIBCPP_HIDE_FROM_ABI void swap(valarray& __v) _NOEXCEPT; 854 855 _LIBCPP_HIDE_FROM_ABI size_t size() const { return static_cast<size_t>(__end_ - __begin_); } 856 857 _LIBCPP_HIDE_FROM_ABI value_type sum() const; 858 _LIBCPP_HIDE_FROM_ABI value_type min() const; 859 _LIBCPP_HIDE_FROM_ABI value_type max() const; 860 861 valarray shift(int __i) const; 862 valarray cshift(int __i) const; 863 valarray apply(value_type __f(value_type)) const; 864 valarray apply(value_type __f(const value_type&)) const; 865 void resize(size_t __n, value_type __x = value_type()); 866 867private: 868 template <class> 869 friend class _LIBCPP_TEMPLATE_VIS valarray; 870 template <class> 871 friend class _LIBCPP_TEMPLATE_VIS slice_array; 872 template <class> 873 friend class _LIBCPP_TEMPLATE_VIS gslice_array; 874 template <class> 875 friend class _LIBCPP_TEMPLATE_VIS mask_array; 876 template <class> 877 friend class __mask_expr; 878 template <class> 879 friend class _LIBCPP_TEMPLATE_VIS indirect_array; 880 template <class> 881 friend class __indirect_expr; 882 template <class> 883 friend class __val_expr; 884 885 template <class _Up> 886 friend _Up* begin(valarray<_Up>& __v); 887 888 template <class _Up> 889 friend const _Up* begin(const valarray<_Up>& __v); 890 891 template <class _Up> 892 friend _Up* end(valarray<_Up>& __v); 893 894 template <class _Up> 895 friend const _Up* end(const valarray<_Up>& __v); 896 897 _LIBCPP_HIDE_FROM_ABI void __clear(size_t __capacity); 898 valarray& __assign_range(const value_type* __f, const value_type* __l); 899}; 900 901#if _LIBCPP_STD_VER >= 17 902template <class _Tp, size_t _Size> 903valarray(const _Tp (&)[_Size], size_t) -> valarray<_Tp>; 904#endif 905 906extern template _LIBCPP_EXPORTED_FROM_ABI void valarray<size_t>::resize(size_t, size_t); 907 908template <class _Op, class _Tp> 909struct _UnaryOp<_Op, valarray<_Tp> > { 910 typedef typename _Op::__result_type __result_type; 911 using value_type = __decay_t<__result_type>; 912 913 _Op __op_; 914 const valarray<_Tp>& __a0_; 915 916 _LIBCPP_HIDE_FROM_ABI _UnaryOp(const _Op& __op, const valarray<_Tp>& __a0) : __op_(__op), __a0_(__a0) {} 917 918 _LIBCPP_HIDE_FROM_ABI __result_type operator[](size_t __i) const { return __op_(__a0_[__i]); } 919 920 _LIBCPP_HIDE_FROM_ABI size_t size() const { return __a0_.size(); } 921}; 922 923template <class _Op, class _Tp, class _A1> 924struct _BinaryOp<_Op, valarray<_Tp>, _A1> { 925 typedef typename _Op::__result_type __result_type; 926 using value_type = __decay_t<__result_type>; 927 928 _Op __op_; 929 const valarray<_Tp>& __a0_; 930 _A1 __a1_; 931 932 _LIBCPP_HIDE_FROM_ABI _BinaryOp(const _Op& __op, const valarray<_Tp>& __a0, const _A1& __a1) 933 : __op_(__op), __a0_(__a0), __a1_(__a1) {} 934 935 _LIBCPP_HIDE_FROM_ABI __result_type operator[](size_t __i) const { return __op_(__a0_[__i], __a1_[__i]); } 936 937 _LIBCPP_HIDE_FROM_ABI size_t size() const { return __a0_.size(); } 938}; 939 940template <class _Op, class _A0, class _Tp> 941struct _BinaryOp<_Op, _A0, valarray<_Tp> > { 942 typedef typename _Op::__result_type __result_type; 943 using value_type = __decay_t<__result_type>; 944 945 _Op __op_; 946 _A0 __a0_; 947 const valarray<_Tp>& __a1_; 948 949 _LIBCPP_HIDE_FROM_ABI _BinaryOp(const _Op& __op, const _A0& __a0, const valarray<_Tp>& __a1) 950 : __op_(__op), __a0_(__a0), __a1_(__a1) {} 951 952 _LIBCPP_HIDE_FROM_ABI __result_type operator[](size_t __i) const { return __op_(__a0_[__i], __a1_[__i]); } 953 954 _LIBCPP_HIDE_FROM_ABI size_t size() const { return __a0_.size(); } 955}; 956 957template <class _Op, class _Tp> 958struct _BinaryOp<_Op, valarray<_Tp>, valarray<_Tp> > { 959 typedef typename _Op::__result_type __result_type; 960 using value_type = __decay_t<__result_type>; 961 962 _Op __op_; 963 const valarray<_Tp>& __a0_; 964 const valarray<_Tp>& __a1_; 965 966 _LIBCPP_HIDE_FROM_ABI _BinaryOp(const _Op& __op, const valarray<_Tp>& __a0, const valarray<_Tp>& __a1) 967 : __op_(__op), __a0_(__a0), __a1_(__a1) {} 968 969 _LIBCPP_HIDE_FROM_ABI __result_type operator[](size_t __i) const { return __op_(__a0_[__i], __a1_[__i]); } 970 971 _LIBCPP_HIDE_FROM_ABI size_t size() const { return __a0_.size(); } 972}; 973 974// slice_array 975 976template <class _Tp> 977class _LIBCPP_TEMPLATE_VIS slice_array { 978public: 979 typedef _Tp value_type; 980 981private: 982 value_type* __vp_; 983 size_t __size_; 984 size_t __stride_; 985 986public: 987 template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 988 void _LIBCPP_HIDE_FROM_ABI operator=(const _Expr& __v) const; 989 990 template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 991 void _LIBCPP_HIDE_FROM_ABI operator*=(const _Expr& __v) const; 992 993 template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 994 void _LIBCPP_HIDE_FROM_ABI operator/=(const _Expr& __v) const; 995 996 template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 997 void _LIBCPP_HIDE_FROM_ABI operator%=(const _Expr& __v) const; 998 999 template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 1000 void _LIBCPP_HIDE_FROM_ABI operator+=(const _Expr& __v) const; 1001 1002 template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 1003 void _LIBCPP_HIDE_FROM_ABI operator-=(const _Expr& __v) const; 1004 1005 template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 1006 void _LIBCPP_HIDE_FROM_ABI operator^=(const _Expr& __v) const; 1007 1008 template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 1009 void _LIBCPP_HIDE_FROM_ABI operator&=(const _Expr& __v) const; 1010 1011 template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 1012 void _LIBCPP_HIDE_FROM_ABI operator|=(const _Expr& __v) const; 1013 1014 template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 1015 void _LIBCPP_HIDE_FROM_ABI operator<<=(const _Expr& __v) const; 1016 1017 template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 1018 void _LIBCPP_HIDE_FROM_ABI operator>>=(const _Expr& __v) const; 1019 1020 slice_array(slice_array const&) = default; 1021 1022 _LIBCPP_HIDE_FROM_ABI const slice_array& operator=(const slice_array& __sa) const; 1023 1024 _LIBCPP_HIDE_FROM_ABI void operator=(const value_type& __x) const; 1025 1026 _LIBCPP_HIDE_FROM_ABI void operator=(const valarray<value_type>& __va) const; 1027 1028private: 1029 _LIBCPP_HIDE_FROM_ABI slice_array(const slice& __sl, const valarray<value_type>& __v) 1030 : __vp_(const_cast<value_type*>(__v.__begin_ + __sl.start())), __size_(__sl.size()), __stride_(__sl.stride()) {} 1031 1032 template <class> 1033 friend class valarray; 1034}; 1035 1036template <class _Tp> 1037inline const slice_array<_Tp>& slice_array<_Tp>::operator=(const slice_array& __sa) const { 1038 value_type* __t = __vp_; 1039 const value_type* __s = __sa.__vp_; 1040 for (size_t __n = __size_; __n; --__n, __t += __stride_, __s += __sa.__stride_) 1041 *__t = *__s; 1042 return *this; 1043} 1044 1045template <class _Tp> 1046template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> > 1047inline void slice_array<_Tp>::operator=(const _Expr& __v) const { 1048 value_type* __t = __vp_; 1049 for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_) 1050 *__t = __v[__i]; 1051} 1052 1053template <class _Tp> 1054inline void slice_array<_Tp>::operator=(const valarray<value_type>& __va) const { 1055 value_type* __t = __vp_; 1056 for (size_t __i = 0; __i < __va.size(); ++__i, __t += __stride_) 1057 *__t = __va[__i]; 1058} 1059 1060template <class _Tp> 1061template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> > 1062inline void slice_array<_Tp>::operator*=(const _Expr& __v) const { 1063 value_type* __t = __vp_; 1064 for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_) 1065 *__t *= __v[__i]; 1066} 1067 1068template <class _Tp> 1069template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> > 1070inline void slice_array<_Tp>::operator/=(const _Expr& __v) const { 1071 value_type* __t = __vp_; 1072 for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_) 1073 *__t /= __v[__i]; 1074} 1075 1076template <class _Tp> 1077template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> > 1078inline void slice_array<_Tp>::operator%=(const _Expr& __v) const { 1079 value_type* __t = __vp_; 1080 for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_) 1081 *__t %= __v[__i]; 1082} 1083 1084template <class _Tp> 1085template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> > 1086inline void slice_array<_Tp>::operator+=(const _Expr& __v) const { 1087 value_type* __t = __vp_; 1088 for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_) 1089 *__t += __v[__i]; 1090} 1091 1092template <class _Tp> 1093template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> > 1094inline void slice_array<_Tp>::operator-=(const _Expr& __v) const { 1095 value_type* __t = __vp_; 1096 for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_) 1097 *__t -= __v[__i]; 1098} 1099 1100template <class _Tp> 1101template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> > 1102inline void slice_array<_Tp>::operator^=(const _Expr& __v) const { 1103 value_type* __t = __vp_; 1104 for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_) 1105 *__t ^= __v[__i]; 1106} 1107 1108template <class _Tp> 1109template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> > 1110inline void slice_array<_Tp>::operator&=(const _Expr& __v) const { 1111 value_type* __t = __vp_; 1112 for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_) 1113 *__t &= __v[__i]; 1114} 1115 1116template <class _Tp> 1117template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> > 1118inline void slice_array<_Tp>::operator|=(const _Expr& __v) const { 1119 value_type* __t = __vp_; 1120 for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_) 1121 *__t |= __v[__i]; 1122} 1123 1124template <class _Tp> 1125template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> > 1126inline void slice_array<_Tp>::operator<<=(const _Expr& __v) const { 1127 value_type* __t = __vp_; 1128 for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_) 1129 *__t <<= __v[__i]; 1130} 1131 1132template <class _Tp> 1133template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> > 1134inline void slice_array<_Tp>::operator>>=(const _Expr& __v) const { 1135 value_type* __t = __vp_; 1136 for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_) 1137 *__t >>= __v[__i]; 1138} 1139 1140template <class _Tp> 1141inline void slice_array<_Tp>::operator=(const value_type& __x) const { 1142 value_type* __t = __vp_; 1143 for (size_t __n = __size_; __n; --__n, __t += __stride_) 1144 *__t = __x; 1145} 1146 1147// gslice 1148 1149class _LIBCPP_EXPORTED_FROM_ABI gslice { 1150 valarray<size_t> __size_; 1151 valarray<size_t> __stride_; 1152 valarray<size_t> __1d_; 1153 1154public: 1155 _LIBCPP_HIDE_FROM_ABI gslice() {} 1156 1157 _LIBCPP_HIDE_FROM_ABI gslice(size_t __start, const valarray<size_t>& __size, const valarray<size_t>& __stride) 1158 : __size_(__size), __stride_(__stride) { 1159 __init(__start); 1160 } 1161 1162#ifndef _LIBCPP_CXX03_LANG 1163 1164 _LIBCPP_HIDE_FROM_ABI gslice(size_t __start, const valarray<size_t>& __size, valarray<size_t>&& __stride) 1165 : __size_(__size), __stride_(std::move(__stride)) { 1166 __init(__start); 1167 } 1168 1169 _LIBCPP_HIDE_FROM_ABI gslice(size_t __start, valarray<size_t>&& __size, const valarray<size_t>& __stride) 1170 : __size_(std::move(__size)), __stride_(__stride) { 1171 __init(__start); 1172 } 1173 1174 _LIBCPP_HIDE_FROM_ABI gslice(size_t __start, valarray<size_t>&& __size, valarray<size_t>&& __stride) 1175 : __size_(std::move(__size)), __stride_(std::move(__stride)) { 1176 __init(__start); 1177 } 1178 1179#endif // _LIBCPP_CXX03_LANG 1180 1181 _LIBCPP_HIDE_FROM_ABI size_t start() const { return __1d_.size() ? __1d_[0] : 0; } 1182 1183 _LIBCPP_HIDE_FROM_ABI valarray<size_t> size() const { return __size_; } 1184 1185 _LIBCPP_HIDE_FROM_ABI valarray<size_t> stride() const { return __stride_; } 1186 1187private: 1188 void __init(size_t __start); 1189 1190 template <class> 1191 friend class gslice_array; 1192 template <class> 1193 friend class valarray; 1194 template <class> 1195 friend class __val_expr; 1196}; 1197 1198// gslice_array 1199 1200template <class _Tp> 1201class _LIBCPP_TEMPLATE_VIS gslice_array { 1202public: 1203 typedef _Tp value_type; 1204 1205private: 1206 value_type* __vp_; 1207 valarray<size_t> __1d_; 1208 1209public: 1210 template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 1211 void _LIBCPP_HIDE_FROM_ABI operator=(const _Expr& __v) const; 1212 1213 template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 1214 void _LIBCPP_HIDE_FROM_ABI operator*=(const _Expr& __v) const; 1215 1216 template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 1217 void _LIBCPP_HIDE_FROM_ABI operator/=(const _Expr& __v) const; 1218 1219 template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 1220 void _LIBCPP_HIDE_FROM_ABI operator%=(const _Expr& __v) const; 1221 1222 template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 1223 void _LIBCPP_HIDE_FROM_ABI operator+=(const _Expr& __v) const; 1224 1225 template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 1226 void _LIBCPP_HIDE_FROM_ABI operator-=(const _Expr& __v) const; 1227 1228 template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 1229 void _LIBCPP_HIDE_FROM_ABI operator^=(const _Expr& __v) const; 1230 1231 template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 1232 void _LIBCPP_HIDE_FROM_ABI operator&=(const _Expr& __v) const; 1233 1234 template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 1235 void _LIBCPP_HIDE_FROM_ABI operator|=(const _Expr& __v) const; 1236 1237 template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 1238 void _LIBCPP_HIDE_FROM_ABI operator<<=(const _Expr& __v) const; 1239 1240 template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 1241 void _LIBCPP_HIDE_FROM_ABI operator>>=(const _Expr& __v) const; 1242 1243 _LIBCPP_HIDE_FROM_ABI const gslice_array& operator=(const gslice_array& __ga) const; 1244 1245 _LIBCPP_HIDE_FROM_ABI void operator=(const value_type& __x) const; 1246 1247 gslice_array(const gslice_array&) = default; 1248 1249private: 1250 gslice_array(const gslice& __gs, const valarray<value_type>& __v) 1251 : __vp_(const_cast<value_type*>(__v.__begin_)), __1d_(__gs.__1d_) {} 1252 1253#ifndef _LIBCPP_CXX03_LANG 1254 gslice_array(gslice&& __gs, const valarray<value_type>& __v) 1255 : __vp_(const_cast<value_type*>(__v.__begin_)), __1d_(std::move(__gs.__1d_)) {} 1256#endif // _LIBCPP_CXX03_LANG 1257 1258 template <class> 1259 friend class valarray; 1260}; 1261 1262template <class _Tp> 1263template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> > 1264inline void gslice_array<_Tp>::operator=(const _Expr& __v) const { 1265 typedef const size_t* _Ip; 1266 size_t __j = 0; 1267 for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j) 1268 __vp_[*__i] = __v[__j]; 1269} 1270 1271template <class _Tp> 1272template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> > 1273inline void gslice_array<_Tp>::operator*=(const _Expr& __v) const { 1274 typedef const size_t* _Ip; 1275 size_t __j = 0; 1276 for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j) 1277 __vp_[*__i] *= __v[__j]; 1278} 1279 1280template <class _Tp> 1281template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> > 1282inline void gslice_array<_Tp>::operator/=(const _Expr& __v) const { 1283 typedef const size_t* _Ip; 1284 size_t __j = 0; 1285 for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j) 1286 __vp_[*__i] /= __v[__j]; 1287} 1288 1289template <class _Tp> 1290template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> > 1291inline void gslice_array<_Tp>::operator%=(const _Expr& __v) const { 1292 typedef const size_t* _Ip; 1293 size_t __j = 0; 1294 for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j) 1295 __vp_[*__i] %= __v[__j]; 1296} 1297 1298template <class _Tp> 1299template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> > 1300inline void gslice_array<_Tp>::operator+=(const _Expr& __v) const { 1301 typedef const size_t* _Ip; 1302 size_t __j = 0; 1303 for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j) 1304 __vp_[*__i] += __v[__j]; 1305} 1306 1307template <class _Tp> 1308template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> > 1309inline void gslice_array<_Tp>::operator-=(const _Expr& __v) const { 1310 typedef const size_t* _Ip; 1311 size_t __j = 0; 1312 for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j) 1313 __vp_[*__i] -= __v[__j]; 1314} 1315 1316template <class _Tp> 1317template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> > 1318inline void gslice_array<_Tp>::operator^=(const _Expr& __v) const { 1319 typedef const size_t* _Ip; 1320 size_t __j = 0; 1321 for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j) 1322 __vp_[*__i] ^= __v[__j]; 1323} 1324 1325template <class _Tp> 1326template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> > 1327inline void gslice_array<_Tp>::operator&=(const _Expr& __v) const { 1328 typedef const size_t* _Ip; 1329 size_t __j = 0; 1330 for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j) 1331 __vp_[*__i] &= __v[__j]; 1332} 1333 1334template <class _Tp> 1335template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> > 1336inline void gslice_array<_Tp>::operator|=(const _Expr& __v) const { 1337 typedef const size_t* _Ip; 1338 size_t __j = 0; 1339 for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j) 1340 __vp_[*__i] |= __v[__j]; 1341} 1342 1343template <class _Tp> 1344template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> > 1345inline void gslice_array<_Tp>::operator<<=(const _Expr& __v) const { 1346 typedef const size_t* _Ip; 1347 size_t __j = 0; 1348 for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j) 1349 __vp_[*__i] <<= __v[__j]; 1350} 1351 1352template <class _Tp> 1353template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> > 1354inline void gslice_array<_Tp>::operator>>=(const _Expr& __v) const { 1355 typedef const size_t* _Ip; 1356 size_t __j = 0; 1357 for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j) 1358 __vp_[*__i] >>= __v[__j]; 1359} 1360 1361template <class _Tp> 1362inline const gslice_array<_Tp>& gslice_array<_Tp>::operator=(const gslice_array& __ga) const { 1363 typedef const size_t* _Ip; 1364 const value_type* __s = __ga.__vp_; 1365 for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_, __j = __ga.__1d_.__begin_; __i != __e; ++__i, ++__j) 1366 __vp_[*__i] = __s[*__j]; 1367 return *this; 1368} 1369 1370template <class _Tp> 1371inline void gslice_array<_Tp>::operator=(const value_type& __x) const { 1372 typedef const size_t* _Ip; 1373 for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i) 1374 __vp_[*__i] = __x; 1375} 1376 1377// mask_array 1378 1379template <class _Tp> 1380class _LIBCPP_TEMPLATE_VIS mask_array { 1381public: 1382 typedef _Tp value_type; 1383 1384private: 1385 value_type* __vp_; 1386 valarray<size_t> __1d_; 1387 1388public: 1389 template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 1390 void _LIBCPP_HIDE_FROM_ABI operator=(const _Expr& __v) const; 1391 1392 template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 1393 void _LIBCPP_HIDE_FROM_ABI operator*=(const _Expr& __v) const; 1394 1395 template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 1396 void _LIBCPP_HIDE_FROM_ABI operator/=(const _Expr& __v) const; 1397 1398 template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 1399 void _LIBCPP_HIDE_FROM_ABI operator%=(const _Expr& __v) const; 1400 1401 template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 1402 void _LIBCPP_HIDE_FROM_ABI operator+=(const _Expr& __v) const; 1403 1404 template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 1405 void _LIBCPP_HIDE_FROM_ABI operator-=(const _Expr& __v) const; 1406 1407 template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 1408 void _LIBCPP_HIDE_FROM_ABI operator^=(const _Expr& __v) const; 1409 1410 template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 1411 void _LIBCPP_HIDE_FROM_ABI operator&=(const _Expr& __v) const; 1412 1413 template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 1414 void _LIBCPP_HIDE_FROM_ABI operator|=(const _Expr& __v) const; 1415 1416 template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 1417 void _LIBCPP_HIDE_FROM_ABI operator<<=(const _Expr& __v) const; 1418 1419 template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 1420 void _LIBCPP_HIDE_FROM_ABI operator>>=(const _Expr& __v) const; 1421 1422 mask_array(const mask_array&) = default; 1423 1424 _LIBCPP_HIDE_FROM_ABI const mask_array& operator=(const mask_array& __ma) const; 1425 1426 _LIBCPP_HIDE_FROM_ABI void operator=(const value_type& __x) const; 1427 1428private: 1429 _LIBCPP_HIDE_FROM_ABI mask_array(const valarray<bool>& __vb, const valarray<value_type>& __v) 1430 : __vp_(const_cast<value_type*>(__v.__begin_)), 1431 __1d_(static_cast<size_t>(count(__vb.__begin_, __vb.__end_, true))) { 1432 size_t __j = 0; 1433 for (size_t __i = 0; __i < __vb.size(); ++__i) 1434 if (__vb[__i]) 1435 __1d_[__j++] = __i; 1436 } 1437 1438 template <class> 1439 friend class valarray; 1440}; 1441 1442template <class _Tp> 1443template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> > 1444inline void mask_array<_Tp>::operator=(const _Expr& __v) const { 1445 size_t __n = __1d_.size(); 1446 for (size_t __i = 0; __i < __n; ++__i) 1447 __vp_[__1d_[__i]] = __v[__i]; 1448} 1449 1450template <class _Tp> 1451template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> > 1452inline void mask_array<_Tp>::operator*=(const _Expr& __v) const { 1453 size_t __n = __1d_.size(); 1454 for (size_t __i = 0; __i < __n; ++__i) 1455 __vp_[__1d_[__i]] *= __v[__i]; 1456} 1457 1458template <class _Tp> 1459template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> > 1460inline void mask_array<_Tp>::operator/=(const _Expr& __v) const { 1461 size_t __n = __1d_.size(); 1462 for (size_t __i = 0; __i < __n; ++__i) 1463 __vp_[__1d_[__i]] /= __v[__i]; 1464} 1465 1466template <class _Tp> 1467template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> > 1468inline void mask_array<_Tp>::operator%=(const _Expr& __v) const { 1469 size_t __n = __1d_.size(); 1470 for (size_t __i = 0; __i < __n; ++__i) 1471 __vp_[__1d_[__i]] %= __v[__i]; 1472} 1473 1474template <class _Tp> 1475template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> > 1476inline void mask_array<_Tp>::operator+=(const _Expr& __v) const { 1477 size_t __n = __1d_.size(); 1478 for (size_t __i = 0; __i < __n; ++__i) 1479 __vp_[__1d_[__i]] += __v[__i]; 1480} 1481 1482template <class _Tp> 1483template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> > 1484inline void mask_array<_Tp>::operator-=(const _Expr& __v) const { 1485 size_t __n = __1d_.size(); 1486 for (size_t __i = 0; __i < __n; ++__i) 1487 __vp_[__1d_[__i]] -= __v[__i]; 1488} 1489 1490template <class _Tp> 1491template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> > 1492inline void mask_array<_Tp>::operator^=(const _Expr& __v) const { 1493 size_t __n = __1d_.size(); 1494 for (size_t __i = 0; __i < __n; ++__i) 1495 __vp_[__1d_[__i]] ^= __v[__i]; 1496} 1497 1498template <class _Tp> 1499template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> > 1500inline void mask_array<_Tp>::operator&=(const _Expr& __v) const { 1501 size_t __n = __1d_.size(); 1502 for (size_t __i = 0; __i < __n; ++__i) 1503 __vp_[__1d_[__i]] &= __v[__i]; 1504} 1505 1506template <class _Tp> 1507template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> > 1508inline void mask_array<_Tp>::operator|=(const _Expr& __v) const { 1509 size_t __n = __1d_.size(); 1510 for (size_t __i = 0; __i < __n; ++__i) 1511 __vp_[__1d_[__i]] |= __v[__i]; 1512} 1513 1514template <class _Tp> 1515template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> > 1516inline void mask_array<_Tp>::operator<<=(const _Expr& __v) const { 1517 size_t __n = __1d_.size(); 1518 for (size_t __i = 0; __i < __n; ++__i) 1519 __vp_[__1d_[__i]] <<= __v[__i]; 1520} 1521 1522template <class _Tp> 1523template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> > 1524inline void mask_array<_Tp>::operator>>=(const _Expr& __v) const { 1525 size_t __n = __1d_.size(); 1526 for (size_t __i = 0; __i < __n; ++__i) 1527 __vp_[__1d_[__i]] >>= __v[__i]; 1528} 1529 1530template <class _Tp> 1531inline const mask_array<_Tp>& mask_array<_Tp>::operator=(const mask_array& __ma) const { 1532 size_t __n = __1d_.size(); 1533 for (size_t __i = 0; __i < __n; ++__i) 1534 __vp_[__1d_[__i]] = __ma.__vp_[__1d_[__i]]; 1535 return *this; 1536} 1537 1538template <class _Tp> 1539inline void mask_array<_Tp>::operator=(const value_type& __x) const { 1540 size_t __n = __1d_.size(); 1541 for (size_t __i = 0; __i < __n; ++__i) 1542 __vp_[__1d_[__i]] = __x; 1543} 1544 1545template <class _ValExpr> 1546class __mask_expr { 1547 typedef __libcpp_remove_reference_t<_ValExpr> _RmExpr; 1548 1549public: 1550 typedef typename _RmExpr::value_type value_type; 1551 typedef value_type __result_type; 1552 1553private: 1554 _ValExpr __expr_; 1555 valarray<size_t> __1d_; 1556 1557 _LIBCPP_HIDE_FROM_ABI __mask_expr(const valarray<bool>& __vb, const _RmExpr& __e) 1558 : __expr_(__e), __1d_(static_cast<size_t>(count(__vb.__begin_, __vb.__end_, true))) { 1559 size_t __j = 0; 1560 for (size_t __i = 0; __i < __vb.size(); ++__i) 1561 if (__vb[__i]) 1562 __1d_[__j++] = __i; 1563 } 1564 1565public: 1566 _LIBCPP_HIDE_FROM_ABI __result_type operator[](size_t __i) const { return __expr_[__1d_[__i]]; } 1567 1568 _LIBCPP_HIDE_FROM_ABI size_t size() const { return __1d_.size(); } 1569 1570 template <class> 1571 friend class __val_expr; 1572 template <class> 1573 friend class valarray; 1574}; 1575 1576// indirect_array 1577 1578template <class _Tp> 1579class _LIBCPP_TEMPLATE_VIS indirect_array { 1580public: 1581 typedef _Tp value_type; 1582 1583private: 1584 value_type* __vp_; 1585 valarray<size_t> __1d_; 1586 1587public: 1588 template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 1589 void _LIBCPP_HIDE_FROM_ABI operator=(const _Expr& __v) const; 1590 1591 template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 1592 void _LIBCPP_HIDE_FROM_ABI operator*=(const _Expr& __v) const; 1593 1594 template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 1595 void _LIBCPP_HIDE_FROM_ABI operator/=(const _Expr& __v) const; 1596 1597 template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 1598 void _LIBCPP_HIDE_FROM_ABI operator%=(const _Expr& __v) const; 1599 1600 template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 1601 void _LIBCPP_HIDE_FROM_ABI operator+=(const _Expr& __v) const; 1602 1603 template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 1604 void _LIBCPP_HIDE_FROM_ABI operator-=(const _Expr& __v) const; 1605 1606 template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 1607 void _LIBCPP_HIDE_FROM_ABI operator^=(const _Expr& __v) const; 1608 1609 template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 1610 void _LIBCPP_HIDE_FROM_ABI operator&=(const _Expr& __v) const; 1611 1612 template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 1613 void _LIBCPP_HIDE_FROM_ABI operator|=(const _Expr& __v) const; 1614 1615 template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 1616 void _LIBCPP_HIDE_FROM_ABI operator<<=(const _Expr& __v) const; 1617 1618 template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 1619 void _LIBCPP_HIDE_FROM_ABI operator>>=(const _Expr& __v) const; 1620 1621 indirect_array(const indirect_array&) = default; 1622 1623 _LIBCPP_HIDE_FROM_ABI const indirect_array& operator=(const indirect_array& __ia) const; 1624 1625 _LIBCPP_HIDE_FROM_ABI void operator=(const value_type& __x) const; 1626 1627private: 1628 _LIBCPP_HIDE_FROM_ABI indirect_array(const valarray<size_t>& __ia, const valarray<value_type>& __v) 1629 : __vp_(const_cast<value_type*>(__v.__begin_)), __1d_(__ia) {} 1630 1631#ifndef _LIBCPP_CXX03_LANG 1632 1633 _LIBCPP_HIDE_FROM_ABI indirect_array(valarray<size_t>&& __ia, const valarray<value_type>& __v) 1634 : __vp_(const_cast<value_type*>(__v.__begin_)), __1d_(std::move(__ia)) {} 1635 1636#endif // _LIBCPP_CXX03_LANG 1637 1638 template <class> 1639 friend class valarray; 1640}; 1641 1642template <class _Tp> 1643template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> > 1644inline void indirect_array<_Tp>::operator=(const _Expr& __v) const { 1645 size_t __n = __1d_.size(); 1646 for (size_t __i = 0; __i < __n; ++__i) 1647 __vp_[__1d_[__i]] = __v[__i]; 1648} 1649 1650template <class _Tp> 1651template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> > 1652inline void indirect_array<_Tp>::operator*=(const _Expr& __v) const { 1653 size_t __n = __1d_.size(); 1654 for (size_t __i = 0; __i < __n; ++__i) 1655 __vp_[__1d_[__i]] *= __v[__i]; 1656} 1657 1658template <class _Tp> 1659template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> > 1660inline void indirect_array<_Tp>::operator/=(const _Expr& __v) const { 1661 size_t __n = __1d_.size(); 1662 for (size_t __i = 0; __i < __n; ++__i) 1663 __vp_[__1d_[__i]] /= __v[__i]; 1664} 1665 1666template <class _Tp> 1667template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> > 1668inline void indirect_array<_Tp>::operator%=(const _Expr& __v) const { 1669 size_t __n = __1d_.size(); 1670 for (size_t __i = 0; __i < __n; ++__i) 1671 __vp_[__1d_[__i]] %= __v[__i]; 1672} 1673 1674template <class _Tp> 1675template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> > 1676inline void indirect_array<_Tp>::operator+=(const _Expr& __v) const { 1677 size_t __n = __1d_.size(); 1678 for (size_t __i = 0; __i < __n; ++__i) 1679 __vp_[__1d_[__i]] += __v[__i]; 1680} 1681 1682template <class _Tp> 1683template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> > 1684inline void indirect_array<_Tp>::operator-=(const _Expr& __v) const { 1685 size_t __n = __1d_.size(); 1686 for (size_t __i = 0; __i < __n; ++__i) 1687 __vp_[__1d_[__i]] -= __v[__i]; 1688} 1689 1690template <class _Tp> 1691template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> > 1692inline void indirect_array<_Tp>::operator^=(const _Expr& __v) const { 1693 size_t __n = __1d_.size(); 1694 for (size_t __i = 0; __i < __n; ++__i) 1695 __vp_[__1d_[__i]] ^= __v[__i]; 1696} 1697 1698template <class _Tp> 1699template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> > 1700inline void indirect_array<_Tp>::operator&=(const _Expr& __v) const { 1701 size_t __n = __1d_.size(); 1702 for (size_t __i = 0; __i < __n; ++__i) 1703 __vp_[__1d_[__i]] &= __v[__i]; 1704} 1705 1706template <class _Tp> 1707template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> > 1708inline void indirect_array<_Tp>::operator|=(const _Expr& __v) const { 1709 size_t __n = __1d_.size(); 1710 for (size_t __i = 0; __i < __n; ++__i) 1711 __vp_[__1d_[__i]] |= __v[__i]; 1712} 1713 1714template <class _Tp> 1715template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> > 1716inline void indirect_array<_Tp>::operator<<=(const _Expr& __v) const { 1717 size_t __n = __1d_.size(); 1718 for (size_t __i = 0; __i < __n; ++__i) 1719 __vp_[__1d_[__i]] <<= __v[__i]; 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> 1731inline const indirect_array<_Tp>& indirect_array<_Tp>::operator=(const indirect_array& __ia) const { 1732 typedef const size_t* _Ip; 1733 const value_type* __s = __ia.__vp_; 1734 for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_, __j = __ia.__1d_.__begin_; __i != __e; ++__i, ++__j) 1735 __vp_[*__i] = __s[*__j]; 1736 return *this; 1737} 1738 1739template <class _Tp> 1740inline void indirect_array<_Tp>::operator=(const value_type& __x) const { 1741 typedef const size_t* _Ip; 1742 for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i) 1743 __vp_[*__i] = __x; 1744} 1745 1746template <class _ValExpr> 1747class __indirect_expr { 1748 typedef __libcpp_remove_reference_t<_ValExpr> _RmExpr; 1749 1750public: 1751 typedef typename _RmExpr::value_type value_type; 1752 typedef value_type __result_type; 1753 1754private: 1755 _ValExpr __expr_; 1756 valarray<size_t> __1d_; 1757 1758 _LIBCPP_HIDE_FROM_ABI __indirect_expr(const valarray<size_t>& __ia, const _RmExpr& __e) : __expr_(__e), __1d_(__ia) {} 1759 1760#ifndef _LIBCPP_CXX03_LANG 1761 1762 _LIBCPP_HIDE_FROM_ABI __indirect_expr(valarray<size_t>&& __ia, const _RmExpr& __e) 1763 : __expr_(__e), __1d_(std::move(__ia)) {} 1764 1765#endif // _LIBCPP_CXX03_LANG 1766 1767public: 1768 _LIBCPP_HIDE_FROM_ABI __result_type operator[](size_t __i) const { return __expr_[__1d_[__i]]; } 1769 1770 _LIBCPP_HIDE_FROM_ABI size_t size() const { return __1d_.size(); } 1771 1772 template <class> 1773 friend class __val_expr; 1774 template <class> 1775 friend class _LIBCPP_TEMPLATE_VIS valarray; 1776}; 1777 1778template <class _ValExpr> 1779class __val_expr { 1780 typedef __libcpp_remove_reference_t<_ValExpr> _RmExpr; 1781 1782 _ValExpr __expr_; 1783 1784public: 1785 typedef typename _RmExpr::value_type value_type; 1786 typedef typename _RmExpr::__result_type __result_type; 1787 1788 _LIBCPP_HIDE_FROM_ABI explicit __val_expr(const _RmExpr& __e) : __expr_(__e) {} 1789 1790 _LIBCPP_HIDE_FROM_ABI __result_type operator[](size_t __i) const { return __expr_[__i]; } 1791 1792 _LIBCPP_HIDE_FROM_ABI __val_expr<__slice_expr<_ValExpr> > operator[](slice __s) const { 1793 typedef __slice_expr<_ValExpr> _NewExpr; 1794 return __val_expr< _NewExpr >(_NewExpr(__s, __expr_)); 1795 } 1796 1797 _LIBCPP_HIDE_FROM_ABI __val_expr<__indirect_expr<_ValExpr> > operator[](const gslice& __gs) const { 1798 typedef __indirect_expr<_ValExpr> _NewExpr; 1799 return __val_expr<_NewExpr >(_NewExpr(__gs.__1d_, __expr_)); 1800 } 1801 1802 _LIBCPP_HIDE_FROM_ABI __val_expr<__mask_expr<_ValExpr> > operator[](const valarray<bool>& __vb) const { 1803 typedef __mask_expr<_ValExpr> _NewExpr; 1804 return __val_expr< _NewExpr >(_NewExpr(__vb, __expr_)); 1805 } 1806 1807 _LIBCPP_HIDE_FROM_ABI __val_expr<__indirect_expr<_ValExpr> > operator[](const valarray<size_t>& __vs) const { 1808 typedef __indirect_expr<_ValExpr> _NewExpr; 1809 return __val_expr< _NewExpr >(_NewExpr(__vs, __expr_)); 1810 } 1811 1812 _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__unary_plus<value_type>, _ValExpr> > operator+() const { 1813 typedef _UnaryOp<__unary_plus<value_type>, _ValExpr> _NewExpr; 1814 return __val_expr<_NewExpr>(_NewExpr(__unary_plus<value_type>(), __expr_)); 1815 } 1816 1817 _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<negate<value_type>, _ValExpr> > operator-() const { 1818 typedef _UnaryOp<negate<value_type>, _ValExpr> _NewExpr; 1819 return __val_expr<_NewExpr>(_NewExpr(negate<value_type>(), __expr_)); 1820 } 1821 1822 _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__bit_not<value_type>, _ValExpr> > operator~() const { 1823 typedef _UnaryOp<__bit_not<value_type>, _ValExpr> _NewExpr; 1824 return __val_expr<_NewExpr>(_NewExpr(__bit_not<value_type>(), __expr_)); 1825 } 1826 1827 _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<logical_not<value_type>, _ValExpr> > operator!() const { 1828 typedef _UnaryOp<logical_not<value_type>, _ValExpr> _NewExpr; 1829 return __val_expr<_NewExpr>(_NewExpr(logical_not<value_type>(), __expr_)); 1830 } 1831 1832 operator valarray<__result_type>() const; 1833 1834 _LIBCPP_HIDE_FROM_ABI size_t size() const { return __expr_.size(); } 1835 1836 _LIBCPP_HIDE_FROM_ABI __result_type sum() const { 1837 size_t __n = __expr_.size(); 1838 __result_type __r = __n ? __expr_[0] : __result_type(); 1839 for (size_t __i = 1; __i < __n; ++__i) 1840 __r += __expr_[__i]; 1841 return __r; 1842 } 1843 1844 _LIBCPP_HIDE_FROM_ABI __result_type min() const { 1845 size_t __n = size(); 1846 __result_type __r = __n ? (*this)[0] : __result_type(); 1847 for (size_t __i = 1; __i < __n; ++__i) { 1848 __result_type __x = __expr_[__i]; 1849 if (__x < __r) 1850 __r = __x; 1851 } 1852 return __r; 1853 } 1854 1855 _LIBCPP_HIDE_FROM_ABI __result_type max() const { 1856 size_t __n = size(); 1857 __result_type __r = __n ? (*this)[0] : __result_type(); 1858 for (size_t __i = 1; __i < __n; ++__i) { 1859 __result_type __x = __expr_[__i]; 1860 if (__r < __x) 1861 __r = __x; 1862 } 1863 return __r; 1864 } 1865 1866 _LIBCPP_HIDE_FROM_ABI __val_expr<__shift_expr<_ValExpr> > shift(int __i) const { 1867 return __val_expr<__shift_expr<_ValExpr> >(__shift_expr<_ValExpr>(__i, __expr_)); 1868 } 1869 1870 _LIBCPP_HIDE_FROM_ABI __val_expr<__cshift_expr<_ValExpr> > cshift(int __i) const { 1871 return __val_expr<__cshift_expr<_ValExpr> >(__cshift_expr<_ValExpr>(__i, __expr_)); 1872 } 1873 1874 _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__apply_expr<value_type, value_type (*)(value_type)>, _ValExpr> > 1875 apply(value_type __f(value_type)) const { 1876 typedef __apply_expr<value_type, value_type (*)(value_type)> _Op; 1877 typedef _UnaryOp<_Op, _ValExpr> _NewExpr; 1878 return __val_expr<_NewExpr>(_NewExpr(_Op(__f), __expr_)); 1879 } 1880 1881 _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__apply_expr<value_type, value_type (*)(const value_type&)>, _ValExpr> > 1882 apply(value_type __f(const value_type&)) const { 1883 typedef __apply_expr<value_type, value_type (*)(const value_type&)> _Op; 1884 typedef _UnaryOp<_Op, _ValExpr> _NewExpr; 1885 return __val_expr<_NewExpr>(_NewExpr(_Op(__f), __expr_)); 1886 } 1887}; 1888 1889template <class _ValExpr> 1890__val_expr<_ValExpr>::operator valarray<__val_expr::__result_type>() const { 1891 valarray<__result_type> __r; 1892 size_t __n = __expr_.size(); 1893 if (__n) { 1894 __r.__begin_ = __r.__end_ = allocator<__result_type>().allocate(__n); 1895 for (size_t __i = 0; __i != __n; ++__r.__end_, ++__i) 1896 ::new ((void*)__r.__end_) __result_type(__expr_[__i]); 1897 } 1898 return __r; 1899} 1900 1901// valarray 1902 1903template <class _Tp> 1904inline valarray<_Tp>::valarray(size_t __n) : __begin_(nullptr), __end_(nullptr) { 1905 if (__n) { 1906 __begin_ = __end_ = allocator<value_type>().allocate(__n); 1907#ifndef _LIBCPP_HAS_NO_EXCEPTIONS 1908 try { 1909#endif // _LIBCPP_HAS_NO_EXCEPTIONS 1910 for (size_t __n_left = __n; __n_left; --__n_left, ++__end_) 1911 ::new ((void*)__end_) value_type(); 1912#ifndef _LIBCPP_HAS_NO_EXCEPTIONS 1913 } catch (...) { 1914 __clear(__n); 1915 throw; 1916 } 1917#endif // _LIBCPP_HAS_NO_EXCEPTIONS 1918 } 1919} 1920 1921template <class _Tp> 1922inline valarray<_Tp>::valarray(const value_type& __x, size_t __n) : __begin_(nullptr), __end_(nullptr) { 1923 resize(__n, __x); 1924} 1925 1926template <class _Tp> 1927valarray<_Tp>::valarray(const value_type* __p, size_t __n) : __begin_(nullptr), __end_(nullptr) { 1928 if (__n) { 1929 __begin_ = __end_ = allocator<value_type>().allocate(__n); 1930#ifndef _LIBCPP_HAS_NO_EXCEPTIONS 1931 try { 1932#endif // _LIBCPP_HAS_NO_EXCEPTIONS 1933 for (size_t __n_left = __n; __n_left; ++__end_, ++__p, --__n_left) 1934 ::new ((void*)__end_) value_type(*__p); 1935#ifndef _LIBCPP_HAS_NO_EXCEPTIONS 1936 } catch (...) { 1937 __clear(__n); 1938 throw; 1939 } 1940#endif // _LIBCPP_HAS_NO_EXCEPTIONS 1941 } 1942} 1943 1944template <class _Tp> 1945valarray<_Tp>::valarray(const valarray& __v) : __begin_(nullptr), __end_(nullptr) { 1946 if (__v.size()) { 1947 __begin_ = __end_ = allocator<value_type>().allocate(__v.size()); 1948#ifndef _LIBCPP_HAS_NO_EXCEPTIONS 1949 try { 1950#endif // _LIBCPP_HAS_NO_EXCEPTIONS 1951 for (value_type* __p = __v.__begin_; __p != __v.__end_; ++__end_, ++__p) 1952 ::new ((void*)__end_) value_type(*__p); 1953#ifndef _LIBCPP_HAS_NO_EXCEPTIONS 1954 } catch (...) { 1955 __clear(__v.size()); 1956 throw; 1957 } 1958#endif // _LIBCPP_HAS_NO_EXCEPTIONS 1959 } 1960} 1961 1962#ifndef _LIBCPP_CXX03_LANG 1963 1964template <class _Tp> 1965inline valarray<_Tp>::valarray(valarray&& __v) _NOEXCEPT : __begin_(__v.__begin_), __end_(__v.__end_) { 1966 __v.__begin_ = __v.__end_ = nullptr; 1967} 1968 1969template <class _Tp> 1970valarray<_Tp>::valarray(initializer_list<value_type> __il) : __begin_(nullptr), __end_(nullptr) { 1971 const size_t __n = __il.size(); 1972 if (__n) { 1973 __begin_ = __end_ = allocator<value_type>().allocate(__n); 1974# ifndef _LIBCPP_HAS_NO_EXCEPTIONS 1975 try { 1976# endif // _LIBCPP_HAS_NO_EXCEPTIONS 1977 size_t __n_left = __n; 1978 for (const value_type* __p = __il.begin(); __n_left; ++__end_, ++__p, --__n_left) 1979 ::new ((void*)__end_) value_type(*__p); 1980# ifndef _LIBCPP_HAS_NO_EXCEPTIONS 1981 } catch (...) { 1982 __clear(__n); 1983 throw; 1984 } 1985# endif // _LIBCPP_HAS_NO_EXCEPTIONS 1986 } 1987} 1988 1989#endif // _LIBCPP_CXX03_LANG 1990 1991template <class _Tp> 1992valarray<_Tp>::valarray(const slice_array<value_type>& __sa) : __begin_(nullptr), __end_(nullptr) { 1993 const size_t __n = __sa.__size_; 1994 if (__n) { 1995 __begin_ = __end_ = allocator<value_type>().allocate(__n); 1996#ifndef _LIBCPP_HAS_NO_EXCEPTIONS 1997 try { 1998#endif // _LIBCPP_HAS_NO_EXCEPTIONS 1999 size_t __n_left = __n; 2000 for (const value_type* __p = __sa.__vp_; __n_left; ++__end_, __p += __sa.__stride_, --__n_left) 2001 ::new ((void*)__end_) value_type(*__p); 2002#ifndef _LIBCPP_HAS_NO_EXCEPTIONS 2003 } catch (...) { 2004 __clear(__n); 2005 throw; 2006 } 2007#endif // _LIBCPP_HAS_NO_EXCEPTIONS 2008 } 2009} 2010 2011template <class _Tp> 2012valarray<_Tp>::valarray(const gslice_array<value_type>& __ga) : __begin_(nullptr), __end_(nullptr) { 2013 const size_t __n = __ga.__1d_.size(); 2014 if (__n) { 2015 __begin_ = __end_ = allocator<value_type>().allocate(__n); 2016#ifndef _LIBCPP_HAS_NO_EXCEPTIONS 2017 try { 2018#endif // _LIBCPP_HAS_NO_EXCEPTIONS 2019 typedef const size_t* _Ip; 2020 const value_type* __s = __ga.__vp_; 2021 for (_Ip __i = __ga.__1d_.__begin_, __e = __ga.__1d_.__end_; __i != __e; ++__i, ++__end_) 2022 ::new ((void*)__end_) value_type(__s[*__i]); 2023#ifndef _LIBCPP_HAS_NO_EXCEPTIONS 2024 } catch (...) { 2025 __clear(__n); 2026 throw; 2027 } 2028#endif // _LIBCPP_HAS_NO_EXCEPTIONS 2029 } 2030} 2031 2032template <class _Tp> 2033valarray<_Tp>::valarray(const mask_array<value_type>& __ma) : __begin_(nullptr), __end_(nullptr) { 2034 const size_t __n = __ma.__1d_.size(); 2035 if (__n) { 2036 __begin_ = __end_ = allocator<value_type>().allocate(__n); 2037#ifndef _LIBCPP_HAS_NO_EXCEPTIONS 2038 try { 2039#endif // _LIBCPP_HAS_NO_EXCEPTIONS 2040 typedef const size_t* _Ip; 2041 const value_type* __s = __ma.__vp_; 2042 for (_Ip __i = __ma.__1d_.__begin_, __e = __ma.__1d_.__end_; __i != __e; ++__i, ++__end_) 2043 ::new ((void*)__end_) value_type(__s[*__i]); 2044#ifndef _LIBCPP_HAS_NO_EXCEPTIONS 2045 } catch (...) { 2046 __clear(__n); 2047 throw; 2048 } 2049#endif // _LIBCPP_HAS_NO_EXCEPTIONS 2050 } 2051} 2052 2053template <class _Tp> 2054valarray<_Tp>::valarray(const indirect_array<value_type>& __ia) : __begin_(nullptr), __end_(nullptr) { 2055 const size_t __n = __ia.__1d_.size(); 2056 if (__n) { 2057 __begin_ = __end_ = allocator<value_type>().allocate(__n); 2058#ifndef _LIBCPP_HAS_NO_EXCEPTIONS 2059 try { 2060#endif // _LIBCPP_HAS_NO_EXCEPTIONS 2061 typedef const size_t* _Ip; 2062 const value_type* __s = __ia.__vp_; 2063 for (_Ip __i = __ia.__1d_.__begin_, __e = __ia.__1d_.__end_; __i != __e; ++__i, ++__end_) 2064 ::new ((void*)__end_) value_type(__s[*__i]); 2065#ifndef _LIBCPP_HAS_NO_EXCEPTIONS 2066 } catch (...) { 2067 __clear(__n); 2068 throw; 2069 } 2070#endif // _LIBCPP_HAS_NO_EXCEPTIONS 2071 } 2072} 2073 2074template <class _Tp> 2075inline valarray<_Tp>::~valarray() { 2076 __clear(size()); 2077} 2078 2079template <class _Tp> 2080valarray<_Tp>& valarray<_Tp>::__assign_range(const value_type* __f, const value_type* __l) { 2081 size_t __n = __l - __f; 2082 if (size() != __n) { 2083 __clear(size()); 2084 __begin_ = allocator<value_type>().allocate(__n); 2085 __end_ = __begin_ + __n; 2086 std::uninitialized_copy(__f, __l, __begin_); 2087 } else { 2088 std::copy(__f, __l, __begin_); 2089 } 2090 return *this; 2091} 2092 2093template <class _Tp> 2094valarray<_Tp>& valarray<_Tp>::operator=(const valarray& __v) { 2095 if (this != std::addressof(__v)) 2096 return __assign_range(__v.__begin_, __v.__end_); 2097 return *this; 2098} 2099 2100#ifndef _LIBCPP_CXX03_LANG 2101 2102template <class _Tp> 2103inline valarray<_Tp>& valarray<_Tp>::operator=(valarray&& __v) _NOEXCEPT { 2104 __clear(size()); 2105 __begin_ = __v.__begin_; 2106 __end_ = __v.__end_; 2107 __v.__begin_ = nullptr; 2108 __v.__end_ = nullptr; 2109 return *this; 2110} 2111 2112template <class _Tp> 2113inline valarray<_Tp>& valarray<_Tp>::operator=(initializer_list<value_type> __il) { 2114 return __assign_range(__il.begin(), __il.end()); 2115} 2116 2117#endif // _LIBCPP_CXX03_LANG 2118 2119template <class _Tp> 2120inline valarray<_Tp>& valarray<_Tp>::operator=(const value_type& __x) { 2121 std::fill(__begin_, __end_, __x); 2122 return *this; 2123} 2124 2125template <class _Tp> 2126inline valarray<_Tp>& valarray<_Tp>::operator=(const slice_array<value_type>& __sa) { 2127 value_type* __t = __begin_; 2128 const value_type* __s = __sa.__vp_; 2129 for (size_t __n = __sa.__size_; __n; --__n, __s += __sa.__stride_, ++__t) 2130 *__t = *__s; 2131 return *this; 2132} 2133 2134template <class _Tp> 2135inline valarray<_Tp>& valarray<_Tp>::operator=(const gslice_array<value_type>& __ga) { 2136 typedef const size_t* _Ip; 2137 value_type* __t = __begin_; 2138 const value_type* __s = __ga.__vp_; 2139 for (_Ip __i = __ga.__1d_.__begin_, __e = __ga.__1d_.__end_; __i != __e; ++__i, ++__t) 2140 *__t = __s[*__i]; 2141 return *this; 2142} 2143 2144template <class _Tp> 2145inline valarray<_Tp>& valarray<_Tp>::operator=(const mask_array<value_type>& __ma) { 2146 typedef const size_t* _Ip; 2147 value_type* __t = __begin_; 2148 const value_type* __s = __ma.__vp_; 2149 for (_Ip __i = __ma.__1d_.__begin_, __e = __ma.__1d_.__end_; __i != __e; ++__i, ++__t) 2150 *__t = __s[*__i]; 2151 return *this; 2152} 2153 2154template <class _Tp> 2155inline valarray<_Tp>& valarray<_Tp>::operator=(const indirect_array<value_type>& __ia) { 2156 typedef const size_t* _Ip; 2157 value_type* __t = __begin_; 2158 const value_type* __s = __ia.__vp_; 2159 for (_Ip __i = __ia.__1d_.__begin_, __e = __ia.__1d_.__end_; __i != __e; ++__i, ++__t) 2160 *__t = __s[*__i]; 2161 return *this; 2162} 2163 2164template <class _Tp> 2165template <class _ValExpr> 2166inline valarray<_Tp>& valarray<_Tp>::operator=(const __val_expr<_ValExpr>& __v) { 2167 size_t __n = __v.size(); 2168 if (size() != __n) 2169 resize(__n); 2170 value_type* __t = __begin_; 2171 for (size_t __i = 0; __i != __n; ++__t, ++__i) 2172 *__t = __result_type(__v[__i]); 2173 return *this; 2174} 2175 2176template <class _Tp> 2177inline __val_expr<__slice_expr<const valarray<_Tp>&> > valarray<_Tp>::operator[](slice __s) const { 2178 return __val_expr<__slice_expr<const valarray&> >(__slice_expr<const valarray&>(__s, *this)); 2179} 2180 2181template <class _Tp> 2182inline slice_array<_Tp> valarray<_Tp>::operator[](slice __s) { 2183 return slice_array<value_type>(__s, *this); 2184} 2185 2186template <class _Tp> 2187inline __val_expr<__indirect_expr<const valarray<_Tp>&> > valarray<_Tp>::operator[](const gslice& __gs) const { 2188 return __val_expr<__indirect_expr<const valarray&> >(__indirect_expr<const valarray&>(__gs.__1d_, *this)); 2189} 2190 2191template <class _Tp> 2192inline gslice_array<_Tp> valarray<_Tp>::operator[](const gslice& __gs) { 2193 return gslice_array<value_type>(__gs, *this); 2194} 2195 2196#ifndef _LIBCPP_CXX03_LANG 2197 2198template <class _Tp> 2199inline __val_expr<__indirect_expr<const valarray<_Tp>&> > valarray<_Tp>::operator[](gslice&& __gs) const { 2200 return __val_expr<__indirect_expr<const valarray&> >(__indirect_expr<const valarray&>(std::move(__gs.__1d_), *this)); 2201} 2202 2203template <class _Tp> 2204inline gslice_array<_Tp> valarray<_Tp>::operator[](gslice&& __gs) { 2205 return gslice_array<value_type>(std::move(__gs), *this); 2206} 2207 2208#endif // _LIBCPP_CXX03_LANG 2209 2210template <class _Tp> 2211inline __val_expr<__mask_expr<const valarray<_Tp>&> > valarray<_Tp>::operator[](const valarray<bool>& __vb) const { 2212 return __val_expr<__mask_expr<const valarray&> >(__mask_expr<const valarray&>(__vb, *this)); 2213} 2214 2215template <class _Tp> 2216inline mask_array<_Tp> valarray<_Tp>::operator[](const valarray<bool>& __vb) { 2217 return mask_array<value_type>(__vb, *this); 2218} 2219 2220#ifndef _LIBCPP_CXX03_LANG 2221 2222template <class _Tp> 2223inline __val_expr<__mask_expr<const valarray<_Tp>&> > valarray<_Tp>::operator[](valarray<bool>&& __vb) const { 2224 return __val_expr<__mask_expr<const valarray&> >(__mask_expr<const valarray&>(std::move(__vb), *this)); 2225} 2226 2227template <class _Tp> 2228inline mask_array<_Tp> valarray<_Tp>::operator[](valarray<bool>&& __vb) { 2229 return mask_array<value_type>(std::move(__vb), *this); 2230} 2231 2232#endif // _LIBCPP_CXX03_LANG 2233 2234template <class _Tp> 2235inline __val_expr<__indirect_expr<const valarray<_Tp>&> > 2236valarray<_Tp>::operator[](const valarray<size_t>& __vs) const { 2237 return __val_expr<__indirect_expr<const valarray&> >(__indirect_expr<const valarray&>(__vs, *this)); 2238} 2239 2240template <class _Tp> 2241inline indirect_array<_Tp> valarray<_Tp>::operator[](const valarray<size_t>& __vs) { 2242 return indirect_array<value_type>(__vs, *this); 2243} 2244 2245#ifndef _LIBCPP_CXX03_LANG 2246 2247template <class _Tp> 2248inline __val_expr<__indirect_expr<const valarray<_Tp>&> > valarray<_Tp>::operator[](valarray<size_t>&& __vs) const { 2249 return __val_expr<__indirect_expr<const valarray&> >(__indirect_expr<const valarray&>(std::move(__vs), *this)); 2250} 2251 2252template <class _Tp> 2253inline indirect_array<_Tp> valarray<_Tp>::operator[](valarray<size_t>&& __vs) { 2254 return indirect_array<value_type>(std::move(__vs), *this); 2255} 2256 2257#endif // _LIBCPP_CXX03_LANG 2258 2259template <class _Tp> 2260inline __val_expr<_UnaryOp<__unary_plus<_Tp>, const valarray<_Tp>&> > valarray<_Tp>::operator+() const { 2261 using _Op = _UnaryOp<__unary_plus<_Tp>, const valarray<_Tp>&>; 2262 return __val_expr<_Op>(_Op(__unary_plus<_Tp>(), *this)); 2263} 2264 2265template <class _Tp> 2266inline __val_expr<_UnaryOp<negate<_Tp>, const valarray<_Tp>&> > valarray<_Tp>::operator-() const { 2267 using _Op = _UnaryOp<negate<_Tp>, const valarray<_Tp>&>; 2268 return __val_expr<_Op>(_Op(negate<_Tp>(), *this)); 2269} 2270 2271template <class _Tp> 2272inline __val_expr<_UnaryOp<__bit_not<_Tp>, const valarray<_Tp>&> > valarray<_Tp>::operator~() const { 2273 using _Op = _UnaryOp<__bit_not<_Tp>, const valarray<_Tp>&>; 2274 return __val_expr<_Op>(_Op(__bit_not<_Tp>(), *this)); 2275} 2276 2277template <class _Tp> 2278inline __val_expr<_UnaryOp<logical_not<_Tp>, const valarray<_Tp>&> > valarray<_Tp>::operator!() const { 2279 using _Op = _UnaryOp<logical_not<_Tp>, const valarray<_Tp>&>; 2280 return __val_expr<_Op>(_Op(logical_not<_Tp>(), *this)); 2281} 2282 2283template <class _Tp> 2284inline valarray<_Tp>& valarray<_Tp>::operator*=(const value_type& __x) { 2285 for (value_type* __p = __begin_; __p != __end_; ++__p) 2286 *__p *= __x; 2287 return *this; 2288} 2289 2290template <class _Tp> 2291inline valarray<_Tp>& valarray<_Tp>::operator/=(const value_type& __x) { 2292 for (value_type* __p = __begin_; __p != __end_; ++__p) 2293 *__p /= __x; 2294 return *this; 2295} 2296 2297template <class _Tp> 2298inline valarray<_Tp>& valarray<_Tp>::operator%=(const value_type& __x) { 2299 for (value_type* __p = __begin_; __p != __end_; ++__p) 2300 *__p %= __x; 2301 return *this; 2302} 2303 2304template <class _Tp> 2305inline valarray<_Tp>& valarray<_Tp>::operator+=(const value_type& __x) { 2306 for (value_type* __p = __begin_; __p != __end_; ++__p) 2307 *__p += __x; 2308 return *this; 2309} 2310 2311template <class _Tp> 2312inline valarray<_Tp>& valarray<_Tp>::operator-=(const value_type& __x) { 2313 for (value_type* __p = __begin_; __p != __end_; ++__p) 2314 *__p -= __x; 2315 return *this; 2316} 2317 2318template <class _Tp> 2319inline valarray<_Tp>& valarray<_Tp>::operator^=(const value_type& __x) { 2320 for (value_type* __p = __begin_; __p != __end_; ++__p) 2321 *__p ^= __x; 2322 return *this; 2323} 2324 2325template <class _Tp> 2326inline valarray<_Tp>& valarray<_Tp>::operator&=(const value_type& __x) { 2327 for (value_type* __p = __begin_; __p != __end_; ++__p) 2328 *__p &= __x; 2329 return *this; 2330} 2331 2332template <class _Tp> 2333inline valarray<_Tp>& valarray<_Tp>::operator|=(const value_type& __x) { 2334 for (value_type* __p = __begin_; __p != __end_; ++__p) 2335 *__p |= __x; 2336 return *this; 2337} 2338 2339template <class _Tp> 2340inline valarray<_Tp>& valarray<_Tp>::operator<<=(const value_type& __x) { 2341 for (value_type* __p = __begin_; __p != __end_; ++__p) 2342 *__p <<= __x; 2343 return *this; 2344} 2345 2346template <class _Tp> 2347inline valarray<_Tp>& valarray<_Tp>::operator>>=(const value_type& __x) { 2348 for (value_type* __p = __begin_; __p != __end_; ++__p) 2349 *__p >>= __x; 2350 return *this; 2351} 2352 2353template <class _Tp> 2354template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> > 2355inline valarray<_Tp>& valarray<_Tp>::operator*=(const _Expr& __v) { 2356 size_t __i = 0; 2357 for (value_type* __t = __begin_; __t != __end_; ++__t, ++__i) 2358 *__t *= __v[__i]; 2359 return *this; 2360} 2361 2362template <class _Tp> 2363template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> > 2364inline valarray<_Tp>& valarray<_Tp>::operator/=(const _Expr& __v) { 2365 size_t __i = 0; 2366 for (value_type* __t = __begin_; __t != __end_; ++__t, ++__i) 2367 *__t /= __v[__i]; 2368 return *this; 2369} 2370 2371template <class _Tp> 2372template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> > 2373inline valarray<_Tp>& valarray<_Tp>::operator%=(const _Expr& __v) { 2374 size_t __i = 0; 2375 for (value_type* __t = __begin_; __t != __end_; ++__t, ++__i) 2376 *__t %= __v[__i]; 2377 return *this; 2378} 2379 2380template <class _Tp> 2381template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> > 2382inline valarray<_Tp>& valarray<_Tp>::operator+=(const _Expr& __v) { 2383 size_t __i = 0; 2384 for (value_type* __t = __begin_; __t != __end_; ++__t, ++__i) 2385 *__t += __v[__i]; 2386 return *this; 2387} 2388 2389template <class _Tp> 2390template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> > 2391inline valarray<_Tp>& valarray<_Tp>::operator-=(const _Expr& __v) { 2392 size_t __i = 0; 2393 for (value_type* __t = __begin_; __t != __end_; ++__t, ++__i) 2394 *__t -= __v[__i]; 2395 return *this; 2396} 2397 2398template <class _Tp> 2399template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> > 2400inline valarray<_Tp>& valarray<_Tp>::operator^=(const _Expr& __v) { 2401 size_t __i = 0; 2402 for (value_type* __t = __begin_; __t != __end_; ++__t, ++__i) 2403 *__t ^= __v[__i]; 2404 return *this; 2405} 2406 2407template <class _Tp> 2408template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> > 2409inline valarray<_Tp>& valarray<_Tp>::operator|=(const _Expr& __v) { 2410 size_t __i = 0; 2411 for (value_type* __t = __begin_; __t != __end_; ++__t, ++__i) 2412 *__t |= __v[__i]; 2413 return *this; 2414} 2415 2416template <class _Tp> 2417template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> > 2418inline valarray<_Tp>& valarray<_Tp>::operator&=(const _Expr& __v) { 2419 size_t __i = 0; 2420 for (value_type* __t = __begin_; __t != __end_; ++__t, ++__i) 2421 *__t &= __v[__i]; 2422 return *this; 2423} 2424 2425template <class _Tp> 2426template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> > 2427inline valarray<_Tp>& valarray<_Tp>::operator<<=(const _Expr& __v) { 2428 size_t __i = 0; 2429 for (value_type* __t = __begin_; __t != __end_; ++__t, ++__i) 2430 *__t <<= __v[__i]; 2431 return *this; 2432} 2433 2434template <class _Tp> 2435template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> > 2436inline valarray<_Tp>& valarray<_Tp>::operator>>=(const _Expr& __v) { 2437 size_t __i = 0; 2438 for (value_type* __t = __begin_; __t != __end_; ++__t, ++__i) 2439 *__t >>= __v[__i]; 2440 return *this; 2441} 2442 2443template <class _Tp> 2444inline void valarray<_Tp>::swap(valarray& __v) _NOEXCEPT { 2445 std::swap(__begin_, __v.__begin_); 2446 std::swap(__end_, __v.__end_); 2447} 2448 2449template <class _Tp> 2450inline _Tp valarray<_Tp>::sum() const { 2451 if (__begin_ == __end_) 2452 return value_type(); 2453 const value_type* __p = __begin_; 2454 _Tp __r = *__p; 2455 for (++__p; __p != __end_; ++__p) 2456 __r += *__p; 2457 return __r; 2458} 2459 2460template <class _Tp> 2461inline _Tp valarray<_Tp>::min() const { 2462 if (__begin_ == __end_) 2463 return value_type(); 2464 return *std::min_element(__begin_, __end_); 2465} 2466 2467template <class _Tp> 2468inline _Tp valarray<_Tp>::max() const { 2469 if (__begin_ == __end_) 2470 return value_type(); 2471 return *std::max_element(__begin_, __end_); 2472} 2473 2474template <class _Tp> 2475valarray<_Tp> valarray<_Tp>::shift(int __i) const { 2476 valarray<value_type> __r; 2477 size_t __n = size(); 2478 if (__n) { 2479 __r.__begin_ = __r.__end_ = allocator<value_type>().allocate(__n); 2480 const value_type* __sb; 2481 value_type* __tb; 2482 value_type* __te; 2483 if (__i >= 0) { 2484 __i = std::min(__i, static_cast<int>(__n)); 2485 __sb = __begin_ + __i; 2486 __tb = __r.__begin_; 2487 __te = __r.__begin_ + (__n - __i); 2488 } else { 2489 __i = std::min(-__i, static_cast<int>(__n)); 2490 __sb = __begin_; 2491 __tb = __r.__begin_ + __i; 2492 __te = __r.__begin_ + __n; 2493 } 2494 for (; __r.__end_ != __tb; ++__r.__end_) 2495 ::new ((void*)__r.__end_) value_type(); 2496 for (; __r.__end_ != __te; ++__r.__end_, ++__sb) 2497 ::new ((void*)__r.__end_) value_type(*__sb); 2498 for (__te = __r.__begin_ + __n; __r.__end_ != __te; ++__r.__end_) 2499 ::new ((void*)__r.__end_) value_type(); 2500 } 2501 return __r; 2502} 2503 2504template <class _Tp> 2505valarray<_Tp> valarray<_Tp>::cshift(int __i) const { 2506 valarray<value_type> __r; 2507 size_t __n = size(); 2508 if (__n) { 2509 __r.__begin_ = __r.__end_ = allocator<value_type>().allocate(__n); 2510 __i %= static_cast<int>(__n); 2511 const value_type* __m = __i >= 0 ? __begin_ + __i : __end_ + __i; 2512 for (const value_type* __s = __m; __s != __end_; ++__r.__end_, ++__s) 2513 ::new ((void*)__r.__end_) value_type(*__s); 2514 for (const value_type* __s = __begin_; __s != __m; ++__r.__end_, ++__s) 2515 ::new ((void*)__r.__end_) value_type(*__s); 2516 } 2517 return __r; 2518} 2519 2520template <class _Tp> 2521valarray<_Tp> valarray<_Tp>::apply(value_type __f(value_type)) const { 2522 valarray<value_type> __r; 2523 size_t __n = size(); 2524 if (__n) { 2525 __r.__begin_ = __r.__end_ = allocator<value_type>().allocate(__n); 2526 for (const value_type* __p = __begin_; __n; ++__r.__end_, ++__p, --__n) 2527 ::new ((void*)__r.__end_) value_type(__f(*__p)); 2528 } 2529 return __r; 2530} 2531 2532template <class _Tp> 2533valarray<_Tp> valarray<_Tp>::apply(value_type __f(const value_type&)) const { 2534 valarray<value_type> __r; 2535 size_t __n = size(); 2536 if (__n) { 2537 __r.__begin_ = __r.__end_ = allocator<value_type>().allocate(__n); 2538 for (const value_type* __p = __begin_; __n; ++__r.__end_, ++__p, --__n) 2539 ::new ((void*)__r.__end_) value_type(__f(*__p)); 2540 } 2541 return __r; 2542} 2543 2544template <class _Tp> 2545inline void valarray<_Tp>::__clear(size_t __capacity) { 2546 if (__begin_ != nullptr) { 2547 while (__end_ != __begin_) 2548 (--__end_)->~value_type(); 2549 allocator<value_type>().deallocate(__begin_, __capacity); 2550 __begin_ = __end_ = nullptr; 2551 } 2552} 2553 2554template <class _Tp> 2555void valarray<_Tp>::resize(size_t __n, value_type __x) { 2556 __clear(size()); 2557 if (__n) { 2558 __begin_ = __end_ = allocator<value_type>().allocate(__n); 2559#ifndef _LIBCPP_HAS_NO_EXCEPTIONS 2560 try { 2561#endif // _LIBCPP_HAS_NO_EXCEPTIONS 2562 for (size_t __n_left = __n; __n_left; --__n_left, ++__end_) 2563 ::new ((void*)__end_) value_type(__x); 2564#ifndef _LIBCPP_HAS_NO_EXCEPTIONS 2565 } catch (...) { 2566 __clear(__n); 2567 throw; 2568 } 2569#endif // _LIBCPP_HAS_NO_EXCEPTIONS 2570 } 2571} 2572 2573template <class _Tp> 2574inline _LIBCPP_HIDE_FROM_ABI void swap(valarray<_Tp>& __x, valarray<_Tp>& __y) _NOEXCEPT { 2575 __x.swap(__y); 2576} 2577 2578template <class _Expr1, 2579 class _Expr2, 2580 __enable_if_t<__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, int> = 0> 2581inline _LIBCPP_HIDE_FROM_ABI __val_expr<_BinaryOp<multiplies<typename _Expr1::value_type>, _Expr1, _Expr2> > 2582operator*(const _Expr1& __x, const _Expr2& __y) { 2583 typedef typename _Expr1::value_type value_type; 2584 typedef _BinaryOp<multiplies<value_type>, _Expr1, _Expr2> _Op; 2585 return __val_expr<_Op>(_Op(multiplies<value_type>(), __x, __y)); 2586} 2587 2588template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 2589inline _LIBCPP_HIDE_FROM_ABI 2590 __val_expr<_BinaryOp<multiplies<typename _Expr::value_type>, _Expr, __scalar_expr<typename _Expr::value_type> > > 2591 operator*(const _Expr& __x, const typename _Expr::value_type& __y) { 2592 typedef typename _Expr::value_type value_type; 2593 typedef _BinaryOp<multiplies<value_type>, _Expr, __scalar_expr<value_type> > _Op; 2594 return __val_expr<_Op>(_Op(multiplies<value_type>(), __x, __scalar_expr<value_type>(__y, __x.size()))); 2595} 2596 2597template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 2598inline _LIBCPP_HIDE_FROM_ABI 2599 __val_expr<_BinaryOp<multiplies<typename _Expr::value_type>, __scalar_expr<typename _Expr::value_type>, _Expr> > 2600 operator*(const typename _Expr::value_type& __x, const _Expr& __y) { 2601 typedef typename _Expr::value_type value_type; 2602 typedef _BinaryOp<multiplies<value_type>, __scalar_expr<value_type>, _Expr> _Op; 2603 return __val_expr<_Op>(_Op(multiplies<value_type>(), __scalar_expr<value_type>(__x, __y.size()), __y)); 2604} 2605 2606template <class _Expr1, 2607 class _Expr2, 2608 __enable_if_t<__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, int> = 0> 2609inline _LIBCPP_HIDE_FROM_ABI __val_expr<_BinaryOp<divides<typename _Expr1::value_type>, _Expr1, _Expr2> > 2610operator/(const _Expr1& __x, const _Expr2& __y) { 2611 typedef typename _Expr1::value_type value_type; 2612 typedef _BinaryOp<divides<value_type>, _Expr1, _Expr2> _Op; 2613 return __val_expr<_Op>(_Op(divides<value_type>(), __x, __y)); 2614} 2615 2616template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 2617inline _LIBCPP_HIDE_FROM_ABI 2618 __val_expr<_BinaryOp<divides<typename _Expr::value_type>, _Expr, __scalar_expr<typename _Expr::value_type> > > 2619 operator/(const _Expr& __x, const typename _Expr::value_type& __y) { 2620 typedef typename _Expr::value_type value_type; 2621 typedef _BinaryOp<divides<value_type>, _Expr, __scalar_expr<value_type> > _Op; 2622 return __val_expr<_Op>(_Op(divides<value_type>(), __x, __scalar_expr<value_type>(__y, __x.size()))); 2623} 2624 2625template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 2626inline _LIBCPP_HIDE_FROM_ABI 2627 __val_expr<_BinaryOp<divides<typename _Expr::value_type>, __scalar_expr<typename _Expr::value_type>, _Expr> > 2628 operator/(const typename _Expr::value_type& __x, const _Expr& __y) { 2629 typedef typename _Expr::value_type value_type; 2630 typedef _BinaryOp<divides<value_type>, __scalar_expr<value_type>, _Expr> _Op; 2631 return __val_expr<_Op>(_Op(divides<value_type>(), __scalar_expr<value_type>(__x, __y.size()), __y)); 2632} 2633 2634template <class _Expr1, 2635 class _Expr2, 2636 __enable_if_t<__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, int> = 0> 2637inline _LIBCPP_HIDE_FROM_ABI __val_expr<_BinaryOp<modulus<typename _Expr1::value_type>, _Expr1, _Expr2> > 2638operator%(const _Expr1& __x, const _Expr2& __y) { 2639 typedef typename _Expr1::value_type value_type; 2640 typedef _BinaryOp<modulus<value_type>, _Expr1, _Expr2> _Op; 2641 return __val_expr<_Op>(_Op(modulus<value_type>(), __x, __y)); 2642} 2643 2644template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 2645inline _LIBCPP_HIDE_FROM_ABI 2646 __val_expr<_BinaryOp<modulus<typename _Expr::value_type>, _Expr, __scalar_expr<typename _Expr::value_type> > > 2647 operator%(const _Expr& __x, const typename _Expr::value_type& __y) { 2648 typedef typename _Expr::value_type value_type; 2649 typedef _BinaryOp<modulus<value_type>, _Expr, __scalar_expr<value_type> > _Op; 2650 return __val_expr<_Op>(_Op(modulus<value_type>(), __x, __scalar_expr<value_type>(__y, __x.size()))); 2651} 2652 2653template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 2654inline _LIBCPP_HIDE_FROM_ABI 2655 __val_expr<_BinaryOp<modulus<typename _Expr::value_type>, __scalar_expr<typename _Expr::value_type>, _Expr> > 2656 operator%(const typename _Expr::value_type& __x, const _Expr& __y) { 2657 typedef typename _Expr::value_type value_type; 2658 typedef _BinaryOp<modulus<value_type>, __scalar_expr<value_type>, _Expr> _Op; 2659 return __val_expr<_Op>(_Op(modulus<value_type>(), __scalar_expr<value_type>(__x, __y.size()), __y)); 2660} 2661 2662template <class _Expr1, 2663 class _Expr2, 2664 __enable_if_t<__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, int> = 0> 2665inline _LIBCPP_HIDE_FROM_ABI __val_expr<_BinaryOp<plus<typename _Expr1::value_type>, _Expr1, _Expr2> > 2666operator+(const _Expr1& __x, const _Expr2& __y) { 2667 typedef typename _Expr1::value_type value_type; 2668 typedef _BinaryOp<plus<value_type>, _Expr1, _Expr2> _Op; 2669 return __val_expr<_Op>(_Op(plus<value_type>(), __x, __y)); 2670} 2671 2672template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 2673inline _LIBCPP_HIDE_FROM_ABI 2674 __val_expr<_BinaryOp<plus<typename _Expr::value_type>, _Expr, __scalar_expr<typename _Expr::value_type> > > 2675 operator+(const _Expr& __x, const typename _Expr::value_type& __y) { 2676 typedef typename _Expr::value_type value_type; 2677 typedef _BinaryOp<plus<value_type>, _Expr, __scalar_expr<value_type> > _Op; 2678 return __val_expr<_Op>(_Op(plus<value_type>(), __x, __scalar_expr<value_type>(__y, __x.size()))); 2679} 2680 2681template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 2682inline _LIBCPP_HIDE_FROM_ABI 2683 __val_expr<_BinaryOp<plus<typename _Expr::value_type>, __scalar_expr<typename _Expr::value_type>, _Expr> > 2684 operator+(const typename _Expr::value_type& __x, const _Expr& __y) { 2685 typedef typename _Expr::value_type value_type; 2686 typedef _BinaryOp<plus<value_type>, __scalar_expr<value_type>, _Expr> _Op; 2687 return __val_expr<_Op>(_Op(plus<value_type>(), __scalar_expr<value_type>(__x, __y.size()), __y)); 2688} 2689 2690template <class _Expr1, 2691 class _Expr2, 2692 __enable_if_t<__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, int> = 0> 2693inline _LIBCPP_HIDE_FROM_ABI __val_expr<_BinaryOp<minus<typename _Expr1::value_type>, _Expr1, _Expr2> > 2694operator-(const _Expr1& __x, const _Expr2& __y) { 2695 typedef typename _Expr1::value_type value_type; 2696 typedef _BinaryOp<minus<value_type>, _Expr1, _Expr2> _Op; 2697 return __val_expr<_Op>(_Op(minus<value_type>(), __x, __y)); 2698} 2699 2700template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 2701inline _LIBCPP_HIDE_FROM_ABI 2702 __val_expr<_BinaryOp<minus<typename _Expr::value_type>, _Expr, __scalar_expr<typename _Expr::value_type> > > 2703 operator-(const _Expr& __x, const typename _Expr::value_type& __y) { 2704 typedef typename _Expr::value_type value_type; 2705 typedef _BinaryOp<minus<value_type>, _Expr, __scalar_expr<value_type> > _Op; 2706 return __val_expr<_Op>(_Op(minus<value_type>(), __x, __scalar_expr<value_type>(__y, __x.size()))); 2707} 2708 2709template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 2710inline _LIBCPP_HIDE_FROM_ABI 2711 __val_expr<_BinaryOp<minus<typename _Expr::value_type>, __scalar_expr<typename _Expr::value_type>, _Expr> > 2712 operator-(const typename _Expr::value_type& __x, const _Expr& __y) { 2713 typedef typename _Expr::value_type value_type; 2714 typedef _BinaryOp<minus<value_type>, __scalar_expr<value_type>, _Expr> _Op; 2715 return __val_expr<_Op>(_Op(minus<value_type>(), __scalar_expr<value_type>(__x, __y.size()), __y)); 2716} 2717 2718template <class _Expr1, 2719 class _Expr2, 2720 __enable_if_t<__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, int> = 0> 2721inline _LIBCPP_HIDE_FROM_ABI __val_expr<_BinaryOp<bit_xor<typename _Expr1::value_type>, _Expr1, _Expr2> > 2722operator^(const _Expr1& __x, const _Expr2& __y) { 2723 typedef typename _Expr1::value_type value_type; 2724 typedef _BinaryOp<bit_xor<value_type>, _Expr1, _Expr2> _Op; 2725 return __val_expr<_Op>(_Op(bit_xor<value_type>(), __x, __y)); 2726} 2727 2728template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 2729inline _LIBCPP_HIDE_FROM_ABI 2730 __val_expr<_BinaryOp<bit_xor<typename _Expr::value_type>, _Expr, __scalar_expr<typename _Expr::value_type> > > 2731 operator^(const _Expr& __x, const typename _Expr::value_type& __y) { 2732 typedef typename _Expr::value_type value_type; 2733 typedef _BinaryOp<bit_xor<value_type>, _Expr, __scalar_expr<value_type> > _Op; 2734 return __val_expr<_Op>(_Op(bit_xor<value_type>(), __x, __scalar_expr<value_type>(__y, __x.size()))); 2735} 2736 2737template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 2738inline _LIBCPP_HIDE_FROM_ABI 2739 __val_expr<_BinaryOp<bit_xor<typename _Expr::value_type>, __scalar_expr<typename _Expr::value_type>, _Expr> > 2740 operator^(const typename _Expr::value_type& __x, const _Expr& __y) { 2741 typedef typename _Expr::value_type value_type; 2742 typedef _BinaryOp<bit_xor<value_type>, __scalar_expr<value_type>, _Expr> _Op; 2743 return __val_expr<_Op>(_Op(bit_xor<value_type>(), __scalar_expr<value_type>(__x, __y.size()), __y)); 2744} 2745 2746template <class _Expr1, 2747 class _Expr2, 2748 __enable_if_t<__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, int> = 0> 2749inline _LIBCPP_HIDE_FROM_ABI __val_expr<_BinaryOp<bit_and<typename _Expr1::value_type>, _Expr1, _Expr2> > 2750operator&(const _Expr1& __x, const _Expr2& __y) { 2751 typedef typename _Expr1::value_type value_type; 2752 typedef _BinaryOp<bit_and<value_type>, _Expr1, _Expr2> _Op; 2753 return __val_expr<_Op>(_Op(bit_and<value_type>(), __x, __y)); 2754} 2755 2756template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 2757inline _LIBCPP_HIDE_FROM_ABI 2758 __val_expr<_BinaryOp<bit_and<typename _Expr::value_type>, _Expr, __scalar_expr<typename _Expr::value_type> > > 2759 operator&(const _Expr& __x, const typename _Expr::value_type& __y) { 2760 typedef typename _Expr::value_type value_type; 2761 typedef _BinaryOp<bit_and<value_type>, _Expr, __scalar_expr<value_type> > _Op; 2762 return __val_expr<_Op>(_Op(bit_and<value_type>(), __x, __scalar_expr<value_type>(__y, __x.size()))); 2763} 2764 2765template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 2766inline _LIBCPP_HIDE_FROM_ABI 2767 __val_expr<_BinaryOp<bit_and<typename _Expr::value_type>, __scalar_expr<typename _Expr::value_type>, _Expr> > 2768 operator&(const typename _Expr::value_type& __x, const _Expr& __y) { 2769 typedef typename _Expr::value_type value_type; 2770 typedef _BinaryOp<bit_and<value_type>, __scalar_expr<value_type>, _Expr> _Op; 2771 return __val_expr<_Op>(_Op(bit_and<value_type>(), __scalar_expr<value_type>(__x, __y.size()), __y)); 2772} 2773 2774template <class _Expr1, 2775 class _Expr2, 2776 __enable_if_t<__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, int> = 0> 2777inline _LIBCPP_HIDE_FROM_ABI __val_expr<_BinaryOp<bit_or<typename _Expr1::value_type>, _Expr1, _Expr2> > 2778operator|(const _Expr1& __x, const _Expr2& __y) { 2779 typedef typename _Expr1::value_type value_type; 2780 typedef _BinaryOp<bit_or<value_type>, _Expr1, _Expr2> _Op; 2781 return __val_expr<_Op>(_Op(bit_or<value_type>(), __x, __y)); 2782} 2783 2784template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 2785inline _LIBCPP_HIDE_FROM_ABI 2786 __val_expr<_BinaryOp<bit_or<typename _Expr::value_type>, _Expr, __scalar_expr<typename _Expr::value_type> > > 2787 operator|(const _Expr& __x, const typename _Expr::value_type& __y) { 2788 typedef typename _Expr::value_type value_type; 2789 typedef _BinaryOp<bit_or<value_type>, _Expr, __scalar_expr<value_type> > _Op; 2790 return __val_expr<_Op>(_Op(bit_or<value_type>(), __x, __scalar_expr<value_type>(__y, __x.size()))); 2791} 2792 2793template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 2794inline _LIBCPP_HIDE_FROM_ABI 2795 __val_expr<_BinaryOp<bit_or<typename _Expr::value_type>, __scalar_expr<typename _Expr::value_type>, _Expr> > 2796 operator|(const typename _Expr::value_type& __x, const _Expr& __y) { 2797 typedef typename _Expr::value_type value_type; 2798 typedef _BinaryOp<bit_or<value_type>, __scalar_expr<value_type>, _Expr> _Op; 2799 return __val_expr<_Op>(_Op(bit_or<value_type>(), __scalar_expr<value_type>(__x, __y.size()), __y)); 2800} 2801 2802template <class _Expr1, 2803 class _Expr2, 2804 __enable_if_t<__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, int> = 0> 2805inline _LIBCPP_HIDE_FROM_ABI __val_expr<_BinaryOp<__bit_shift_left<typename _Expr1::value_type>, _Expr1, _Expr2> > 2806operator<<(const _Expr1& __x, const _Expr2& __y) { 2807 typedef typename _Expr1::value_type value_type; 2808 typedef _BinaryOp<__bit_shift_left<value_type>, _Expr1, _Expr2> _Op; 2809 return __val_expr<_Op>(_Op(__bit_shift_left<value_type>(), __x, __y)); 2810} 2811 2812template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 2813inline _LIBCPP_HIDE_FROM_ABI __val_expr< 2814 _BinaryOp<__bit_shift_left<typename _Expr::value_type>, _Expr, __scalar_expr<typename _Expr::value_type> > > 2815operator<<(const _Expr& __x, const typename _Expr::value_type& __y) { 2816 typedef typename _Expr::value_type value_type; 2817 typedef _BinaryOp<__bit_shift_left<value_type>, _Expr, __scalar_expr<value_type> > _Op; 2818 return __val_expr<_Op>(_Op(__bit_shift_left<value_type>(), __x, __scalar_expr<value_type>(__y, __x.size()))); 2819} 2820 2821template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 2822inline _LIBCPP_HIDE_FROM_ABI __val_expr< 2823 _BinaryOp<__bit_shift_left<typename _Expr::value_type>, __scalar_expr<typename _Expr::value_type>, _Expr> > 2824operator<<(const typename _Expr::value_type& __x, const _Expr& __y) { 2825 typedef typename _Expr::value_type value_type; 2826 typedef _BinaryOp<__bit_shift_left<value_type>, __scalar_expr<value_type>, _Expr> _Op; 2827 return __val_expr<_Op>(_Op(__bit_shift_left<value_type>(), __scalar_expr<value_type>(__x, __y.size()), __y)); 2828} 2829 2830template <class _Expr1, 2831 class _Expr2, 2832 __enable_if_t<__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, int> = 0> 2833inline _LIBCPP_HIDE_FROM_ABI __val_expr<_BinaryOp<__bit_shift_right<typename _Expr1::value_type>, _Expr1, _Expr2> > 2834operator>>(const _Expr1& __x, const _Expr2& __y) { 2835 typedef typename _Expr1::value_type value_type; 2836 typedef _BinaryOp<__bit_shift_right<value_type>, _Expr1, _Expr2> _Op; 2837 return __val_expr<_Op>(_Op(__bit_shift_right<value_type>(), __x, __y)); 2838} 2839 2840template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 2841inline _LIBCPP_HIDE_FROM_ABI __val_expr< 2842 _BinaryOp<__bit_shift_right<typename _Expr::value_type>, _Expr, __scalar_expr<typename _Expr::value_type> > > 2843operator>>(const _Expr& __x, const typename _Expr::value_type& __y) { 2844 typedef typename _Expr::value_type value_type; 2845 typedef _BinaryOp<__bit_shift_right<value_type>, _Expr, __scalar_expr<value_type> > _Op; 2846 return __val_expr<_Op>(_Op(__bit_shift_right<value_type>(), __x, __scalar_expr<value_type>(__y, __x.size()))); 2847} 2848 2849template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 2850inline _LIBCPP_HIDE_FROM_ABI __val_expr< 2851 _BinaryOp<__bit_shift_right<typename _Expr::value_type>, __scalar_expr<typename _Expr::value_type>, _Expr> > 2852operator>>(const typename _Expr::value_type& __x, const _Expr& __y) { 2853 typedef typename _Expr::value_type value_type; 2854 typedef _BinaryOp<__bit_shift_right<value_type>, __scalar_expr<value_type>, _Expr> _Op; 2855 return __val_expr<_Op>(_Op(__bit_shift_right<value_type>(), __scalar_expr<value_type>(__x, __y.size()), __y)); 2856} 2857 2858template <class _Expr1, 2859 class _Expr2, 2860 __enable_if_t<__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, int> = 0> 2861inline _LIBCPP_HIDE_FROM_ABI __val_expr<_BinaryOp<logical_and<typename _Expr1::value_type>, _Expr1, _Expr2> > 2862operator&&(const _Expr1& __x, const _Expr2& __y) { 2863 typedef typename _Expr1::value_type value_type; 2864 typedef _BinaryOp<logical_and<value_type>, _Expr1, _Expr2> _Op; 2865 return __val_expr<_Op>(_Op(logical_and<value_type>(), __x, __y)); 2866} 2867 2868template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 2869inline _LIBCPP_HIDE_FROM_ABI 2870 __val_expr<_BinaryOp<logical_and<typename _Expr::value_type>, _Expr, __scalar_expr<typename _Expr::value_type> > > 2871 operator&&(const _Expr& __x, const typename _Expr::value_type& __y) { 2872 typedef typename _Expr::value_type value_type; 2873 typedef _BinaryOp<logical_and<value_type>, _Expr, __scalar_expr<value_type> > _Op; 2874 return __val_expr<_Op>(_Op(logical_and<value_type>(), __x, __scalar_expr<value_type>(__y, __x.size()))); 2875} 2876 2877template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 2878inline _LIBCPP_HIDE_FROM_ABI 2879 __val_expr<_BinaryOp<logical_and<typename _Expr::value_type>, __scalar_expr<typename _Expr::value_type>, _Expr> > 2880 operator&&(const typename _Expr::value_type& __x, const _Expr& __y) { 2881 typedef typename _Expr::value_type value_type; 2882 typedef _BinaryOp<logical_and<value_type>, __scalar_expr<value_type>, _Expr> _Op; 2883 return __val_expr<_Op>(_Op(logical_and<value_type>(), __scalar_expr<value_type>(__x, __y.size()), __y)); 2884} 2885 2886template <class _Expr1, 2887 class _Expr2, 2888 __enable_if_t<__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, int> = 0> 2889inline _LIBCPP_HIDE_FROM_ABI __val_expr<_BinaryOp<logical_or<typename _Expr1::value_type>, _Expr1, _Expr2> > 2890operator||(const _Expr1& __x, const _Expr2& __y) { 2891 typedef typename _Expr1::value_type value_type; 2892 typedef _BinaryOp<logical_or<value_type>, _Expr1, _Expr2> _Op; 2893 return __val_expr<_Op>(_Op(logical_or<value_type>(), __x, __y)); 2894} 2895 2896template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 2897inline _LIBCPP_HIDE_FROM_ABI 2898 __val_expr<_BinaryOp<logical_or<typename _Expr::value_type>, _Expr, __scalar_expr<typename _Expr::value_type> > > 2899 operator||(const _Expr& __x, const typename _Expr::value_type& __y) { 2900 typedef typename _Expr::value_type value_type; 2901 typedef _BinaryOp<logical_or<value_type>, _Expr, __scalar_expr<value_type> > _Op; 2902 return __val_expr<_Op>(_Op(logical_or<value_type>(), __x, __scalar_expr<value_type>(__y, __x.size()))); 2903} 2904 2905template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 2906inline _LIBCPP_HIDE_FROM_ABI 2907 __val_expr<_BinaryOp<logical_or<typename _Expr::value_type>, __scalar_expr<typename _Expr::value_type>, _Expr> > 2908 operator||(const typename _Expr::value_type& __x, const _Expr& __y) { 2909 typedef typename _Expr::value_type value_type; 2910 typedef _BinaryOp<logical_or<value_type>, __scalar_expr<value_type>, _Expr> _Op; 2911 return __val_expr<_Op>(_Op(logical_or<value_type>(), __scalar_expr<value_type>(__x, __y.size()), __y)); 2912} 2913 2914template <class _Expr1, 2915 class _Expr2, 2916 __enable_if_t<__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, int> = 0> 2917inline _LIBCPP_HIDE_FROM_ABI __val_expr<_BinaryOp<equal_to<typename _Expr1::value_type>, _Expr1, _Expr2> > 2918operator==(const _Expr1& __x, const _Expr2& __y) { 2919 typedef typename _Expr1::value_type value_type; 2920 typedef _BinaryOp<equal_to<value_type>, _Expr1, _Expr2> _Op; 2921 return __val_expr<_Op>(_Op(equal_to<value_type>(), __x, __y)); 2922} 2923 2924template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 2925inline _LIBCPP_HIDE_FROM_ABI 2926 __val_expr<_BinaryOp<equal_to<typename _Expr::value_type>, _Expr, __scalar_expr<typename _Expr::value_type> > > 2927 operator==(const _Expr& __x, const typename _Expr::value_type& __y) { 2928 typedef typename _Expr::value_type value_type; 2929 typedef _BinaryOp<equal_to<value_type>, _Expr, __scalar_expr<value_type> > _Op; 2930 return __val_expr<_Op>(_Op(equal_to<value_type>(), __x, __scalar_expr<value_type>(__y, __x.size()))); 2931} 2932 2933template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 2934inline _LIBCPP_HIDE_FROM_ABI 2935 __val_expr<_BinaryOp<equal_to<typename _Expr::value_type>, __scalar_expr<typename _Expr::value_type>, _Expr> > 2936 operator==(const typename _Expr::value_type& __x, const _Expr& __y) { 2937 typedef typename _Expr::value_type value_type; 2938 typedef _BinaryOp<equal_to<value_type>, __scalar_expr<value_type>, _Expr> _Op; 2939 return __val_expr<_Op>(_Op(equal_to<value_type>(), __scalar_expr<value_type>(__x, __y.size()), __y)); 2940} 2941 2942template <class _Expr1, 2943 class _Expr2, 2944 __enable_if_t<__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, int> = 0> 2945inline _LIBCPP_HIDE_FROM_ABI __val_expr<_BinaryOp<not_equal_to<typename _Expr1::value_type>, _Expr1, _Expr2> > 2946operator!=(const _Expr1& __x, const _Expr2& __y) { 2947 typedef typename _Expr1::value_type value_type; 2948 typedef _BinaryOp<not_equal_to<value_type>, _Expr1, _Expr2> _Op; 2949 return __val_expr<_Op>(_Op(not_equal_to<value_type>(), __x, __y)); 2950} 2951 2952template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 2953inline _LIBCPP_HIDE_FROM_ABI 2954 __val_expr<_BinaryOp<not_equal_to<typename _Expr::value_type>, _Expr, __scalar_expr<typename _Expr::value_type> > > 2955 operator!=(const _Expr& __x, const typename _Expr::value_type& __y) { 2956 typedef typename _Expr::value_type value_type; 2957 typedef _BinaryOp<not_equal_to<value_type>, _Expr, __scalar_expr<value_type> > _Op; 2958 return __val_expr<_Op>(_Op(not_equal_to<value_type>(), __x, __scalar_expr<value_type>(__y, __x.size()))); 2959} 2960 2961template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 2962inline _LIBCPP_HIDE_FROM_ABI 2963 __val_expr<_BinaryOp<not_equal_to<typename _Expr::value_type>, __scalar_expr<typename _Expr::value_type>, _Expr> > 2964 operator!=(const typename _Expr::value_type& __x, const _Expr& __y) { 2965 typedef typename _Expr::value_type value_type; 2966 typedef _BinaryOp<not_equal_to<value_type>, __scalar_expr<value_type>, _Expr> _Op; 2967 return __val_expr<_Op>(_Op(not_equal_to<value_type>(), __scalar_expr<value_type>(__x, __y.size()), __y)); 2968} 2969 2970template <class _Expr1, 2971 class _Expr2, 2972 __enable_if_t<__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, int> = 0> 2973inline _LIBCPP_HIDE_FROM_ABI __val_expr<_BinaryOp<less<typename _Expr1::value_type>, _Expr1, _Expr2> > 2974operator<(const _Expr1& __x, const _Expr2& __y) { 2975 typedef typename _Expr1::value_type value_type; 2976 typedef _BinaryOp<less<value_type>, _Expr1, _Expr2> _Op; 2977 return __val_expr<_Op>(_Op(less<value_type>(), __x, __y)); 2978} 2979 2980template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 2981inline _LIBCPP_HIDE_FROM_ABI 2982 __val_expr<_BinaryOp<less<typename _Expr::value_type>, _Expr, __scalar_expr<typename _Expr::value_type> > > 2983 operator<(const _Expr& __x, const typename _Expr::value_type& __y) { 2984 typedef typename _Expr::value_type value_type; 2985 typedef _BinaryOp<less<value_type>, _Expr, __scalar_expr<value_type> > _Op; 2986 return __val_expr<_Op>(_Op(less<value_type>(), __x, __scalar_expr<value_type>(__y, __x.size()))); 2987} 2988 2989template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 2990inline _LIBCPP_HIDE_FROM_ABI 2991 __val_expr<_BinaryOp<less<typename _Expr::value_type>, __scalar_expr<typename _Expr::value_type>, _Expr> > 2992 operator<(const typename _Expr::value_type& __x, const _Expr& __y) { 2993 typedef typename _Expr::value_type value_type; 2994 typedef _BinaryOp<less<value_type>, __scalar_expr<value_type>, _Expr> _Op; 2995 return __val_expr<_Op>(_Op(less<value_type>(), __scalar_expr<value_type>(__x, __y.size()), __y)); 2996} 2997 2998template <class _Expr1, 2999 class _Expr2, 3000 __enable_if_t<__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, int> = 0> 3001inline _LIBCPP_HIDE_FROM_ABI __val_expr<_BinaryOp<greater<typename _Expr1::value_type>, _Expr1, _Expr2> > 3002operator>(const _Expr1& __x, const _Expr2& __y) { 3003 typedef typename _Expr1::value_type value_type; 3004 typedef _BinaryOp<greater<value_type>, _Expr1, _Expr2> _Op; 3005 return __val_expr<_Op>(_Op(greater<value_type>(), __x, __y)); 3006} 3007 3008template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 3009inline _LIBCPP_HIDE_FROM_ABI 3010 __val_expr<_BinaryOp<greater<typename _Expr::value_type>, _Expr, __scalar_expr<typename _Expr::value_type> > > 3011 operator>(const _Expr& __x, const typename _Expr::value_type& __y) { 3012 typedef typename _Expr::value_type value_type; 3013 typedef _BinaryOp<greater<value_type>, _Expr, __scalar_expr<value_type> > _Op; 3014 return __val_expr<_Op>(_Op(greater<value_type>(), __x, __scalar_expr<value_type>(__y, __x.size()))); 3015} 3016 3017template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 3018inline _LIBCPP_HIDE_FROM_ABI 3019 __val_expr<_BinaryOp<greater<typename _Expr::value_type>, __scalar_expr<typename _Expr::value_type>, _Expr> > 3020 operator>(const typename _Expr::value_type& __x, const _Expr& __y) { 3021 typedef typename _Expr::value_type value_type; 3022 typedef _BinaryOp<greater<value_type>, __scalar_expr<value_type>, _Expr> _Op; 3023 return __val_expr<_Op>(_Op(greater<value_type>(), __scalar_expr<value_type>(__x, __y.size()), __y)); 3024} 3025 3026template <class _Expr1, 3027 class _Expr2, 3028 __enable_if_t<__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, int> = 0> 3029inline _LIBCPP_HIDE_FROM_ABI __val_expr<_BinaryOp<less_equal<typename _Expr1::value_type>, _Expr1, _Expr2> > 3030operator<=(const _Expr1& __x, const _Expr2& __y) { 3031 typedef typename _Expr1::value_type value_type; 3032 typedef _BinaryOp<less_equal<value_type>, _Expr1, _Expr2> _Op; 3033 return __val_expr<_Op>(_Op(less_equal<value_type>(), __x, __y)); 3034} 3035 3036template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 3037inline _LIBCPP_HIDE_FROM_ABI 3038 __val_expr<_BinaryOp<less_equal<typename _Expr::value_type>, _Expr, __scalar_expr<typename _Expr::value_type> > > 3039 operator<=(const _Expr& __x, const typename _Expr::value_type& __y) { 3040 typedef typename _Expr::value_type value_type; 3041 typedef _BinaryOp<less_equal<value_type>, _Expr, __scalar_expr<value_type> > _Op; 3042 return __val_expr<_Op>(_Op(less_equal<value_type>(), __x, __scalar_expr<value_type>(__y, __x.size()))); 3043} 3044 3045template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 3046inline _LIBCPP_HIDE_FROM_ABI 3047 __val_expr<_BinaryOp<less_equal<typename _Expr::value_type>, __scalar_expr<typename _Expr::value_type>, _Expr> > 3048 operator<=(const typename _Expr::value_type& __x, const _Expr& __y) { 3049 typedef typename _Expr::value_type value_type; 3050 typedef _BinaryOp<less_equal<value_type>, __scalar_expr<value_type>, _Expr> _Op; 3051 return __val_expr<_Op>(_Op(less_equal<value_type>(), __scalar_expr<value_type>(__x, __y.size()), __y)); 3052} 3053 3054template <class _Expr1, 3055 class _Expr2, 3056 __enable_if_t<__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, int> = 0> 3057inline _LIBCPP_HIDE_FROM_ABI __val_expr<_BinaryOp<greater_equal<typename _Expr1::value_type>, _Expr1, _Expr2> > 3058operator>=(const _Expr1& __x, const _Expr2& __y) { 3059 typedef typename _Expr1::value_type value_type; 3060 typedef _BinaryOp<greater_equal<value_type>, _Expr1, _Expr2> _Op; 3061 return __val_expr<_Op>(_Op(greater_equal<value_type>(), __x, __y)); 3062} 3063 3064template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 3065inline _LIBCPP_HIDE_FROM_ABI 3066 __val_expr<_BinaryOp<greater_equal<typename _Expr::value_type>, _Expr, __scalar_expr<typename _Expr::value_type> > > 3067 operator>=(const _Expr& __x, const typename _Expr::value_type& __y) { 3068 typedef typename _Expr::value_type value_type; 3069 typedef _BinaryOp<greater_equal<value_type>, _Expr, __scalar_expr<value_type> > _Op; 3070 return __val_expr<_Op>(_Op(greater_equal<value_type>(), __x, __scalar_expr<value_type>(__y, __x.size()))); 3071} 3072 3073template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 3074inline _LIBCPP_HIDE_FROM_ABI 3075 __val_expr<_BinaryOp<greater_equal<typename _Expr::value_type>, __scalar_expr<typename _Expr::value_type>, _Expr> > 3076 operator>=(const typename _Expr::value_type& __x, const _Expr& __y) { 3077 typedef typename _Expr::value_type value_type; 3078 typedef _BinaryOp<greater_equal<value_type>, __scalar_expr<value_type>, _Expr> _Op; 3079 return __val_expr<_Op>(_Op(greater_equal<value_type>(), __scalar_expr<value_type>(__x, __y.size()), __y)); 3080} 3081 3082template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 3083inline _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__abs_expr<typename _Expr::value_type>, _Expr> > 3084abs(const _Expr& __x) { 3085 typedef typename _Expr::value_type value_type; 3086 typedef _UnaryOp<__abs_expr<value_type>, _Expr> _Op; 3087 return __val_expr<_Op>(_Op(__abs_expr<value_type>(), __x)); 3088} 3089 3090template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 3091inline _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__acos_expr<typename _Expr::value_type>, _Expr> > 3092acos(const _Expr& __x) { 3093 typedef typename _Expr::value_type value_type; 3094 typedef _UnaryOp<__acos_expr<value_type>, _Expr> _Op; 3095 return __val_expr<_Op>(_Op(__acos_expr<value_type>(), __x)); 3096} 3097 3098template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 3099inline _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__asin_expr<typename _Expr::value_type>, _Expr> > 3100asin(const _Expr& __x) { 3101 typedef typename _Expr::value_type value_type; 3102 typedef _UnaryOp<__asin_expr<value_type>, _Expr> _Op; 3103 return __val_expr<_Op>(_Op(__asin_expr<value_type>(), __x)); 3104} 3105 3106template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 3107inline _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__atan_expr<typename _Expr::value_type>, _Expr> > 3108atan(const _Expr& __x) { 3109 typedef typename _Expr::value_type value_type; 3110 typedef _UnaryOp<__atan_expr<value_type>, _Expr> _Op; 3111 return __val_expr<_Op>(_Op(__atan_expr<value_type>(), __x)); 3112} 3113 3114template <class _Expr1, 3115 class _Expr2, 3116 __enable_if_t<__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, int> = 0> 3117inline _LIBCPP_HIDE_FROM_ABI __val_expr<_BinaryOp<__atan2_expr<typename _Expr1::value_type>, _Expr1, _Expr2> > 3118atan2(const _Expr1& __x, const _Expr2& __y) { 3119 typedef typename _Expr1::value_type value_type; 3120 typedef _BinaryOp<__atan2_expr<value_type>, _Expr1, _Expr2> _Op; 3121 return __val_expr<_Op>(_Op(__atan2_expr<value_type>(), __x, __y)); 3122} 3123 3124template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 3125inline _LIBCPP_HIDE_FROM_ABI 3126 __val_expr<_BinaryOp<__atan2_expr<typename _Expr::value_type>, _Expr, __scalar_expr<typename _Expr::value_type> > > 3127 atan2(const _Expr& __x, const typename _Expr::value_type& __y) { 3128 typedef typename _Expr::value_type value_type; 3129 typedef _BinaryOp<__atan2_expr<value_type>, _Expr, __scalar_expr<value_type> > _Op; 3130 return __val_expr<_Op>(_Op(__atan2_expr<value_type>(), __x, __scalar_expr<value_type>(__y, __x.size()))); 3131} 3132 3133template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 3134inline _LIBCPP_HIDE_FROM_ABI 3135 __val_expr<_BinaryOp<__atan2_expr<typename _Expr::value_type>, __scalar_expr<typename _Expr::value_type>, _Expr> > 3136 atan2(const typename _Expr::value_type& __x, const _Expr& __y) { 3137 typedef typename _Expr::value_type value_type; 3138 typedef _BinaryOp<__atan2_expr<value_type>, __scalar_expr<value_type>, _Expr> _Op; 3139 return __val_expr<_Op>(_Op(__atan2_expr<value_type>(), __scalar_expr<value_type>(__x, __y.size()), __y)); 3140} 3141 3142template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 3143inline _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__cos_expr<typename _Expr::value_type>, _Expr> > 3144cos(const _Expr& __x) { 3145 typedef typename _Expr::value_type value_type; 3146 typedef _UnaryOp<__cos_expr<value_type>, _Expr> _Op; 3147 return __val_expr<_Op>(_Op(__cos_expr<value_type>(), __x)); 3148} 3149 3150template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 3151inline _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__cosh_expr<typename _Expr::value_type>, _Expr> > 3152cosh(const _Expr& __x) { 3153 typedef typename _Expr::value_type value_type; 3154 typedef _UnaryOp<__cosh_expr<value_type>, _Expr> _Op; 3155 return __val_expr<_Op>(_Op(__cosh_expr<value_type>(), __x)); 3156} 3157 3158template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 3159inline _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__exp_expr<typename _Expr::value_type>, _Expr> > 3160exp(const _Expr& __x) { 3161 typedef typename _Expr::value_type value_type; 3162 typedef _UnaryOp<__exp_expr<value_type>, _Expr> _Op; 3163 return __val_expr<_Op>(_Op(__exp_expr<value_type>(), __x)); 3164} 3165 3166template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 3167inline _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__log_expr<typename _Expr::value_type>, _Expr> > 3168log(const _Expr& __x) { 3169 typedef typename _Expr::value_type value_type; 3170 typedef _UnaryOp<__log_expr<value_type>, _Expr> _Op; 3171 return __val_expr<_Op>(_Op(__log_expr<value_type>(), __x)); 3172} 3173 3174template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 3175inline _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__log10_expr<typename _Expr::value_type>, _Expr> > 3176log10(const _Expr& __x) { 3177 typedef typename _Expr::value_type value_type; 3178 typedef _UnaryOp<__log10_expr<value_type>, _Expr> _Op; 3179 return __val_expr<_Op>(_Op(__log10_expr<value_type>(), __x)); 3180} 3181 3182template <class _Expr1, 3183 class _Expr2, 3184 __enable_if_t<__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, int> = 0> 3185inline _LIBCPP_HIDE_FROM_ABI __val_expr<_BinaryOp<__pow_expr<typename _Expr1::value_type>, _Expr1, _Expr2> > 3186pow(const _Expr1& __x, const _Expr2& __y) { 3187 typedef typename _Expr1::value_type value_type; 3188 typedef _BinaryOp<__pow_expr<value_type>, _Expr1, _Expr2> _Op; 3189 return __val_expr<_Op>(_Op(__pow_expr<value_type>(), __x, __y)); 3190} 3191 3192template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 3193inline _LIBCPP_HIDE_FROM_ABI 3194 __val_expr<_BinaryOp<__pow_expr<typename _Expr::value_type>, _Expr, __scalar_expr<typename _Expr::value_type> > > 3195 pow(const _Expr& __x, const typename _Expr::value_type& __y) { 3196 typedef typename _Expr::value_type value_type; 3197 typedef _BinaryOp<__pow_expr<value_type>, _Expr, __scalar_expr<value_type> > _Op; 3198 return __val_expr<_Op>(_Op(__pow_expr<value_type>(), __x, __scalar_expr<value_type>(__y, __x.size()))); 3199} 3200 3201template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 3202inline _LIBCPP_HIDE_FROM_ABI 3203 __val_expr<_BinaryOp<__pow_expr<typename _Expr::value_type>, __scalar_expr<typename _Expr::value_type>, _Expr> > 3204 pow(const typename _Expr::value_type& __x, const _Expr& __y) { 3205 typedef typename _Expr::value_type value_type; 3206 typedef _BinaryOp<__pow_expr<value_type>, __scalar_expr<value_type>, _Expr> _Op; 3207 return __val_expr<_Op>(_Op(__pow_expr<value_type>(), __scalar_expr<value_type>(__x, __y.size()), __y)); 3208} 3209 3210template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 3211inline _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__sin_expr<typename _Expr::value_type>, _Expr> > 3212sin(const _Expr& __x) { 3213 typedef typename _Expr::value_type value_type; 3214 typedef _UnaryOp<__sin_expr<value_type>, _Expr> _Op; 3215 return __val_expr<_Op>(_Op(__sin_expr<value_type>(), __x)); 3216} 3217 3218template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 3219inline _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__sinh_expr<typename _Expr::value_type>, _Expr> > 3220sinh(const _Expr& __x) { 3221 typedef typename _Expr::value_type value_type; 3222 typedef _UnaryOp<__sinh_expr<value_type>, _Expr> _Op; 3223 return __val_expr<_Op>(_Op(__sinh_expr<value_type>(), __x)); 3224} 3225 3226template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 3227inline _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__sqrt_expr<typename _Expr::value_type>, _Expr> > 3228sqrt(const _Expr& __x) { 3229 typedef typename _Expr::value_type value_type; 3230 typedef _UnaryOp<__sqrt_expr<value_type>, _Expr> _Op; 3231 return __val_expr<_Op>(_Op(__sqrt_expr<value_type>(), __x)); 3232} 3233 3234template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 3235inline _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__tan_expr<typename _Expr::value_type>, _Expr> > 3236tan(const _Expr& __x) { 3237 typedef typename _Expr::value_type value_type; 3238 typedef _UnaryOp<__tan_expr<value_type>, _Expr> _Op; 3239 return __val_expr<_Op>(_Op(__tan_expr<value_type>(), __x)); 3240} 3241 3242template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0> 3243inline _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__tanh_expr<typename _Expr::value_type>, _Expr> > 3244tanh(const _Expr& __x) { 3245 typedef typename _Expr::value_type value_type; 3246 typedef _UnaryOp<__tanh_expr<value_type>, _Expr> _Op; 3247 return __val_expr<_Op>(_Op(__tanh_expr<value_type>(), __x)); 3248} 3249 3250template <class _Tp> 3251inline _LIBCPP_HIDE_FROM_ABI _Tp* begin(valarray<_Tp>& __v) { 3252 return __v.__begin_; 3253} 3254 3255template <class _Tp> 3256inline _LIBCPP_HIDE_FROM_ABI const _Tp* begin(const valarray<_Tp>& __v) { 3257 return __v.__begin_; 3258} 3259 3260template <class _Tp> 3261inline _LIBCPP_HIDE_FROM_ABI _Tp* end(valarray<_Tp>& __v) { 3262 return __v.__end_; 3263} 3264 3265template <class _Tp> 3266inline _LIBCPP_HIDE_FROM_ABI const _Tp* end(const valarray<_Tp>& __v) { 3267 return __v.__end_; 3268} 3269 3270_LIBCPP_END_NAMESPACE_STD 3271 3272_LIBCPP_POP_MACROS 3273 3274#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20 3275# include <algorithm> 3276# include <concepts> 3277# include <cstdlib> 3278# include <cstring> 3279# include <functional> 3280# include <stdexcept> 3281# include <type_traits> 3282#endif 3283 3284#endif // _LIBCPP_VALARRAY 3285