# 标准库头文件 <valarray>

< cpp‎ | header

此头文件是数值库的一部分。

### 类
valarray | 数值数组与数组切片 (类模板)
slice | valarray 的 BLAS 式切片：起始下标、长度、跨度 (类)
slice_array | 到 valarray 应用 slice 后的子集的代理 (类模板)
gslice | valarray 的通用切片：起始下标、长度集、步幅集 (类)
gslice_array | valarray 应用 gslice 后的子集的代理 (类模板)
mask_array | 到应用布尔掩码 `operator[]` 后的 valarray 子集的代理 (类模板)
indirect_array | 到应用间接 `operator[]` 后的 valarray 子集的代理。 (类模板)
### 函数
##### 操作
std::swap(std::valarray) (C++11) | 特化 std::swap() 算法 (函数模板)
std::begin(std::valarray) (C++11) | 特化的 std::begin (函数模板)
std::end(std::valarray) (C++11) | 特化的 std::end (函数模板)
operator+operator-operator*operator/operator%operator&operator|operator^operator<<operator>>operator&&operator|| | 对两个 valarray 的每个元素，或一个 valarray 的每个元素和一个值运用二元运算符 (函数模板)
operator==operator!=operator<operator<=operator>operator>= | 比较两个 valarrays，或比较一个 valarray 和一个值 (函数模板)
abs(std::valarray) | 应用函数 std::abs 到 valarray 的每个元素 (函数模板)
##### 指数函数
exp(std::valarray) | 应用函数 std::exp 到 valarray 的每个元素 (函数模板)
log(std::valarray) | 应用函数 std::log 到 valarray 的每个元素 (函数模板)
log10(std::valarray) | 应用函数 std::log10 到 valarray 的每个元素 (函数模板)
##### 幂函数
pow(std::valarray) | 应用函数 std::pow 到二个 valarray 或一个 valarray 与一个值 (函数模板)
sqrt(std::valarray) | 应用函数 std::sqrt 到 valarray 的每个元素 (函数模板)
##### 三角函数
sin(std::valarray) | 对 valarray 的每个元素应用std::sin函数 (函数模板)
cos(std::valarray) | 应用函数 std::cos 到 valarray 的每个元素 (函数模板)
tan(std::valarray) | 应用函数 std::tan 到 valarray 的每个元素 (函数模板)
asin(std::valarray) | 应用函数 std::asin 到 valarray 的每个元素 (函数模板)
acos(std::valarray) | 应用函数 std::acos 到 valarray 的每个元素 (函数模板)
atan(std::valarray) | 应用函数 std::atan 到 valarray 的每个元素 (函数模板)
atan2(std::valarray) | 应用函数 std::atan2 到一个 valarray 和一个值 (函数模板)
##### 双曲函数
sinh(std::valarray) | 在 valarray 的每个元素上调用 std::sinh 函数 (函数模板)
cosh(std::valarray) | 在 valarray 的每个元素上调用 std::cosh 函数 (函数模板)
tanh(std::valarray) | 在 valarray 的每个元素上调用 std::tanh 函数 (函数模板)

