mirror of
https://github.com/capstone-engine/llvm-capstone.git
synced 2024-10-07 19:03:57 +00:00
de4a57cb21
This commit re-adds transitive includes that had been removed by4cd04d1687,c36870c8e7,a83f4b9cda,1458458b55,2e2f3158c6, and489637e66d. This should cover almost all the includes that had been removed since LLVM 14 and that would contribute to breaking user code when releasing LLVM 15. It is possible to disable the inclusion of these headers by defining _LIBCPP_REMOVE_TRANSITIVE_INCLUDES. The intent is that vendors will enable that macro and start fixing downstream issues immediately. We can then remove the macro (and the transitive includes) by default in a future release. That way, we will break users only once by removing transitive includes in bulk instead of doing it bit by bit a every release, which is more disruptive for users. Note 1: The set of headers to re-add was found by re-generating the transitive include test on a checkout of release/14.x, which provided the list of all transitive includes we used to provide. Note 2: Several includes of <vector>, <optional>, <array> and <unordered_map> have been added in this commit. These transitive inclusions were added when we implemented boyer_moore_searcher in <functional>. Note 3: This is a best effort patch to try and resolve downstream breakage caused since branching LLVM 14. I wasn't able to perfectly mirror transitive includes in LLVM 14 for a few headers, so I added a release note explaining it. To summarize, adding boyer_moore_searcher created a bunch of circular dependencies, so we have to break backwards compatibility in a few cases. Differential Revision: https://reviews.llvm.org/D128661
4936 lines
132 KiB
C++
4936 lines
132 KiB
C++
// -*- 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;
|
|
};
|
|
|
|
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> // all public C++ headers provide the assertion handler
|
|
#include <__config>
|
|
#include <__functional/operations.h>
|
|
#include <__memory/allocator.h>
|
|
#include <__memory/uninitialized_algorithms.h>
|
|
#include <__utility/move.h>
|
|
#include <__utility/swap.h>
|
|
#include <cmath>
|
|
#include <cstddef>
|
|
#include <new>
|
|
#include <version>
|
|
|
|
#ifndef _LIBCPP_REMOVE_TRANSITIVE_INCLUDES
|
|
# include <algorithm>
|
|
# include <functional>
|
|
#endif
|
|
|
|
// standard-mandated includes
|
|
#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_INLINE_VISIBILITY
|
|
slice()
|
|
: __start_(0),
|
|
__size_(0),
|
|
__stride_(0)
|
|
{}
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
slice(size_t __start, size_t __size, size_t __stride)
|
|
: __start_(__start),
|
|
__size_(__size),
|
|
__stride_(__stride)
|
|
{}
|
|
|
|
_LIBCPP_INLINE_VISIBILITY size_t start() const {return __start_;}
|
|
_LIBCPP_INLINE_VISIBILITY size_t size() const {return __size_;}
|
|
_LIBCPP_INLINE_VISIBILITY size_t stride() const {return __stride_;}
|
|
};
|
|
|
|
template <class _Tp> class _LIBCPP_TEMPLATE_VIS slice_array;
|
|
class _LIBCPP_TYPE_VIS 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_INLINE_VISIBILITY
|
|
_Tp*
|
|
begin(valarray<_Tp>& __v);
|
|
|
|
template <class _Tp>
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
const _Tp*
|
|
begin(const valarray<_Tp>& __v);
|
|
|
|
template <class _Tp>
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
_Tp*
|
|
end(valarray<_Tp>& __v);
|
|
|
|
template <class _Tp>
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
const _Tp*
|
|
end(const valarray<_Tp>& __v);
|
|
|
|
template <class _Op, class _A0>
|
|
struct _UnaryOp
|
|
{
|
|
typedef typename _Op::__result_type __result_type;
|
|
typedef typename decay<__result_type>::type value_type;
|
|
|
|
_Op __op_;
|
|
_A0 __a0_;
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
_UnaryOp(const _Op& __op, const _A0& __a0) : __op_(__op), __a0_(__a0) {}
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
__result_type operator[](size_t __i) const {return __op_(__a0_[__i]);}
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
size_t size() const {return __a0_.size();}
|
|
};
|
|
|
|
template <class _Op, class _A0, class _A1>
|
|
struct _BinaryOp
|
|
{
|
|
typedef typename _Op::__result_type __result_type;
|
|
typedef typename decay<__result_type>::type value_type;
|
|
|
|
_Op __op_;
|
|
_A0 __a0_;
|
|
_A1 __a1_;
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
_BinaryOp(const _Op& __op, const _A0& __a0, const _A1& __a1)
|
|
: __op_(__op), __a0_(__a0), __a1_(__a1) {}
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
__result_type operator[](size_t __i) const {return __op_(__a0_[__i], __a1_[__i]);}
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
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_INLINE_VISIBILITY
|
|
explicit __scalar_expr(const value_type& __t, size_t __s) : __t_(__t), __s_(__s) {}
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
__result_type operator[](size_t) const {return __t_;}
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
size_t size() const {return __s_;}
|
|
};
|
|
|
|
template <class _Tp>
|
|
struct __unary_plus
|
|
{
|
|
typedef _Tp __result_type;
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
_Tp operator()(const _Tp& __x) const
|
|
{return +__x;}
|
|
};
|
|
|
|
template <class _Tp>
|
|
struct __bit_not
|
|
{
|
|
typedef _Tp __result_type;
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
_Tp operator()(const _Tp& __x) const
|
|
{return ~__x;}
|
|
};
|
|
|
|
template <class _Tp>
|
|
struct __bit_shift_left
|
|
{
|
|
typedef _Tp __result_type;
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
_Tp operator()(const _Tp& __x, const _Tp& __y) const
|
|
{return __x << __y;}
|
|
};
|
|
|
|
template <class _Tp>
|
|
struct __bit_shift_right
|
|
{
|
|
typedef _Tp __result_type;
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
_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_INLINE_VISIBILITY
|
|
explicit __apply_expr(_Fp __f) : __f_(__f) {}
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
_Tp operator()(const _Tp& __x) const
|
|
{return __f_(__x);}
|
|
};
|
|
|
|
template <class _Tp>
|
|
struct __abs_expr
|
|
{
|
|
typedef _Tp __result_type;
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
_Tp operator()(const _Tp& __x) const
|
|
{return abs(__x);}
|
|
};
|
|
|
|
template <class _Tp>
|
|
struct __acos_expr
|
|
{
|
|
typedef _Tp __result_type;
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
_Tp operator()(const _Tp& __x) const
|
|
{return acos(__x);}
|
|
};
|
|
|
|
template <class _Tp>
|
|
struct __asin_expr
|
|
{
|
|
typedef _Tp __result_type;
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
_Tp operator()(const _Tp& __x) const
|
|
{return asin(__x);}
|
|
};
|
|
|
|
template <class _Tp>
|
|
struct __atan_expr
|
|
{
|
|
typedef _Tp __result_type;
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
_Tp operator()(const _Tp& __x) const
|
|
{return atan(__x);}
|
|
};
|
|
|
|
template <class _Tp>
|
|
struct __atan2_expr
|
|
{
|
|
typedef _Tp __result_type;
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
_Tp operator()(const _Tp& __x, const _Tp& __y) const
|
|
{return atan2(__x, __y);}
|
|
};
|
|
|
|
template <class _Tp>
|
|
struct __cos_expr
|
|
{
|
|
typedef _Tp __result_type;
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
_Tp operator()(const _Tp& __x) const
|
|
{return cos(__x);}
|
|
};
|
|
|
|
template <class _Tp>
|
|
struct __cosh_expr
|
|
{
|
|
typedef _Tp __result_type;
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
_Tp operator()(const _Tp& __x) const
|
|
{return cosh(__x);}
|
|
};
|
|
|
|
template <class _Tp>
|
|
struct __exp_expr
|
|
{
|
|
typedef _Tp __result_type;
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
_Tp operator()(const _Tp& __x) const
|
|
{return exp(__x);}
|
|
};
|
|
|
|
template <class _Tp>
|
|
struct __log_expr
|
|
{
|
|
typedef _Tp __result_type;
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
_Tp operator()(const _Tp& __x) const
|
|
{return log(__x);}
|
|
};
|
|
|
|
template <class _Tp>
|
|
struct __log10_expr
|
|
{
|
|
typedef _Tp __result_type;
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
_Tp operator()(const _Tp& __x) const
|
|
{return log10(__x);}
|
|
};
|
|
|
|
template <class _Tp>
|
|
struct __pow_expr
|
|
{
|
|
typedef _Tp __result_type;
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
_Tp operator()(const _Tp& __x, const _Tp& __y) const
|
|
{return pow(__x, __y);}
|
|
};
|
|
|
|
template <class _Tp>
|
|
struct __sin_expr
|
|
{
|
|
typedef _Tp __result_type;
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
_Tp operator()(const _Tp& __x) const
|
|
{return sin(__x);}
|
|
};
|
|
|
|
template <class _Tp>
|
|
struct __sinh_expr
|
|
{
|
|
typedef _Tp __result_type;
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
_Tp operator()(const _Tp& __x) const
|
|
{return sinh(__x);}
|
|
};
|
|
|
|
template <class _Tp>
|
|
struct __sqrt_expr
|
|
{
|
|
typedef _Tp __result_type;
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
_Tp operator()(const _Tp& __x) const
|
|
{return sqrt(__x);}
|
|
};
|
|
|
|
template <class _Tp>
|
|
struct __tan_expr
|
|
{
|
|
typedef _Tp __result_type;
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
_Tp operator()(const _Tp& __x) const
|
|
{return tan(__x);}
|
|
};
|
|
|
|
template <class _Tp>
|
|
struct __tanh_expr
|
|
{
|
|
typedef _Tp __result_type;
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
_Tp operator()(const _Tp& __x) const
|
|
{return tanh(__x);}
|
|
};
|
|
|
|
template <class _ValExpr>
|
|
class __slice_expr
|
|
{
|
|
typedef typename remove_reference<_ValExpr>::type _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_INLINE_VISIBILITY
|
|
__slice_expr(const slice& __sl, const _RmExpr& __e)
|
|
: __expr_(__e),
|
|
__start_(__sl.start()),
|
|
__size_(__sl.size()),
|
|
__stride_(__sl.stride())
|
|
{}
|
|
public:
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
__result_type operator[](size_t __i) const
|
|
{return __expr_[__start_ + __i * __stride_];}
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
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 typename remove_reference<_ValExpr>::type _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_INLINE_VISIBILITY
|
|
__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_INLINE_VISIBILITY
|
|
__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_INLINE_VISIBILITY
|
|
size_t size() const {return __size_;}
|
|
|
|
template <class> friend class __val_expr;
|
|
};
|
|
|
|
template <class _ValExpr>
|
|
class __cshift_expr
|
|
{
|
|
typedef typename remove_reference<_ValExpr>::type _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_INLINE_VISIBILITY
|
|
__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_INLINE_VISIBILITY
|
|
__result_type operator[](size_t __i) const
|
|
{
|
|
if (__i < __m_)
|
|
return __expr_[__i + __o1_];
|
|
return __expr_[__i + __o2_];
|
|
}
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
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>
|
|
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_INLINE_VISIBILITY
|
|
valarray() : __begin_(nullptr), __end_(nullptr) {}
|
|
inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1
|
|
explicit valarray(size_t __n);
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
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_INLINE_VISIBILITY
|
|
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_INLINE_VISIBILITY
|
|
valarray& operator=(valarray&& __v) _NOEXCEPT;
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
valarray& operator=(initializer_list<value_type>);
|
|
#endif // _LIBCPP_CXX03_LANG
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
valarray& operator=(const value_type& __x);
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
valarray& operator=(const slice_array<value_type>& __sa);
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
valarray& operator=(const gslice_array<value_type>& __ga);
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
valarray& operator=(const mask_array<value_type>& __ma);
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
valarray& operator=(const indirect_array<value_type>& __ia);
|
|
template <class _ValExpr>
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
valarray& operator=(const __val_expr<_ValExpr>& __v);
|
|
|
|
// element access:
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
const value_type& operator[](size_t __i) const {return __begin_[__i];}
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
value_type& operator[](size_t __i) {return __begin_[__i];}
|
|
|
|
// subset operations:
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
__val_expr<__slice_expr<const valarray&> > operator[](slice __s) const;
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
slice_array<value_type> operator[](slice __s);
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
__val_expr<__indirect_expr<const valarray&> > operator[](const gslice& __gs) const;
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
gslice_array<value_type> operator[](const gslice& __gs);
|
|
#ifndef _LIBCPP_CXX03_LANG
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
__val_expr<__indirect_expr<const valarray&> > operator[](gslice&& __gs) const;
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
gslice_array<value_type> operator[](gslice&& __gs);
|
|
#endif // _LIBCPP_CXX03_LANG
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
__val_expr<__mask_expr<const valarray&> > operator[](const valarray<bool>& __vb) const;
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
mask_array<value_type> operator[](const valarray<bool>& __vb);
|
|
#ifndef _LIBCPP_CXX03_LANG
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
__val_expr<__mask_expr<const valarray&> > operator[](valarray<bool>&& __vb) const;
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
mask_array<value_type> operator[](valarray<bool>&& __vb);
|
|
#endif // _LIBCPP_CXX03_LANG
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
__val_expr<__indirect_expr<const valarray&> > operator[](const valarray<size_t>& __vs) const;
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
indirect_array<value_type> operator[](const valarray<size_t>& __vs);
|
|
#ifndef _LIBCPP_CXX03_LANG
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
__val_expr<__indirect_expr<const valarray&> > operator[](valarray<size_t>&& __vs) const;
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
indirect_array<value_type> operator[](valarray<size_t>&& __vs);
|
|
#endif // _LIBCPP_CXX03_LANG
|
|
|
|
// unary operators:
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
__val_expr<_UnaryOp<__unary_plus<_Tp>, const valarray&> > operator+() const;
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
__val_expr<_UnaryOp<negate<_Tp>, const valarray&> > operator-() const;
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
__val_expr<_UnaryOp<__bit_not<_Tp>, const valarray&> > operator~() const;
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
__val_expr<_UnaryOp<logical_not<_Tp>, const valarray&> > operator!() const;
|
|
|
|
// computed assignment:
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
valarray& operator*= (const value_type& __x);
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
valarray& operator/= (const value_type& __x);
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
valarray& operator%= (const value_type& __x);
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
valarray& operator+= (const value_type& __x);
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
valarray& operator-= (const value_type& __x);
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
valarray& operator^= (const value_type& __x);
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
valarray& operator&= (const value_type& __x);
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
valarray& operator|= (const value_type& __x);
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
valarray& operator<<=(const value_type& __x);
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
valarray& operator>>=(const value_type& __x);
|
|
|
|
template <class _Expr>
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
valarray&
|
|
>::type
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
operator*= (const _Expr& __v);
|
|
|
|
template <class _Expr>
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
valarray&
|
|
>::type
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
operator/= (const _Expr& __v);
|
|
|
|
template <class _Expr>
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
valarray&
|
|
>::type
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
operator%= (const _Expr& __v);
|
|
|
|
template <class _Expr>
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
valarray&
|
|
>::type
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
operator+= (const _Expr& __v);
|
|
|
|
template <class _Expr>
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
valarray&
|
|
>::type
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
operator-= (const _Expr& __v);
|
|
|
|
template <class _Expr>
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
valarray&
|
|
>::type
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
operator^= (const _Expr& __v);
|
|
|
|
template <class _Expr>
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
valarray&
|
|
>::type
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
operator|= (const _Expr& __v);
|
|
|
|
template <class _Expr>
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
valarray&
|
|
>::type
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
operator&= (const _Expr& __v);
|
|
|
|
template <class _Expr>
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
valarray&
|
|
>::type
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
operator<<= (const _Expr& __v);
|
|
|
|
template <class _Expr>
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
valarray&
|
|
>::type
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
operator>>= (const _Expr& __v);
|
|
|
|
// member functions:
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
void swap(valarray& __v) _NOEXCEPT;
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
size_t size() const {return static_cast<size_t>(__end_ - __begin_);}
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
value_type sum() const;
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
value_type min() const;
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
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_INLINE_VISIBILITY
|
|
void __clear(size_t __capacity);
|
|
valarray& __assign_range(const value_type* __f, const value_type* __l);
|
|
};
|
|
|
|
#if _LIBCPP_STD_VER > 14
|
|
template<class _Tp, size_t _Size>
|
|
valarray(const _Tp(&)[_Size], size_t) -> valarray<_Tp>;
|
|
#endif
|
|
|
|
extern template _LIBCPP_FUNC_VIS 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;
|
|
typedef typename decay<__result_type>::type value_type;
|
|
|
|
_Op __op_;
|
|
const valarray<_Tp>& __a0_;
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
_UnaryOp(const _Op& __op, const valarray<_Tp>& __a0) : __op_(__op), __a0_(__a0) {}
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
__result_type operator[](size_t __i) const {return __op_(__a0_[__i]);}
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
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;
|
|
typedef typename decay<__result_type>::type value_type;
|
|
|
|
_Op __op_;
|
|
const valarray<_Tp>& __a0_;
|
|
_A1 __a1_;
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
_BinaryOp(const _Op& __op, const valarray<_Tp>& __a0, const _A1& __a1)
|
|
: __op_(__op), __a0_(__a0), __a1_(__a1) {}
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
__result_type operator[](size_t __i) const {return __op_(__a0_[__i], __a1_[__i]);}
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
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;
|
|
typedef typename decay<__result_type>::type value_type;
|
|
|
|
_Op __op_;
|
|
_A0 __a0_;
|
|
const valarray<_Tp>& __a1_;
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
_BinaryOp(const _Op& __op, const _A0& __a0, const valarray<_Tp>& __a1)
|
|
: __op_(__op), __a0_(__a0), __a1_(__a1) {}
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
__result_type operator[](size_t __i) const {return __op_(__a0_[__i], __a1_[__i]);}
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
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;
|
|
typedef typename decay<__result_type>::type value_type;
|
|
|
|
_Op __op_;
|
|
const valarray<_Tp>& __a0_;
|
|
const valarray<_Tp>& __a1_;
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
_BinaryOp(const _Op& __op, const valarray<_Tp>& __a0, const valarray<_Tp>& __a1)
|
|
: __op_(__op), __a0_(__a0), __a1_(__a1) {}
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
__result_type operator[](size_t __i) const {return __op_(__a0_[__i], __a1_[__i]);}
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
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>
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
void
|
|
>::type
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
operator=(const _Expr& __v) const;
|
|
|
|
template <class _Expr>
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
void
|
|
>::type
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
operator*=(const _Expr& __v) const;
|
|
|
|
template <class _Expr>
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
void
|
|
>::type
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
operator/=(const _Expr& __v) const;
|
|
|
|
template <class _Expr>
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
void
|
|
>::type
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
operator%=(const _Expr& __v) const;
|
|
|
|
template <class _Expr>
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
void
|
|
>::type
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
operator+=(const _Expr& __v) const;
|
|
|
|
template <class _Expr>
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
void
|
|
>::type
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
operator-=(const _Expr& __v) const;
|
|
|
|
template <class _Expr>
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
void
|
|
>::type
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
operator^=(const _Expr& __v) const;
|
|
|
|
template <class _Expr>
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
void
|
|
>::type
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
operator&=(const _Expr& __v) const;
|
|
|
|
template <class _Expr>
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
void
|
|
>::type
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
operator|=(const _Expr& __v) const;
|
|
|
|
template <class _Expr>
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
void
|
|
>::type
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
operator<<=(const _Expr& __v) const;
|
|
|
|
template <class _Expr>
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
void
|
|
>::type
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
operator>>=(const _Expr& __v) const;
|
|
|
|
slice_array(slice_array const&) = default;
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
const slice_array& operator=(const slice_array& __sa) const;
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
void operator=(const value_type& __x) const;
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
void operator=(const valarray<value_type>& __va) const;
|
|
|
|
private:
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
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> friend class sliceExpr;
|
|
};
|
|
|
|
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>
|
|
inline
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
void
|
|
>::type
|
|
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>
|
|
inline
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
void
|
|
>::type
|
|
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>
|
|
inline
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
void
|
|
>::type
|
|
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>
|
|
inline
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
void
|
|
>::type
|
|
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>
|
|
inline
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
void
|
|
>::type
|
|
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>
|
|
inline
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
void
|
|
>::type
|
|
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>
|
|
inline
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
void
|
|
>::type
|
|
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>
|
|
inline
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
void
|
|
>::type
|
|
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>
|
|
inline
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
void
|
|
>::type
|
|
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>
|
|
inline
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
void
|
|
>::type
|
|
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>
|
|
inline
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
void
|
|
>::type
|
|
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_TYPE_VIS gslice
|
|
{
|
|
valarray<size_t> __size_;
|
|
valarray<size_t> __stride_;
|
|
valarray<size_t> __1d_;
|
|
|
|
public:
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
gslice() {}
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
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_INLINE_VISIBILITY
|
|
gslice(size_t __start, const valarray<size_t>& __size,
|
|
valarray<size_t>&& __stride)
|
|
: __size_(__size),
|
|
__stride_(std::move(__stride))
|
|
{__init(__start);}
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
gslice(size_t __start, valarray<size_t>&& __size,
|
|
const valarray<size_t>& __stride)
|
|
: __size_(std::move(__size)),
|
|
__stride_(__stride)
|
|
{__init(__start);}
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
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_INLINE_VISIBILITY
|
|
size_t start() const {return __1d_.size() ? __1d_[0] : 0;}
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
valarray<size_t> size() const {return __size_;}
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
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>
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
void
|
|
>::type
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
operator=(const _Expr& __v) const;
|
|
|
|
template <class _Expr>
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
void
|
|
>::type
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
operator*=(const _Expr& __v) const;
|
|
|
|
template <class _Expr>
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
void
|
|
>::type
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
operator/=(const _Expr& __v) const;
|
|
|
|
template <class _Expr>
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
void
|
|
>::type
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
operator%=(const _Expr& __v) const;
|
|
|
|
template <class _Expr>
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
void
|
|
>::type
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
operator+=(const _Expr& __v) const;
|
|
|
|
template <class _Expr>
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
void
|
|
>::type
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
operator-=(const _Expr& __v) const;
|
|
|
|
template <class _Expr>
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
void
|
|
>::type
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
operator^=(const _Expr& __v) const;
|
|
|
|
template <class _Expr>
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
void
|
|
>::type
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
operator&=(const _Expr& __v) const;
|
|
|
|
template <class _Expr>
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
void
|
|
>::type
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
operator|=(const _Expr& __v) const;
|
|
|
|
template <class _Expr>
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
void
|
|
>::type
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
operator<<=(const _Expr& __v) const;
|
|
|
|
template <class _Expr>
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
void
|
|
>::type
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
operator>>=(const _Expr& __v) const;
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
const gslice_array& operator=(const gslice_array& __ga) const;
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
void operator=(const value_type& __x) const;
|
|
|
|
gslice_array(const gslice_array&) = default;
|
|
|
|
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>
|
|
inline
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
void
|
|
>::type
|
|
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>
|
|
inline
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
void
|
|
>::type
|
|
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>
|
|
inline
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
void
|
|
>::type
|
|
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>
|
|
inline
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
void
|
|
>::type
|
|
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>
|
|
inline
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
void
|
|
>::type
|
|
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>
|
|
inline
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
void
|
|
>::type
|
|
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>
|
|
inline
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
void
|
|
>::type
|
|
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>
|
|
inline
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
void
|
|
>::type
|
|
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>
|
|
inline
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
void
|
|
>::type
|
|
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>
|
|
inline
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
void
|
|
>::type
|
|
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>
|
|
inline
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
void
|
|
>::type
|
|
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>
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
void
|
|
>::type
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
operator=(const _Expr& __v) const;
|
|
|
|
template <class _Expr>
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
void
|
|
>::type
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
operator*=(const _Expr& __v) const;
|
|
|
|
template <class _Expr>
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
void
|
|
>::type
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
operator/=(const _Expr& __v) const;
|
|
|
|
template <class _Expr>
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
void
|
|
>::type
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
operator%=(const _Expr& __v) const;
|
|
|
|
template <class _Expr>
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
void
|
|
>::type
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
operator+=(const _Expr& __v) const;
|
|
|
|
template <class _Expr>
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
void
|
|
>::type
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
operator-=(const _Expr& __v) const;
|
|
|
|
template <class _Expr>
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
void
|
|
>::type
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
operator^=(const _Expr& __v) const;
|
|
|
|
template <class _Expr>
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
void
|
|
>::type
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
operator&=(const _Expr& __v) const;
|
|
|
|
template <class _Expr>
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
void
|
|
>::type
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
operator|=(const _Expr& __v) const;
|
|
|
|
template <class _Expr>
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
void
|
|
>::type
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
operator<<=(const _Expr& __v) const;
|
|
|
|
template <class _Expr>
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
void
|
|
>::type
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
operator>>=(const _Expr& __v) const;
|
|
|
|
mask_array(const mask_array&) = default;
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
const mask_array& operator=(const mask_array& __ma) const;
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
void operator=(const value_type& __x) const;
|
|
|
|
private:
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
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>
|
|
inline
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
void
|
|
>::type
|
|
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>
|
|
inline
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
void
|
|
>::type
|
|
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>
|
|
inline
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
void
|
|
>::type
|
|
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>
|
|
inline
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
void
|
|
>::type
|
|
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>
|
|
inline
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
void
|
|
>::type
|
|
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>
|
|
inline
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
void
|
|
>::type
|
|
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>
|
|
inline
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
void
|
|
>::type
|
|
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>
|
|
inline
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
void
|
|
>::type
|
|
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>
|
|
inline
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
void
|
|
>::type
|
|
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>
|
|
inline
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
void
|
|
>::type
|
|
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>
|
|
inline
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
void
|
|
>::type
|
|
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 typename remove_reference<_ValExpr>::type _RmExpr;
|
|
public:
|
|
typedef typename _RmExpr::value_type value_type;
|
|
typedef value_type __result_type;
|
|
|
|
private:
|
|
_ValExpr __expr_;
|
|
valarray<size_t> __1d_;
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
__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_INLINE_VISIBILITY
|
|
__result_type operator[](size_t __i) const
|
|
{return __expr_[__1d_[__i]];}
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
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>
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
void
|
|
>::type
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
operator=(const _Expr& __v) const;
|
|
|
|
template <class _Expr>
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
void
|
|
>::type
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
operator*=(const _Expr& __v) const;
|
|
|
|
template <class _Expr>
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
void
|
|
>::type
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
operator/=(const _Expr& __v) const;
|
|
|
|
template <class _Expr>
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
void
|
|
>::type
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
operator%=(const _Expr& __v) const;
|
|
|
|
template <class _Expr>
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
void
|
|
>::type
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
operator+=(const _Expr& __v) const;
|
|
|
|
template <class _Expr>
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
void
|
|
>::type
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
operator-=(const _Expr& __v) const;
|
|
|
|
template <class _Expr>
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
void
|
|
>::type
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
operator^=(const _Expr& __v) const;
|
|
|
|
template <class _Expr>
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
void
|
|
>::type
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
operator&=(const _Expr& __v) const;
|
|
|
|
template <class _Expr>
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
void
|
|
>::type
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
operator|=(const _Expr& __v) const;
|
|
|
|
template <class _Expr>
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
void
|
|
>::type
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
operator<<=(const _Expr& __v) const;
|
|
|
|
template <class _Expr>
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
void
|
|
>::type
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
operator>>=(const _Expr& __v) const;
|
|
|
|
indirect_array(const indirect_array&) = default;
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
const indirect_array& operator=(const indirect_array& __ia) const;
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
void operator=(const value_type& __x) const;
|
|
|
|
private:
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
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_INLINE_VISIBILITY
|
|
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>
|
|
inline
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
void
|
|
>::type
|
|
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>
|
|
inline
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
void
|
|
>::type
|
|
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>
|
|
inline
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
void
|
|
>::type
|
|
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>
|
|
inline
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
void
|
|
>::type
|
|
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>
|
|
inline
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
void
|
|
>::type
|
|
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>
|
|
inline
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
void
|
|
>::type
|
|
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>
|
|
inline
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
void
|
|
>::type
|
|
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>
|
|
inline
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
void
|
|
>::type
|
|
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>
|
|
inline
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
void
|
|
>::type
|
|
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>
|
|
inline
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
void
|
|
>::type
|
|
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>
|
|
inline
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
void
|
|
>::type
|
|
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 typename remove_reference<_ValExpr>::type _RmExpr;
|
|
public:
|
|
typedef typename _RmExpr::value_type value_type;
|
|
typedef value_type __result_type;
|
|
|
|
private:
|
|
_ValExpr __expr_;
|
|
valarray<size_t> __1d_;
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
__indirect_expr(const valarray<size_t>& __ia, const _RmExpr& __e)
|
|
: __expr_(__e),
|
|
__1d_(__ia)
|
|
{}
|
|
|
|
#ifndef _LIBCPP_CXX03_LANG
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
__indirect_expr(valarray<size_t>&& __ia, const _RmExpr& __e)
|
|
: __expr_(__e),
|
|
__1d_(std::move(__ia))
|
|
{}
|
|
|
|
#endif // _LIBCPP_CXX03_LANG
|
|
|
|
public:
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
__result_type operator[](size_t __i) const
|
|
{return __expr_[__1d_[__i]];}
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
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 typename remove_reference<_ValExpr>::type _RmExpr;
|
|
|
|
_ValExpr __expr_;
|
|
public:
|
|
typedef typename _RmExpr::value_type value_type;
|
|
typedef typename _RmExpr::__result_type __result_type;
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
explicit __val_expr(const _RmExpr& __e) : __expr_(__e) {}
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
__result_type operator[](size_t __i) const
|
|
{return __expr_[__i];}
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
__val_expr<__slice_expr<_ValExpr> > operator[](slice __s) const
|
|
{
|
|
typedef __slice_expr<_ValExpr> _NewExpr;
|
|
return __val_expr< _NewExpr >(_NewExpr(__s, __expr_));
|
|
}
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
__val_expr<__indirect_expr<_ValExpr> > operator[](const gslice& __gs) const
|
|
{
|
|
typedef __indirect_expr<_ValExpr> _NewExpr;
|
|
return __val_expr<_NewExpr >(_NewExpr(__gs.__1d_, __expr_));
|
|
}
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
__val_expr<__mask_expr<_ValExpr> > operator[](const valarray<bool>& __vb) const
|
|
{
|
|
typedef __mask_expr<_ValExpr> _NewExpr;
|
|
return __val_expr< _NewExpr >( _NewExpr(__vb, __expr_));
|
|
}
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
__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_INLINE_VISIBILITY
|
|
__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_INLINE_VISIBILITY
|
|
__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_INLINE_VISIBILITY
|
|
__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_INLINE_VISIBILITY
|
|
__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_INLINE_VISIBILITY
|
|
size_t size() const {return __expr_.size();}
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
__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_INLINE_VISIBILITY
|
|
__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_INLINE_VISIBILITY
|
|
__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_INLINE_VISIBILITY
|
|
__val_expr<__shift_expr<_ValExpr> > shift (int __i) const
|
|
{return __val_expr<__shift_expr<_ValExpr> >(__shift_expr<_ValExpr>(__i, __expr_));}
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
__val_expr<__cshift_expr<_ValExpr> > cshift(int __i) const
|
|
{return __val_expr<__cshift_expr<_ValExpr> >(__cshift_expr<_ValExpr>(__i, __expr_));}
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
__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_INLINE_VISIBILITY
|
|
__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_NO_EXCEPTIONS
|
|
try
|
|
{
|
|
#endif // _LIBCPP_NO_EXCEPTIONS
|
|
for (size_t __n_left = __n; __n_left; --__n_left, ++__end_)
|
|
::new ((void*)__end_) value_type();
|
|
#ifndef _LIBCPP_NO_EXCEPTIONS
|
|
}
|
|
catch (...)
|
|
{
|
|
__clear(__n);
|
|
throw;
|
|
}
|
|
#endif // _LIBCPP_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_NO_EXCEPTIONS
|
|
try
|
|
{
|
|
#endif // _LIBCPP_NO_EXCEPTIONS
|
|
for (size_t __n_left = __n; __n_left; ++__end_, ++__p, --__n_left)
|
|
::new ((void*)__end_) value_type(*__p);
|
|
#ifndef _LIBCPP_NO_EXCEPTIONS
|
|
}
|
|
catch (...)
|
|
{
|
|
__clear(__n);
|
|
throw;
|
|
}
|
|
#endif // _LIBCPP_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_NO_EXCEPTIONS
|
|
try
|
|
{
|
|
#endif // _LIBCPP_NO_EXCEPTIONS
|
|
for (value_type* __p = __v.__begin_; __p != __v.__end_; ++__end_, ++__p)
|
|
::new ((void*)__end_) value_type(*__p);
|
|
#ifndef _LIBCPP_NO_EXCEPTIONS
|
|
}
|
|
catch (...)
|
|
{
|
|
__clear(__v.size());
|
|
throw;
|
|
}
|
|
#endif // _LIBCPP_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_NO_EXCEPTIONS
|
|
try
|
|
{
|
|
#endif // _LIBCPP_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_NO_EXCEPTIONS
|
|
}
|
|
catch (...)
|
|
{
|
|
__clear(__n);
|
|
throw;
|
|
}
|
|
#endif // _LIBCPP_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_NO_EXCEPTIONS
|
|
try
|
|
{
|
|
#endif // _LIBCPP_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_NO_EXCEPTIONS
|
|
}
|
|
catch (...)
|
|
{
|
|
__clear(__n);
|
|
throw;
|
|
}
|
|
#endif // _LIBCPP_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_NO_EXCEPTIONS
|
|
try
|
|
{
|
|
#endif // _LIBCPP_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_NO_EXCEPTIONS
|
|
}
|
|
catch (...)
|
|
{
|
|
__clear(__n);
|
|
throw;
|
|
}
|
|
#endif // _LIBCPP_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_NO_EXCEPTIONS
|
|
try
|
|
{
|
|
#endif // _LIBCPP_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_NO_EXCEPTIONS
|
|
}
|
|
catch (...)
|
|
{
|
|
__clear(__n);
|
|
throw;
|
|
}
|
|
#endif // _LIBCPP_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_NO_EXCEPTIONS
|
|
try
|
|
{
|
|
#endif // _LIBCPP_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_NO_EXCEPTIONS
|
|
}
|
|
catch (...)
|
|
{
|
|
__clear(__n);
|
|
throw;
|
|
}
|
|
#endif // _LIBCPP_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;
|
|
_VSTD::uninitialized_copy(__f, __l, __begin_);
|
|
} else {
|
|
_VSTD::copy(__f, __l, __begin_);
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
template <class _Tp>
|
|
valarray<_Tp>&
|
|
valarray<_Tp>::operator=(const valarray& __v)
|
|
{
|
|
if (this != _VSTD::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)
|
|
{
|
|
_VSTD::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>
|
|
inline
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
valarray<_Tp>&
|
|
>::type
|
|
valarray<_Tp>::operator*=(const _Expr& __v)
|
|
{
|
|
size_t __i = 0;
|
|
for (value_type* __t = __begin_; __t != __end_ ; ++__t, ++__i)
|
|
*__t *= __v[__i];
|
|
return *this;
|
|
}
|
|
|
|
template <class _Tp>
|
|
template <class _Expr>
|
|
inline
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
valarray<_Tp>&
|
|
>::type
|
|
valarray<_Tp>::operator/=(const _Expr& __v)
|
|
{
|
|
size_t __i = 0;
|
|
for (value_type* __t = __begin_; __t != __end_ ; ++__t, ++__i)
|
|
*__t /= __v[__i];
|
|
return *this;
|
|
}
|
|
|
|
template <class _Tp>
|
|
template <class _Expr>
|
|
inline
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
valarray<_Tp>&
|
|
>::type
|
|
valarray<_Tp>::operator%=(const _Expr& __v)
|
|
{
|
|
size_t __i = 0;
|
|
for (value_type* __t = __begin_; __t != __end_ ; ++__t, ++__i)
|
|
*__t %= __v[__i];
|
|
return *this;
|
|
}
|
|
|
|
template <class _Tp>
|
|
template <class _Expr>
|
|
inline
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
valarray<_Tp>&
|
|
>::type
|
|
valarray<_Tp>::operator+=(const _Expr& __v)
|
|
{
|
|
size_t __i = 0;
|
|
for (value_type* __t = __begin_; __t != __end_ ; ++__t, ++__i)
|
|
*__t += __v[__i];
|
|
return *this;
|
|
}
|
|
|
|
template <class _Tp>
|
|
template <class _Expr>
|
|
inline
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
valarray<_Tp>&
|
|
>::type
|
|
valarray<_Tp>::operator-=(const _Expr& __v)
|
|
{
|
|
size_t __i = 0;
|
|
for (value_type* __t = __begin_; __t != __end_ ; ++__t, ++__i)
|
|
*__t -= __v[__i];
|
|
return *this;
|
|
}
|
|
|
|
template <class _Tp>
|
|
template <class _Expr>
|
|
inline
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
valarray<_Tp>&
|
|
>::type
|
|
valarray<_Tp>::operator^=(const _Expr& __v)
|
|
{
|
|
size_t __i = 0;
|
|
for (value_type* __t = __begin_; __t != __end_ ; ++__t, ++__i)
|
|
*__t ^= __v[__i];
|
|
return *this;
|
|
}
|
|
|
|
template <class _Tp>
|
|
template <class _Expr>
|
|
inline
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
valarray<_Tp>&
|
|
>::type
|
|
valarray<_Tp>::operator|=(const _Expr& __v)
|
|
{
|
|
size_t __i = 0;
|
|
for (value_type* __t = __begin_; __t != __end_ ; ++__t, ++__i)
|
|
*__t |= __v[__i];
|
|
return *this;
|
|
}
|
|
|
|
template <class _Tp>
|
|
template <class _Expr>
|
|
inline
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
valarray<_Tp>&
|
|
>::type
|
|
valarray<_Tp>::operator&=(const _Expr& __v)
|
|
{
|
|
size_t __i = 0;
|
|
for (value_type* __t = __begin_; __t != __end_ ; ++__t, ++__i)
|
|
*__t &= __v[__i];
|
|
return *this;
|
|
}
|
|
|
|
template <class _Tp>
|
|
template <class _Expr>
|
|
inline
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
valarray<_Tp>&
|
|
>::type
|
|
valarray<_Tp>::operator<<=(const _Expr& __v)
|
|
{
|
|
size_t __i = 0;
|
|
for (value_type* __t = __begin_; __t != __end_ ; ++__t, ++__i)
|
|
*__t <<= __v[__i];
|
|
return *this;
|
|
}
|
|
|
|
template <class _Tp>
|
|
template <class _Expr>
|
|
inline
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
valarray<_Tp>&
|
|
>::type
|
|
valarray<_Tp>::operator>>=(const _Expr& __v)
|
|
{
|
|
size_t __i = 0;
|
|
for (value_type* __t = __begin_; __t != __end_ ; ++__t, ++__i)
|
|
*__t >>= __v[__i];
|
|
return *this;
|
|
}
|
|
|
|
template <class _Tp>
|
|
inline
|
|
void
|
|
valarray<_Tp>::swap(valarray& __v) _NOEXCEPT
|
|
{
|
|
_VSTD::swap(__begin_, __v.__begin_);
|
|
_VSTD::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 *_VSTD::min_element(__begin_, __end_);
|
|
}
|
|
|
|
template <class _Tp>
|
|
inline
|
|
_Tp
|
|
valarray<_Tp>::max() const
|
|
{
|
|
if (__begin_ == __end_)
|
|
return value_type();
|
|
return *_VSTD::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 = _VSTD::min(__i, static_cast<int>(__n));
|
|
__sb = __begin_ + __i;
|
|
__tb = __r.__begin_;
|
|
__te = __r.__begin_ + (__n - __i);
|
|
}
|
|
else
|
|
{
|
|
__i = _VSTD::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_NO_EXCEPTIONS
|
|
try
|
|
{
|
|
#endif // _LIBCPP_NO_EXCEPTIONS
|
|
for (size_t __n_left = __n; __n_left; --__n_left, ++__end_)
|
|
::new ((void*)__end_) value_type(__x);
|
|
#ifndef _LIBCPP_NO_EXCEPTIONS
|
|
}
|
|
catch (...)
|
|
{
|
|
__clear(__n);
|
|
throw;
|
|
}
|
|
#endif // _LIBCPP_NO_EXCEPTIONS
|
|
}
|
|
}
|
|
|
|
template<class _Tp>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
void
|
|
swap(valarray<_Tp>& __x, valarray<_Tp>& __y) _NOEXCEPT
|
|
{
|
|
__x.swap(__y);
|
|
}
|
|
|
|
template<class _Expr1, class _Expr2>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value,
|
|
__val_expr<_BinaryOp<multiplies<typename _Expr1::value_type>, _Expr1, _Expr2> >
|
|
>::type
|
|
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>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
__val_expr<_BinaryOp<multiplies<typename _Expr::value_type>,
|
|
_Expr, __scalar_expr<typename _Expr::value_type> > >
|
|
>::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>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
__val_expr<_BinaryOp<multiplies<typename _Expr::value_type>,
|
|
__scalar_expr<typename _Expr::value_type>, _Expr> >
|
|
>::type
|
|
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>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value,
|
|
__val_expr<_BinaryOp<divides<typename _Expr1::value_type>, _Expr1, _Expr2> >
|
|
>::type
|
|
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>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
__val_expr<_BinaryOp<divides<typename _Expr::value_type>,
|
|
_Expr, __scalar_expr<typename _Expr::value_type> > >
|
|
>::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>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
__val_expr<_BinaryOp<divides<typename _Expr::value_type>,
|
|
__scalar_expr<typename _Expr::value_type>, _Expr> >
|
|
>::type
|
|
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>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value,
|
|
__val_expr<_BinaryOp<modulus<typename _Expr1::value_type>, _Expr1, _Expr2> >
|
|
>::type
|
|
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>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
__val_expr<_BinaryOp<modulus<typename _Expr::value_type>,
|
|
_Expr, __scalar_expr<typename _Expr::value_type> > >
|
|
>::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>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
__val_expr<_BinaryOp<modulus<typename _Expr::value_type>,
|
|
__scalar_expr<typename _Expr::value_type>, _Expr> >
|
|
>::type
|
|
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>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value,
|
|
__val_expr<_BinaryOp<plus<typename _Expr1::value_type>, _Expr1, _Expr2> >
|
|
>::type
|
|
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>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
__val_expr<_BinaryOp<plus<typename _Expr::value_type>,
|
|
_Expr, __scalar_expr<typename _Expr::value_type> > >
|
|
>::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>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
__val_expr<_BinaryOp<plus<typename _Expr::value_type>,
|
|
__scalar_expr<typename _Expr::value_type>, _Expr> >
|
|
>::type
|
|
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>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value,
|
|
__val_expr<_BinaryOp<minus<typename _Expr1::value_type>, _Expr1, _Expr2> >
|
|
>::type
|
|
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>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
__val_expr<_BinaryOp<minus<typename _Expr::value_type>,
|
|
_Expr, __scalar_expr<typename _Expr::value_type> > >
|
|
>::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>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
__val_expr<_BinaryOp<minus<typename _Expr::value_type>,
|
|
__scalar_expr<typename _Expr::value_type>, _Expr> >
|
|
>::type
|
|
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>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value,
|
|
__val_expr<_BinaryOp<bit_xor<typename _Expr1::value_type>, _Expr1, _Expr2> >
|
|
>::type
|
|
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>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
__val_expr<_BinaryOp<bit_xor<typename _Expr::value_type>,
|
|
_Expr, __scalar_expr<typename _Expr::value_type> > >
|
|
>::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>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
__val_expr<_BinaryOp<bit_xor<typename _Expr::value_type>,
|
|
__scalar_expr<typename _Expr::value_type>, _Expr> >
|
|
>::type
|
|
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>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value,
|
|
__val_expr<_BinaryOp<bit_and<typename _Expr1::value_type>, _Expr1, _Expr2> >
|
|
>::type
|
|
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>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
__val_expr<_BinaryOp<bit_and<typename _Expr::value_type>,
|
|
_Expr, __scalar_expr<typename _Expr::value_type> > >
|
|
>::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>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
__val_expr<_BinaryOp<bit_and<typename _Expr::value_type>,
|
|
__scalar_expr<typename _Expr::value_type>, _Expr> >
|
|
>::type
|
|
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>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value,
|
|
__val_expr<_BinaryOp<bit_or<typename _Expr1::value_type>, _Expr1, _Expr2> >
|
|
>::type
|
|
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>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
__val_expr<_BinaryOp<bit_or<typename _Expr::value_type>,
|
|
_Expr, __scalar_expr<typename _Expr::value_type> > >
|
|
>::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>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
__val_expr<_BinaryOp<bit_or<typename _Expr::value_type>,
|
|
__scalar_expr<typename _Expr::value_type>, _Expr> >
|
|
>::type
|
|
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>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value,
|
|
__val_expr<_BinaryOp<__bit_shift_left<typename _Expr1::value_type>, _Expr1, _Expr2> >
|
|
>::type
|
|
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>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
__val_expr<_BinaryOp<__bit_shift_left<typename _Expr::value_type>,
|
|
_Expr, __scalar_expr<typename _Expr::value_type> > >
|
|
>::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>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
__val_expr<_BinaryOp<__bit_shift_left<typename _Expr::value_type>,
|
|
__scalar_expr<typename _Expr::value_type>, _Expr> >
|
|
>::type
|
|
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>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value,
|
|
__val_expr<_BinaryOp<__bit_shift_right<typename _Expr1::value_type>, _Expr1, _Expr2> >
|
|
>::type
|
|
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>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
__val_expr<_BinaryOp<__bit_shift_right<typename _Expr::value_type>,
|
|
_Expr, __scalar_expr<typename _Expr::value_type> > >
|
|
>::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>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
__val_expr<_BinaryOp<__bit_shift_right<typename _Expr::value_type>,
|
|
__scalar_expr<typename _Expr::value_type>, _Expr> >
|
|
>::type
|
|
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>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value,
|
|
__val_expr<_BinaryOp<logical_and<typename _Expr1::value_type>, _Expr1, _Expr2> >
|
|
>::type
|
|
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>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
__val_expr<_BinaryOp<logical_and<typename _Expr::value_type>,
|
|
_Expr, __scalar_expr<typename _Expr::value_type> > >
|
|
>::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>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
__val_expr<_BinaryOp<logical_and<typename _Expr::value_type>,
|
|
__scalar_expr<typename _Expr::value_type>, _Expr> >
|
|
>::type
|
|
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>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value,
|
|
__val_expr<_BinaryOp<logical_or<typename _Expr1::value_type>, _Expr1, _Expr2> >
|
|
>::type
|
|
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>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
__val_expr<_BinaryOp<logical_or<typename _Expr::value_type>,
|
|
_Expr, __scalar_expr<typename _Expr::value_type> > >
|
|
>::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>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
__val_expr<_BinaryOp<logical_or<typename _Expr::value_type>,
|
|
__scalar_expr<typename _Expr::value_type>, _Expr> >
|
|
>::type
|
|
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>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value,
|
|
__val_expr<_BinaryOp<equal_to<typename _Expr1::value_type>, _Expr1, _Expr2> >
|
|
>::type
|
|
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>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
__val_expr<_BinaryOp<equal_to<typename _Expr::value_type>,
|
|
_Expr, __scalar_expr<typename _Expr::value_type> > >
|
|
>::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>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
__val_expr<_BinaryOp<equal_to<typename _Expr::value_type>,
|
|
__scalar_expr<typename _Expr::value_type>, _Expr> >
|
|
>::type
|
|
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>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value,
|
|
__val_expr<_BinaryOp<not_equal_to<typename _Expr1::value_type>, _Expr1, _Expr2> >
|
|
>::type
|
|
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>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
__val_expr<_BinaryOp<not_equal_to<typename _Expr::value_type>,
|
|
_Expr, __scalar_expr<typename _Expr::value_type> > >
|
|
>::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>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
__val_expr<_BinaryOp<not_equal_to<typename _Expr::value_type>,
|
|
__scalar_expr<typename _Expr::value_type>, _Expr> >
|
|
>::type
|
|
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>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value,
|
|
__val_expr<_BinaryOp<less<typename _Expr1::value_type>, _Expr1, _Expr2> >
|
|
>::type
|
|
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>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
__val_expr<_BinaryOp<less<typename _Expr::value_type>,
|
|
_Expr, __scalar_expr<typename _Expr::value_type> > >
|
|
>::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>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
__val_expr<_BinaryOp<less<typename _Expr::value_type>,
|
|
__scalar_expr<typename _Expr::value_type>, _Expr> >
|
|
>::type
|
|
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>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value,
|
|
__val_expr<_BinaryOp<greater<typename _Expr1::value_type>, _Expr1, _Expr2> >
|
|
>::type
|
|
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>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
__val_expr<_BinaryOp<greater<typename _Expr::value_type>,
|
|
_Expr, __scalar_expr<typename _Expr::value_type> > >
|
|
>::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>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
__val_expr<_BinaryOp<greater<typename _Expr::value_type>,
|
|
__scalar_expr<typename _Expr::value_type>, _Expr> >
|
|
>::type
|
|
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>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value,
|
|
__val_expr<_BinaryOp<less_equal<typename _Expr1::value_type>, _Expr1, _Expr2> >
|
|
>::type
|
|
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>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
__val_expr<_BinaryOp<less_equal<typename _Expr::value_type>,
|
|
_Expr, __scalar_expr<typename _Expr::value_type> > >
|
|
>::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>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
__val_expr<_BinaryOp<less_equal<typename _Expr::value_type>,
|
|
__scalar_expr<typename _Expr::value_type>, _Expr> >
|
|
>::type
|
|
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>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value,
|
|
__val_expr<_BinaryOp<greater_equal<typename _Expr1::value_type>, _Expr1, _Expr2> >
|
|
>::type
|
|
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>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
__val_expr<_BinaryOp<greater_equal<typename _Expr::value_type>,
|
|
_Expr, __scalar_expr<typename _Expr::value_type> > >
|
|
>::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>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
__val_expr<_BinaryOp<greater_equal<typename _Expr::value_type>,
|
|
__scalar_expr<typename _Expr::value_type>, _Expr> >
|
|
>::type
|
|
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>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
__val_expr<_UnaryOp<__abs_expr<typename _Expr::value_type>, _Expr> >
|
|
>::type
|
|
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>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
__val_expr<_UnaryOp<__acos_expr<typename _Expr::value_type>, _Expr> >
|
|
>::type
|
|
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>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
__val_expr<_UnaryOp<__asin_expr<typename _Expr::value_type>, _Expr> >
|
|
>::type
|
|
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>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
__val_expr<_UnaryOp<__atan_expr<typename _Expr::value_type>, _Expr> >
|
|
>::type
|
|
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>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value,
|
|
__val_expr<_BinaryOp<__atan2_expr<typename _Expr1::value_type>, _Expr1, _Expr2> >
|
|
>::type
|
|
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>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
__val_expr<_BinaryOp<__atan2_expr<typename _Expr::value_type>,
|
|
_Expr, __scalar_expr<typename _Expr::value_type> > >
|
|
>::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>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
__val_expr<_BinaryOp<__atan2_expr<typename _Expr::value_type>,
|
|
__scalar_expr<typename _Expr::value_type>, _Expr> >
|
|
>::type
|
|
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>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
__val_expr<_UnaryOp<__cos_expr<typename _Expr::value_type>, _Expr> >
|
|
>::type
|
|
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>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
__val_expr<_UnaryOp<__cosh_expr<typename _Expr::value_type>, _Expr> >
|
|
>::type
|
|
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>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
__val_expr<_UnaryOp<__exp_expr<typename _Expr::value_type>, _Expr> >
|
|
>::type
|
|
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>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
__val_expr<_UnaryOp<__log_expr<typename _Expr::value_type>, _Expr> >
|
|
>::type
|
|
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>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
__val_expr<_UnaryOp<__log10_expr<typename _Expr::value_type>, _Expr> >
|
|
>::type
|
|
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>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value,
|
|
__val_expr<_BinaryOp<__pow_expr<typename _Expr1::value_type>, _Expr1, _Expr2> >
|
|
>::type
|
|
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>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
__val_expr<_BinaryOp<__pow_expr<typename _Expr::value_type>,
|
|
_Expr, __scalar_expr<typename _Expr::value_type> > >
|
|
>::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>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
__val_expr<_BinaryOp<__pow_expr<typename _Expr::value_type>,
|
|
__scalar_expr<typename _Expr::value_type>, _Expr> >
|
|
>::type
|
|
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>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
__val_expr<_UnaryOp<__sin_expr<typename _Expr::value_type>, _Expr> >
|
|
>::type
|
|
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>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
__val_expr<_UnaryOp<__sinh_expr<typename _Expr::value_type>, _Expr> >
|
|
>::type
|
|
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>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
__val_expr<_UnaryOp<__sqrt_expr<typename _Expr::value_type>, _Expr> >
|
|
>::type
|
|
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>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
__val_expr<_UnaryOp<__tan_expr<typename _Expr::value_type>, _Expr> >
|
|
>::type
|
|
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>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
typename enable_if
|
|
<
|
|
__is_val_expr<_Expr>::value,
|
|
__val_expr<_UnaryOp<__tanh_expr<typename _Expr::value_type>, _Expr> >
|
|
>::type
|
|
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_INLINE_VISIBILITY
|
|
_Tp*
|
|
begin(valarray<_Tp>& __v)
|
|
{
|
|
return __v.__begin_;
|
|
}
|
|
|
|
template <class _Tp>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
const _Tp*
|
|
begin(const valarray<_Tp>& __v)
|
|
{
|
|
return __v.__begin_;
|
|
}
|
|
|
|
template <class _Tp>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
_Tp*
|
|
end(valarray<_Tp>& __v)
|
|
{
|
|
return __v.__end_;
|
|
}
|
|
|
|
template <class _Tp>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
const _Tp*
|
|
end(const valarray<_Tp>& __v)
|
|
{
|
|
return __v.__end_;
|
|
}
|
|
|
|
_LIBCPP_END_NAMESPACE_STD
|
|
|
|
_LIBCPP_POP_MACROS
|
|
|
|
#endif // _LIBCPP_VALARRAY
|