mirrors/llvm-project
0
0
Fork 0
mirror of https://github.com/llvm/llvm-project.git synced 2025-05-03 18:46:06 +00:00
Code Issues Projects Releases Wiki Activity
llvm-project/libcxx/include/__cxx03/valarray
Nikolas Klauser e78f53d1e8
Reapply "[libc++][C++03] Copy the LLVM 19 headers (#108999)" (#112127) 
This reverts commit 68c04b0ae62d8431d72d8b47fc13008002ee4387.

This disables the IWYU mapping that caused the failure, since
the headers aren't reachable for now.

This is the first part of the "Freezing C++03 headers" proposal
explained in
https://discourse.llvm.org/t/rfc-freezing-c-03-headers-in-libc/77319/58.

This patch mechanically copies the headers as of the LLVM 19.1 release
into a subdirectory of libc++ so that we can start using these headers
when building in C++03 mode. We are going to be backporting important
changes to that copy of the headers until the LLVM 21 release. After the
LLVM 21 release, only critical bugfixes will be fixed in the C++03 copy
of the headers.

This patch only performs a copy of the headers -- these headers are
still unused by the rest of the codebase.
2024-10-24 00:17:37 +02:00

3365 lines
124 KiB
C++
Raw Blame History

// -*- C++ -*-
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef _LIBCPP_VALARRAY
#define _LIBCPP_VALARRAY
/*
valarray synopsis
namespace std
{
template<class T>
class valarray
{
public:
typedef T value_type;
// construct/destroy:
valarray();
explicit valarray(size_t n);
valarray(const value_type& x, size_t n);
valarray(const value_type* px, size_t n);
valarray(const valarray& v);
valarray(valarray&& v) noexcept;
valarray(const slice_array<value_type>& sa);
valarray(const gslice_array<value_type>& ga);
valarray(const mask_array<value_type>& ma);
valarray(const indirect_array<value_type>& ia);
valarray(initializer_list<value_type> il);
~valarray();
// assignment:
valarray& operator=(const valarray& v);
valarray& operator=(valarray&& v) noexcept;
valarray& operator=(initializer_list<value_type> il);
valarray& operator=(const value_type& x);
valarray& operator=(const slice_array<value_type>& sa);
valarray& operator=(const gslice_array<value_type>& ga);
valarray& operator=(const mask_array<value_type>& ma);
valarray& operator=(const indirect_array<value_type>& ia);
// element access:
const value_type& operator[](size_t i) const;
value_type& operator[](size_t i);
// subset operations:
valarray operator[](slice s) const;
slice_array<value_type> operator[](slice s);
valarray operator[](const gslice& gs) const;
gslice_array<value_type> operator[](const gslice& gs);
valarray operator[](const valarray<bool>& vb) const;
mask_array<value_type> operator[](const valarray<bool>& vb);
valarray operator[](const valarray<size_t>& vs) const;
indirect_array<value_type> operator[](const valarray<size_t>& vs);
// unary operators:
valarray operator+() const;
valarray operator-() const;
valarray operator~() const;
valarray<bool> operator!() const;
// computed assignment:
valarray& operator*= (const value_type& x);
valarray& operator/= (const value_type& x);
valarray& operator%= (const value_type& x);
valarray& operator+= (const value_type& x);
valarray& operator-= (const value_type& x);
valarray& operator^= (const value_type& x);
valarray& operator&= (const value_type& x);
valarray& operator|= (const value_type& x);
valarray& operator<<=(const value_type& x);
valarray& operator>>=(const value_type& x);
valarray& operator*= (const valarray& v);
valarray& operator/= (const valarray& v);
valarray& operator%= (const valarray& v);
valarray& operator+= (const valarray& v);
valarray& operator-= (const valarray& v);
valarray& operator^= (const valarray& v);
valarray& operator|= (const valarray& v);
valarray& operator&= (const valarray& v);
valarray& operator<<=(const valarray& v);
valarray& operator>>=(const valarray& v);
// member functions:
void swap(valarray& v) noexcept;
size_t size() const;
value_type sum() const;
value_type min() const;
value_type max() const;
valarray shift (int i) const;
valarray cshift(int i) const;
valarray apply(value_type f(value_type)) const;
valarray apply(value_type f(const value_type&)) const;
void resize(size_t n, value_type x = value_type());
};
template<class T, size_t cnt> valarray(const T(&)[cnt], size_t) -> valarray<T>;
class slice
{
public:
slice();
slice(size_t start, size_t size, size_t stride);
size_t start() const;
size_t size() const;
size_t stride() const;
friend bool operator==(const slice& x, const slice& y); // since C++20
};
template <class T>
class slice_array
{
public:
typedef T value_type;
const slice_array& operator=(const slice_array& sa) const;
void operator= (const valarray<value_type>& v) const;
void operator*= (const valarray<value_type>& v) const;
void operator/= (const valarray<value_type>& v) const;
void operator%= (const valarray<value_type>& v) const;
void operator+= (const valarray<value_type>& v) const;
void operator-= (const valarray<value_type>& v) const;
void operator^= (const valarray<value_type>& v) const;
void operator&= (const valarray<value_type>& v) const;
void operator|= (const valarray<value_type>& v) const;
void operator<<=(const valarray<value_type>& v) const;
void operator>>=(const valarray<value_type>& v) const;
void operator=(const value_type& x) const;
void operator=(const valarray<T>& val_arr) const;
slice_array() = delete;
};
class gslice
{
public:
gslice();
gslice(size_t start, const valarray<size_t>& size,
const valarray<size_t>& stride);
size_t start() const;
valarray<size_t> size() const;
valarray<size_t> stride() const;
};
template <class T>
class gslice_array
{
public:
typedef T value_type;
void operator= (const valarray<value_type>& v) const;
void operator*= (const valarray<value_type>& v) const;
void operator/= (const valarray<value_type>& v) const;
void operator%= (const valarray<value_type>& v) const;
void operator+= (const valarray<value_type>& v) const;
void operator-= (const valarray<value_type>& v) const;
void operator^= (const valarray<value_type>& v) const;
void operator&= (const valarray<value_type>& v) const;
void operator|= (const valarray<value_type>& v) const;
void operator<<=(const valarray<value_type>& v) const;
void operator>>=(const valarray<value_type>& v) const;
gslice_array(const gslice_array& ga);
~gslice_array();
const gslice_array& operator=(const gslice_array& ga) const;
void operator=(const value_type& x) const;
gslice_array() = delete;
};
template <class T>
class mask_array
{
public:
typedef T value_type;
void operator= (const valarray<value_type>& v) const;
void operator*= (const valarray<value_type>& v) const;
void operator/= (const valarray<value_type>& v) const;
void operator%= (const valarray<value_type>& v) const;
void operator+= (const valarray<value_type>& v) const;
void operator-= (const valarray<value_type>& v) const;
void operator^= (const valarray<value_type>& v) const;
void operator&= (const valarray<value_type>& v) const;
void operator|= (const valarray<value_type>& v) const;
void operator<<=(const valarray<value_type>& v) const;
void operator>>=(const valarray<value_type>& v) const;
mask_array(const mask_array& ma);
~mask_array();
const mask_array& operator=(const mask_array& ma) const;
void operator=(const value_type& x) const;
mask_array() = delete;
};
template <class T>
class indirect_array
{
public:
typedef T value_type;
void operator= (const valarray<value_type>& v) const;
void operator*= (const valarray<value_type>& v) const;
void operator/= (const valarray<value_type>& v) const;
void operator%= (const valarray<value_type>& v) const;
void operator+= (const valarray<value_type>& v) const;
void operator-= (const valarray<value_type>& v) const;
void operator^= (const valarray<value_type>& v) const;
void operator&= (const valarray<value_type>& v) const;
void operator|= (const valarray<value_type>& v) const;
void operator<<=(const valarray<value_type>& v) const;
void operator>>=(const valarray<value_type>& v) const;
indirect_array(const indirect_array& ia);
~indirect_array();
const indirect_array& operator=(const indirect_array& ia) const;
void operator=(const value_type& x) const;
indirect_array() = delete;
};
template<class T> void swap(valarray<T>& x, valarray<T>& y) noexcept;
template<class T> valarray<T> operator* (const valarray<T>& x, const valarray<T>& y);
template<class T> valarray<T> operator* (const valarray<T>& x, const T& y);
template<class T> valarray<T> operator* (const T& x, const valarray<T>& y);
template<class T> valarray<T> operator/ (const valarray<T>& x, const valarray<T>& y);
template<class T> valarray<T> operator/ (const valarray<T>& x, const T& y);
template<class T> valarray<T> operator/ (const T& x, const valarray<T>& y);
template<class T> valarray<T> operator% (const valarray<T>& x, const valarray<T>& y);
template<class T> valarray<T> operator% (const valarray<T>& x, const T& y);
template<class T> valarray<T> operator% (const T& x, const valarray<T>& y);
template<class T> valarray<T> operator+ (const valarray<T>& x, const valarray<T>& y);
template<class T> valarray<T> operator+ (const valarray<T>& x, const T& y);
template<class T> valarray<T> operator+ (const T& x, const valarray<T>& y);
template<class T> valarray<T> operator- (const valarray<T>& x, const valarray<T>& y);
template<class T> valarray<T> operator- (const valarray<T>& x, const T& y);
template<class T> valarray<T> operator- (const T& x, const valarray<T>& y);
template<class T> valarray<T> operator^ (const valarray<T>& x, const valarray<T>& y);
template<class T> valarray<T> operator^ (const valarray<T>& x, const T& y);
template<class T> valarray<T> operator^ (const T& x, const valarray<T>& y);
template<class T> valarray<T> operator& (const valarray<T>& x, const valarray<T>& y);
template<class T> valarray<T> operator& (const valarray<T>& x, const T& y);
template<class T> valarray<T> operator& (const T& x, const valarray<T>& y);
template<class T> valarray<T> operator| (const valarray<T>& x, const valarray<T>& y);
template<class T> valarray<T> operator| (const valarray<T>& x, const T& y);
template<class T> valarray<T> operator| (const T& x, const valarray<T>& y);
template<class T> valarray<T> operator<<(const valarray<T>& x, const valarray<T>& y);
template<class T> valarray<T> operator<<(const valarray<T>& x, const T& y);
template<class T> valarray<T> operator<<(const T& x, const valarray<T>& y);
template<class T> valarray<T> operator>>(const valarray<T>& x, const valarray<T>& y);
template<class T> valarray<T> operator>>(const valarray<T>& x, const T& y);
template<class T> valarray<T> operator>>(const T& x, const valarray<T>& y);
template<class T> valarray<bool> operator&&(const valarray<T>& x, const valarray<T>& y);
template<class T> valarray<bool> operator&&(const valarray<T>& x, const T& y);
template<class T> valarray<bool> operator&&(const T& x, const valarray<T>& y);
template<class T> valarray<bool> operator||(const valarray<T>& x, const valarray<T>& y);
template<class T> valarray<bool> operator||(const valarray<T>& x, const T& y);
template<class T> valarray<bool> operator||(const T& x, const valarray<T>& y);
template<class T> valarray<bool> operator==(const valarray<T>& x, const valarray<T>& y);
template<class T> valarray<bool> operator==(const valarray<T>& x, const T& y);
template<class T> valarray<bool> operator==(const T& x, const valarray<T>& y);
template<class T> valarray<bool> operator!=(const valarray<T>& x, const valarray<T>& y);
template<class T> valarray<bool> operator!=(const valarray<T>& x, const T& y);
template<class T> valarray<bool> operator!=(const T& x, const valarray<T>& y);
template<class T> valarray<bool> operator< (const valarray<T>& x, const valarray<T>& y);
template<class T> valarray<bool> operator< (const valarray<T>& x, const T& y);
template<class T> valarray<bool> operator< (const T& x, const valarray<T>& y);
template<class T> valarray<bool> operator> (const valarray<T>& x, const valarray<T>& y);
template<class T> valarray<bool> operator> (const valarray<T>& x, const T& y);
template<class T> valarray<bool> operator> (const T& x, const valarray<T>& y);
template<class T> valarray<bool> operator<=(const valarray<T>& x, const valarray<T>& y);
template<class T> valarray<bool> operator<=(const valarray<T>& x, const T& y);
template<class T> valarray<bool> operator<=(const T& x, const valarray<T>& y);
template<class T> valarray<bool> operator>=(const valarray<T>& x, const valarray<T>& y);
template<class T> valarray<bool> operator>=(const valarray<T>& x, const T& y);
template<class T> valarray<bool> operator>=(const T& x, const valarray<T>& y);
template<class T> valarray<T> abs (const valarray<T>& x);
template<class T> valarray<T> acos (const valarray<T>& x);
template<class T> valarray<T> asin (const valarray<T>& x);
template<class T> valarray<T> atan (const valarray<T>& x);
template<class T> valarray<T> atan2(const valarray<T>& x, const valarray<T>& y);
template<class T> valarray<T> atan2(const valarray<T>& x, const T& y);
template<class T> valarray<T> atan2(const T& x, const valarray<T>& y);
template<class T> valarray<T> cos (const valarray<T>& x);
template<class T> valarray<T> cosh (const valarray<T>& x);
template<class T> valarray<T> exp (const valarray<T>& x);
template<class T> valarray<T> log (const valarray<T>& x);
template<class T> valarray<T> log10(const valarray<T>& x);
template<class T> valarray<T> pow(const valarray<T>& x, const valarray<T>& y);
template<class T> valarray<T> pow(const valarray<T>& x, const T& y);
template<class T> valarray<T> pow(const T& x, const valarray<T>& y);
template<class T> valarray<T> sin (const valarray<T>& x);
template<class T> valarray<T> sinh (const valarray<T>& x);
template<class T> valarray<T> sqrt (const valarray<T>& x);
template<class T> valarray<T> tan (const valarray<T>& x);
template<class T> valarray<T> tanh (const valarray<T>& x);
template <class T> unspecified1 begin(valarray<T>& v);
template <class T> unspecified2 begin(const valarray<T>& v);
template <class T> unspecified1 end(valarray<T>& v);
template <class T> unspecified2 end(const valarray<T>& v);
} // std
*/
#include <__algorithm/copy.h>
#include <__algorithm/count.h>
#include <__algorithm/fill.h>
#include <__algorithm/max_element.h>
#include <__algorithm/min.h>
#include <__algorithm/min_element.h>
#include <__algorithm/unwrap_iter.h>
#include <__assert>
#include <__config>
#include <__functional/operations.h>
#include <__memory/addressof.h>
#include <__memory/allocator.h>
#include <__memory/uninitialized_algorithms.h>
#include <__type_traits/decay.h>
#include <__type_traits/remove_reference.h>
#include <__utility/move.h>
#include <__utility/swap.h>
#include <cmath>
#include <cstddef>
#include <new>
#include <version>
// standard-mandated includes
// [valarray.syn]
#include <initializer_list>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header
#endif
_LIBCPP_PUSH_MACROS
#include <__undef_macros>
_LIBCPP_BEGIN_NAMESPACE_STD
template <class _Tp>
class _LIBCPP_TEMPLATE_VIS valarray;
class _LIBCPP_TEMPLATE_VIS slice {
size_t __start_;
size_t __size_;
size_t __stride_;
public:
_LIBCPP_HIDE_FROM_ABI slice() : __start_(0), __size_(0), __stride_(0) {}
_LIBCPP_HIDE_FROM_ABI slice(size_t __start, size_t __size, size_t __stride)
: __start_(__start), __size_(__size), __stride_(__stride) {}
_LIBCPP_HIDE_FROM_ABI size_t start() const { return __start_; }
_LIBCPP_HIDE_FROM_ABI size_t size() const { return __size_; }
_LIBCPP_HIDE_FROM_ABI size_t stride() const { return __stride_; }
#if _LIBCPP_STD_VER >= 20
_LIBCPP_HIDE_FROM_ABI friend bool operator==(const slice& __x, const slice& __y) {
return __x.start() == __y.start() && __x.size() == __y.size() && __x.stride() == __y.stride();
}
#endif
};
template <class _Tp>
class _LIBCPP_TEMPLATE_VIS slice_array;
class _LIBCPP_EXPORTED_FROM_ABI gslice;
template <class _Tp>
class _LIBCPP_TEMPLATE_VIS gslice_array;
template <class _Tp>
class _LIBCPP_TEMPLATE_VIS mask_array;
template <class _Tp>
class _LIBCPP_TEMPLATE_VIS indirect_array;
template <class _Tp>
_LIBCPP_HIDE_FROM_ABI _Tp* begin(valarray<_Tp>& __v);
template <class _Tp>
_LIBCPP_HIDE_FROM_ABI const _Tp* begin(const valarray<_Tp>& __v);
template <class _Tp>
_LIBCPP_HIDE_FROM_ABI _Tp* end(valarray<_Tp>& __v);
template <class _Tp>
_LIBCPP_HIDE_FROM_ABI const _Tp* end(const valarray<_Tp>& __v);
template <class _Op, class _A0>
struct _UnaryOp {
typedef typename _Op::__result_type __result_type;
using value_type = __decay_t<__result_type>;
_Op __op_;
_A0 __a0_;
_LIBCPP_HIDE_FROM_ABI _UnaryOp(const _Op& __op, const _A0& __a0) : __op_(__op), __a0_(__a0) {}
_LIBCPP_HIDE_FROM_ABI __result_type operator[](size_t __i) const { return __op_(__a0_[__i]); }
_LIBCPP_HIDE_FROM_ABI size_t size() const { return __a0_.size(); }
};
template <class _Op, class _A0, class _A1>
struct _BinaryOp {
typedef typename _Op::__result_type __result_type;
using value_type = __decay_t<__result_type>;
_Op __op_;
_A0 __a0_;
_A1 __a1_;
_LIBCPP_HIDE_FROM_ABI _BinaryOp(const _Op& __op, const _A0& __a0, const _A1& __a1)
: __op_(__op), __a0_(__a0), __a1_(__a1) {}
_LIBCPP_HIDE_FROM_ABI __result_type operator[](size_t __i) const { return __op_(__a0_[__i], __a1_[__i]); }
_LIBCPP_HIDE_FROM_ABI size_t size() const { return __a0_.size(); }
};
template <class _Tp>
class __scalar_expr {
public:
typedef _Tp value_type;
typedef const _Tp& __result_type;
private:
const value_type& __t_;
size_t __s_;
public:
_LIBCPP_HIDE_FROM_ABI explicit __scalar_expr(const value_type& __t, size_t __s) : __t_(__t), __s_(__s) {}
_LIBCPP_HIDE_FROM_ABI __result_type operator[](size_t) const { return __t_; }
_LIBCPP_HIDE_FROM_ABI size_t size() const { return __s_; }
};
template <class _Tp>
struct __unary_plus {
typedef _Tp __result_type;
_LIBCPP_HIDE_FROM_ABI _Tp operator()(const _Tp& __x) const { return +__x; }
};
template <class _Tp>
struct __bit_not {
typedef _Tp __result_type;
_LIBCPP_HIDE_FROM_ABI _Tp operator()(const _Tp& __x) const { return ~__x; }
};
template <class _Tp>
struct __bit_shift_left {
typedef _Tp __result_type;
_LIBCPP_HIDE_FROM_ABI _Tp operator()(const _Tp& __x, const _Tp& __y) const { return __x << __y; }
};
template <class _Tp>
struct __bit_shift_right {
typedef _Tp __result_type;
_LIBCPP_HIDE_FROM_ABI _Tp operator()(const _Tp& __x, const _Tp& __y) const { return __x >> __y; }
};
template <class _Tp, class _Fp>
struct __apply_expr {
private:
_Fp __f_;
public:
typedef _Tp __result_type;
_LIBCPP_HIDE_FROM_ABI explicit __apply_expr(_Fp __f) : __f_(__f) {}
_LIBCPP_HIDE_FROM_ABI _Tp operator()(const _Tp& __x) const { return __f_(__x); }
};
template <class _Tp>
struct __abs_expr {
typedef _Tp __result_type;
_LIBCPP_HIDE_FROM_ABI _Tp operator()(const _Tp& __x) const { return std::abs(__x); }
};
template <class _Tp>
struct __acos_expr {
typedef _Tp __result_type;
_LIBCPP_HIDE_FROM_ABI _Tp operator()(const _Tp& __x) const { return std::acos(__x); }
};
template <class _Tp>
struct __asin_expr {
typedef _Tp __result_type;
_LIBCPP_HIDE_FROM_ABI _Tp operator()(const _Tp& __x) const { return std::asin(__x); }
};
template <class _Tp>
struct __atan_expr {
typedef _Tp __result_type;
_LIBCPP_HIDE_FROM_ABI _Tp operator()(const _Tp& __x) const { return std::atan(__x); }
};
template <class _Tp>
struct __atan2_expr {
typedef _Tp __result_type;
_LIBCPP_HIDE_FROM_ABI _Tp operator()(const _Tp& __x, const _Tp& __y) const { return std::atan2(__x, __y); }
};
template <class _Tp>
struct __cos_expr {
typedef _Tp __result_type;
_LIBCPP_HIDE_FROM_ABI _Tp operator()(const _Tp& __x) const { return std::cos(__x); }
};
template <class _Tp>
struct __cosh_expr {
typedef _Tp __result_type;
_LIBCPP_HIDE_FROM_ABI _Tp operator()(const _Tp& __x) const { return std::cosh(__x); }
};
template <class _Tp>
struct __exp_expr {
typedef _Tp __result_type;
_LIBCPP_HIDE_FROM_ABI _Tp operator()(const _Tp& __x) const { return std::exp(__x); }
};
template <class _Tp>
struct __log_expr {
typedef _Tp __result_type;
_LIBCPP_HIDE_FROM_ABI _Tp operator()(const _Tp& __x) const { return std::log(__x); }
};
template <class _Tp>
struct __log10_expr {
typedef _Tp __result_type;
_LIBCPP_HIDE_FROM_ABI _Tp operator()(const _Tp& __x) const { return std::log10(__x); }
};
template <class _Tp>
struct __pow_expr {
typedef _Tp __result_type;
_LIBCPP_HIDE_FROM_ABI _Tp operator()(const _Tp& __x, const _Tp& __y) const { return std::pow(__x, __y); }
};
template <class _Tp>
struct __sin_expr {
typedef _Tp __result_type;
_LIBCPP_HIDE_FROM_ABI _Tp operator()(const _Tp& __x) const { return std::sin(__x); }
};
template <class _Tp>
struct __sinh_expr {
typedef _Tp __result_type;
_LIBCPP_HIDE_FROM_ABI _Tp operator()(const _Tp& __x) const { return std::sinh(__x); }
};
template <class _Tp>
struct __sqrt_expr {
typedef _Tp __result_type;
_LIBCPP_HIDE_FROM_ABI _Tp operator()(const _Tp& __x) const { return std::sqrt(__x); }
};
template <class _Tp>
struct __tan_expr {
typedef _Tp __result_type;
_LIBCPP_HIDE_FROM_ABI _Tp operator()(const _Tp& __x) const { return std::tan(__x); }
};
template <class _Tp>
struct __tanh_expr {
typedef _Tp __result_type;
_LIBCPP_HIDE_FROM_ABI _Tp operator()(const _Tp& __x) const { return std::tanh(__x); }
};
template <class _ValExpr>
class __slice_expr {
typedef __libcpp_remove_reference_t<_ValExpr> _RmExpr;
public:
typedef typename _RmExpr::value_type value_type;
typedef value_type __result_type;
private:
_ValExpr __expr_;
size_t __start_;
size_t __size_;
size_t __stride_;
_LIBCPP_HIDE_FROM_ABI __slice_expr(const slice& __sl, const _RmExpr& __e)
: __expr_(__e), __start_(__sl.start()), __size_(__sl.size()), __stride_(__sl.stride()) {}
public:
_LIBCPP_HIDE_FROM_ABI __result_type operator[](size_t __i) const { return __expr_[__start_ + __i * __stride_]; }
_LIBCPP_HIDE_FROM_ABI size_t size() const { return __size_; }
template <class>
friend class __val_expr;
template <class>
friend class _LIBCPP_TEMPLATE_VIS valarray;
};
template <class _ValExpr>
class __mask_expr;
template <class _ValExpr>
class __indirect_expr;
template <class _ValExpr>
class __shift_expr {
typedef __libcpp_remove_reference_t<_ValExpr> _RmExpr;
public:
typedef typename _RmExpr::value_type value_type;
typedef value_type __result_type;
private:
_ValExpr __expr_;
size_t __size_;
ptrdiff_t __ul_;
ptrdiff_t __sn_;
ptrdiff_t __n_;
static const ptrdiff_t _Np = static_cast<ptrdiff_t>(sizeof(ptrdiff_t) * __CHAR_BIT__ - 1);
_LIBCPP_HIDE_FROM_ABI __shift_expr(int __n, const _RmExpr& __e) : __expr_(__e), __size_(__e.size()), __n_(__n) {
ptrdiff_t __neg_n = static_cast<ptrdiff_t>(__n_ >> _Np);
__sn_ = __neg_n | static_cast<ptrdiff_t>(static_cast<size_t>(-__n_) >> _Np);
__ul_ = ((__size_ - __n_) & ~__neg_n) | ((__n_ + 1) & __neg_n);
}
public:
_LIBCPP_HIDE_FROM_ABI __result_type operator[](size_t __j) const {
ptrdiff_t __i = static_cast<ptrdiff_t>(__j);
ptrdiff_t __m = (__sn_ * __i - __ul_) >> _Np;
return (__expr_[(__i + __n_) & __m] & __m) | (value_type() & ~__m);
}
_LIBCPP_HIDE_FROM_ABI size_t size() const { return __size_; }
template <class>
friend class __val_expr;
};
template <class _ValExpr>
class __cshift_expr {
typedef __libcpp_remove_reference_t<_ValExpr> _RmExpr;
public:
typedef typename _RmExpr::value_type value_type;
typedef value_type __result_type;
private:
_ValExpr __expr_;
size_t __size_;
size_t __m_;
size_t __o1_;
size_t __o2_;
_LIBCPP_HIDE_FROM_ABI __cshift_expr(int __n, const _RmExpr& __e) : __expr_(__e), __size_(__e.size()) {
__n %= static_cast<int>(__size_);
if (__n >= 0) {
__m_ = __size_ - __n;
__o1_ = __n;
__o2_ = __n - __size_;
} else {
__m_ = -__n;
__o1_ = __n + __size_;
__o2_ = __n;
}
}
public:
_LIBCPP_HIDE_FROM_ABI __result_type operator[](size_t __i) const {
if (__i < __m_)
return __expr_[__i + __o1_];
return __expr_[__i + __o2_];
}
_LIBCPP_HIDE_FROM_ABI size_t size() const { return __size_; }
template <class>
friend class __val_expr;
};
template <class _ValExpr>
class __val_expr;
template <class _ValExpr>
struct __is_val_expr : false_type {};
template <class _ValExpr>
struct __is_val_expr<__val_expr<_ValExpr> > : true_type {};
template <class _Tp>
struct __is_val_expr<valarray<_Tp> > : true_type {};
template <class _Tp>
struct __is_val_expr<slice_array<_Tp> > : true_type {};
template <class _Tp>
struct __is_val_expr<gslice_array<_Tp> > : true_type {};
template <class _Tp>
struct __is_val_expr<mask_array<_Tp> > : true_type {};
template <class _Tp>
struct __is_val_expr<indirect_array<_Tp> > : true_type {};
// The functions using a __val_expr access the elements by their index.
// valarray and the libc++ lazy proxies have an operator[]. The
// Standard proxy array's don't have this operator, instead they have a
// implementation specific accessor
// __get(size_t)
//
// The functions use the non-member function
// __get(__val_expr, size_t)
//
// If the __val_expr is a specialization of __val_expr_use_member_functions it
// uses the __val_expr's member function
// __get(size_t)
// else it uses the __val_expr's member function
// operator[](size_t)
template <class _ValExpr>
struct __val_expr_use_member_functions;
template <class>
struct __val_expr_use_member_functions : false_type {};
template <class _Tp>
struct __val_expr_use_member_functions<slice_array<_Tp> > : true_type {};
template <class _Tp>
struct __val_expr_use_member_functions<gslice_array<_Tp> > : true_type {};
template <class _Tp>
struct __val_expr_use_member_functions<mask_array<_Tp> > : true_type {};
template <class _Tp>
struct __val_expr_use_member_functions<indirect_array<_Tp> > : true_type {};
template <class _Tp>
class _LIBCPP_TEMPLATE_VIS valarray {
public:
typedef _Tp value_type;
typedef _Tp __result_type;
private:
value_type* __begin_;
value_type* __end_;
public:
// construct/destroy:
_LIBCPP_HIDE_FROM_ABI valarray() : __begin_(nullptr), __end_(nullptr) {}
inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 explicit valarray(size_t __n);
_LIBCPP_HIDE_FROM_ABI valarray(const value_type& __x, size_t __n);
valarray(const value_type* __p, size_t __n);
valarray(const valarray& __v);
#ifndef _LIBCPP_CXX03_LANG
_LIBCPP_HIDE_FROM_ABI valarray(valarray&& __v) _NOEXCEPT;
valarray(initializer_list<value_type> __il);
#endif // _LIBCPP_CXX03_LANG
valarray(const slice_array<value_type>& __sa);
valarray(const gslice_array<value_type>& __ga);
valarray(const mask_array<value_type>& __ma);
valarray(const indirect_array<value_type>& __ia);
inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 ~valarray();
// assignment:
valarray& operator=(const valarray& __v);
#ifndef _LIBCPP_CXX03_LANG
_LIBCPP_HIDE_FROM_ABI valarray& operator=(valarray&& __v) _NOEXCEPT;
_LIBCPP_HIDE_FROM_ABI valarray& operator=(initializer_list<value_type>);
#endif // _LIBCPP_CXX03_LANG
_LIBCPP_HIDE_FROM_ABI valarray& operator=(const value_type& __x);
_LIBCPP_HIDE_FROM_ABI valarray& operator=(const slice_array<value_type>& __sa);
_LIBCPP_HIDE_FROM_ABI valarray& operator=(const gslice_array<value_type>& __ga);
_LIBCPP_HIDE_FROM_ABI valarray& operator=(const mask_array<value_type>& __ma);
_LIBCPP_HIDE_FROM_ABI valarray& operator=(const indirect_array<value_type>& __ia);
template <class _ValExpr>
_LIBCPP_HIDE_FROM_ABI valarray& operator=(const __val_expr<_ValExpr>& __v);
// element access:
_LIBCPP_HIDE_FROM_ABI const value_type& operator[](size_t __i) const { return __begin_[__i]; }
_LIBCPP_HIDE_FROM_ABI value_type& operator[](size_t __i) { return __begin_[__i]; }
// subset operations:
_LIBCPP_HIDE_FROM_ABI __val_expr<__slice_expr<const valarray&> > operator[](slice __s) const;
_LIBCPP_HIDE_FROM_ABI slice_array<value_type> operator[](slice __s);
_LIBCPP_HIDE_FROM_ABI __val_expr<__indirect_expr<const valarray&> > operator[](const gslice& __gs) const;
_LIBCPP_HIDE_FROM_ABI gslice_array<value_type> operator[](const gslice& __gs);
#ifndef _LIBCPP_CXX03_LANG
_LIBCPP_HIDE_FROM_ABI __val_expr<__indirect_expr<const valarray&> > operator[](gslice&& __gs) const;
_LIBCPP_HIDE_FROM_ABI gslice_array<value_type> operator[](gslice&& __gs);
#endif // _LIBCPP_CXX03_LANG
_LIBCPP_HIDE_FROM_ABI __val_expr<__mask_expr<const valarray&> > operator[](const valarray<bool>& __vb) const;
_LIBCPP_HIDE_FROM_ABI mask_array<value_type> operator[](const valarray<bool>& __vb);
#ifndef _LIBCPP_CXX03_LANG
_LIBCPP_HIDE_FROM_ABI __val_expr<__mask_expr<const valarray&> > operator[](valarray<bool>&& __vb) const;
_LIBCPP_HIDE_FROM_ABI mask_array<value_type> operator[](valarray<bool>&& __vb);
#endif // _LIBCPP_CXX03_LANG
_LIBCPP_HIDE_FROM_ABI __val_expr<__indirect_expr<const valarray&> > operator[](const valarray<size_t>& __vs) const;
_LIBCPP_HIDE_FROM_ABI indirect_array<value_type> operator[](const valarray<size_t>& __vs);
#ifndef _LIBCPP_CXX03_LANG
_LIBCPP_HIDE_FROM_ABI __val_expr<__indirect_expr<const valarray&> > operator[](valarray<size_t>&& __vs) const;
_LIBCPP_HIDE_FROM_ABI indirect_array<value_type> operator[](valarray<size_t>&& __vs);
#endif // _LIBCPP_CXX03_LANG
// unary operators:
_LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__unary_plus<_Tp>, const valarray&> > operator+() const;
_LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<negate<_Tp>, const valarray&> > operator-() const;
_LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__bit_not<_Tp>, const valarray&> > operator~() const;
_LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<logical_not<_Tp>, const valarray&> > operator!() const;
// computed assignment:
_LIBCPP_HIDE_FROM_ABI valarray& operator*=(const value_type& __x);
_LIBCPP_HIDE_FROM_ABI valarray& operator/=(const value_type& __x);
_LIBCPP_HIDE_FROM_ABI valarray& operator%=(const value_type& __x);
_LIBCPP_HIDE_FROM_ABI valarray& operator+=(const value_type& __x);
_LIBCPP_HIDE_FROM_ABI valarray& operator-=(const value_type& __x);
_LIBCPP_HIDE_FROM_ABI valarray& operator^=(const value_type& __x);
_LIBCPP_HIDE_FROM_ABI valarray& operator&=(const value_type& __x);
_LIBCPP_HIDE_FROM_ABI valarray& operator|=(const value_type& __x);
_LIBCPP_HIDE_FROM_ABI valarray& operator<<=(const value_type& __x);
_LIBCPP_HIDE_FROM_ABI valarray& operator>>=(const value_type& __x);
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
_LIBCPP_HIDE_FROM_ABI valarray& operator*=(const _Expr& __v);
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
_LIBCPP_HIDE_FROM_ABI valarray& operator/=(const _Expr& __v);
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
_LIBCPP_HIDE_FROM_ABI valarray& operator%=(const _Expr& __v);
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
_LIBCPP_HIDE_FROM_ABI valarray& operator+=(const _Expr& __v);
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
_LIBCPP_HIDE_FROM_ABI valarray& operator-=(const _Expr& __v);
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
_LIBCPP_HIDE_FROM_ABI valarray& operator^=(const _Expr& __v);
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
_LIBCPP_HIDE_FROM_ABI valarray& operator|=(const _Expr& __v);
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
_LIBCPP_HIDE_FROM_ABI valarray& operator&=(const _Expr& __v);
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
_LIBCPP_HIDE_FROM_ABI valarray& operator<<=(const _Expr& __v);
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
_LIBCPP_HIDE_FROM_ABI valarray& operator>>=(const _Expr& __v);
// member functions:
_LIBCPP_HIDE_FROM_ABI void swap(valarray& __v) _NOEXCEPT;
_LIBCPP_HIDE_FROM_ABI size_t size() const { return static_cast<size_t>(__end_ - __begin_); }
_LIBCPP_HIDE_FROM_ABI value_type sum() const;
_LIBCPP_HIDE_FROM_ABI value_type min() const;
_LIBCPP_HIDE_FROM_ABI value_type max() const;
valarray shift(int __i) const;
valarray cshift(int __i) const;
valarray apply(value_type __f(value_type)) const;
valarray apply(value_type __f(const value_type&)) const;
void resize(size_t __n, value_type __x = value_type());
private:
template <class>
friend class _LIBCPP_TEMPLATE_VIS valarray;
template <class>
friend class _LIBCPP_TEMPLATE_VIS slice_array;
template <class>
friend class _LIBCPP_TEMPLATE_VIS gslice_array;
template <class>
friend class _LIBCPP_TEMPLATE_VIS mask_array;
template <class>
friend class __mask_expr;
template <class>
friend class _LIBCPP_TEMPLATE_VIS indirect_array;
template <class>
friend class __indirect_expr;
template <class>
friend class __val_expr;
template <class _Up>
friend _Up* begin(valarray<_Up>& __v);
template <class _Up>
friend const _Up* begin(const valarray<_Up>& __v);
template <class _Up>
friend _Up* end(valarray<_Up>& __v);
template <class _Up>
friend const _Up* end(const valarray<_Up>& __v);
_LIBCPP_HIDE_FROM_ABI void __clear(size_t __capacity);
valarray& __assign_range(const value_type* __f, const value_type* __l);
};
#if _LIBCPP_STD_VER >= 17
template <class _Tp, size_t _Size>
valarray(const _Tp (&)[_Size], size_t) -> valarray<_Tp>;
#endif
template <class _Expr,
__enable_if_t<__is_val_expr<_Expr>::value && __val_expr_use_member_functions<_Expr>::value, int> = 0>
_LIBCPP_HIDE_FROM_ABI typename _Expr::value_type __get(const _Expr& __v, size_t __i) {
return __v.__get(__i);
}
template <class _Expr,
__enable_if_t<__is_val_expr<_Expr>::value && !__val_expr_use_member_functions<_Expr>::value, int> = 0>
_LIBCPP_HIDE_FROM_ABI typename _Expr::value_type __get(const _Expr& __v, size_t __i) {
return __v[__i];
}
extern template _LIBCPP_EXPORTED_FROM_ABI void valarray<size_t>::resize(size_t, size_t);
template <class _Op, class _Tp>
struct _UnaryOp<_Op, valarray<_Tp> > {
typedef typename _Op::__result_type __result_type;
using value_type = __decay_t<__result_type>;
_Op __op_;
const valarray<_Tp>& __a0_;
_LIBCPP_HIDE_FROM_ABI _UnaryOp(const _Op& __op, const valarray<_Tp>& __a0) : __op_(__op), __a0_(__a0) {}
_LIBCPP_HIDE_FROM_ABI __result_type operator[](size_t __i) const { return __op_(__a0_[__i]); }
_LIBCPP_HIDE_FROM_ABI size_t size() const { return __a0_.size(); }
};
template <class _Op, class _Tp, class _A1>
struct _BinaryOp<_Op, valarray<_Tp>, _A1> {
typedef typename _Op::__result_type __result_type;
using value_type = __decay_t<__result_type>;
_Op __op_;
const valarray<_Tp>& __a0_;
_A1 __a1_;
_LIBCPP_HIDE_FROM_ABI _BinaryOp(const _Op& __op, const valarray<_Tp>& __a0, const _A1& __a1)
: __op_(__op), __a0_(__a0), __a1_(__a1) {}
_LIBCPP_HIDE_FROM_ABI __result_type operator[](size_t __i) const { return __op_(__a0_[__i], __a1_[__i]); }
_LIBCPP_HIDE_FROM_ABI size_t size() const { return __a0_.size(); }
};
template <class _Op, class _A0, class _Tp>
struct _BinaryOp<_Op, _A0, valarray<_Tp> > {
typedef typename _Op::__result_type __result_type;
using value_type = __decay_t<__result_type>;
_Op __op_;
_A0 __a0_;
const valarray<_Tp>& __a1_;
_LIBCPP_HIDE_FROM_ABI _BinaryOp(const _Op& __op, const _A0& __a0, const valarray<_Tp>& __a1)
: __op_(__op), __a0_(__a0), __a1_(__a1) {}
_LIBCPP_HIDE_FROM_ABI __result_type operator[](size_t __i) const { return __op_(__a0_[__i], __a1_[__i]); }
_LIBCPP_HIDE_FROM_ABI size_t size() const { return __a0_.size(); }
};
template <class _Op, class _Tp>
struct _BinaryOp<_Op, valarray<_Tp>, valarray<_Tp> > {
typedef typename _Op::__result_type __result_type;
using value_type = __decay_t<__result_type>;
_Op __op_;
const valarray<_Tp>& __a0_;
const valarray<_Tp>& __a1_;
_LIBCPP_HIDE_FROM_ABI _BinaryOp(const _Op& __op, const valarray<_Tp>& __a0, const valarray<_Tp>& __a1)
: __op_(__op), __a0_(__a0), __a1_(__a1) {}
_LIBCPP_HIDE_FROM_ABI __result_type operator[](size_t __i) const { return __op_(__a0_[__i], __a1_[__i]); }
_LIBCPP_HIDE_FROM_ABI size_t size() const { return __a0_.size(); }
};
// slice_array
template <class _Tp>
class _LIBCPP_TEMPLATE_VIS slice_array {
public:
typedef _Tp value_type;
private:
value_type* __vp_;
size_t __size_;
size_t __stride_;
public:
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
void _LIBCPP_HIDE_FROM_ABI operator=(const _Expr& __v) const;
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
void _LIBCPP_HIDE_FROM_ABI operator*=(const _Expr& __v) const;
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
void _LIBCPP_HIDE_FROM_ABI operator/=(const _Expr& __v) const;
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
void _LIBCPP_HIDE_FROM_ABI operator%=(const _Expr& __v) const;
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
void _LIBCPP_HIDE_FROM_ABI operator+=(const _Expr& __v) const;
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
void _LIBCPP_HIDE_FROM_ABI operator-=(const _Expr& __v) const;
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
void _LIBCPP_HIDE_FROM_ABI operator^=(const _Expr& __v) const;
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
void _LIBCPP_HIDE_FROM_ABI operator&=(const _Expr& __v) const;
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
void _LIBCPP_HIDE_FROM_ABI operator|=(const _Expr& __v) const;
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
void _LIBCPP_HIDE_FROM_ABI operator<<=(const _Expr& __v) const;
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
void _LIBCPP_HIDE_FROM_ABI operator>>=(const _Expr& __v) const;
slice_array(slice_array const&) = default;
_LIBCPP_HIDE_FROM_ABI const slice_array& operator=(const slice_array& __sa) const;
_LIBCPP_HIDE_FROM_ABI void operator=(const value_type& __x) const;
_LIBCPP_HIDE_FROM_ABI void operator=(const valarray<value_type>& __va) const;
// Behaves like __val_expr::operator[], which returns by value.
_LIBCPP_HIDE_FROM_ABI value_type __get(size_t __i) const {
_LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(__i < __size_, "slice_array.__get() index out of bounds");
return __vp_[__i * __stride_];
}
private:
_LIBCPP_HIDE_FROM_ABI slice_array(const slice& __sl, const valarray<value_type>& __v)
: __vp_(const_cast<value_type*>(__v.__begin_ + __sl.start())), __size_(__sl.size()), __stride_(__sl.stride()) {}
template <class>
friend class valarray;
};
template <class _Tp>
inline const slice_array<_Tp>& slice_array<_Tp>::operator=(const slice_array& __sa) const {
value_type* __t = __vp_;
const value_type* __s = __sa.__vp_;
for (size_t __n = __size_; __n; --__n, __t += __stride_, __s += __sa.__stride_)
*__t = *__s;
return *this;
}
template <class _Tp>
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
inline void slice_array<_Tp>::operator=(const _Expr& __v) const {
value_type* __t = __vp_;
for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_)
*__t = __v[__i];
}
template <class _Tp>
inline void slice_array<_Tp>::operator=(const valarray<value_type>& __va) const {
value_type* __t = __vp_;
for (size_t __i = 0; __i < __va.size(); ++__i, __t += __stride_)
*__t = __va[__i];
}
template <class _Tp>
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
inline void slice_array<_Tp>::operator*=(const _Expr& __v) const {
value_type* __t = __vp_;
for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_)
*__t *= __v[__i];
}
template <class _Tp>
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
inline void slice_array<_Tp>::operator/=(const _Expr& __v) const {
value_type* __t = __vp_;
for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_)
*__t /= __v[__i];
}
template <class _Tp>
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
inline void slice_array<_Tp>::operator%=(const _Expr& __v) const {
value_type* __t = __vp_;
for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_)
*__t %= __v[__i];
}
template <class _Tp>
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
inline void slice_array<_Tp>::operator+=(const _Expr& __v) const {
value_type* __t = __vp_;
for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_)
*__t += __v[__i];
}
template <class _Tp>
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
inline void slice_array<_Tp>::operator-=(const _Expr& __v) const {
value_type* __t = __vp_;
for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_)
*__t -= __v[__i];
}
template <class _Tp>
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
inline void slice_array<_Tp>::operator^=(const _Expr& __v) const {
value_type* __t = __vp_;
for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_)
*__t ^= __v[__i];
}
template <class _Tp>
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
inline void slice_array<_Tp>::operator&=(const _Expr& __v) const {
value_type* __t = __vp_;
for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_)
*__t &= __v[__i];
}
template <class _Tp>
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
inline void slice_array<_Tp>::operator|=(const _Expr& __v) const {
value_type* __t = __vp_;
for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_)
*__t |= __v[__i];
}
template <class _Tp>
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
inline void slice_array<_Tp>::operator<<=(const _Expr& __v) const {
value_type* __t = __vp_;
for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_)
*__t <<= __v[__i];
}
template <class _Tp>
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
inline void slice_array<_Tp>::operator>>=(const _Expr& __v) const {
value_type* __t = __vp_;
for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_)
*__t >>= __v[__i];
}
template <class _Tp>
inline void slice_array<_Tp>::operator=(const value_type& __x) const {
value_type* __t = __vp_;
for (size_t __n = __size_; __n; --__n, __t += __stride_)
*__t = __x;
}
// gslice
class _LIBCPP_EXPORTED_FROM_ABI gslice {
valarray<size_t> __size_;
valarray<size_t> __stride_;
valarray<size_t> __1d_;
public:
_LIBCPP_HIDE_FROM_ABI gslice() {}
_LIBCPP_HIDE_FROM_ABI gslice(size_t __start, const valarray<size_t>& __size, const valarray<size_t>& __stride)
: __size_(__size), __stride_(__stride) {
__init(__start);
}
#ifndef _LIBCPP_CXX03_LANG
_LIBCPP_HIDE_FROM_ABI gslice(size_t __start, const valarray<size_t>& __size, valarray<size_t>&& __stride)
: __size_(__size), __stride_(std::move(__stride)) {
__init(__start);
}
_LIBCPP_HIDE_FROM_ABI gslice(size_t __start, valarray<size_t>&& __size, const valarray<size_t>& __stride)
: __size_(std::move(__size)), __stride_(__stride) {
__init(__start);
}
_LIBCPP_HIDE_FROM_ABI gslice(size_t __start, valarray<size_t>&& __size, valarray<size_t>&& __stride)
: __size_(std::move(__size)), __stride_(std::move(__stride)) {
__init(__start);
}
#endif // _LIBCPP_CXX03_LANG
_LIBCPP_HIDE_FROM_ABI size_t start() const { return __1d_.size() ? __1d_[0] : 0; }
_LIBCPP_HIDE_FROM_ABI valarray<size_t> size() const { return __size_; }
_LIBCPP_HIDE_FROM_ABI valarray<size_t> stride() const { return __stride_; }
private:
void __init(size_t __start);
template <class>
friend class gslice_array;
template <class>
friend class valarray;
template <class>
friend class __val_expr;
};
// gslice_array
template <class _Tp>
class _LIBCPP_TEMPLATE_VIS gslice_array {
public:
typedef _Tp value_type;
private:
value_type* __vp_;
valarray<size_t> __1d_;
public:
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
void _LIBCPP_HIDE_FROM_ABI operator=(const _Expr& __v) const;
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
void _LIBCPP_HIDE_FROM_ABI operator*=(const _Expr& __v) const;
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
void _LIBCPP_HIDE_FROM_ABI operator/=(const _Expr& __v) const;
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
void _LIBCPP_HIDE_FROM_ABI operator%=(const _Expr& __v) const;
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
void _LIBCPP_HIDE_FROM_ABI operator+=(const _Expr& __v) const;
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
void _LIBCPP_HIDE_FROM_ABI operator-=(const _Expr& __v) const;
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
void _LIBCPP_HIDE_FROM_ABI operator^=(const _Expr& __v) const;
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
void _LIBCPP_HIDE_FROM_ABI operator&=(const _Expr& __v) const;
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
void _LIBCPP_HIDE_FROM_ABI operator|=(const _Expr& __v) const;
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
void _LIBCPP_HIDE_FROM_ABI operator<<=(const _Expr& __v) const;
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
void _LIBCPP_HIDE_FROM_ABI operator>>=(const _Expr& __v) const;
_LIBCPP_HIDE_FROM_ABI const gslice_array& operator=(const gslice_array& __ga) const;
_LIBCPP_HIDE_FROM_ABI void operator=(const value_type& __x) const;
gslice_array(const gslice_array&) = default;
// Behaves like __val_expr::operator[], which returns by value.
_LIBCPP_HIDE_FROM_ABI value_type __get(size_t __i) const {
_LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(__i < __1d_.size(), "gslice_array.__get() index out of bounds");
return __vp_[__1d_[__i]];
}
private:
gslice_array(const gslice& __gs, const valarray<value_type>& __v)
: __vp_(const_cast<value_type*>(__v.__begin_)), __1d_(__gs.__1d_) {}
#ifndef _LIBCPP_CXX03_LANG
gslice_array(gslice&& __gs, const valarray<value_type>& __v)
: __vp_(const_cast<value_type*>(__v.__begin_)), __1d_(std::move(__gs.__1d_)) {}
#endif // _LIBCPP_CXX03_LANG
template <class>
friend class valarray;
};
template <class _Tp>
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
inline void gslice_array<_Tp>::operator=(const _Expr& __v) const {
typedef const size_t* _Ip;
size_t __j = 0;
for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j)
__vp_[*__i] = __v[__j];
}
template <class _Tp>
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
inline void gslice_array<_Tp>::operator*=(const _Expr& __v) const {
typedef const size_t* _Ip;
size_t __j = 0;
for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j)
__vp_[*__i] *= __v[__j];
}
template <class _Tp>
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
inline void gslice_array<_Tp>::operator/=(const _Expr& __v) const {
typedef const size_t* _Ip;
size_t __j = 0;
for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j)
__vp_[*__i] /= __v[__j];
}
template <class _Tp>
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
inline void gslice_array<_Tp>::operator%=(const _Expr& __v) const {
typedef const size_t* _Ip;
size_t __j = 0;
for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j)
__vp_[*__i] %= __v[__j];
}
template <class _Tp>
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
inline void gslice_array<_Tp>::operator+=(const _Expr& __v) const {
typedef const size_t* _Ip;
size_t __j = 0;
for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j)
__vp_[*__i] += __v[__j];
}
template <class _Tp>
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
inline void gslice_array<_Tp>::operator-=(const _Expr& __v) const {
typedef const size_t* _Ip;
size_t __j = 0;
for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j)
__vp_[*__i] -= __v[__j];
}
template <class _Tp>
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
inline void gslice_array<_Tp>::operator^=(const _Expr& __v) const {
typedef const size_t* _Ip;
size_t __j = 0;
for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j)
__vp_[*__i] ^= __v[__j];
}
template <class _Tp>
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
inline void gslice_array<_Tp>::operator&=(const _Expr& __v) const {
typedef const size_t* _Ip;
size_t __j = 0;
for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j)
__vp_[*__i] &= __v[__j];
}
template <class _Tp>
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
inline void gslice_array<_Tp>::operator|=(const _Expr& __v) const {
typedef const size_t* _Ip;
size_t __j = 0;
for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j)
__vp_[*__i] |= __v[__j];
}
template <class _Tp>
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
inline void gslice_array<_Tp>::operator<<=(const _Expr& __v) const {
typedef const size_t* _Ip;
size_t __j = 0;
for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j)
__vp_[*__i] <<= __v[__j];
}
template <class _Tp>
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
inline void gslice_array<_Tp>::operator>>=(const _Expr& __v) const {
typedef const size_t* _Ip;
size_t __j = 0;
for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j)
__vp_[*__i] >>= __v[__j];
}
template <class _Tp>
inline const gslice_array<_Tp>& gslice_array<_Tp>::operator=(const gslice_array& __ga) const {
typedef const size_t* _Ip;
const value_type* __s = __ga.__vp_;
for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_, __j = __ga.__1d_.__begin_; __i != __e; ++__i, ++__j)
__vp_[*__i] = __s[*__j];
return *this;
}
template <class _Tp>
inline void gslice_array<_Tp>::operator=(const value_type& __x) const {
typedef const size_t* _Ip;
for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i)
__vp_[*__i] = __x;
}
// mask_array
template <class _Tp>
class _LIBCPP_TEMPLATE_VIS mask_array {
public:
typedef _Tp value_type;
private:
value_type* __vp_;
valarray<size_t> __1d_;
public:
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
void _LIBCPP_HIDE_FROM_ABI operator=(const _Expr& __v) const;
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
void _LIBCPP_HIDE_FROM_ABI operator*=(const _Expr& __v) const;
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
void _LIBCPP_HIDE_FROM_ABI operator/=(const _Expr& __v) const;
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
void _LIBCPP_HIDE_FROM_ABI operator%=(const _Expr& __v) const;
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
void _LIBCPP_HIDE_FROM_ABI operator+=(const _Expr& __v) const;
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
void _LIBCPP_HIDE_FROM_ABI operator-=(const _Expr& __v) const;
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
void _LIBCPP_HIDE_FROM_ABI operator^=(const _Expr& __v) const;
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
void _LIBCPP_HIDE_FROM_ABI operator&=(const _Expr& __v) const;
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
void _LIBCPP_HIDE_FROM_ABI operator|=(const _Expr& __v) const;
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
void _LIBCPP_HIDE_FROM_ABI operator<<=(const _Expr& __v) const;
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
void _LIBCPP_HIDE_FROM_ABI operator>>=(const _Expr& __v) const;
mask_array(const mask_array&) = default;
_LIBCPP_HIDE_FROM_ABI const mask_array& operator=(const mask_array& __ma) const;
_LIBCPP_HIDE_FROM_ABI void operator=(const value_type& __x) const;
// Behaves like __val_expr::operator[], which returns by value.
_LIBCPP_HIDE_FROM_ABI value_type __get(size_t __i) const {
_LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(__i < __1d_.size(), "mask_array.__get() index out of bounds");
return __vp_[__1d_[__i]];
}
private:
_LIBCPP_HIDE_FROM_ABI mask_array(const valarray<bool>& __vb, const valarray<value_type>& __v)
: __vp_(const_cast<value_type*>(__v.__begin_)),
__1d_(static_cast<size_t>(count(__vb.__begin_, __vb.__end_, true))) {
size_t __j = 0;
for (size_t __i = 0; __i < __vb.size(); ++__i)
if (__vb[__i])
__1d_[__j++] = __i;
}
template <class>
friend class valarray;
};
template <class _Tp>
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
inline void mask_array<_Tp>::operator=(const _Expr& __v) const {
size_t __n = __1d_.size();
for (size_t __i = 0; __i < __n; ++__i)
__vp_[__1d_[__i]] = __v[__i];
}
template <class _Tp>
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
inline void mask_array<_Tp>::operator*=(const _Expr& __v) const {
size_t __n = __1d_.size();
for (size_t __i = 0; __i < __n; ++__i)
__vp_[__1d_[__i]] *= __v[__i];
}
template <class _Tp>
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
inline void mask_array<_Tp>::operator/=(const _Expr& __v) const {
size_t __n = __1d_.size();
for (size_t __i = 0; __i < __n; ++__i)
__vp_[__1d_[__i]] /= __v[__i];
}
template <class _Tp>
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
inline void mask_array<_Tp>::operator%=(const _Expr& __v) const {
size_t __n = __1d_.size();
for (size_t __i = 0; __i < __n; ++__i)
__vp_[__1d_[__i]] %= __v[__i];
}
template <class _Tp>
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
inline void mask_array<_Tp>::operator+=(const _Expr& __v) const {
size_t __n = __1d_.size();
for (size_t __i = 0; __i < __n; ++__i)
__vp_[__1d_[__i]] += __v[__i];
}
template <class _Tp>
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
inline void mask_array<_Tp>::operator-=(const _Expr& __v) const {
size_t __n = __1d_.size();
for (size_t __i = 0; __i < __n; ++__i)
__vp_[__1d_[__i]] -= __v[__i];
}
template <class _Tp>
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
inline void mask_array<_Tp>::operator^=(const _Expr& __v) const {
size_t __n = __1d_.size();
for (size_t __i = 0; __i < __n; ++__i)
__vp_[__1d_[__i]] ^= __v[__i];
}
template <class _Tp>
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
inline void mask_array<_Tp>::operator&=(const _Expr& __v) const {
size_t __n = __1d_.size();
for (size_t __i = 0; __i < __n; ++__i)
__vp_[__1d_[__i]] &= __v[__i];
}
template <class _Tp>
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
inline void mask_array<_Tp>::operator|=(const _Expr& __v) const {
size_t __n = __1d_.size();
for (size_t __i = 0; __i < __n; ++__i)
__vp_[__1d_[__i]] |= __v[__i];
}
template <class _Tp>
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
inline void mask_array<_Tp>::operator<<=(const _Expr& __v) const {
size_t __n = __1d_.size();
for (size_t __i = 0; __i < __n; ++__i)
__vp_[__1d_[__i]] <<= __v[__i];
}
template <class _Tp>
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
inline void mask_array<_Tp>::operator>>=(const _Expr& __v) const {
size_t __n = __1d_.size();
for (size_t __i = 0; __i < __n; ++__i)
__vp_[__1d_[__i]] >>= __v[__i];
}
template <class _Tp>
inline const mask_array<_Tp>& mask_array<_Tp>::operator=(const mask_array& __ma) const {
size_t __n = __1d_.size();
for (size_t __i = 0; __i < __n; ++__i)
__vp_[__1d_[__i]] = __ma.__vp_[__1d_[__i]];
return *this;
}
template <class _Tp>
inline void mask_array<_Tp>::operator=(const value_type& __x) const {
size_t __n = __1d_.size();
for (size_t __i = 0; __i < __n; ++__i)
__vp_[__1d_[__i]] = __x;
}
template <class _ValExpr>
class __mask_expr {
typedef __libcpp_remove_reference_t<_ValExpr> _RmExpr;
public:
typedef typename _RmExpr::value_type value_type;
typedef value_type __result_type;
private:
_ValExpr __expr_;
valarray<size_t> __1d_;
_LIBCPP_HIDE_FROM_ABI __mask_expr(const valarray<bool>& __vb, const _RmExpr& __e)
: __expr_(__e), __1d_(static_cast<size_t>(count(__vb.__begin_, __vb.__end_, true))) {
size_t __j = 0;
for (size_t __i = 0; __i < __vb.size(); ++__i)
if (__vb[__i])
__1d_[__j++] = __i;
}
public:
_LIBCPP_HIDE_FROM_ABI __result_type operator[](size_t __i) const { return __expr_[__1d_[__i]]; }
_LIBCPP_HIDE_FROM_ABI size_t size() const { return __1d_.size(); }
template <class>
friend class __val_expr;
template <class>
friend class valarray;
};
// indirect_array
template <class _Tp>
class _LIBCPP_TEMPLATE_VIS indirect_array {
public:
typedef _Tp value_type;
private:
value_type* __vp_;
valarray<size_t> __1d_;
public:
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
void _LIBCPP_HIDE_FROM_ABI operator=(const _Expr& __v) const;
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
void _LIBCPP_HIDE_FROM_ABI operator*=(const _Expr& __v) const;
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
void _LIBCPP_HIDE_FROM_ABI operator/=(const _Expr& __v) const;
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
void _LIBCPP_HIDE_FROM_ABI operator%=(const _Expr& __v) const;
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
void _LIBCPP_HIDE_FROM_ABI operator+=(const _Expr& __v) const;
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
void _LIBCPP_HIDE_FROM_ABI operator-=(const _Expr& __v) const;
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
void _LIBCPP_HIDE_FROM_ABI operator^=(const _Expr& __v) const;
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
void _LIBCPP_HIDE_FROM_ABI operator&=(const _Expr& __v) const;
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
void _LIBCPP_HIDE_FROM_ABI operator|=(const _Expr& __v) const;
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
void _LIBCPP_HIDE_FROM_ABI operator<<=(const _Expr& __v) const;
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
void _LIBCPP_HIDE_FROM_ABI operator>>=(const _Expr& __v) const;
indirect_array(const indirect_array&) = default;
_LIBCPP_HIDE_FROM_ABI const indirect_array& operator=(const indirect_array& __ia) const;
_LIBCPP_HIDE_FROM_ABI void operator=(const value_type& __x) const;
// Behaves like __val_expr::operator[], which returns by value.
_LIBCPP_HIDE_FROM_ABI value_type __get(size_t __i) const {
_LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(__i < __1d_.size(), "indirect_array.__get() index out of bounds");
return __vp_[__1d_[__i]];
}
private:
_LIBCPP_HIDE_FROM_ABI indirect_array(const valarray<size_t>& __ia, const valarray<value_type>& __v)
: __vp_(const_cast<value_type*>(__v.__begin_)), __1d_(__ia) {}
#ifndef _LIBCPP_CXX03_LANG
_LIBCPP_HIDE_FROM_ABI indirect_array(valarray<size_t>&& __ia, const valarray<value_type>& __v)
: __vp_(const_cast<value_type*>(__v.__begin_)), __1d_(std::move(__ia)) {}
#endif // _LIBCPP_CXX03_LANG
template <class>
friend class valarray;
};
template <class _Tp>
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
inline void indirect_array<_Tp>::operator=(const _Expr& __v) const {
size_t __n = __1d_.size();
for (size_t __i = 0; __i < __n; ++__i)
__vp_[__1d_[__i]] = __v[__i];
}
template <class _Tp>
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
inline void indirect_array<_Tp>::operator*=(const _Expr& __v) const {
size_t __n = __1d_.size();
for (size_t __i = 0; __i < __n; ++__i)
__vp_[__1d_[__i]] *= __v[__i];
}
template <class _Tp>
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
inline void indirect_array<_Tp>::operator/=(const _Expr& __v) const {
size_t __n = __1d_.size();
for (size_t __i = 0; __i < __n; ++__i)
__vp_[__1d_[__i]] /= __v[__i];
}
template <class _Tp>
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
inline void indirect_array<_Tp>::operator%=(const _Expr& __v) const {
size_t __n = __1d_.size();
for (size_t __i = 0; __i < __n; ++__i)
__vp_[__1d_[__i]] %= __v[__i];
}
template <class _Tp>
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
inline void indirect_array<_Tp>::operator+=(const _Expr& __v) const {
size_t __n = __1d_.size();
for (size_t __i = 0; __i < __n; ++__i)
__vp_[__1d_[__i]] += __v[__i];
}
template <class _Tp>
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
inline void indirect_array<_Tp>::operator-=(const _Expr& __v) const {
size_t __n = __1d_.size();
for (size_t __i = 0; __i < __n; ++__i)
__vp_[__1d_[__i]] -= __v[__i];
}
template <class _Tp>
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
inline void indirect_array<_Tp>::operator^=(const _Expr& __v) const {
size_t __n = __1d_.size();
for (size_t __i = 0; __i < __n; ++__i)
__vp_[__1d_[__i]] ^= __v[__i];
}
template <class _Tp>
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
inline void indirect_array<_Tp>::operator&=(const _Expr& __v) const {
size_t __n = __1d_.size();
for (size_t __i = 0; __i < __n; ++__i)
__vp_[__1d_[__i]] &= __v[__i];
}
template <class _Tp>
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
inline void indirect_array<_Tp>::operator|=(const _Expr& __v) const {
size_t __n = __1d_.size();
for (size_t __i = 0; __i < __n; ++__i)
__vp_[__1d_[__i]] |= __v[__i];
}
template <class _Tp>
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
inline void indirect_array<_Tp>::operator<<=(const _Expr& __v) const {
size_t __n = __1d_.size();
for (size_t __i = 0; __i < __n; ++__i)
__vp_[__1d_[__i]] <<= __v[__i];
}
template <class _Tp>
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
inline void indirect_array<_Tp>::operator>>=(const _Expr& __v) const {
size_t __n = __1d_.size();
for (size_t __i = 0; __i < __n; ++__i)
__vp_[__1d_[__i]] >>= __v[__i];
}
template <class _Tp>
inline const indirect_array<_Tp>& indirect_array<_Tp>::operator=(const indirect_array& __ia) const {
typedef const size_t* _Ip;
const value_type* __s = __ia.__vp_;
for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_, __j = __ia.__1d_.__begin_; __i != __e; ++__i, ++__j)
__vp_[*__i] = __s[*__j];
return *this;
}
template <class _Tp>
inline void indirect_array<_Tp>::operator=(const value_type& __x) const {
typedef const size_t* _Ip;
for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i)
__vp_[*__i] = __x;
}
template <class _ValExpr>
class __indirect_expr {
typedef __libcpp_remove_reference_t<_ValExpr> _RmExpr;
public:
typedef typename _RmExpr::value_type value_type;
typedef value_type __result_type;
private:
_ValExpr __expr_;
valarray<size_t> __1d_;
_LIBCPP_HIDE_FROM_ABI __indirect_expr(const valarray<size_t>& __ia, const _RmExpr& __e) : __expr_(__e), __1d_(__ia) {}
#ifndef _LIBCPP_CXX03_LANG
_LIBCPP_HIDE_FROM_ABI __indirect_expr(valarray<size_t>&& __ia, const _RmExpr& __e)
: __expr_(__e), __1d_(std::move(__ia)) {}
#endif // _LIBCPP_CXX03_LANG
public:
_LIBCPP_HIDE_FROM_ABI __result_type operator[](size_t __i) const { return __expr_[__1d_[__i]]; }
_LIBCPP_HIDE_FROM_ABI size_t size() const { return __1d_.size(); }
template <class>
friend class __val_expr;
template <class>
friend class _LIBCPP_TEMPLATE_VIS valarray;
};
template <class _ValExpr>
class __val_expr {
typedef __libcpp_remove_reference_t<_ValExpr> _RmExpr;
_ValExpr __expr_;
public:
typedef typename _RmExpr::value_type value_type;
typedef typename _RmExpr::__result_type __result_type;
_LIBCPP_HIDE_FROM_ABI explicit __val_expr(const _RmExpr& __e) : __expr_(__e) {}
_LIBCPP_HIDE_FROM_ABI __result_type operator[](size_t __i) const { return __expr_[__i]; }
_LIBCPP_HIDE_FROM_ABI __val_expr<__slice_expr<_ValExpr> > operator[](slice __s) const {
typedef __slice_expr<_ValExpr> _NewExpr;
return __val_expr< _NewExpr >(_NewExpr(__s, __expr_));
}
_LIBCPP_HIDE_FROM_ABI __val_expr<__indirect_expr<_ValExpr> > operator[](const gslice& __gs) const {
typedef __indirect_expr<_ValExpr> _NewExpr;
return __val_expr<_NewExpr >(_NewExpr(__gs.__1d_, __expr_));
}
_LIBCPP_HIDE_FROM_ABI __val_expr<__mask_expr<_ValExpr> > operator[](const valarray<bool>& __vb) const {
typedef __mask_expr<_ValExpr> _NewExpr;
return __val_expr< _NewExpr >(_NewExpr(__vb, __expr_));
}
_LIBCPP_HIDE_FROM_ABI __val_expr<__indirect_expr<_ValExpr> > operator[](const valarray<size_t>& __vs) const {
typedef __indirect_expr<_ValExpr> _NewExpr;
return __val_expr< _NewExpr >(_NewExpr(__vs, __expr_));
}
_LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__unary_plus<value_type>, _ValExpr> > operator+() const {
typedef _UnaryOp<__unary_plus<value_type>, _ValExpr> _NewExpr;
return __val_expr<_NewExpr>(_NewExpr(__unary_plus<value_type>(), __expr_));
}
_LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<negate<value_type>, _ValExpr> > operator-() const {
typedef _UnaryOp<negate<value_type>, _ValExpr> _NewExpr;
return __val_expr<_NewExpr>(_NewExpr(negate<value_type>(), __expr_));
}
_LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__bit_not<value_type>, _ValExpr> > operator~() const {
typedef _UnaryOp<__bit_not<value_type>, _ValExpr> _NewExpr;
return __val_expr<_NewExpr>(_NewExpr(__bit_not<value_type>(), __expr_));
}
_LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<logical_not<value_type>, _ValExpr> > operator!() const {
typedef _UnaryOp<logical_not<value_type>, _ValExpr> _NewExpr;
return __val_expr<_NewExpr>(_NewExpr(logical_not<value_type>(), __expr_));
}
operator valarray<__result_type>() const;
_LIBCPP_HIDE_FROM_ABI size_t size() const { return __expr_.size(); }
_LIBCPP_HIDE_FROM_ABI __result_type sum() const {
size_t __n = __expr_.size();
__result_type __r = __n ? __expr_[0] : __result_type();
for (size_t __i = 1; __i < __n; ++__i)
__r += __expr_[__i];
return __r;
}
_LIBCPP_HIDE_FROM_ABI __result_type min() const {
size_t __n = size();
__result_type __r = __n ? (*this)[0] : __result_type();
for (size_t __i = 1; __i < __n; ++__i) {
__result_type __x = __expr_[__i];
if (__x < __r)
__r = __x;
}
return __r;
}
_LIBCPP_HIDE_FROM_ABI __result_type max() const {
size_t __n = size();
__result_type __r = __n ? (*this)[0] : __result_type();
for (size_t __i = 1; __i < __n; ++__i) {
__result_type __x = __expr_[__i];
if (__r < __x)
__r = __x;
}
return __r;
}
_LIBCPP_HIDE_FROM_ABI __val_expr<__shift_expr<_ValExpr> > shift(int __i) const {
return __val_expr<__shift_expr<_ValExpr> >(__shift_expr<_ValExpr>(__i, __expr_));
}
_LIBCPP_HIDE_FROM_ABI __val_expr<__cshift_expr<_ValExpr> > cshift(int __i) const {
return __val_expr<__cshift_expr<_ValExpr> >(__cshift_expr<_ValExpr>(__i, __expr_));
}
_LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__apply_expr<value_type, value_type (*)(value_type)>, _ValExpr> >
apply(value_type __f(value_type)) const {
typedef __apply_expr<value_type, value_type (*)(value_type)> _Op;
typedef _UnaryOp<_Op, _ValExpr> _NewExpr;
return __val_expr<_NewExpr>(_NewExpr(_Op(__f), __expr_));
}
_LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__apply_expr<value_type, value_type (*)(const value_type&)>, _ValExpr> >
apply(value_type __f(const value_type&)) const {
typedef __apply_expr<value_type, value_type (*)(const value_type&)> _Op;
typedef _UnaryOp<_Op, _ValExpr> _NewExpr;
return __val_expr<_NewExpr>(_NewExpr(_Op(__f), __expr_));
}
};
template <class _ValExpr>
__val_expr<_ValExpr>::operator valarray<__val_expr::__result_type>() const {
valarray<__result_type> __r;
size_t __n = __expr_.size();
if (__n) {
__r.__begin_ = __r.__end_ = allocator<__result_type>().allocate(__n);
for (size_t __i = 0; __i != __n; ++__r.__end_, ++__i)
::new ((void*)__r.__end_) __result_type(__expr_[__i]);
}
return __r;
}
// valarray
template <class _Tp>
inline valarray<_Tp>::valarray(size_t __n) : __begin_(nullptr), __end_(nullptr) {
if (__n) {
__begin_ = __end_ = allocator<value_type>().allocate(__n);
#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
try {
#endif // _LIBCPP_HAS_NO_EXCEPTIONS
for (size_t __n_left = __n; __n_left; --__n_left, ++__end_)
::new ((void*)__end_) value_type();
#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
} catch (...) {
__clear(__n);
throw;
}
#endif // _LIBCPP_HAS_NO_EXCEPTIONS
}
}
template <class _Tp>
inline valarray<_Tp>::valarray(const value_type& __x, size_t __n) : __begin_(nullptr), __end_(nullptr) {
resize(__n, __x);
}
template <class _Tp>
valarray<_Tp>::valarray(const value_type* __p, size_t __n) : __begin_(nullptr), __end_(nullptr) {
if (__n) {
__begin_ = __end_ = allocator<value_type>().allocate(__n);
#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
try {
#endif // _LIBCPP_HAS_NO_EXCEPTIONS
for (size_t __n_left = __n; __n_left; ++__end_, ++__p, --__n_left)
::new ((void*)__end_) value_type(*__p);
#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
} catch (...) {
__clear(__n);
throw;
}
#endif // _LIBCPP_HAS_NO_EXCEPTIONS
}
}
template <class _Tp>
valarray<_Tp>::valarray(const valarray& __v) : __begin_(nullptr), __end_(nullptr) {
if (__v.size()) {
__begin_ = __end_ = allocator<value_type>().allocate(__v.size());
#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
try {
#endif // _LIBCPP_HAS_NO_EXCEPTIONS
for (value_type* __p = __v.__begin_; __p != __v.__end_; ++__end_, ++__p)
::new ((void*)__end_) value_type(*__p);
#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
} catch (...) {
__clear(__v.size());
throw;
}
#endif // _LIBCPP_HAS_NO_EXCEPTIONS
}
}
#ifndef _LIBCPP_CXX03_LANG
template <class _Tp>
inline valarray<_Tp>::valarray(valarray&& __v) _NOEXCEPT : __begin_(__v.__begin_), __end_(__v.__end_) {
__v.__begin_ = __v.__end_ = nullptr;
}
template <class _Tp>
valarray<_Tp>::valarray(initializer_list<value_type> __il) : __begin_(nullptr), __end_(nullptr) {
const size_t __n = __il.size();
if (__n) {
__begin_ = __end_ = allocator<value_type>().allocate(__n);
# ifndef _LIBCPP_HAS_NO_EXCEPTIONS
try {
# endif // _LIBCPP_HAS_NO_EXCEPTIONS
size_t __n_left = __n;
for (const value_type* __p = __il.begin(); __n_left; ++__end_, ++__p, --__n_left)
::new ((void*)__end_) value_type(*__p);
# ifndef _LIBCPP_HAS_NO_EXCEPTIONS
} catch (...) {
__clear(__n);
throw;
}
# endif // _LIBCPP_HAS_NO_EXCEPTIONS
}
}
#endif // _LIBCPP_CXX03_LANG
template <class _Tp>
valarray<_Tp>::valarray(const slice_array<value_type>& __sa) : __begin_(nullptr), __end_(nullptr) {
const size_t __n = __sa.__size_;
if (__n) {
__begin_ = __end_ = allocator<value_type>().allocate(__n);
#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
try {
#endif // _LIBCPP_HAS_NO_EXCEPTIONS
size_t __n_left = __n;
for (const value_type* __p = __sa.__vp_; __n_left; ++__end_, __p += __sa.__stride_, --__n_left)
::new ((void*)__end_) value_type(*__p);
#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
} catch (...) {
__clear(__n);
throw;
}
#endif // _LIBCPP_HAS_NO_EXCEPTIONS
}
}
template <class _Tp>
valarray<_Tp>::valarray(const gslice_array<value_type>& __ga) : __begin_(nullptr), __end_(nullptr) {
const size_t __n = __ga.__1d_.size();
if (__n) {
__begin_ = __end_ = allocator<value_type>().allocate(__n);
#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
try {
#endif // _LIBCPP_HAS_NO_EXCEPTIONS
typedef const size_t* _Ip;
const value_type* __s = __ga.__vp_;
for (_Ip __i = __ga.__1d_.__begin_, __e = __ga.__1d_.__end_; __i != __e; ++__i, ++__end_)
::new ((void*)__end_) value_type(__s[*__i]);
#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
} catch (...) {
__clear(__n);
throw;
}
#endif // _LIBCPP_HAS_NO_EXCEPTIONS
}
}
template <class _Tp>
valarray<_Tp>::valarray(const mask_array<value_type>& __ma) : __begin_(nullptr), __end_(nullptr) {
const size_t __n = __ma.__1d_.size();
if (__n) {
__begin_ = __end_ = allocator<value_type>().allocate(__n);
#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
try {
#endif // _LIBCPP_HAS_NO_EXCEPTIONS
typedef const size_t* _Ip;
const value_type* __s = __ma.__vp_;
for (_Ip __i = __ma.__1d_.__begin_, __e = __ma.__1d_.__end_; __i != __e; ++__i, ++__end_)
::new ((void*)__end_) value_type(__s[*__i]);
#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
} catch (...) {
__clear(__n);
throw;
}
#endif // _LIBCPP_HAS_NO_EXCEPTIONS
}
}
template <class _Tp>
valarray<_Tp>::valarray(const indirect_array<value_type>& __ia) : __begin_(nullptr), __end_(nullptr) {
const size_t __n = __ia.__1d_.size();
if (__n) {
__begin_ = __end_ = allocator<value_type>().allocate(__n);
#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
try {
#endif // _LIBCPP_HAS_NO_EXCEPTIONS
typedef const size_t* _Ip;
const value_type* __s = __ia.__vp_;
for (_Ip __i = __ia.__1d_.__begin_, __e = __ia.__1d_.__end_; __i != __e; ++__i, ++__end_)
::new ((void*)__end_) value_type(__s[*__i]);
#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
} catch (...) {
__clear(__n);
throw;
}
#endif // _LIBCPP_HAS_NO_EXCEPTIONS
}
}
template <class _Tp>
inline valarray<_Tp>::~valarray() {
__clear(size());
}
template <class _Tp>
valarray<_Tp>& valarray<_Tp>::__assign_range(const value_type* __f, const value_type* __l) {
size_t __n = __l - __f;
if (size() != __n) {
__clear(size());
__begin_ = allocator<value_type>().allocate(__n);
__end_ = __begin_ + __n;
std::uninitialized_copy(__f, __l, __begin_);
} else {
std::copy(__f, __l, __begin_);
}
return *this;
}
template <class _Tp>
valarray<_Tp>& valarray<_Tp>::operator=(const valarray& __v) {
if (this != std::addressof(__v))
return __assign_range(__v.__begin_, __v.__end_);
return *this;
}
#ifndef _LIBCPP_CXX03_LANG
template <class _Tp>
inline valarray<_Tp>& valarray<_Tp>::operator=(valarray&& __v) _NOEXCEPT {
__clear(size());
__begin_ = __v.__begin_;
__end_ = __v.__end_;
__v.__begin_ = nullptr;
__v.__end_ = nullptr;
return *this;
}
template <class _Tp>
inline valarray<_Tp>& valarray<_Tp>::operator=(initializer_list<value_type> __il) {
return __assign_range(__il.begin(), __il.end());
}
#endif // _LIBCPP_CXX03_LANG
template <class _Tp>
inline valarray<_Tp>& valarray<_Tp>::operator=(const value_type& __x) {
std::fill(__begin_, __end_, __x);
return *this;
}
template <class _Tp>
inline valarray<_Tp>& valarray<_Tp>::operator=(const slice_array<value_type>& __sa) {
value_type* __t = __begin_;
const value_type* __s = __sa.__vp_;
for (size_t __n = __sa.__size_; __n; --__n, __s += __sa.__stride_, ++__t)
*__t = *__s;
return *this;
}
template <class _Tp>
inline valarray<_Tp>& valarray<_Tp>::operator=(const gslice_array<value_type>& __ga) {
typedef const size_t* _Ip;
value_type* __t = __begin_;
const value_type* __s = __ga.__vp_;
for (_Ip __i = __ga.__1d_.__begin_, __e = __ga.__1d_.__end_; __i != __e; ++__i, ++__t)
*__t = __s[*__i];
return *this;
}
template <class _Tp>
inline valarray<_Tp>& valarray<_Tp>::operator=(const mask_array<value_type>& __ma) {
typedef const size_t* _Ip;
value_type* __t = __begin_;
const value_type* __s = __ma.__vp_;
for (_Ip __i = __ma.__1d_.__begin_, __e = __ma.__1d_.__end_; __i != __e; ++__i, ++__t)
*__t = __s[*__i];
return *this;
}
template <class _Tp>
inline valarray<_Tp>& valarray<_Tp>::operator=(const indirect_array<value_type>& __ia) {
typedef const size_t* _Ip;
value_type* __t = __begin_;
const value_type* __s = __ia.__vp_;
for (_Ip __i = __ia.__1d_.__begin_, __e = __ia.__1d_.__end_; __i != __e; ++__i, ++__t)
*__t = __s[*__i];
return *this;
}
template <class _Tp>
template <class _ValExpr>
inline valarray<_Tp>& valarray<_Tp>::operator=(const __val_expr<_ValExpr>& __v) {
size_t __n = __v.size();
if (size() != __n)
resize(__n);
value_type* __t = __begin_;
for (size_t __i = 0; __i != __n; ++__t, ++__i)
*__t = __result_type(__v[__i]);
return *this;
}
template <class _Tp>
inline __val_expr<__slice_expr<const valarray<_Tp>&> > valarray<_Tp>::operator[](slice __s) const {
return __val_expr<__slice_expr<const valarray&> >(__slice_expr<const valarray&>(__s, *this));
}
template <class _Tp>
inline slice_array<_Tp> valarray<_Tp>::operator[](slice __s) {
return slice_array<value_type>(__s, *this);
}
template <class _Tp>
inline __val_expr<__indirect_expr<const valarray<_Tp>&> > valarray<_Tp>::operator[](const gslice& __gs) const {
return __val_expr<__indirect_expr<const valarray&> >(__indirect_expr<const valarray&>(__gs.__1d_, *this));
}
template <class _Tp>
inline gslice_array<_Tp> valarray<_Tp>::operator[](const gslice& __gs) {
return gslice_array<value_type>(__gs, *this);
}
#ifndef _LIBCPP_CXX03_LANG
template <class _Tp>
inline __val_expr<__indirect_expr<const valarray<_Tp>&> > valarray<_Tp>::operator[](gslice&& __gs) const {
return __val_expr<__indirect_expr<const valarray&> >(__indirect_expr<const valarray&>(std::move(__gs.__1d_), *this));
}
template <class _Tp>
inline gslice_array<_Tp> valarray<_Tp>::operator[](gslice&& __gs) {
return gslice_array<value_type>(std::move(__gs), *this);
}
#endif // _LIBCPP_CXX03_LANG
template <class _Tp>
inline __val_expr<__mask_expr<const valarray<_Tp>&> > valarray<_Tp>::operator[](const valarray<bool>& __vb) const {
return __val_expr<__mask_expr<const valarray&> >(__mask_expr<const valarray&>(__vb, *this));
}
template <class _Tp>
inline mask_array<_Tp> valarray<_Tp>::operator[](const valarray<bool>& __vb) {
return mask_array<value_type>(__vb, *this);
}
#ifndef _LIBCPP_CXX03_LANG
template <class _Tp>
inline __val_expr<__mask_expr<const valarray<_Tp>&> > valarray<_Tp>::operator[](valarray<bool>&& __vb) const {
return __val_expr<__mask_expr<const valarray&> >(__mask_expr<const valarray&>(std::move(__vb), *this));
}
template <class _Tp>
inline mask_array<_Tp> valarray<_Tp>::operator[](valarray<bool>&& __vb) {
return mask_array<value_type>(std::move(__vb), *this);
}
#endif // _LIBCPP_CXX03_LANG
template <class _Tp>
inline __val_expr<__indirect_expr<const valarray<_Tp>&> >
valarray<_Tp>::operator[](const valarray<size_t>& __vs) const {
return __val_expr<__indirect_expr<const valarray&> >(__indirect_expr<const valarray&>(__vs, *this));
}
template <class _Tp>
inline indirect_array<_Tp> valarray<_Tp>::operator[](const valarray<size_t>& __vs) {
return indirect_array<value_type>(__vs, *this);
}
#ifndef _LIBCPP_CXX03_LANG
template <class _Tp>
inline __val_expr<__indirect_expr<const valarray<_Tp>&> > valarray<_Tp>::operator[](valarray<size_t>&& __vs) const {
return __val_expr<__indirect_expr<const valarray&> >(__indirect_expr<const valarray&>(std::move(__vs), *this));
}
template <class _Tp>
inline indirect_array<_Tp> valarray<_Tp>::operator[](valarray<size_t>&& __vs) {
return indirect_array<value_type>(std::move(__vs), *this);
}
#endif // _LIBCPP_CXX03_LANG
template <class _Tp>
inline __val_expr<_UnaryOp<__unary_plus<_Tp>, const valarray<_Tp>&> > valarray<_Tp>::operator+() const {
using _Op = _UnaryOp<__unary_plus<_Tp>, const valarray<_Tp>&>;
return __val_expr<_Op>(_Op(__unary_plus<_Tp>(), *this));
}
template <class _Tp>
inline __val_expr<_UnaryOp<negate<_Tp>, const valarray<_Tp>&> > valarray<_Tp>::operator-() const {
using _Op = _UnaryOp<negate<_Tp>, const valarray<_Tp>&>;
return __val_expr<_Op>(_Op(negate<_Tp>(), *this));
}
template <class _Tp>
inline __val_expr<_UnaryOp<__bit_not<_Tp>, const valarray<_Tp>&> > valarray<_Tp>::operator~() const {
using _Op = _UnaryOp<__bit_not<_Tp>, const valarray<_Tp>&>;
return __val_expr<_Op>(_Op(__bit_not<_Tp>(), *this));
}
template <class _Tp>
inline __val_expr<_UnaryOp<logical_not<_Tp>, const valarray<_Tp>&> > valarray<_Tp>::operator!() const {
using _Op = _UnaryOp<logical_not<_Tp>, const valarray<_Tp>&>;
return __val_expr<_Op>(_Op(logical_not<_Tp>(), *this));
}
template <class _Tp>
inline valarray<_Tp>& valarray<_Tp>::operator*=(const value_type& __x) {
for (value_type* __p = __begin_; __p != __end_; ++__p)
*__p *= __x;
return *this;
}
template <class _Tp>
inline valarray<_Tp>& valarray<_Tp>::operator/=(const value_type& __x) {
for (value_type* __p = __begin_; __p != __end_; ++__p)
*__p /= __x;
return *this;
}
template <class _Tp>
inline valarray<_Tp>& valarray<_Tp>::operator%=(const value_type& __x) {
for (value_type* __p = __begin_; __p != __end_; ++__p)
*__p %= __x;
return *this;
}
template <class _Tp>
inline valarray<_Tp>& valarray<_Tp>::operator+=(const value_type& __x) {
for (value_type* __p = __begin_; __p != __end_; ++__p)
*__p += __x;
return *this;
}
template <class _Tp>
inline valarray<_Tp>& valarray<_Tp>::operator-=(const value_type& __x) {
for (value_type* __p = __begin_; __p != __end_; ++__p)
*__p -= __x;
return *this;
}
template <class _Tp>
inline valarray<_Tp>& valarray<_Tp>::operator^=(const value_type& __x) {
for (value_type* __p = __begin_; __p != __end_; ++__p)
*__p ^= __x;
return *this;
}
template <class _Tp>
inline valarray<_Tp>& valarray<_Tp>::operator&=(const value_type& __x) {
for (value_type* __p = __begin_; __p != __end_; ++__p)
*__p &= __x;
return *this;
}
template <class _Tp>
inline valarray<_Tp>& valarray<_Tp>::operator|=(const value_type& __x) {
for (value_type* __p = __begin_; __p != __end_; ++__p)
*__p |= __x;
return *this;
}
template <class _Tp>
inline valarray<_Tp>& valarray<_Tp>::operator<<=(const value_type& __x) {
for (value_type* __p = __begin_; __p != __end_; ++__p)
*__p <<= __x;
return *this;
}
template <class _Tp>
inline valarray<_Tp>& valarray<_Tp>::operator>>=(const value_type& __x) {
for (value_type* __p = __begin_; __p != __end_; ++__p)
*__p >>= __x;
return *this;
}
template <class _Tp>
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
inline valarray<_Tp>& valarray<_Tp>::operator*=(const _Expr& __v) {
size_t __i = 0;
for (value_type* __t = __begin_; __t != __end_; ++__t, ++__i)
*__t *= std::__get(__v, __i);
return *this;
}
template <class _Tp>
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
inline valarray<_Tp>& valarray<_Tp>::operator/=(const _Expr& __v) {
size_t __i = 0;
for (value_type* __t = __begin_; __t != __end_; ++__t, ++__i)
*__t /= std::__get(__v, __i);
return *this;
}
template <class _Tp>
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
inline valarray<_Tp>& valarray<_Tp>::operator%=(const _Expr& __v) {
size_t __i = 0;
for (value_type* __t = __begin_; __t != __end_; ++__t, ++__i)
*__t %= std::__get(__v, __i);
return *this;
}
template <class _Tp>
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
inline valarray<_Tp>& valarray<_Tp>::operator+=(const _Expr& __v) {
size_t __i = 0;
for (value_type* __t = __begin_; __t != __end_; ++__t, ++__i)
*__t += std::__get(__v, __i);
return *this;
}
template <class _Tp>
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
inline valarray<_Tp>& valarray<_Tp>::operator-=(const _Expr& __v) {
size_t __i = 0;
for (value_type* __t = __begin_; __t != __end_; ++__t, ++__i)
*__t -= std::__get(__v, __i);
return *this;
}
template <class _Tp>
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
inline valarray<_Tp>& valarray<_Tp>::operator^=(const _Expr& __v) {
size_t __i = 0;
for (value_type* __t = __begin_; __t != __end_; ++__t, ++__i)
*__t ^= std::__get(__v, __i);
return *this;
}
template <class _Tp>
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
inline valarray<_Tp>& valarray<_Tp>::operator|=(const _Expr& __v) {
size_t __i = 0;
for (value_type* __t = __begin_; __t != __end_; ++__t, ++__i)
*__t |= std::__get(__v, __i);
return *this;
}
template <class _Tp>
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
inline valarray<_Tp>& valarray<_Tp>::operator&=(const _Expr& __v) {
size_t __i = 0;
for (value_type* __t = __begin_; __t != __end_; ++__t, ++__i)
*__t &= std::__get(__v, __i);
return *this;
}
template <class _Tp>
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
inline valarray<_Tp>& valarray<_Tp>::operator<<=(const _Expr& __v) {
size_t __i = 0;
for (value_type* __t = __begin_; __t != __end_; ++__t, ++__i)
*__t <<= std::__get(__v, __i);
return *this;
}
template <class _Tp>
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
inline valarray<_Tp>& valarray<_Tp>::operator>>=(const _Expr& __v) {
size_t __i = 0;
for (value_type* __t = __begin_; __t != __end_; ++__t, ++__i)
*__t >>= std::__get(__v, __i);
return *this;
}
template <class _Tp>
inline void valarray<_Tp>::swap(valarray& __v) _NOEXCEPT {
std::swap(__begin_, __v.__begin_);
std::swap(__end_, __v.__end_);
}
template <class _Tp>
inline _Tp valarray<_Tp>::sum() const {
if (__begin_ == __end_)
return value_type();
const value_type* __p = __begin_;
_Tp __r = *__p;
for (++__p; __p != __end_; ++__p)
__r += *__p;
return __r;
}
template <class _Tp>
inline _Tp valarray<_Tp>::min() const {
if (__begin_ == __end_)
return value_type();
return *std::min_element(__begin_, __end_);
}
template <class _Tp>
inline _Tp valarray<_Tp>::max() const {
if (__begin_ == __end_)
return value_type();
return *std::max_element(__begin_, __end_);
}
template <class _Tp>
valarray<_Tp> valarray<_Tp>::shift(int __i) const {
valarray<value_type> __r;
size_t __n = size();
if (__n) {
__r.__begin_ = __r.__end_ = allocator<value_type>().allocate(__n);
const value_type* __sb;
value_type* __tb;
value_type* __te;
if (__i >= 0) {
__i = std::min(__i, static_cast<int>(__n));
__sb = __begin_ + __i;
__tb = __r.__begin_;
__te = __r.__begin_ + (__n - __i);
} else {
__i = std::min(-__i, static_cast<int>(__n));
__sb = __begin_;
__tb = __r.__begin_ + __i;
__te = __r.__begin_ + __n;
}
for (; __r.__end_ != __tb; ++__r.__end_)
::new ((void*)__r.__end_) value_type();
for (; __r.__end_ != __te; ++__r.__end_, ++__sb)
::new ((void*)__r.__end_) value_type(*__sb);
for (__te = __r.__begin_ + __n; __r.__end_ != __te; ++__r.__end_)
::new ((void*)__r.__end_) value_type();
}
return __r;
}
template <class _Tp>
valarray<_Tp> valarray<_Tp>::cshift(int __i) const {
valarray<value_type> __r;
size_t __n = size();
if (__n) {
__r.__begin_ = __r.__end_ = allocator<value_type>().allocate(__n);
__i %= static_cast<int>(__n);
const value_type* __m = __i >= 0 ? __begin_ + __i : __end_ + __i;
for (const value_type* __s = __m; __s != __end_; ++__r.__end_, ++__s)
::new ((void*)__r.__end_) value_type(*__s);
for (const value_type* __s = __begin_; __s != __m; ++__r.__end_, ++__s)
::new ((void*)__r.__end_) value_type(*__s);
}
return __r;
}
template <class _Tp>
valarray<_Tp> valarray<_Tp>::apply(value_type __f(value_type)) const {
valarray<value_type> __r;
size_t __n = size();
if (__n) {
__r.__begin_ = __r.__end_ = allocator<value_type>().allocate(__n);
for (const value_type* __p = __begin_; __n; ++__r.__end_, ++__p, --__n)
::new ((void*)__r.__end_) value_type(__f(*__p));
}
return __r;
}
template <class _Tp>
valarray<_Tp> valarray<_Tp>::apply(value_type __f(const value_type&)) const {
valarray<value_type> __r;
size_t __n = size();
if (__n) {
__r.__begin_ = __r.__end_ = allocator<value_type>().allocate(__n);
for (const value_type* __p = __begin_; __n; ++__r.__end_, ++__p, --__n)
::new ((void*)__r.__end_) value_type(__f(*__p));
}
return __r;
}
template <class _Tp>
inline void valarray<_Tp>::__clear(size_t __capacity) {
if (__begin_ != nullptr) {
while (__end_ != __begin_)
(--__end_)->~value_type();
allocator<value_type>().deallocate(__begin_, __capacity);
__begin_ = __end_ = nullptr;
}
}
template <class _Tp>
void valarray<_Tp>::resize(size_t __n, value_type __x) {
__clear(size());
if (__n) {
__begin_ = __end_ = allocator<value_type>().allocate(__n);
#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
try {
#endif // _LIBCPP_HAS_NO_EXCEPTIONS
for (size_t __n_left = __n; __n_left; --__n_left, ++__end_)
::new ((void*)__end_) value_type(__x);
#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
} catch (...) {
__clear(__n);
throw;
}
#endif // _LIBCPP_HAS_NO_EXCEPTIONS
}
}
template <class _Tp>
inline _LIBCPP_HIDE_FROM_ABI void swap(valarray<_Tp>& __x, valarray<_Tp>& __y) _NOEXCEPT {
__x.swap(__y);
}
template <class _Expr1,
class _Expr2,
__enable_if_t<__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, int> = 0>
inline _LIBCPP_HIDE_FROM_ABI __val_expr<_BinaryOp<multiplies<typename _Expr1::value_type>, _Expr1, _Expr2> >
operator*(const _Expr1& __x, const _Expr2& __y) {
typedef typename _Expr1::value_type value_type;
typedef _BinaryOp<multiplies<value_type>, _Expr1, _Expr2> _Op;
return __val_expr<_Op>(_Op(multiplies<value_type>(), __x, __y));
}
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
inline _LIBCPP_HIDE_FROM_ABI
__val_expr<_BinaryOp<multiplies<typename _Expr::value_type>, _Expr, __scalar_expr<typename _Expr::value_type> > >
operator*(const _Expr& __x, const typename _Expr::value_type& __y) {
typedef typename _Expr::value_type value_type;
typedef _BinaryOp<multiplies<value_type>, _Expr, __scalar_expr<value_type> > _Op;
return __val_expr<_Op>(_Op(multiplies<value_type>(), __x, __scalar_expr<value_type>(__y, __x.size())));
}
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
inline _LIBCPP_HIDE_FROM_ABI
__val_expr<_BinaryOp<multiplies<typename _Expr::value_type>, __scalar_expr<typename _Expr::value_type>, _Expr> >
operator*(const typename _Expr::value_type& __x, const _Expr& __y) {
typedef typename _Expr::value_type value_type;
typedef _BinaryOp<multiplies<value_type>, __scalar_expr<value_type>, _Expr> _Op;
return __val_expr<_Op>(_Op(multiplies<value_type>(), __scalar_expr<value_type>(__x, __y.size()), __y));
}
template <class _Expr1,
class _Expr2,
__enable_if_t<__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, int> = 0>
inline _LIBCPP_HIDE_FROM_ABI __val_expr<_BinaryOp<divides<typename _Expr1::value_type>, _Expr1, _Expr2> >
operator/(const _Expr1& __x, const _Expr2& __y) {
typedef typename _Expr1::value_type value_type;
typedef _BinaryOp<divides<value_type>, _Expr1, _Expr2> _Op;
return __val_expr<_Op>(_Op(divides<value_type>(), __x, __y));
}
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
inline _LIBCPP_HIDE_FROM_ABI
__val_expr<_BinaryOp<divides<typename _Expr::value_type>, _Expr, __scalar_expr<typename _Expr::value_type> > >
operator/(const _Expr& __x, const typename _Expr::value_type& __y) {
typedef typename _Expr::value_type value_type;
typedef _BinaryOp<divides<value_type>, _Expr, __scalar_expr<value_type> > _Op;
return __val_expr<_Op>(_Op(divides<value_type>(), __x, __scalar_expr<value_type>(__y, __x.size())));
}
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
inline _LIBCPP_HIDE_FROM_ABI
__val_expr<_BinaryOp<divides<typename _Expr::value_type>, __scalar_expr<typename _Expr::value_type>, _Expr> >
operator/(const typename _Expr::value_type& __x, const _Expr& __y) {
typedef typename _Expr::value_type value_type;
typedef _BinaryOp<divides<value_type>, __scalar_expr<value_type>, _Expr> _Op;
return __val_expr<_Op>(_Op(divides<value_type>(), __scalar_expr<value_type>(__x, __y.size()), __y));
}
template <class _Expr1,
class _Expr2,
__enable_if_t<__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, int> = 0>
inline _LIBCPP_HIDE_FROM_ABI __val_expr<_BinaryOp<modulus<typename _Expr1::value_type>, _Expr1, _Expr2> >
operator%(const _Expr1& __x, const _Expr2& __y) {
typedef typename _Expr1::value_type value_type;
typedef _BinaryOp<modulus<value_type>, _Expr1, _Expr2> _Op;
return __val_expr<_Op>(_Op(modulus<value_type>(), __x, __y));
}
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
inline _LIBCPP_HIDE_FROM_ABI
__val_expr<_BinaryOp<modulus<typename _Expr::value_type>, _Expr, __scalar_expr<typename _Expr::value_type> > >
operator%(const _Expr& __x, const typename _Expr::value_type& __y) {
typedef typename _Expr::value_type value_type;
typedef _BinaryOp<modulus<value_type>, _Expr, __scalar_expr<value_type> > _Op;
return __val_expr<_Op>(_Op(modulus<value_type>(), __x, __scalar_expr<value_type>(__y, __x.size())));
}
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
inline _LIBCPP_HIDE_FROM_ABI
__val_expr<_BinaryOp<modulus<typename _Expr::value_type>, __scalar_expr<typename _Expr::value_type>, _Expr> >
operator%(const typename _Expr::value_type& __x, const _Expr& __y) {
typedef typename _Expr::value_type value_type;
typedef _BinaryOp<modulus<value_type>, __scalar_expr<value_type>, _Expr> _Op;
return __val_expr<_Op>(_Op(modulus<value_type>(), __scalar_expr<value_type>(__x, __y.size()), __y));
}
template <class _Expr1,
class _Expr2,
__enable_if_t<__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, int> = 0>
inline _LIBCPP_HIDE_FROM_ABI __val_expr<_BinaryOp<plus<typename _Expr1::value_type>, _Expr1, _Expr2> >
operator+(const _Expr1& __x, const _Expr2& __y) {
typedef typename _Expr1::value_type value_type;
typedef _BinaryOp<plus<value_type>, _Expr1, _Expr2> _Op;
return __val_expr<_Op>(_Op(plus<value_type>(), __x, __y));
}
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
inline _LIBCPP_HIDE_FROM_ABI
__val_expr<_BinaryOp<plus<typename _Expr::value_type>, _Expr, __scalar_expr<typename _Expr::value_type> > >
operator+(const _Expr& __x, const typename _Expr::value_type& __y) {
typedef typename _Expr::value_type value_type;
typedef _BinaryOp<plus<value_type>, _Expr, __scalar_expr<value_type> > _Op;
return __val_expr<_Op>(_Op(plus<value_type>(), __x, __scalar_expr<value_type>(__y, __x.size())));
}
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
inline _LIBCPP_HIDE_FROM_ABI
__val_expr<_BinaryOp<plus<typename _Expr::value_type>, __scalar_expr<typename _Expr::value_type>, _Expr> >
operator+(const typename _Expr::value_type& __x, const _Expr& __y) {
typedef typename _Expr::value_type value_type;
typedef _BinaryOp<plus<value_type>, __scalar_expr<value_type>, _Expr> _Op;
return __val_expr<_Op>(_Op(plus<value_type>(), __scalar_expr<value_type>(__x, __y.size()), __y));
}
template <class _Expr1,
class _Expr2,
__enable_if_t<__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, int> = 0>
inline _LIBCPP_HIDE_FROM_ABI __val_expr<_BinaryOp<minus<typename _Expr1::value_type>, _Expr1, _Expr2> >
operator-(const _Expr1& __x, const _Expr2& __y) {
typedef typename _Expr1::value_type value_type;
typedef _BinaryOp<minus<value_type>, _Expr1, _Expr2> _Op;
return __val_expr<_Op>(_Op(minus<value_type>(), __x, __y));
}
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
inline _LIBCPP_HIDE_FROM_ABI
__val_expr<_BinaryOp<minus<typename _Expr::value_type>, _Expr, __scalar_expr<typename _Expr::value_type> > >
operator-(const _Expr& __x, const typename _Expr::value_type& __y) {
typedef typename _Expr::value_type value_type;
typedef _BinaryOp<minus<value_type>, _Expr, __scalar_expr<value_type> > _Op;
return __val_expr<_Op>(_Op(minus<value_type>(), __x, __scalar_expr<value_type>(__y, __x.size())));
}
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
inline _LIBCPP_HIDE_FROM_ABI
__val_expr<_BinaryOp<minus<typename _Expr::value_type>, __scalar_expr<typename _Expr::value_type>, _Expr> >
operator-(const typename _Expr::value_type& __x, const _Expr& __y) {
typedef typename _Expr::value_type value_type;
typedef _BinaryOp<minus<value_type>, __scalar_expr<value_type>, _Expr> _Op;
return __val_expr<_Op>(_Op(minus<value_type>(), __scalar_expr<value_type>(__x, __y.size()), __y));
}
template <class _Expr1,
class _Expr2,
__enable_if_t<__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, int> = 0>
inline _LIBCPP_HIDE_FROM_ABI __val_expr<_BinaryOp<bit_xor<typename _Expr1::value_type>, _Expr1, _Expr2> >
operator^(const _Expr1& __x, const _Expr2& __y) {
typedef typename _Expr1::value_type value_type;
typedef _BinaryOp<bit_xor<value_type>, _Expr1, _Expr2> _Op;
return __val_expr<_Op>(_Op(bit_xor<value_type>(), __x, __y));
}
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
inline _LIBCPP_HIDE_FROM_ABI
__val_expr<_BinaryOp<bit_xor<typename _Expr::value_type>, _Expr, __scalar_expr<typename _Expr::value_type> > >
operator^(const _Expr& __x, const typename _Expr::value_type& __y) {
typedef typename _Expr::value_type value_type;
typedef _BinaryOp<bit_xor<value_type>, _Expr, __scalar_expr<value_type> > _Op;
return __val_expr<_Op>(_Op(bit_xor<value_type>(), __x, __scalar_expr<value_type>(__y, __x.size())));
}
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
inline _LIBCPP_HIDE_FROM_ABI
__val_expr<_BinaryOp<bit_xor<typename _Expr::value_type>, __scalar_expr<typename _Expr::value_type>, _Expr> >
operator^(const typename _Expr::value_type& __x, const _Expr& __y) {
typedef typename _Expr::value_type value_type;
typedef _BinaryOp<bit_xor<value_type>, __scalar_expr<value_type>, _Expr> _Op;
return __val_expr<_Op>(_Op(bit_xor<value_type>(), __scalar_expr<value_type>(__x, __y.size()), __y));
}
template <class _Expr1,
class _Expr2,
__enable_if_t<__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, int> = 0>
inline _LIBCPP_HIDE_FROM_ABI __val_expr<_BinaryOp<bit_and<typename _Expr1::value_type>, _Expr1, _Expr2> >
operator&(const _Expr1& __x, const _Expr2& __y) {
typedef typename _Expr1::value_type value_type;
typedef _BinaryOp<bit_and<value_type>, _Expr1, _Expr2> _Op;
return __val_expr<_Op>(_Op(bit_and<value_type>(), __x, __y));
}
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
inline _LIBCPP_HIDE_FROM_ABI
__val_expr<_BinaryOp<bit_and<typename _Expr::value_type>, _Expr, __scalar_expr<typename _Expr::value_type> > >
operator&(const _Expr& __x, const typename _Expr::value_type& __y) {
typedef typename _Expr::value_type value_type;
typedef _BinaryOp<bit_and<value_type>, _Expr, __scalar_expr<value_type> > _Op;
return __val_expr<_Op>(_Op(bit_and<value_type>(), __x, __scalar_expr<value_type>(__y, __x.size())));
}
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
inline _LIBCPP_HIDE_FROM_ABI
__val_expr<_BinaryOp<bit_and<typename _Expr::value_type>, __scalar_expr<typename _Expr::value_type>, _Expr> >
operator&(const typename _Expr::value_type& __x, const _Expr& __y) {
typedef typename _Expr::value_type value_type;
typedef _BinaryOp<bit_and<value_type>, __scalar_expr<value_type>, _Expr> _Op;
return __val_expr<_Op>(_Op(bit_and<value_type>(), __scalar_expr<value_type>(__x, __y.size()), __y));
}
template <class _Expr1,
class _Expr2,
__enable_if_t<__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, int> = 0>
inline _LIBCPP_HIDE_FROM_ABI __val_expr<_BinaryOp<bit_or<typename _Expr1::value_type>, _Expr1, _Expr2> >
operator|(const _Expr1& __x, const _Expr2& __y) {
typedef typename _Expr1::value_type value_type;
typedef _BinaryOp<bit_or<value_type>, _Expr1, _Expr2> _Op;
return __val_expr<_Op>(_Op(bit_or<value_type>(), __x, __y));
}
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
inline _LIBCPP_HIDE_FROM_ABI
__val_expr<_BinaryOp<bit_or<typename _Expr::value_type>, _Expr, __scalar_expr<typename _Expr::value_type> > >
operator|(const _Expr& __x, const typename _Expr::value_type& __y) {
typedef typename _Expr::value_type value_type;
typedef _BinaryOp<bit_or<value_type>, _Expr, __scalar_expr<value_type> > _Op;
return __val_expr<_Op>(_Op(bit_or<value_type>(), __x, __scalar_expr<value_type>(__y, __x.size())));
}
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
inline _LIBCPP_HIDE_FROM_ABI
__val_expr<_BinaryOp<bit_or<typename _Expr::value_type>, __scalar_expr<typename _Expr::value_type>, _Expr> >
operator|(const typename _Expr::value_type& __x, const _Expr& __y) {
typedef typename _Expr::value_type value_type;
typedef _BinaryOp<bit_or<value_type>, __scalar_expr<value_type>, _Expr> _Op;
return __val_expr<_Op>(_Op(bit_or<value_type>(), __scalar_expr<value_type>(__x, __y.size()), __y));
}
template <class _Expr1,
class _Expr2,
__enable_if_t<__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, int> = 0>
inline _LIBCPP_HIDE_FROM_ABI __val_expr<_BinaryOp<__bit_shift_left<typename _Expr1::value_type>, _Expr1, _Expr2> >
operator<<(const _Expr1& __x, const _Expr2& __y) {
typedef typename _Expr1::value_type value_type;
typedef _BinaryOp<__bit_shift_left<value_type>, _Expr1, _Expr2> _Op;
return __val_expr<_Op>(_Op(__bit_shift_left<value_type>(), __x, __y));
}
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
inline _LIBCPP_HIDE_FROM_ABI
__val_expr< _BinaryOp<__bit_shift_left<typename _Expr::value_type>, _Expr, __scalar_expr<typename _Expr::value_type> > >
operator<<(const _Expr& __x, const typename _Expr::value_type& __y) {
typedef typename _Expr::value_type value_type;
typedef _BinaryOp<__bit_shift_left<value_type>, _Expr, __scalar_expr<value_type> > _Op;
return __val_expr<_Op>(_Op(__bit_shift_left<value_type>(), __x, __scalar_expr<value_type>(__y, __x.size())));
}
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
inline _LIBCPP_HIDE_FROM_ABI
__val_expr< _BinaryOp<__bit_shift_left<typename _Expr::value_type>, __scalar_expr<typename _Expr::value_type>, _Expr> >
operator<<(const typename _Expr::value_type& __x, const _Expr& __y) {
typedef typename _Expr::value_type value_type;
typedef _BinaryOp<__bit_shift_left<value_type>, __scalar_expr<value_type>, _Expr> _Op;
return __val_expr<_Op>(_Op(__bit_shift_left<value_type>(), __scalar_expr<value_type>(__x, __y.size()), __y));
}
template <class _Expr1,
class _Expr2,
__enable_if_t<__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, int> = 0>
inline _LIBCPP_HIDE_FROM_ABI __val_expr<_BinaryOp<__bit_shift_right<typename _Expr1::value_type>, _Expr1, _Expr2> >
operator>>(const _Expr1& __x, const _Expr2& __y) {
typedef typename _Expr1::value_type value_type;
typedef _BinaryOp<__bit_shift_right<value_type>, _Expr1, _Expr2> _Op;
return __val_expr<_Op>(_Op(__bit_shift_right<value_type>(), __x, __y));
}
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
inline _LIBCPP_HIDE_FROM_ABI __val_expr<
_BinaryOp<__bit_shift_right<typename _Expr::value_type>, _Expr, __scalar_expr<typename _Expr::value_type> > >
operator>>(const _Expr& __x, const typename _Expr::value_type& __y) {
typedef typename _Expr::value_type value_type;
typedef _BinaryOp<__bit_shift_right<value_type>, _Expr, __scalar_expr<value_type> > _Op;
return __val_expr<_Op>(_Op(__bit_shift_right<value_type>(), __x, __scalar_expr<value_type>(__y, __x.size())));
}
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
inline _LIBCPP_HIDE_FROM_ABI
__val_expr< _BinaryOp<__bit_shift_right<typename _Expr::value_type>, __scalar_expr<typename _Expr::value_type>, _Expr> >
operator>>(const typename _Expr::value_type& __x, const _Expr& __y) {
typedef typename _Expr::value_type value_type;
typedef _BinaryOp<__bit_shift_right<value_type>, __scalar_expr<value_type>, _Expr> _Op;
return __val_expr<_Op>(_Op(__bit_shift_right<value_type>(), __scalar_expr<value_type>(__x, __y.size()), __y));
}
template <class _Expr1,
class _Expr2,
__enable_if_t<__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, int> = 0>
inline _LIBCPP_HIDE_FROM_ABI __val_expr<_BinaryOp<logical_and<typename _Expr1::value_type>, _Expr1, _Expr2> >
operator&&(const _Expr1& __x, const _Expr2& __y) {
typedef typename _Expr1::value_type value_type;
typedef _BinaryOp<logical_and<value_type>, _Expr1, _Expr2> _Op;
return __val_expr<_Op>(_Op(logical_and<value_type>(), __x, __y));
}
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
inline _LIBCPP_HIDE_FROM_ABI
__val_expr<_BinaryOp<logical_and<typename _Expr::value_type>, _Expr, __scalar_expr<typename _Expr::value_type> > >
operator&&(const _Expr& __x, const typename _Expr::value_type& __y) {
typedef typename _Expr::value_type value_type;
typedef _BinaryOp<logical_and<value_type>, _Expr, __scalar_expr<value_type> > _Op;
return __val_expr<_Op>(_Op(logical_and<value_type>(), __x, __scalar_expr<value_type>(__y, __x.size())));
}
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
inline _LIBCPP_HIDE_FROM_ABI
__val_expr<_BinaryOp<logical_and<typename _Expr::value_type>, __scalar_expr<typename _Expr::value_type>, _Expr> >
operator&&(const typename _Expr::value_type& __x, const _Expr& __y) {
typedef typename _Expr::value_type value_type;
typedef _BinaryOp<logical_and<value_type>, __scalar_expr<value_type>, _Expr> _Op;
return __val_expr<_Op>(_Op(logical_and<value_type>(), __scalar_expr<value_type>(__x, __y.size()), __y));
}
template <class _Expr1,
class _Expr2,
__enable_if_t<__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, int> = 0>
inline _LIBCPP_HIDE_FROM_ABI __val_expr<_BinaryOp<logical_or<typename _Expr1::value_type>, _Expr1, _Expr2> >
operator||(const _Expr1& __x, const _Expr2& __y) {
typedef typename _Expr1::value_type value_type;
typedef _BinaryOp<logical_or<value_type>, _Expr1, _Expr2> _Op;
return __val_expr<_Op>(_Op(logical_or<value_type>(), __x, __y));
}
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
inline _LIBCPP_HIDE_FROM_ABI
__val_expr<_BinaryOp<logical_or<typename _Expr::value_type>, _Expr, __scalar_expr<typename _Expr::value_type> > >
operator||(const _Expr& __x, const typename _Expr::value_type& __y) {
typedef typename _Expr::value_type value_type;
typedef _BinaryOp<logical_or<value_type>, _Expr, __scalar_expr<value_type> > _Op;
return __val_expr<_Op>(_Op(logical_or<value_type>(), __x, __scalar_expr<value_type>(__y, __x.size())));
}
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
inline _LIBCPP_HIDE_FROM_ABI
__val_expr<_BinaryOp<logical_or<typename _Expr::value_type>, __scalar_expr<typename _Expr::value_type>, _Expr> >
operator||(const typename _Expr::value_type& __x, const _Expr& __y) {
typedef typename _Expr::value_type value_type;
typedef _BinaryOp<logical_or<value_type>, __scalar_expr<value_type>, _Expr> _Op;
return __val_expr<_Op>(_Op(logical_or<value_type>(), __scalar_expr<value_type>(__x, __y.size()), __y));
}
template <class _Expr1,
class _Expr2,
__enable_if_t<__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, int> = 0>
inline _LIBCPP_HIDE_FROM_ABI __val_expr<_BinaryOp<equal_to<typename _Expr1::value_type>, _Expr1, _Expr2> >
operator==(const _Expr1& __x, const _Expr2& __y) {
typedef typename _Expr1::value_type value_type;
typedef _BinaryOp<equal_to<value_type>, _Expr1, _Expr2> _Op;
return __val_expr<_Op>(_Op(equal_to<value_type>(), __x, __y));
}
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
inline _LIBCPP_HIDE_FROM_ABI
__val_expr<_BinaryOp<equal_to<typename _Expr::value_type>, _Expr, __scalar_expr<typename _Expr::value_type> > >
operator==(const _Expr& __x, const typename _Expr::value_type& __y) {
typedef typename _Expr::value_type value_type;
typedef _BinaryOp<equal_to<value_type>, _Expr, __scalar_expr<value_type> > _Op;
return __val_expr<_Op>(_Op(equal_to<value_type>(), __x, __scalar_expr<value_type>(__y, __x.size())));
}
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
inline _LIBCPP_HIDE_FROM_ABI
__val_expr<_BinaryOp<equal_to<typename _Expr::value_type>, __scalar_expr<typename _Expr::value_type>, _Expr> >
operator==(const typename _Expr::value_type& __x, const _Expr& __y) {
typedef typename _Expr::value_type value_type;
typedef _BinaryOp<equal_to<value_type>, __scalar_expr<value_type>, _Expr> _Op;
return __val_expr<_Op>(_Op(equal_to<value_type>(), __scalar_expr<value_type>(__x, __y.size()), __y));
}
template <class _Expr1,
class _Expr2,
__enable_if_t<__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, int> = 0>
inline _LIBCPP_HIDE_FROM_ABI __val_expr<_BinaryOp<not_equal_to<typename _Expr1::value_type>, _Expr1, _Expr2> >
operator!=(const _Expr1& __x, const _Expr2& __y) {
typedef typename _Expr1::value_type value_type;
typedef _BinaryOp<not_equal_to<value_type>, _Expr1, _Expr2> _Op;
return __val_expr<_Op>(_Op(not_equal_to<value_type>(), __x, __y));
}
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
inline _LIBCPP_HIDE_FROM_ABI
__val_expr<_BinaryOp<not_equal_to<typename _Expr::value_type>, _Expr, __scalar_expr<typename _Expr::value_type> > >
operator!=(const _Expr& __x, const typename _Expr::value_type& __y) {
typedef typename _Expr::value_type value_type;
typedef _BinaryOp<not_equal_to<value_type>, _Expr, __scalar_expr<value_type> > _Op;
return __val_expr<_Op>(_Op(not_equal_to<value_type>(), __x, __scalar_expr<value_type>(__y, __x.size())));
}
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
inline _LIBCPP_HIDE_FROM_ABI
__val_expr<_BinaryOp<not_equal_to<typename _Expr::value_type>, __scalar_expr<typename _Expr::value_type>, _Expr> >
operator!=(const typename _Expr::value_type& __x, const _Expr& __y) {
typedef typename _Expr::value_type value_type;
typedef _BinaryOp<not_equal_to<value_type>, __scalar_expr<value_type>, _Expr> _Op;
return __val_expr<_Op>(_Op(not_equal_to<value_type>(), __scalar_expr<value_type>(__x, __y.size()), __y));
}
template <class _Expr1,
class _Expr2,
__enable_if_t<__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, int> = 0>
inline _LIBCPP_HIDE_FROM_ABI __val_expr<_BinaryOp<less<typename _Expr1::value_type>, _Expr1, _Expr2> >
operator<(const _Expr1& __x, const _Expr2& __y) {
typedef typename _Expr1::value_type value_type;
typedef _BinaryOp<less<value_type>, _Expr1, _Expr2> _Op;
return __val_expr<_Op>(_Op(less<value_type>(), __x, __y));
}
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
inline _LIBCPP_HIDE_FROM_ABI
__val_expr<_BinaryOp<less<typename _Expr::value_type>, _Expr, __scalar_expr<typename _Expr::value_type> > >
operator<(const _Expr& __x, const typename _Expr::value_type& __y) {
typedef typename _Expr::value_type value_type;
typedef _BinaryOp<less<value_type>, _Expr, __scalar_expr<value_type> > _Op;
return __val_expr<_Op>(_Op(less<value_type>(), __x, __scalar_expr<value_type>(__y, __x.size())));
}
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
inline _LIBCPP_HIDE_FROM_ABI
__val_expr<_BinaryOp<less<typename _Expr::value_type>, __scalar_expr<typename _Expr::value_type>, _Expr> >
operator<(const typename _Expr::value_type& __x, const _Expr& __y) {
typedef typename _Expr::value_type value_type;
typedef _BinaryOp<less<value_type>, __scalar_expr<value_type>, _Expr> _Op;
return __val_expr<_Op>(_Op(less<value_type>(), __scalar_expr<value_type>(__x, __y.size()), __y));
}
template <class _Expr1,
class _Expr2,
__enable_if_t<__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, int> = 0>
inline _LIBCPP_HIDE_FROM_ABI __val_expr<_BinaryOp<greater<typename _Expr1::value_type>, _Expr1, _Expr2> >
operator>(const _Expr1& __x, const _Expr2& __y) {
typedef typename _Expr1::value_type value_type;
typedef _BinaryOp<greater<value_type>, _Expr1, _Expr2> _Op;
return __val_expr<_Op>(_Op(greater<value_type>(), __x, __y));
}
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
inline _LIBCPP_HIDE_FROM_ABI
__val_expr<_BinaryOp<greater<typename _Expr::value_type>, _Expr, __scalar_expr<typename _Expr::value_type> > >
operator>(const _Expr& __x, const typename _Expr::value_type& __y) {
typedef typename _Expr::value_type value_type;
typedef _BinaryOp<greater<value_type>, _Expr, __scalar_expr<value_type> > _Op;
return __val_expr<_Op>(_Op(greater<value_type>(), __x, __scalar_expr<value_type>(__y, __x.size())));
}
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
inline _LIBCPP_HIDE_FROM_ABI
__val_expr<_BinaryOp<greater<typename _Expr::value_type>, __scalar_expr<typename _Expr::value_type>, _Expr> >
operator>(const typename _Expr::value_type& __x, const _Expr& __y) {
typedef typename _Expr::value_type value_type;
typedef _BinaryOp<greater<value_type>, __scalar_expr<value_type>, _Expr> _Op;
return __val_expr<_Op>(_Op(greater<value_type>(), __scalar_expr<value_type>(__x, __y.size()), __y));
}
template <class _Expr1,
class _Expr2,
__enable_if_t<__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, int> = 0>
inline _LIBCPP_HIDE_FROM_ABI __val_expr<_BinaryOp<less_equal<typename _Expr1::value_type>, _Expr1, _Expr2> >
operator<=(const _Expr1& __x, const _Expr2& __y) {
typedef typename _Expr1::value_type value_type;
typedef _BinaryOp<less_equal<value_type>, _Expr1, _Expr2> _Op;
return __val_expr<_Op>(_Op(less_equal<value_type>(), __x, __y));
}
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
inline _LIBCPP_HIDE_FROM_ABI
__val_expr<_BinaryOp<less_equal<typename _Expr::value_type>, _Expr, __scalar_expr<typename _Expr::value_type> > >
operator<=(const _Expr& __x, const typename _Expr::value_type& __y) {
typedef typename _Expr::value_type value_type;
typedef _BinaryOp<less_equal<value_type>, _Expr, __scalar_expr<value_type> > _Op;
return __val_expr<_Op>(_Op(less_equal<value_type>(), __x, __scalar_expr<value_type>(__y, __x.size())));
}
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
inline _LIBCPP_HIDE_FROM_ABI
__val_expr<_BinaryOp<less_equal<typename _Expr::value_type>, __scalar_expr<typename _Expr::value_type>, _Expr> >
operator<=(const typename _Expr::value_type& __x, const _Expr& __y) {
typedef typename _Expr::value_type value_type;
typedef _BinaryOp<less_equal<value_type>, __scalar_expr<value_type>, _Expr> _Op;
return __val_expr<_Op>(_Op(less_equal<value_type>(), __scalar_expr<value_type>(__x, __y.size()), __y));
}
template <class _Expr1,
class _Expr2,
__enable_if_t<__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, int> = 0>
inline _LIBCPP_HIDE_FROM_ABI __val_expr<_BinaryOp<greater_equal<typename _Expr1::value_type>, _Expr1, _Expr2> >
operator>=(const _Expr1& __x, const _Expr2& __y) {
typedef typename _Expr1::value_type value_type;
typedef _BinaryOp<greater_equal<value_type>, _Expr1, _Expr2> _Op;
return __val_expr<_Op>(_Op(greater_equal<value_type>(), __x, __y));
}
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
inline _LIBCPP_HIDE_FROM_ABI
__val_expr<_BinaryOp<greater_equal<typename _Expr::value_type>, _Expr, __scalar_expr<typename _Expr::value_type> > >
operator>=(const _Expr& __x, const typename _Expr::value_type& __y) {
typedef typename _Expr::value_type value_type;
typedef _BinaryOp<greater_equal<value_type>, _Expr, __scalar_expr<value_type> > _Op;
return __val_expr<_Op>(_Op(greater_equal<value_type>(), __x, __scalar_expr<value_type>(__y, __x.size())));
}
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
inline _LIBCPP_HIDE_FROM_ABI
__val_expr<_BinaryOp<greater_equal<typename _Expr::value_type>, __scalar_expr<typename _Expr::value_type>, _Expr> >
operator>=(const typename _Expr::value_type& __x, const _Expr& __y) {
typedef typename _Expr::value_type value_type;
typedef _BinaryOp<greater_equal<value_type>, __scalar_expr<value_type>, _Expr> _Op;
return __val_expr<_Op>(_Op(greater_equal<value_type>(), __scalar_expr<value_type>(__x, __y.size()), __y));
}
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
inline _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__abs_expr<typename _Expr::value_type>, _Expr> >
abs(const _Expr& __x) {
typedef typename _Expr::value_type value_type;
typedef _UnaryOp<__abs_expr<value_type>, _Expr> _Op;
return __val_expr<_Op>(_Op(__abs_expr<value_type>(), __x));
}
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
inline _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__acos_expr<typename _Expr::value_type>, _Expr> >
acos(const _Expr& __x) {
typedef typename _Expr::value_type value_type;
typedef _UnaryOp<__acos_expr<value_type>, _Expr> _Op;
return __val_expr<_Op>(_Op(__acos_expr<value_type>(), __x));
}
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
inline _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__asin_expr<typename _Expr::value_type>, _Expr> >
asin(const _Expr& __x) {
typedef typename _Expr::value_type value_type;
typedef _UnaryOp<__asin_expr<value_type>, _Expr> _Op;
return __val_expr<_Op>(_Op(__asin_expr<value_type>(), __x));
}
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
inline _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__atan_expr<typename _Expr::value_type>, _Expr> >
atan(const _Expr& __x) {
typedef typename _Expr::value_type value_type;
typedef _UnaryOp<__atan_expr<value_type>, _Expr> _Op;
return __val_expr<_Op>(_Op(__atan_expr<value_type>(), __x));
}
template <class _Expr1,
class _Expr2,
__enable_if_t<__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, int> = 0>
inline _LIBCPP_HIDE_FROM_ABI __val_expr<_BinaryOp<__atan2_expr<typename _Expr1::value_type>, _Expr1, _Expr2> >
atan2(const _Expr1& __x, const _Expr2& __y) {
typedef typename _Expr1::value_type value_type;
typedef _BinaryOp<__atan2_expr<value_type>, _Expr1, _Expr2> _Op;
return __val_expr<_Op>(_Op(__atan2_expr<value_type>(), __x, __y));
}
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
inline _LIBCPP_HIDE_FROM_ABI
__val_expr<_BinaryOp<__atan2_expr<typename _Expr::value_type>, _Expr, __scalar_expr<typename _Expr::value_type> > >
atan2(const _Expr& __x, const typename _Expr::value_type& __y) {
typedef typename _Expr::value_type value_type;
typedef _BinaryOp<__atan2_expr<value_type>, _Expr, __scalar_expr<value_type> > _Op;
return __val_expr<_Op>(_Op(__atan2_expr<value_type>(), __x, __scalar_expr<value_type>(__y, __x.size())));
}
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
inline _LIBCPP_HIDE_FROM_ABI
__val_expr<_BinaryOp<__atan2_expr<typename _Expr::value_type>, __scalar_expr<typename _Expr::value_type>, _Expr> >
atan2(const typename _Expr::value_type& __x, const _Expr& __y) {
typedef typename _Expr::value_type value_type;
typedef _BinaryOp<__atan2_expr<value_type>, __scalar_expr<value_type>, _Expr> _Op;
return __val_expr<_Op>(_Op(__atan2_expr<value_type>(), __scalar_expr<value_type>(__x, __y.size()), __y));
}
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
inline _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__cos_expr<typename _Expr::value_type>, _Expr> >
cos(const _Expr& __x) {
typedef typename _Expr::value_type value_type;
typedef _UnaryOp<__cos_expr<value_type>, _Expr> _Op;
return __val_expr<_Op>(_Op(__cos_expr<value_type>(), __x));
}
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
inline _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__cosh_expr<typename _Expr::value_type>, _Expr> >
cosh(const _Expr& __x) {
typedef typename _Expr::value_type value_type;
typedef _UnaryOp<__cosh_expr<value_type>, _Expr> _Op;
return __val_expr<_Op>(_Op(__cosh_expr<value_type>(), __x));
}
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
inline _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__exp_expr<typename _Expr::value_type>, _Expr> >
exp(const _Expr& __x) {
typedef typename _Expr::value_type value_type;
typedef _UnaryOp<__exp_expr<value_type>, _Expr> _Op;
return __val_expr<_Op>(_Op(__exp_expr<value_type>(), __x));
}
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
inline _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__log_expr<typename _Expr::value_type>, _Expr> >
log(const _Expr& __x) {
typedef typename _Expr::value_type value_type;
typedef _UnaryOp<__log_expr<value_type>, _Expr> _Op;
return __val_expr<_Op>(_Op(__log_expr<value_type>(), __x));
}
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
inline _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__log10_expr<typename _Expr::value_type>, _Expr> >
log10(const _Expr& __x) {
typedef typename _Expr::value_type value_type;
typedef _UnaryOp<__log10_expr<value_type>, _Expr> _Op;
return __val_expr<_Op>(_Op(__log10_expr<value_type>(), __x));
}
template <class _Expr1,
class _Expr2,
__enable_if_t<__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, int> = 0>
inline _LIBCPP_HIDE_FROM_ABI __val_expr<_BinaryOp<__pow_expr<typename _Expr1::value_type>, _Expr1, _Expr2> >
pow(const _Expr1& __x, const _Expr2& __y) {
typedef typename _Expr1::value_type value_type;
typedef _BinaryOp<__pow_expr<value_type>, _Expr1, _Expr2> _Op;
return __val_expr<_Op>(_Op(__pow_expr<value_type>(), __x, __y));
}
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
inline _LIBCPP_HIDE_FROM_ABI
__val_expr<_BinaryOp<__pow_expr<typename _Expr::value_type>, _Expr, __scalar_expr<typename _Expr::value_type> > >
pow(const _Expr& __x, const typename _Expr::value_type& __y) {
typedef typename _Expr::value_type value_type;
typedef _BinaryOp<__pow_expr<value_type>, _Expr, __scalar_expr<value_type> > _Op;
return __val_expr<_Op>(_Op(__pow_expr<value_type>(), __x, __scalar_expr<value_type>(__y, __x.size())));
}
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
inline _LIBCPP_HIDE_FROM_ABI
__val_expr<_BinaryOp<__pow_expr<typename _Expr::value_type>, __scalar_expr<typename _Expr::value_type>, _Expr> >
pow(const typename _Expr::value_type& __x, const _Expr& __y) {
typedef typename _Expr::value_type value_type;
typedef _BinaryOp<__pow_expr<value_type>, __scalar_expr<value_type>, _Expr> _Op;
return __val_expr<_Op>(_Op(__pow_expr<value_type>(), __scalar_expr<value_type>(__x, __y.size()), __y));
}
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
inline _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__sin_expr<typename _Expr::value_type>, _Expr> >
sin(const _Expr& __x) {
typedef typename _Expr::value_type value_type;
typedef _UnaryOp<__sin_expr<value_type>, _Expr> _Op;
return __val_expr<_Op>(_Op(__sin_expr<value_type>(), __x));
}
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
inline _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__sinh_expr<typename _Expr::value_type>, _Expr> >
sinh(const _Expr& __x) {
typedef typename _Expr::value_type value_type;
typedef _UnaryOp<__sinh_expr<value_type>, _Expr> _Op;
return __val_expr<_Op>(_Op(__sinh_expr<value_type>(), __x));
}
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
inline _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__sqrt_expr<typename _Expr::value_type>, _Expr> >
sqrt(const _Expr& __x) {
typedef typename _Expr::value_type value_type;
typedef _UnaryOp<__sqrt_expr<value_type>, _Expr> _Op;
return __val_expr<_Op>(_Op(__sqrt_expr<value_type>(), __x));
}
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
inline _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__tan_expr<typename _Expr::value_type>, _Expr> >
tan(const _Expr& __x) {
typedef typename _Expr::value_type value_type;
typedef _UnaryOp<__tan_expr<value_type>, _Expr> _Op;
return __val_expr<_Op>(_Op(__tan_expr<value_type>(), __x));
}
template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
inline _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__tanh_expr<typename _Expr::value_type>, _Expr> >
tanh(const _Expr& __x) {
typedef typename _Expr::value_type value_type;
typedef _UnaryOp<__tanh_expr<value_type>, _Expr> _Op;
return __val_expr<_Op>(_Op(__tanh_expr<value_type>(), __x));
}
template <class _Tp>
inline _LIBCPP_HIDE_FROM_ABI _Tp* begin(valarray<_Tp>& __v) {
return __v.__begin_;
}
template <class _Tp>
inline _LIBCPP_HIDE_FROM_ABI const _Tp* begin(const valarray<_Tp>& __v) {
return __v.__begin_;
}
template <class _Tp>
inline _LIBCPP_HIDE_FROM_ABI _Tp* end(valarray<_Tp>& __v) {
return __v.__end_;
}
template <class _Tp>
inline _LIBCPP_HIDE_FROM_ABI const _Tp* end(const valarray<_Tp>& __v) {
return __v.__end_;
}
_LIBCPP_END_NAMESPACE_STD
_LIBCPP_POP_MACROS
#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
# include <algorithm>
# include <concepts>
# include <cstdlib>
# include <cstring>
# include <functional>
# include <stdexcept>
# include <type_traits>
#endif
#endif // _LIBCPP_VALARRAY
Reference in New Issue View Git Blame Copy Permalink