### 概要

    #include <initializer_list>

    namespace std {
      template<class T> class valarray;         // T 类型的数组
      class slice;                              // 数组上的 BLAS 式切片
      template<class T> class slice_array;
      class gslice;                             // 数组上的广义切片
      template<class T> class gslice_array;
      template<class T> class mask_array;       // 掩码数组
      template<class T> class indirect_array;   // 间接数组

      template<class T> void swap(valarray<T>&, valarray<T>&) noexcept;

      template<class T> valarray<T> operator* (const valarray<T>&, const valarray<T>&);
      template<class T> valarray<T> operator* (const valarray<T>&,
                                               const typename valarray<T>::value_type&);
      template<class T> valarray<T> operator* (const typename valarray<T>::value_type&,
                                               const valarray<T>&);

      template<class T> valarray<T> operator/ (const valarray<T>&, const valarray<T>&);
      template<class T> valarray<T> operator/ (const valarray<T>&,
                                               const typename valarray<T>::value_type&);
      template<class T> valarray<T> operator/ (const typename valarray<T>::value_type&,
                                               const valarray<T>&);

      template<class T> valarray<T> operator% (const valarray<T>&, const valarray<T>&);
      template<class T> valarray<T> operator% (const valarray<T>&,
                                               const typename valarray<T>::value_type&);
      template<class T> valarray<T> operator% (const typename valarray<T>::value_type&,
                                               const valarray<T>&);

      template<class T> valarray<T> operator+ (const valarray<T>&, const valarray<T>&);
      template<class T> valarray<T> operator+ (const valarray<T>&,
                                               const typename valarray<T>::value_type&);
      template<class T> valarray<T> operator+ (const typename valarray<T>::value_type&,
                                               const valarray<T>&);

      template<class T> valarray<T> operator- (const valarray<T>&, const valarray<T>&);
      template<class T> valarray<T> operator- (const valarray<T>&,
                                               const typename valarray<T>::value_type&);
      template<class T> valarray<T> operator- (const typename valarray<T>::value_type&,
                                               const valarray<T>&);

      template<class T> valarray<T> operator^ (const valarray<T>&, const valarray<T>&);
      template<class T> valarray<T> operator^ (const valarray<T>&,
                                               const typename valarray<T>::value_type&);
      template<class T> valarray<T> operator^ (const typename valarray<T>::value_type&,
                                               const valarray<T>&);

      template<class T> valarray<T> operator& (const valarray<T>&, const valarray<T>&);
      template<class T> valarray<T> operator& (const valarray<T>&,
                                               const typename valarray<T>::value_type&);
      template<class T> valarray<T> operator& (const typename valarray<T>::value_type&,
                                               const valarray<T>&);

      template<class T> valarray<T> operator| (const valarray<T>&, const valarray<T>&);
      template<class T> valarray<T> operator| (const valarray<T>&,
                                               const typename valarray<T>::value_type&);
      template<class T> valarray<T> operator| (const typename valarray<T>::value_type&,
                                               const valarray<T>&);

      template<class T> valarray<T> operator<<(const valarray<T>&, const valarray<T>&);
      template<class T> valarray<T> operator<<(const valarray<T>&,
                                               const typename valarray<T>::value_type&);
      template<class T> valarray<T> operator<<(const typename valarray<T>::value_type&,
                                               const valarray<T>&);

      template<class T> valarray<T> operator>>(const valarray<T>&, const valarray<T>&);
      template<class T> valarray<T> operator>>(const valarray<T>&,
                                               const typename valarray<T>::value_type&);
      template<class T> valarray<T> operator>>(const typename valarray<T>::value_type&,
                                               const valarray<T>&);

      template<class T> valarray<bool> operator&&(const valarray<T>&, const valarray<T>&);
      template<class T> valarray<bool> operator&&(const valarray<T>&,
                                                  const typename valarray<T>::value_type&);
      template<class T> valarray<bool> operator&&(const typename valarray<T>::value_type&,
                                                  const valarray<T>&);

      template<class T> valarray<bool> operator||(const valarray<T>&, const valarray<T>&);
      template<class T> valarray<bool> operator||(const valarray<T>&,
                                                  const typename valarray<T>::value_type&);
      template<class T> valarray<bool> operator||(const typename valarray<T>::value_type&,
                                                  const valarray<T>&);

      template<class T> valarray<bool> operator==(const valarray<T>&, const valarray<T>&);
      template<class T> valarray<bool> operator==(const valarray<T>&,
                                                  const typename valarray<T>::value_type&);
      template<class T> valarray<bool> operator==(const typename valarray<T>::value_type&,
                                                  const valarray<T>&);
      template<class T> valarray<bool> operator!=(const valarray<T>&, const valarray<T>&);
      template<class T> valarray<bool> operator!=(const valarray<T>&,
                                                  const typename valarray<T>::value_type&);
      template<class T> valarray<bool> operator!=(const typename valarray<T>::value_type&,
                                                  const valarray<T>&);

      template<class T> valarray<bool> operator< (const valarray<T>&, const valarray<T>&);
      template<class T> valarray<bool> operator< (const valarray<T>&,
                                                  const typename valarray<T>::value_type&);
      template<class T> valarray<bool> operator< (const typename valarray<T>::value_type&,
                                                  const valarray<T>&);
      template<class T> valarray<bool> operator> (const valarray<T>&, const valarray<T>&);
      template<class T> valarray<bool> operator> (const valarray<T>&,
                                                  const typename valarray<T>::value_type&);
      template<class T> valarray<bool> operator> (const typename valarray<T>::value_type&,
                                                  const valarray<T>&);
      template<class T> valarray<bool> operator<=(const valarray<T>&, const valarray<T>&);
      template<class T> valarray<bool> operator<=(const valarray<T>&,
                                                  const typename valarray<T>::value_type&);
      template<class T> valarray<bool> operator<=(const typename valarray<T>::value_type&,
                                                  const valarray<T>&);
      template<class T> valarray<bool> operator>=(const valarray<T>&, const valarray<T>&);
      template<class T> valarray<bool> operator>=(const valarray<T>&,
                                                  const typename valarray<T>::value_type&);
      template<class T> valarray<bool> operator>=(const typename valarray<T>::value_type&,
                                                  const valarray<T>&);

      template<class T> valarray<T> abs  (const valarray<T>&);
      template<class T> valarray<T> acos (const valarray<T>&);
      template<class T> valarray<T> asin (const valarray<T>&);
      template<class T> valarray<T> atan (const valarray<T>&);

      template<class T> valarray<T> atan2(const valarray<T>&, const valarray<T>&);
      template<class T> valarray<T> atan2(const valarray<T>&,
                                          const typename valarray<T>::value_type&);
      template<class T> valarray<T> atan2(const typename valarray<T>::value_type&,
                                          const valarray<T>&);

      template<class T> valarray<T> cos  (const valarray<T>&);
      template<class T> valarray<T> cosh (const valarray<T>&);
      template<class T> valarray<T> exp  (const valarray<T>&);
      template<class T> valarray<T> log  (const valarray<T>&);
      template<class T> valarray<T> log10(const valarray<T>&);

      template<class T> valarray<T> pow(const valarray<T>&, const valarray<T>&);
      template<class T> valarray<T> pow(const valarray<T>&,
                                        const typename valarray<T>::value_type&);
      template<class T> valarray<T> pow(const typename valarray<T>::value_type&,
                                        const valarray<T>&);

      template<class T> valarray<T> sin  (const valarray<T>&);
      template<class T> valarray<T> sinh (const valarray<T>&);
      template<class T> valarray<T> sqrt (const valarray<T>&);
      template<class T> valarray<T> tan  (const valarray<T>&);
      template<class T> valarray<T> tanh (const valarray<T>&);

      template<class T> /* 未指明 1 */ begin(valarray<T>& v);
      template<class T> /* 未指明 2 */ begin(const valarray<T>& v);
      template<class T> /* 未指明 1 */ end(valarray<T>& v);
      template<class T> /* 未指明 2 */ end(const valarray<T>& v);
    }

