valarray

标准库标头<valarray>

此标头是数字图书馆。

班

valarray	numeric arrays and array slices (class template)
slice	BLAS-like slice of a valarray: starting index, length, stride (class)
slice_array	proxy to a subset of a valarray after applying a slice (class template)
gslice	generalized slice of a valarray: starting index, set of lengths, set of strides (class)
gslice_array	proxy to a subset of a valarray after applying a gslice (class template)
mask_array	proxy to a subset of a valarray after applying a boolean mask operator
indirect_array	proxy to a subset of a valarray after applying indirect operator

功能

操作

*。

调换%28std：：valArray%29%28C++11%29专门用于std：：swp%28%29算法%28函数模板%29

Std：：开始%28std：：valArray%29%28C++11%29专门用于std：：BEGIN%28函数模板%29

std：：end%28 std：：valArray%29%28C++11%29专门的std：：end%28函数模板%29

运算符+运算符%2A操作符/运算符%运算符和运算符运算符^运算符<<operator>>运算符&运算符将二进制运算符应用于两个valArray或valArray和值%28函数模板%29的每个元素。

运算符==运算符%21=运算符<运算符<=运算符>>=比较两个值数组或值为%28函数模板%29的valArray

ABS%28std：：valArray%29将函数std：：abs应用于valArray%28函数模板%29的每个元素

指数函数

Exp%28std：：valArray%29将函数std：：exp应用于valArray%28函数模板%29的每个元素

log%28std：：valArray%29将函数std：：log应用于valArray%28函数模板%29的每个元素

log 10%28std：：valArray%29将函数std：：log 10应用于valArray%28函数模板%29的每个元素

幂函数

POW%28std：：valArray%29将函数std：：pow应用于两个valArray或valArray和值%28的函数模板%29

sqrt%28std：：valArray%29将函数std：：sqrt应用于valArray%28函数模板%29的每个元素

三角函数

sin%28 std：：valArray%29将函数std：：sin应用于valArray%28函数模板%29的每个元素

Cos%28std：：valArray%29将函数std：：cos应用于valArray%28函数模板%29的每个元素

Tan%28 std：：valArray%29将函数std：：Tan应用于valArray%28函数模板%29的每个元素

Asin%28std：：valArray%29将函数std：：asin应用于valArray%28函数模板%29的每个元素

ACOS%28std：：valArray%29将函数std：：acos应用于valArray%28函数模板%29的每个元素

Atan%28std：：valArray%29将函数std：：atan应用于valArray%28函数模板%29的每个元素

atan 2%28std：：valArray%29将函数std：：atan 2应用于valArray，并将值%28的函数模板%29应用于valArray。

双曲函数

Sinh%28std：：valArray%29将函数std：：sinh应用于valArray%28函数模板%29的每个元素

COSH%28std：：valArray%29将函数std：：cosh应用于valArray%28函数模板%29的每个元素

Tanh%28std：：valArray%29将函数std：：tanh应用于valArray%28函数模板%29的每个元素

简介

二次

#include <initializer_list>
 
