codekingpro/portable-devtools
115k
1// -*- C++ -*-2//===-------------------------- valarray ----------------------------------===//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-exception7// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.8//9//===----------------------------------------------------------------------===//10 11#ifndef _LIBCUDACXX_VALARRAY12#define _LIBCUDACXX_VALARRAY13 14/*15 valarray synopsis16 17namespace std18{19 20template<class T>21class valarray22{23public:24 typedef T value_type;25 26 // construct/destroy:27 valarray();28 explicit valarray(size_t n);29 valarray(const value_type& x, size_t n);30 valarray(const value_type* px, size_t n);31 valarray(const valarray& v);32 valarray(valarray&& v) noexcept;33 valarray(const slice_array<value_type>& sa);34 valarray(const gslice_array<value_type>& ga);35 valarray(const mask_array<value_type>& ma);36 valarray(const indirect_array<value_type>& ia);37 valarray(initializer_list<value_type> il);38 ~valarray();39 40 // assignment:41 valarray& operator=(const valarray& v);42 valarray& operator=(valarray&& v) noexcept;43 valarray& operator=(initializer_list<value_type> il);44 valarray& operator=(const value_type& x);45 valarray& operator=(const slice_array<value_type>& sa);46 valarray& operator=(const gslice_array<value_type>& ga);47 valarray& operator=(const mask_array<value_type>& ma);48 valarray& operator=(const indirect_array<value_type>& ia);49 50 // element access:51 const value_type& operator[](size_t i) const;52 value_type& operator[](size_t i);53 54 // subset operations:55 valarray operator[](slice s) const;56 slice_array<value_type> operator[](slice s);57 valarray operator[](const gslice& gs) const;58 gslice_array<value_type> operator[](const gslice& gs);59 valarray operator[](const valarray<bool>& vb) const;60 mask_array<value_type> operator[](const valarray<bool>& vb);61 valarray operator[](const valarray<size_t>& vs) const;62 indirect_array<value_type> operator[](const valarray<size_t>& vs);63 64 // unary operators:65 valarray operator+() const;66 valarray operator-() const;67 valarray operator~() const;68 valarray<bool> operator!() const;69 70 // computed assignment:71 valarray& operator*= (const value_type& x);72 valarray& operator/= (const value_type& x);73 valarray& operator%= (const value_type& x);74 valarray& operator+= (const value_type& x);75 valarray& operator-= (const value_type& x);76 valarray& operator^= (const value_type& x);77 valarray& operator&= (const value_type& x);78 valarray& operator|= (const value_type& x);79 valarray& operator<<=(const value_type& x);80 valarray& operator>>=(const value_type& x);81 82 valarray& operator*= (const valarray& v);83 valarray& operator/= (const valarray& v);84 valarray& operator%= (const valarray& v);85 valarray& operator+= (const valarray& v);86 valarray& operator-= (const valarray& v);87 valarray& operator^= (const valarray& v);88 valarray& operator|= (const valarray& v);89 valarray& operator&= (const valarray& v);90 valarray& operator<<=(const valarray& v);91 valarray& operator>>=(const valarray& v);92 93 // member functions:94 void swap(valarray& v) noexcept;95 96 size_t size() const;97 98 value_type sum() const;99 value_type min() const;100 value_type max() const;101 102 valarray shift (int i) const;103 valarray cshift(int i) const;104 valarray apply(value_type f(value_type)) const;105 valarray apply(value_type f(const value_type&)) const;106 void resize(size_t n, value_type x = value_type());107};108 109template<class T, size_t cnt> valarray(const T(&)[cnt], size_t) -> valarray<T>;110 111class slice112{113public:114 slice();115 slice(size_t start, size_t size, size_t stride);116 117 size_t start() const;118 size_t size() const;119 size_t stride() const;120};121 122template <class T>123class slice_array124{125public:126 typedef T value_type;127 128 const slice_array& operator=(const slice_array& sa) const;129 void operator= (const valarray<value_type>& v) const;130 void operator*= (const valarray<value_type>& v) const;131 void operator/= (const valarray<value_type>& v) const;132 void operator%= (const valarray<value_type>& v) const;133 void operator+= (const valarray<value_type>& v) const;134 void operator-= (const valarray<value_type>& v) const;135 void operator^= (const valarray<value_type>& v) const;136 void operator&= (const valarray<value_type>& v) const;137 void operator|= (const valarray<value_type>& v) const;138 void operator<<=(const valarray<value_type>& v) const;139 void operator>>=(const valarray<value_type>& v) const;140 141 void operator=(const value_type& x) const;142 void operator=(const valarray<T>& val_arr) const;143 144 slice_array() = delete;145};146 147class gslice148{149public:150 gslice();151 gslice(size_t start, const valarray<size_t>& size,152 const valarray<size_t>& stride);153 154 size_t start() const;155 valarray<size_t> size() const;156 valarray<size_t> stride() const;157};158 159template <class T>160class gslice_array161{162public:163 typedef T value_type;164 165 void operator= (const valarray<value_type>& v) const;166 void operator*= (const valarray<value_type>& v) const;167 void operator/= (const valarray<value_type>& v) const;168 void operator%= (const valarray<value_type>& v) const;169 void operator+= (const valarray<value_type>& v) const;170 void operator-= (const valarray<value_type>& v) const;171 void operator^= (const valarray<value_type>& v) const;172 void operator&= (const valarray<value_type>& v) const;173 void operator|= (const valarray<value_type>& v) const;174 void operator<<=(const valarray<value_type>& v) const;175 void operator>>=(const valarray<value_type>& v) const;176 177 gslice_array(const gslice_array& ga);178 ~gslice_array();179 const gslice_array& operator=(const gslice_array& ga) const;180 void operator=(const value_type& x) const;181 182 gslice_array() = delete;183};184 185template <class T>186class mask_array187{188public:189 typedef T value_type;190 191 void operator= (const valarray<value_type>& v) const;192 void operator*= (const valarray<value_type>& v) const;193 void operator/= (const valarray<value_type>& v) const;194 void operator%= (const valarray<value_type>& v) const;195 void operator+= (const valarray<value_type>& v) const;196 void operator-= (const valarray<value_type>& v) const;197 void operator^= (const valarray<value_type>& v) const;198 void operator&= (const valarray<value_type>& v) const;199 void operator|= (const valarray<value_type>& v) const;200 void operator<<=(const valarray<value_type>& v) const;201 void operator>>=(const valarray<value_type>& v) const;202 203 mask_array(const mask_array& ma);204 ~mask_array();205 const mask_array& operator=(const mask_array& ma) const;206 void operator=(const value_type& x) const;207 208 mask_array() = delete;209};210 211template <class T>212class indirect_array213{214public:215 typedef T value_type;216 217 void operator= (const valarray<value_type>& v) const;218 void operator*= (const valarray<value_type>& v) const;219 void operator/= (const valarray<value_type>& v) const;220 void operator%= (const valarray<value_type>& v) const;221 void operator+= (const valarray<value_type>& v) const;222 void operator-= (const valarray<value_type>& v) const;223 void operator^= (const valarray<value_type>& v) const;224 void operator&= (const valarray<value_type>& v) const;225 void operator|= (const valarray<value_type>& v) const;226 void operator<<=(const valarray<value_type>& v) const;227 void operator>>=(const valarray<value_type>& v) const;228 229 indirect_array(const indirect_array& ia);230 ~indirect_array();231 const indirect_array& operator=(const indirect_array& ia) const;232 void operator=(const value_type& x) const;233 234 indirect_array() = delete;235};236 237template<class T> void swap(valarray<T>& x, valarray<T>& y) noexcept;238 239template<class T> valarray<T> operator* (const valarray<T>& x, const valarray<T>& y);240template<class T> valarray<T> operator* (const valarray<T>& x, const T& y);241template<class T> valarray<T> operator* (const T& x, const valarray<T>& y);242 243template<class T> valarray<T> operator/ (const valarray<T>& x, const valarray<T>& y);244template<class T> valarray<T> operator/ (const valarray<T>& x, const T& y);245template<class T> valarray<T> operator/ (const T& x, const valarray<T>& y);246 247template<class T> valarray<T> operator% (const valarray<T>& x, const valarray<T>& y);248template<class T> valarray<T> operator% (const valarray<T>& x, const T& y);249template<class T> valarray<T> operator% (const T& x, const valarray<T>& y);250 251template<class T> valarray<T> operator+ (const valarray<T>& x, const valarray<T>& y);252template<class T> valarray<T> operator+ (const valarray<T>& x, const T& y);253template<class T> valarray<T> operator+ (const T& x, const valarray<T>& y);254 255template<class T> valarray<T> operator- (const valarray<T>& x, const valarray<T>& y);256template<class T> valarray<T> operator- (const valarray<T>& x, const T& y);257template<class T> valarray<T> operator- (const T& x, const valarray<T>& y);258 259template<class T> valarray<T> operator^ (const valarray<T>& x, const valarray<T>& y);260template<class T> valarray<T> operator^ (const valarray<T>& x, const T& y);261template<class T> valarray<T> operator^ (const T& x, const valarray<T>& y);262 263template<class T> valarray<T> operator& (const valarray<T>& x, const valarray<T>& y);264template<class T> valarray<T> operator& (const valarray<T>& x, const T& y);265template<class T> valarray<T> operator& (const T& x, const valarray<T>& y);266 267template<class T> valarray<T> operator| (const valarray<T>& x, const valarray<T>& y);268template<class T> valarray<T> operator| (const valarray<T>& x, const T& y);269template<class T> valarray<T> operator| (const T& x, const valarray<T>& y);270 271template<class T> valarray<T> operator<<(const valarray<T>& x, const valarray<T>& y);272template<class T> valarray<T> operator<<(const valarray<T>& x, const T& y);273template<class T> valarray<T> operator<<(const T& x, const valarray<T>& y);274 275template<class T> valarray<T> operator>>(const valarray<T>& x, const valarray<T>& y);276template<class T> valarray<T> operator>>(const valarray<T>& x, const T& y);277template<class T> valarray<T> operator>>(const T& x, const valarray<T>& y);278 279template<class T> valarray<bool> operator&&(const valarray<T>& x, const valarray<T>& y);280template<class T> valarray<bool> operator&&(const valarray<T>& x, const T& y);281template<class T> valarray<bool> operator&&(const T& x, const valarray<T>& y);282 283template<class T> valarray<bool> operator||(const valarray<T>& x, const valarray<T>& y);284template<class T> valarray<bool> operator||(const valarray<T>& x, const T& y);285template<class T> valarray<bool> operator||(const T& x, const valarray<T>& y);286 287template<class T> valarray<bool> operator==(const valarray<T>& x, const valarray<T>& y);288template<class T> valarray<bool> operator==(const valarray<T>& x, const T& y);289template<class T> valarray<bool> operator==(const T& x, const valarray<T>& y);290 291template<class T> valarray<bool> operator!=(const valarray<T>& x, const valarray<T>& y);292template<class T> valarray<bool> operator!=(const valarray<T>& x, const T& y);293template<class T> valarray<bool> operator!=(const T& x, const valarray<T>& y);294 295template<class T> valarray<bool> operator< (const valarray<T>& x, const valarray<T>& y);296template<class T> valarray<bool> operator< (const valarray<T>& x, const T& y);297template<class T> valarray<bool> operator< (const T& x, const valarray<T>& y);298 299template<class T> valarray<bool> operator> (const valarray<T>& x, const valarray<T>& y);300template<class T> valarray<bool> operator> (const valarray<T>& x, const T& y);301template<class T> valarray<bool> operator> (const T& x, const valarray<T>& y);302 303template<class T> valarray<bool> operator<=(const valarray<T>& x, const valarray<T>& y);304template<class T> valarray<bool> operator<=(const valarray<T>& x, const T& y);305template<class T> valarray<bool> operator<=(const T& x, const valarray<T>& y);306 307template<class T> valarray<bool> operator>=(const valarray<T>& x, const valarray<T>& y);308template<class T> valarray<bool> operator>=(const valarray<T>& x, const T& y);309template<class T> valarray<bool> operator>=(const T& x, const valarray<T>& y);310 311template<class T> valarray<T> abs (const valarray<T>& x);312template<class T> valarray<T> acos (const valarray<T>& x);313template<class T> valarray<T> asin (const valarray<T>& x);314template<class T> valarray<T> atan (const valarray<T>& x);315 316template<class T> valarray<T> atan2(const valarray<T>& x, const valarray<T>& y);317template<class T> valarray<T> atan2(const valarray<T>& x, const T& y);318template<class T> valarray<T> atan2(const T& x, const valarray<T>& y);319 320template<class T> valarray<T> cos (const valarray<T>& x);321template<class T> valarray<T> cosh (const valarray<T>& x);322template<class T> valarray<T> exp (const valarray<T>& x);323template<class T> valarray<T> log (const valarray<T>& x);324template<class T> valarray<T> log10(const valarray<T>& x);325 326template<class T> valarray<T> pow(const valarray<T>& x, const valarray<T>& y);327template<class T> valarray<T> pow(const valarray<T>& x, const T& y);328template<class T> valarray<T> pow(const T& x, const valarray<T>& y);329 330template<class T> valarray<T> sin (const valarray<T>& x);331template<class T> valarray<T> sinh (const valarray<T>& x);332template<class T> valarray<T> sqrt (const valarray<T>& x);333template<class T> valarray<T> tan (const valarray<T>& x);334template<class T> valarray<T> tanh (const valarray<T>& x);335 336template <class T> unspecified1 begin(valarray<T>& v);337template <class T> unspecified2 begin(const valarray<T>& v);338template <class T> unspecified1 end(valarray<T>& v);339template <class T> unspecified2 end(const valarray<T>& v);340 341} // std342 343*/344 345#include <__config>346 347#include <__functional/operations.h>348#include <__type_traits/decay.h>349#include <__type_traits/remove_reference.h>350#include <__utility/move.h>351#include <__utility/swap.h>352#include <algorithm>353#include <cmath>354#include <cstddef>355#include <memory>356#include <new>357#include <version>358 359// standard-mandated includes360 361// [valarray.syn]362#include <initializer_list>363 364#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)365# pragma GCC system_header366#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)367# pragma clang system_header368#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)369# pragma system_header370#endif // no system header371 372_LIBCUDACXX_PUSH_MACROS373#include <__undef_macros>374 375_LIBCUDACXX_BEGIN_NAMESPACE_STD376 377template<class _Tp> class _LIBCUDACXX_TEMPLATE_VIS valarray;378 379class _LIBCUDACXX_TEMPLATE_VIS slice380{381 size_t __start_;382 size_t __size_;383 size_t __stride_;384public:385 _LIBCUDACXX_INLINE_VISIBILITY386 slice()387 : __start_(0),388 __size_(0),389 __stride_(0)390 {}391 392 _LIBCUDACXX_INLINE_VISIBILITY393 slice(size_t __start, size_t __size, size_t __stride)394 : __start_(__start),395 __size_(__size),396 __stride_(__stride)397 {}398 399 _LIBCUDACXX_INLINE_VISIBILITY size_t start() const {return __start_;}400 _LIBCUDACXX_INLINE_VISIBILITY size_t size() const {return __size_;}401 _LIBCUDACXX_INLINE_VISIBILITY size_t stride() const {return __stride_;}402};403 404template <class _Tp> class _LIBCUDACXX_TEMPLATE_VIS slice_array;405class _LIBCUDACXX_TYPE_VIS gslice;406template <class _Tp> class _LIBCUDACXX_TEMPLATE_VIS gslice_array;407template <class _Tp> class _LIBCUDACXX_TEMPLATE_VIS mask_array;408template <class _Tp> class _LIBCUDACXX_TEMPLATE_VIS indirect_array;409 410template <class _Tp>411_LIBCUDACXX_INLINE_VISIBILITY412_Tp*413begin(valarray<_Tp>& __v);414 415template <class _Tp>416_LIBCUDACXX_INLINE_VISIBILITY417const _Tp*418begin(const valarray<_Tp>& __v);419 420template <class _Tp>421_LIBCUDACXX_INLINE_VISIBILITY422_Tp*423end(valarray<_Tp>& __v);424 425template <class _Tp>426_LIBCUDACXX_INLINE_VISIBILITY427const _Tp*428end(const valarray<_Tp>& __v);429 430template <class _Op, class _A0>431struct _UnaryOp432{433 typedef typename _Op::__result_type __result_type;434 typedef __decay_t<__result_type> value_type;435 436 _Op __op_;437 _A0 __a0_;438 439 _LIBCUDACXX_INLINE_VISIBILITY440 _UnaryOp(const _Op& __op, const _A0& __a0) : __op_(__op), __a0_(__a0) {}441 442 _LIBCUDACXX_INLINE_VISIBILITY443 __result_type operator[](size_t __i) const {return __op_(__a0_[__i]);}444 445 _LIBCUDACXX_INLINE_VISIBILITY446 size_t size() const {return __a0_.size();}447};448 449template <class _Op, class _A0, class _A1>450struct _BinaryOp451{452 typedef typename _Op::__result_type __result_type;453 typedef __decay_t<__result_type> value_type;454 455 _Op __op_;456 _A0 __a0_;457 _A1 __a1_;458 459 _LIBCUDACXX_INLINE_VISIBILITY460 _BinaryOp(const _Op& __op, const _A0& __a0, const _A1& __a1)461 : __op_(__op), __a0_(__a0), __a1_(__a1) {}462 463 _LIBCUDACXX_INLINE_VISIBILITY464 __result_type operator[](size_t __i) const {return __op_(__a0_[__i], __a1_[__i]);}465 466 _LIBCUDACXX_INLINE_VISIBILITY467 size_t size() const {return __a0_.size();}468};469 470template <class _Tp>471class __scalar_expr472{473public:474 typedef _Tp value_type;475 typedef const _Tp& __result_type;476private:477 const value_type& __t_;478 size_t __s_;479public:480 _LIBCUDACXX_INLINE_VISIBILITY481 explicit __scalar_expr(const value_type& __t, size_t __s) : __t_(__t), __s_(__s) {}482 483 _LIBCUDACXX_INLINE_VISIBILITY484 __result_type operator[](size_t) const {return __t_;}485 486 _LIBCUDACXX_INLINE_VISIBILITY487 size_t size() const {return __s_;}488};489 490template <class _Tp>491struct __unary_plus492{493 typedef _Tp __result_type;494 _LIBCUDACXX_INLINE_VISIBILITY495 _Tp operator()(const _Tp& __x) const496 {return +__x;}497};498 499template <class _Tp>500struct __bit_not501{502 typedef _Tp __result_type;503 _LIBCUDACXX_INLINE_VISIBILITY504 _Tp operator()(const _Tp& __x) const505 {return ~__x;}506};507 508template <class _Tp>509struct __bit_shift_left510{511 typedef _Tp __result_type;512 _LIBCUDACXX_INLINE_VISIBILITY513 _Tp operator()(const _Tp& __x, const _Tp& __y) const514 {return __x << __y;}515};516 517template <class _Tp>518struct __bit_shift_right519{520 typedef _Tp __result_type;521 _LIBCUDACXX_INLINE_VISIBILITY522 _Tp operator()(const _Tp& __x, const _Tp& __y) const523 {return __x >> __y;}524};525 526template <class _Tp, class _Fp>527struct __apply_expr528{529private:530 _Fp __f_;531public:532 typedef _Tp __result_type;533 534 _LIBCUDACXX_INLINE_VISIBILITY535 explicit __apply_expr(_Fp __f) : __f_(__f) {}536 537 _LIBCUDACXX_INLINE_VISIBILITY538 _Tp operator()(const _Tp& __x) const539 {return __f_(__x);}540};541 542template <class _Tp>543struct __abs_expr544{545 typedef _Tp __result_type;546 _LIBCUDACXX_INLINE_VISIBILITY547 _Tp operator()(const _Tp& __x) const548 {return _CUDA_VSTD::abs(__x);}549};550 551template <class _Tp>552struct __acos_expr553{554 typedef _Tp __result_type;555 _LIBCUDACXX_INLINE_VISIBILITY556 _Tp operator()(const _Tp& __x) const557 {return _CUDA_VSTD::acos(__x);}558};559 560template <class _Tp>561struct __asin_expr562{563 typedef _Tp __result_type;564 _LIBCUDACXX_INLINE_VISIBILITY565 _Tp operator()(const _Tp& __x) const566 {return _CUDA_VSTD::asin(__x);}567};568 569template <class _Tp>570struct __atan_expr571{572 typedef _Tp __result_type;573 _LIBCUDACXX_INLINE_VISIBILITY574 _Tp operator()(const _Tp& __x) const575 {return _CUDA_VSTD::atan(__x);}576};577 578template <class _Tp>579struct __atan2_expr580{581 typedef _Tp __result_type;582 _LIBCUDACXX_INLINE_VISIBILITY583 _Tp operator()(const _Tp& __x, const _Tp& __y) const584 {return _CUDA_VSTD::atan2(__x, __y);}585};586 587template <class _Tp>588struct __cos_expr589{590 typedef _Tp __result_type;591 _LIBCUDACXX_INLINE_VISIBILITY592 _Tp operator()(const _Tp& __x) const593 {return _CUDA_VSTD::cos(__x);}594};595 596template <class _Tp>597struct __cosh_expr598{599 typedef _Tp __result_type;600 _LIBCUDACXX_INLINE_VISIBILITY601 _Tp operator()(const _Tp& __x) const602 {return _CUDA_VSTD::cosh(__x);}603};604 605template <class _Tp>606struct __exp_expr607{608 typedef _Tp __result_type;609 _LIBCUDACXX_INLINE_VISIBILITY610 _Tp operator()(const _Tp& __x) const611 {return _CUDA_VSTD::exp(__x);}612};613 614template <class _Tp>615struct __log_expr616{617 typedef _Tp __result_type;618 _LIBCUDACXX_INLINE_VISIBILITY619 _Tp operator()(const _Tp& __x) const620 {return _CUDA_VSTD::log(__x);}621};622 623template <class _Tp>624struct __log10_expr625{626 typedef _Tp __result_type;627 _LIBCUDACXX_INLINE_VISIBILITY628 _Tp operator()(const _Tp& __x) const629 {return _CUDA_VSTD::log10(__x);}630};631 632template <class _Tp>633struct __pow_expr634{635 typedef _Tp __result_type;636 _LIBCUDACXX_INLINE_VISIBILITY637 _Tp operator()(const _Tp& __x, const _Tp& __y) const638 {return _CUDA_VSTD::pow(__x, __y);}639};640 641template <class _Tp>642struct __sin_expr643{644 typedef _Tp __result_type;645 _LIBCUDACXX_INLINE_VISIBILITY646 _Tp operator()(const _Tp& __x) const647 {return _CUDA_VSTD::sin(__x);}648};649 650template <class _Tp>651struct __sinh_expr652{653 typedef _Tp __result_type;654 _LIBCUDACXX_INLINE_VISIBILITY655 _Tp operator()(const _Tp& __x) const656 {return _CUDA_VSTD::sinh(__x);}657};658 659template <class _Tp>660struct __sqrt_expr661{662 typedef _Tp __result_type;663 _LIBCUDACXX_INLINE_VISIBILITY664 _Tp operator()(const _Tp& __x) const665 {return _CUDA_VSTD::sqrt(__x);}666};667 668template <class _Tp>669struct __tan_expr670{671 typedef _Tp __result_type;672 _LIBCUDACXX_INLINE_VISIBILITY673 _Tp operator()(const _Tp& __x) const674 {return _CUDA_VSTD::tan(__x);}675};676 677template <class _Tp>678struct __tanh_expr679{680 typedef _Tp __result_type;681 _LIBCUDACXX_INLINE_VISIBILITY682 _Tp operator()(const _Tp& __x) const683 {return _CUDA_VSTD::tanh(__x);}684};685 686template <class _ValExpr>687class __slice_expr688{689 typedef __libcpp_remove_reference_t<_ValExpr> _RmExpr;690public:691 typedef typename _RmExpr::value_type value_type;692 typedef value_type __result_type;693 694private:695 _ValExpr __expr_;696 size_t __start_;697 size_t __size_;698 size_t __stride_;699 700 _LIBCUDACXX_INLINE_VISIBILITY701 __slice_expr(const slice& __sl, const _RmExpr& __e)702 : __expr_(__e),703 __start_(__sl.start()),704 __size_(__sl.size()),705 __stride_(__sl.stride())706 {}707public:708 709 _LIBCUDACXX_INLINE_VISIBILITY710 __result_type operator[](size_t __i) const711 {return __expr_[__start_ + __i * __stride_];}712 713 _LIBCUDACXX_INLINE_VISIBILITY714 size_t size() const {return __size_;}715 716 template <class> friend class __val_expr;717 template <class> friend class _LIBCUDACXX_TEMPLATE_VIS valarray;718};719 720template <class _ValExpr>721class __mask_expr;722 723template <class _ValExpr>724class __indirect_expr;725 726template <class _ValExpr>727class __shift_expr728{729 typedef __libcpp_remove_reference_t<_ValExpr> _RmExpr;730public:731 typedef typename _RmExpr::value_type value_type;732 typedef value_type __result_type;733 734private:735 _ValExpr __expr_;736 size_t __size_;737 ptrdiff_t __ul_;738 ptrdiff_t __sn_;739 ptrdiff_t __n_;740 static const ptrdiff_t _Np = static_cast<ptrdiff_t>(741 sizeof(ptrdiff_t) * __CHAR_BIT__ - 1);742 743 _LIBCUDACXX_INLINE_VISIBILITY744 __shift_expr(int __n, const _RmExpr& __e)745 : __expr_(__e),746 __size_(__e.size()),747 __n_(__n)748 {749 ptrdiff_t __neg_n = static_cast<ptrdiff_t>(__n_ >> _Np);750 __sn_ = __neg_n | static_cast<ptrdiff_t>(static_cast<size_t>(-__n_) >> _Np);751 __ul_ = ((__size_ - __n_) & ~__neg_n) | ((__n_ + 1) & __neg_n);752 }753public:754 755 _LIBCUDACXX_INLINE_VISIBILITY756 __result_type operator[](size_t __j) const757 {758 ptrdiff_t __i = static_cast<ptrdiff_t>(__j);759 ptrdiff_t __m = (__sn_ * __i - __ul_) >> _Np;760 return (__expr_[(__i + __n_) & __m] & __m) | (value_type() & ~__m);761 }762 763 _LIBCUDACXX_INLINE_VISIBILITY764 size_t size() const {return __size_;}765 766 template <class> friend class __val_expr;767};768 769template <class _ValExpr>770class __cshift_expr771{772 typedef __libcpp_remove_reference_t<_ValExpr> _RmExpr;773public:774 typedef typename _RmExpr::value_type value_type;775 typedef value_type __result_type;776 777private:778 _ValExpr __expr_;779 size_t __size_;780 size_t __m_;781 size_t __o1_;782 size_t __o2_;783 784 _LIBCUDACXX_INLINE_VISIBILITY785 __cshift_expr(int __n, const _RmExpr& __e)786 : __expr_(__e),787 __size_(__e.size())788 {789 __n %= static_cast<int>(__size_);790 if (__n >= 0)791 {792 __m_ = __size_ - __n;793 __o1_ = __n;794 __o2_ = __n - __size_;795 }796 else797 {798 __m_ = -__n;799 __o1_ = __n + __size_;800 __o2_ = __n;801 }802 }803public:804 805 _LIBCUDACXX_INLINE_VISIBILITY806 __result_type operator[](size_t __i) const807 {808 if (__i < __m_)809 return __expr_[__i + __o1_];810 return __expr_[__i + __o2_];811 }812 813 _LIBCUDACXX_INLINE_VISIBILITY814 size_t size() const {return __size_;}815 816 template <class> friend class __val_expr;817};818 819template<class _ValExpr>820class __val_expr;821 822template<class _ValExpr>823struct __is_val_expr : false_type {};824 825template<class _ValExpr>826struct __is_val_expr<__val_expr<_ValExpr> > : true_type {};827 828template<class _Tp>829struct __is_val_expr<valarray<_Tp> > : true_type {};830 831template<class _Tp>832class _LIBCUDACXX_TEMPLATE_VIS valarray833{834public:835 typedef _Tp value_type;836 typedef _Tp __result_type;837 838private:839 value_type* __begin_;840 value_type* __end_;841 842public:843 // construct/destroy:844 _LIBCUDACXX_INLINE_VISIBILITY845 valarray() : __begin_(nullptr), __end_(nullptr) {}846 inline _LIBCUDACXX_HIDE_FROM_ABI_AFTER_V1847 explicit valarray(size_t __n);848 _LIBCUDACXX_INLINE_VISIBILITY849 valarray(const value_type& __x, size_t __n);850 valarray(const value_type* __p, size_t __n);851 valarray(const valarray& __v);852 _LIBCUDACXX_INLINE_VISIBILITY853 valarray(valarray&& __v) noexcept;854 valarray(initializer_list<value_type> __il);855 valarray(const slice_array<value_type>& __sa);856 valarray(const gslice_array<value_type>& __ga);857 valarray(const mask_array<value_type>& __ma);858 valarray(const indirect_array<value_type>& __ia);859 inline _LIBCUDACXX_HIDE_FROM_ABI_AFTER_V1860 ~valarray();861 862 // assignment:863 valarray& operator=(const valarray& __v);864 _LIBCUDACXX_INLINE_VISIBILITY865 valarray& operator=(valarray&& __v) noexcept;866 _LIBCUDACXX_INLINE_VISIBILITY867 valarray& operator=(initializer_list<value_type>);868 _LIBCUDACXX_INLINE_VISIBILITY869 valarray& operator=(const value_type& __x);870 _LIBCUDACXX_INLINE_VISIBILITY871 valarray& operator=(const slice_array<value_type>& __sa);872 _LIBCUDACXX_INLINE_VISIBILITY873 valarray& operator=(const gslice_array<value_type>& __ga);874 _LIBCUDACXX_INLINE_VISIBILITY875 valarray& operator=(const mask_array<value_type>& __ma);876 _LIBCUDACXX_INLINE_VISIBILITY877 valarray& operator=(const indirect_array<value_type>& __ia);878 template <class _ValExpr>879 _LIBCUDACXX_INLINE_VISIBILITY880 valarray& operator=(const __val_expr<_ValExpr>& __v);881 882 // element access:883 _LIBCUDACXX_INLINE_VISIBILITY884 const value_type& operator[](size_t __i) const {return __begin_[__i];}885 886 _LIBCUDACXX_INLINE_VISIBILITY887 value_type& operator[](size_t __i) {return __begin_[__i];}888 889 // subset operations:890 _LIBCUDACXX_INLINE_VISIBILITY891 __val_expr<__slice_expr<const valarray&> > operator[](slice __s) const;892 _LIBCUDACXX_INLINE_VISIBILITY893 slice_array<value_type> operator[](slice __s);894 _LIBCUDACXX_INLINE_VISIBILITY895 __val_expr<__indirect_expr<const valarray&> > operator[](const gslice& __gs) const;896 _LIBCUDACXX_INLINE_VISIBILITY897 gslice_array<value_type> operator[](const gslice& __gs);898 _LIBCUDACXX_INLINE_VISIBILITY899 __val_expr<__indirect_expr<const valarray&> > operator[](gslice&& __gs) const;900 _LIBCUDACXX_INLINE_VISIBILITY901 gslice_array<value_type> operator[](gslice&& __gs);902 _LIBCUDACXX_INLINE_VISIBILITY903 __val_expr<__mask_expr<const valarray&> > operator[](const valarray<bool>& __vb) const;904 _LIBCUDACXX_INLINE_VISIBILITY905 mask_array<value_type> operator[](const valarray<bool>& __vb);906 _LIBCUDACXX_INLINE_VISIBILITY907 __val_expr<__mask_expr<const valarray&> > operator[](valarray<bool>&& __vb) const;908 _LIBCUDACXX_INLINE_VISIBILITY909 mask_array<value_type> operator[](valarray<bool>&& __vb);910 _LIBCUDACXX_INLINE_VISIBILITY911 __val_expr<__indirect_expr<const valarray&> > operator[](const valarray<size_t>& __vs) const;912 _LIBCUDACXX_INLINE_VISIBILITY913 indirect_array<value_type> operator[](const valarray<size_t>& __vs);914 _LIBCUDACXX_INLINE_VISIBILITY915 __val_expr<__indirect_expr<const valarray&> > operator[](valarray<size_t>&& __vs) const;916 _LIBCUDACXX_INLINE_VISIBILITY917 indirect_array<value_type> operator[](valarray<size_t>&& __vs);918 919 // unary operators:920 _LIBCUDACXX_INLINE_VISIBILITY921 __val_expr<_UnaryOp<__unary_plus<_Tp>, const valarray&> > operator+() const;922 _LIBCUDACXX_INLINE_VISIBILITY923 __val_expr<_UnaryOp<negate<_Tp>, const valarray&> > operator-() const;924 _LIBCUDACXX_INLINE_VISIBILITY925 __val_expr<_UnaryOp<__bit_not<_Tp>, const valarray&> > operator~() const;926 _LIBCUDACXX_INLINE_VISIBILITY927 __val_expr<_UnaryOp<logical_not<_Tp>, const valarray&> > operator!() const;928 929 // computed assignment:930 _LIBCUDACXX_INLINE_VISIBILITY931 valarray& operator*= (const value_type& __x);932 _LIBCUDACXX_INLINE_VISIBILITY933 valarray& operator/= (const value_type& __x);934 _LIBCUDACXX_INLINE_VISIBILITY935 valarray& operator%= (const value_type& __x);936 _LIBCUDACXX_INLINE_VISIBILITY937 valarray& operator+= (const value_type& __x);938 _LIBCUDACXX_INLINE_VISIBILITY939 valarray& operator-= (const value_type& __x);940 _LIBCUDACXX_INLINE_VISIBILITY941 valarray& operator^= (const value_type& __x);942 _LIBCUDACXX_INLINE_VISIBILITY943 valarray& operator&= (const value_type& __x);944 _LIBCUDACXX_INLINE_VISIBILITY945 valarray& operator|= (const value_type& __x);946 _LIBCUDACXX_INLINE_VISIBILITY947 valarray& operator<<=(const value_type& __x);948 _LIBCUDACXX_INLINE_VISIBILITY949 valarray& operator>>=(const value_type& __x);950 951 template <class _Expr>952 typename enable_if953 <954 __is_val_expr<_Expr>::value,955 valarray&956 >::type957 _LIBCUDACXX_INLINE_VISIBILITY958 operator*= (const _Expr& __v);959 960 template <class _Expr>961 typename enable_if962 <963 __is_val_expr<_Expr>::value,964 valarray&965 >::type966 _LIBCUDACXX_INLINE_VISIBILITY967 operator/= (const _Expr& __v);968 969 template <class _Expr>970 typename enable_if971 <972 __is_val_expr<_Expr>::value,973 valarray&974 >::type975 _LIBCUDACXX_INLINE_VISIBILITY976 operator%= (const _Expr& __v);977 978 template <class _Expr>979 typename enable_if980 <981 __is_val_expr<_Expr>::value,982 valarray&983 >::type984 _LIBCUDACXX_INLINE_VISIBILITY985 operator+= (const _Expr& __v);986 987 template <class _Expr>988 typename enable_if989 <990 __is_val_expr<_Expr>::value,991 valarray&992 >::type993 _LIBCUDACXX_INLINE_VISIBILITY994 operator-= (const _Expr& __v);995 996 template <class _Expr>997 typename enable_if998 <999 __is_val_expr<_Expr>::value,1000 valarray&1001 >::type1002 _LIBCUDACXX_INLINE_VISIBILITY1003 operator^= (const _Expr& __v);1004 1005 template <class _Expr>1006 typename enable_if1007 <1008 __is_val_expr<_Expr>::value,1009 valarray&1010 >::type1011 _LIBCUDACXX_INLINE_VISIBILITY1012 operator|= (const _Expr& __v);1013 1014 template <class _Expr>1015 typename enable_if1016 <1017 __is_val_expr<_Expr>::value,1018 valarray&1019 >::type1020 _LIBCUDACXX_INLINE_VISIBILITY1021 operator&= (const _Expr& __v);1022 1023 template <class _Expr>1024 typename enable_if1025 <1026 __is_val_expr<_Expr>::value,1027 valarray&1028 >::type1029 _LIBCUDACXX_INLINE_VISIBILITY1030 operator<<= (const _Expr& __v);1031 1032 template <class _Expr>1033 typename enable_if1034 <1035 __is_val_expr<_Expr>::value,1036 valarray&1037 >::type1038 _LIBCUDACXX_INLINE_VISIBILITY1039 operator>>= (const _Expr& __v);1040 1041 // member functions:1042 _LIBCUDACXX_INLINE_VISIBILITY1043 void swap(valarray& __v) noexcept;1044 1045 _LIBCUDACXX_INLINE_VISIBILITY1046 size_t size() const {return static_cast<size_t>(__end_ - __begin_);}1047 1048 _LIBCUDACXX_INLINE_VISIBILITY1049 value_type sum() const;1050 _LIBCUDACXX_INLINE_VISIBILITY1051 value_type min() const;1052 _LIBCUDACXX_INLINE_VISIBILITY1053 value_type max() const;1054 1055 valarray shift (int __i) const;1056 valarray cshift(int __i) const;1057 valarray apply(value_type __f(value_type)) const;1058 valarray apply(value_type __f(const value_type&)) const;1059 void resize(size_t __n, value_type __x = value_type());1060 1061private:1062 template <class> friend class _LIBCUDACXX_TEMPLATE_VIS valarray;1063 template <class> friend class _LIBCUDACXX_TEMPLATE_VIS slice_array;1064 template <class> friend class _LIBCUDACXX_TEMPLATE_VIS gslice_array;1065 template <class> friend class _LIBCUDACXX_TEMPLATE_VIS mask_array;1066 template <class> friend class __mask_expr;1067 template <class> friend class _LIBCUDACXX_TEMPLATE_VIS indirect_array;1068 template <class> friend class __indirect_expr;1069 template <class> friend class __val_expr;1070 1071 template <class _Up>1072 friend1073 _Up*1074 begin(valarray<_Up>& __v);1075 1076 template <class _Up>1077 friend1078 const _Up*1079 begin(const valarray<_Up>& __v);1080 1081 template <class _Up>1082 friend1083 _Up*1084 end(valarray<_Up>& __v);1085 1086 template <class _Up>1087 friend1088 const _Up*1089 end(const valarray<_Up>& __v);1090 1091 _LIBCUDACXX_INLINE_VISIBILITY1092 void __clear(size_t __capacity);1093 valarray& __assign_range(const value_type* __f, const value_type* __l);1094};1095 1096#if _LIBCUDACXX_STD_VER > 14 && !defined(_LIBCUDACXX_HAS_NO_DEDUCTION_GUIDES)1097template<class _Tp, size_t _Size>1098valarray(const _Tp(&)[_Size], size_t) -> valarray<_Tp>;1099#endif1100 1101extern template _LIBCUDACXX_FUNC_VIS void valarray<size_t>::resize(size_t, size_t);1102 1103template <class _Op, class _Tp>1104struct _UnaryOp<_Op, valarray<_Tp> >1105{1106 typedef typename _Op::__result_type __result_type;1107 typedef __decay_t<__result_type> value_type;1108 1109 _Op __op_;1110 const valarray<_Tp>& __a0_;1111 1112 _LIBCUDACXX_INLINE_VISIBILITY1113 _UnaryOp(const _Op& __op, const valarray<_Tp>& __a0) : __op_(__op), __a0_(__a0) {}1114 1115 _LIBCUDACXX_INLINE_VISIBILITY1116 __result_type operator[](size_t __i) const {return __op_(__a0_[__i]);}1117 1118 _LIBCUDACXX_INLINE_VISIBILITY1119 size_t size() const {return __a0_.size();}1120};1121 1122template <class _Op, class _Tp, class _A1>1123struct _BinaryOp<_Op, valarray<_Tp>, _A1>1124{1125 typedef typename _Op::__result_type __result_type;1126 typedef __decay_t<__result_type> value_type;1127 1128 _Op __op_;1129 const valarray<_Tp>& __a0_;1130 _A1 __a1_;1131 1132 _LIBCUDACXX_INLINE_VISIBILITY1133 _BinaryOp(const _Op& __op, const valarray<_Tp>& __a0, const _A1& __a1)1134 : __op_(__op), __a0_(__a0), __a1_(__a1) {}1135 1136 _LIBCUDACXX_INLINE_VISIBILITY1137 __result_type operator[](size_t __i) const {return __op_(__a0_[__i], __a1_[__i]);}1138 1139 _LIBCUDACXX_INLINE_VISIBILITY1140 size_t size() const {return __a0_.size();}1141};1142 1143template <class _Op, class _A0, class _Tp>1144struct _BinaryOp<_Op, _A0, valarray<_Tp> >1145{1146 typedef typename _Op::__result_type __result_type;1147 typedef __decay_t<__result_type> value_type;1148 1149 _Op __op_;1150 _A0 __a0_;1151 const valarray<_Tp>& __a1_;1152 1153 _LIBCUDACXX_INLINE_VISIBILITY1154 _BinaryOp(const _Op& __op, const _A0& __a0, const valarray<_Tp>& __a1)1155 : __op_(__op), __a0_(__a0), __a1_(__a1) {}1156 1157 _LIBCUDACXX_INLINE_VISIBILITY1158 __result_type operator[](size_t __i) const {return __op_(__a0_[__i], __a1_[__i]);}1159 1160 _LIBCUDACXX_INLINE_VISIBILITY1161 size_t size() const {return __a0_.size();}1162};1163 1164template <class _Op, class _Tp>1165struct _BinaryOp<_Op, valarray<_Tp>, valarray<_Tp> >1166{1167 typedef typename _Op::__result_type __result_type;1168 typedef __decay_t<__result_type> value_type;1169 1170 _Op __op_;1171 const valarray<_Tp>& __a0_;1172 const valarray<_Tp>& __a1_;1173 1174 _LIBCUDACXX_INLINE_VISIBILITY1175 _BinaryOp(const _Op& __op, const valarray<_Tp>& __a0, const valarray<_Tp>& __a1)1176 : __op_(__op), __a0_(__a0), __a1_(__a1) {}1177 1178 _LIBCUDACXX_INLINE_VISIBILITY1179 __result_type operator[](size_t __i) const {return __op_(__a0_[__i], __a1_[__i]);}1180 1181 _LIBCUDACXX_INLINE_VISIBILITY1182 size_t size() const {return __a0_.size();}1183};1184 1185// slice_array1186 1187template <class _Tp>1188class _LIBCUDACXX_TEMPLATE_VIS slice_array1189{1190public:1191 typedef _Tp value_type;1192 1193private:1194 value_type* __vp_;1195 size_t __size_;1196 size_t __stride_;1197 1198public:1199 template <class _Expr>1200 typename enable_if