Namespaces
Variants
Actions

Standard library header <valarray>

From cppreference.com
< cpp‎ | header
 
 
Standard library headers
Algorithms
<algorithm>
<numeric>
Strings
<cctype>
<cstring>
<cuchar> (C++11)
<cwchar>
<cwctype>
<string_view> (C++17)
<string>
Text processing
<clocale>
<codecvt> (C++11/17/26*)
<locale>
<regex> (C++11)
<text_encoding> (C++26)   
Numerics
<cfenv> (C++11)
<cmath>
<complex>
<linalg> (C++26)
<numbers> (C++20)
<random> (C++11)
<simd> (C++26)
<stdckdint.h> (C++26)
<valarray>
Time
<chrono> (C++11)
<ctime>
C compatibility
<ccomplex> (C++11/17/20*)
<ciso646> (until C++20)
<cstdalign> (C++11/17/20*)
<cstdbool> (C++11/17/20*)
<ctgmath> (C++11/17/20*)
 

This header is part of the numeric library.

Contents

Includes

std::initializer_list class template[edit]

Classes

Numeric arrays and array slices
(class template) BLAS-like slice of a valarray: starting index, length, stride
(class) [edit] proxy to a subset of a valarray after applying a slice
(class template) [edit] generalized slice of a valarray: starting index, set of lengths, set of strides
(class) [edit] proxy to a subset of a valarray after applying a gslice
(class template) [edit] proxy to a subset of a valarray after applying a boolean mask operator[]
(class template) [edit] proxy to a subset of a valarray after applying indirect operator[]
(class template) [edit]

Functions

Operations
specializes the std::swap algorithm
(function template) [edit] overloads std::begin
(function template) [edit] specializes std::end
(function template) [edit] applies binary operators to each element of two valarrays, or a valarray and a value
(function template) [edit] compares two valarrays or a valarray with a value
(function template) [edit] applies the function abs to each element of valarray
(function template) [edit]
Exponential functions
applies the function std::exp to each element of valarray
(function template) [edit] applies the function std::log to each element of valarray
(function template) [edit] applies the function std::log10 to each element of valarray
(function template) [edit]
Power functions
applies the function std::pow to two valarrays or a valarray and a value
(function template) [edit] applies the function std::sqrt to each element of valarray
(function template) [edit]
Trigonometric functions
applies the function std::sin to each element of valarray
(function template) [edit] applies the function std::cos to each element of valarray
(function template) [edit] applies the function std::tan to each element of valarray
(function template) [edit] applies the function std::asin to each element of valarray
(function template) [edit] applies the function std::acos to each element of valarray
(function template) [edit] applies the function std::atan to each element of valarray
(function template) [edit] applies the function std::atan2 to a valarray and a value
(function template) [edit]
Hyperbolic functions
applies the function std::sinh to each element of valarray
(function template) [edit] applies the function std::cosh to each element of valarray
(function template) [edit] applies the function std::tanh to each element of valarray
(function template) [edit]

[edit] Synopsis

#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 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> /* 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);
}

[edit] Class template std::valarray 

namespace std {
 template<class T> class valarray {
 public:
 using value_type = T;
 
 // 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();
 
 // assignment
 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>&);
 
 // element access
 const T& operator[](size_t) const;
 T& operator[](size_t);
 
 // subset operations
 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>&);
 
 // unary operators
 valarray operator+() const;
 valarray operator-() const;
 valarray operator~() const;
 valarray<bool> operator!() const;
 
 // compound assignment
 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&);
 
 // member functions
 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>;
}

[edit] Class 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);
 };
}

[edit] Class template 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; // as implied by declaring copy constructor above
 };
}

[edit] Class 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;
 };
}

[edit] Class template 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; // as implied by declaring copy constructor above
 };
}

[edit] Class template 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; // as implied by declaring copy constructor above
 };
}

[edit] Class template 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; // as implied by declaring copy constructor above
 };
}

[edit] Defect reports

The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

DR Applied to Behavior as published Correct behavior
LWG 125 C++98 the return type of valarray<T>::operator!()
was valarray<T> in the synopsis 		corrected to valarray<bool>

AltStyle によって変換されたページ (->オリジナル) /