namespace std {
    template<class T> class valarray;       // An array of type T
    class slice;                            // a BLAS-like slice out of an array
    template<class T> class slice_array;   
    class gslice;                           // a generalized slice out of an array
    template<class T> class gslice_array;
    template<class T> class mask_array;     // a masked array
    template<class T> class indirect_array; // an indirected 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 T&
    template<class T> valarray<T> operator* (const T&, 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 T&
    template<class T> valarray<T> operator/ (const T&, 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 T&
    template<class T> valarray<T> operator% (const T&, 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 T&
    template<class T> valarray<T> operator+ (const T&, 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 T&
    template<class T> valarray<T> operator- (const T&, 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 T&
    template<class T> valarray<T> operator^ (const T&, 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 T&
    template<class T> valarray<T> operator& (const T&, 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 T&
    template<class T> valarray<T> operator| (const T&, 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 T&
    template<class T> valarray<T> operator<<(const T&, 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 T&
    template<class T> valarray<T> operator>>(const T&, 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 T&
    template<class T> valarray<bool> operator&&(const T&, 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 T&
    template<class T> valarray<bool> operator||(const T&, 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 T&
    template<class T> valarray<bool> operator==(const T&, 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 T&
    template<class T> valarray<bool> operator!=(const T&, 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 T&
    template<class T> valarray<bool> operator< (const T&, 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 T&
    template<class T> valarray<bool> operator> (const T&, 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 T&
    template<class T> valarray<bool> operator<=(const T&, 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 T&
    template<class T> valarray<bool> operator>=(const T&, 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 T&
    template<class T> valarray<T> atan2(const T&, 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 T&
    template<class T> valarray<T> pow(const T&, 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>  /*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::valarray

二次

namespace std {
    template<class T> class valarray {
    public:
        typedef T value_type;
 
        // 26.6.2.2 construct/destroy:
        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(
 
        // 26.6.2.3 assignment:
        valarray<T>& operator=(const valarray<T>&
        valarray<T>& operator=(valarray<T>&&) noexcept;
        valarray& operator=(initializer_list<T>
        valarray<T>& operator=(const T&
        valarray<T>& operator=(const slice_array<T>&
        valarray<T>& operator=(const gslice_array<T>&
        valarray<T>& operator=(const mask_array<T>&
        valarray<T>& operator=(const indirect_array<T>&
 
        // 26.6.2.4 element access:
        const T&        operator[](size_t) const;
        T&              operator[](size_t
 
        // 26.6.2.5 subset operations:
        valarray<T>             operator[](slice) const;
        slice_array<T>          operator[](slice
        valarray<T>             operator[](const gslice&) const;
        gslice_array<T>         operator[](const gslice&
        valarray<T>             operator[](const valarray<bool>&) const;
        mask_array<T>           operator[](const valarray<bool>&
        valarray<T>             operator[](const valarray<size_t>&) const;
        indirect_array<T>       operator[](const valarray<size_t>&
 
        // 26.6.2.6 unary operators:
        valarray<T> operator+() const;
        valarray<T> operator-() const;
        valarray<T> operator~() const;
        valarray<bool> operator!() const;
 
        // 26.6.2.7 computed assignment:
        valarray<T>& operator*= (const T&
        valarray<T>& operator/= (const T&
        valarray<T>& operator%= (const T&
        valarray<T>& operator+= (const T&
        valarray<T>& operator-= (const T&
        valarray<T>& operator^= (const T&
        valarray<T>& operator&= (const T&
        valarray<T>& operator|= (const T&
        valarray<T>& operator<<=(const T&
        valarray<T>& operator>>=(const T&
 
        valarray<T>& operator*= (const valarray<T>&
        valarray<T>& operator/= (const valarray<T>&
        valarray<T>& operator%= (const valarray<T>&
        valarray<T>& operator+= (const valarray<T>&
        valarray<T>& operator-= (const valarray<T>&
        valarray<T>& operator^= (const valarray<T>&
        valarray<T>& operator|= (const valarray<T>&
        valarray<T>& operator&= (const valarray<T>&
        valarray<T>& operator<<=(const valarray<T>&
        valarray<T>& operator>>=(const valarray<T>&
 
        // 26.6.2.8 member functions:
        void swap(valarray&) noexcept;
 
        size_t size() const;
 
        T sum() const;
        T min() const;
        T max() const;
 
        valarray<T> shift (int) const;
        valarray<T> cshift(int) const;
        valarray<T> apply(T func(T)) const;
        valarray<T> apply(T func(const T&)) const;
        void resize(size_t sz, T c = 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;
    };
}

二次

std::slice_array

二次

namespace std {
template <class T> class slice_array {
    public:
        typedef T value_type;
 
        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;
        // as implied by declaring copy constructor above
    };
}

二次

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:
        typedef T value_type;
        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;        // as implied by declaring copy constructor above
    };
}

二次

std::mask_array

二次

namespace std {
    template <class T> class mask_array {
    public:
        typedef T value_type;
 
        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;        // as implied by declaring copy constructor above
    };
}

二次

std::indirect_array

二次

namespace std {
    template <class T> class indirect_array {
    public:
        typedef T value_type;
 
        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; // as implied by declaring copy constructor above
    };
}

二次

 © cppreference.com

在CreativeCommonsAttribution下授权-ShareAlike未移植许可v3.0。

http：//en.cppreference.com/w/cpp/报头/valArray