### 类模板 std::valarray

    namespace std {
      template<class T> class valarray {
      public:
        using value_type = T;

        // 构造/析构
        valarray();
        explicit valarray(size_t);
        valarray(const T&, size_t);
        valarray(const T*, size_t);
        valarray(const valarray&);
        valarray(valarray&&) noexcept;
        valarray(const slice_array<T>&);
        valarray(const gslice_array<T>&);
        valarray(const mask_array<T>&);
        valarray(const indirect_array<T>&);
        valarray(initializer_list<T>);
        ~valarray();

        // 赋值
        valarray& operator=(const valarray&);
        valarray& operator=(valarray&&) noexcept;
        valarray& operator=(initializer_list<T>);
        valarray& operator=(const T&);
        valarray& operator=(const slice_array<T>&);
        valarray& operator=(const gslice_array<T>&);
        valarray& operator=(const mask_array<T>&);
        valarray& operator=(const indirect_array<T>&);

        // 元素访问
        const T&          operator[](size_t) const;
        T&                operator[](size_t);

        // 子集操作
        valarray          operator[](slice) const;
        slice_array<T>    operator[](slice);
        valarray          operator[](const gslice&) const;
        gslice_array<T>   operator[](const gslice&);
        valarray          operator[](const valarray<bool>&) const;
        mask_array<T>     operator[](const valarray<bool>&);
        valarray          operator[](const valarray<size_t>&) const;
        indirect_array<T> operator[](const valarray<size_t>&);

        // 一元运算符
        valarray operator+() const;
        valarray operator-() const;
        valarray operator~() const;
        valarray<bool> operator!() const;

        // 复合赋值
        valarray& operator*= (const T&);
        valarray& operator/= (const T&);
        valarray& operator%= (const T&);
        valarray& operator+= (const T&);
        valarray& operator-= (const T&);
        valarray& operator^= (const T&);
        valarray& operator&= (const T&);
        valarray& operator|= (const T&);
        valarray& operator<<=(const T&);
        valarray& operator>>=(const T&);

        valarray& operator*= (const valarray&);
        valarray& operator/= (const valarray&);
        valarray& operator%= (const valarray&);
        valarray& operator+= (const valarray&);
        valarray& operator-= (const valarray&);
        valarray& operator^= (const valarray&);
        valarray& operator|= (const valarray&);
        valarray& operator&= (const valarray&);
        valarray& operator<<=(const valarray&);
        valarray& operator>>=(const valarray&);

        // 成员函数
        void swap(valarray&) noexcept;

        size_t size() const;

        T sum() const;
        T min() const;
        T max() const;

        valarray shift (int) const;
        valarray cshift(int) const;
        valarray apply(T func(T)) const;
        valarray apply(T func(const T&)) const;
        void resize(size_t sz, T c = T());
      };

      template<class T, size_t cnt> valarray(const T(&)[cnt], size_t) -> valarray<T>;
    }

### 类 std::slice

    namespace std {
      class slice {
      public:
        slice();
        slice(size_t, size_t, size_t);

        size_t start() const;
        size_t size() const;
        size_t stride() const;

        friend bool operator==(const slice& x, const slice& y);
      };
    }

### 类模板 std::slice_array

    namespace std {
      template<class T> class slice_array {
      public:
        using value_type = T;

        void operator=  (const valarray<T>&) const;
        void operator*= (const valarray<T>&) const;
        void operator/= (const valarray<T>&) const;
        void operator%= (const valarray<T>&) const;
        void operator+= (const valarray<T>&) const;
        void operator-= (const valarray<T>&) const;
        void operator^= (const valarray<T>&) const;
        void operator&= (const valarray<T>&) const;
        void operator|= (const valarray<T>&) const;
        void operator<<=(const valarray<T>&) const;
        void operator>>=(const valarray<T>&) const;

        slice_array(const slice_array&);
        ~slice_array();
        const slice_array& operator=(const slice_array&) const;
        void operator=(const T&) const;

        slice_array() = delete;     // 上面声明的复制构造函数所隐含
      };
    }

### 类 std::gslice

    namespace std {
      class gslice {
      public:
        gslice();
        gslice(size_t s, const valarray<size_t>& l, const valarray<size_t>& d);

        size_t           start() const;
        valarray<size_t> size() const;
        valarray<size_t> stride() const;
      };
    }

### 类模板 std::gslice_array

    namespace std {
      template<class T> class gslice_array {
      public:
        using value_type = T;

        void operator=  (const valarray<T>&) const;
        void operator*= (const valarray<T>&) const;
        void operator/= (const valarray<T>&) const;
        void operator%= (const valarray<T>&) const;
        void operator+= (const valarray<T>&) const;
        void operator-= (const valarray<T>&) const;
        void operator^= (const valarray<T>&) const;
        void operator&= (const valarray<T>&) const;
        void operator|= (const valarray<T>&) const;
        void operator<<=(const valarray<T>&) const;
        void operator>>=(const valarray<T>&) const;

        gslice_array(const gslice_array&);
        ~gslice_array();
        const gslice_array& operator=(const gslice_array&) const;
        void operator=(const T&) const;

        gslice_array() = delete;    // 上面声明的复制构造函数所隐含
      };
    }

### 类模板 std::mask_array

    namespace std {
      template<class T> class mask_array {
      public:
        using value_type = T;

        void operator=  (const valarray<T>&) const;
        void operator*= (const valarray<T>&) const;
        void operator/= (const valarray<T>&) const;
        void operator%= (const valarray<T>&) const;
        void operator+= (const valarray<T>&) const;
        void operator-= (const valarray<T>&) const;
        void operator^= (const valarray<T>&) const;
        void operator&= (const valarray<T>&) const;
        void operator|= (const valarray<T>&) const;
        void operator<<=(const valarray<T>&) const;
        void operator>>=(const valarray<T>&) const;

        mask_array(const mask_array&);
        ~mask_array();
        const mask_array& operator=(const mask_array&) const;
        void operator=(const T&) const;

        mask_array() = delete;      // 上面声明的复制构造函数所隐含
      };
    }

### 类模板 std::indirect_array

    namespace std {
      template<class T> class indirect_array {
      public:
        using value_type = T;

        void operator=  (const valarray<T>&) const;
        void operator*= (const valarray<T>&) const;
        void operator/= (const valarray<T>&) const;
        void operator%= (const valarray<T>&) const;
        void operator+= (const valarray<T>&) const;
        void operator-= (const valarray<T>&) const;
        void operator^= (const valarray<T>&) const;
        void operator&= (const valarray<T>&) const;
        void operator|= (const valarray<T>&) const;
        void operator<<=(const valarray<T>&) const;
        void operator>>=(const valarray<T>&) const;

        indirect_array(const indirect_array&);
        ~indirect_array();
        const indirect_array& operator=(const indirect_array&) const;
        void operator=(const T&) const;

        indirect_array() = delete;  // 上面声明的复制构造函数所隐含
      };
    }