---
name: "std::valarray"
section: "3cxx"
platform: "linux"
package: "libstdc++-12-doc"
version: "12.4.0-5"
release: "Debian 13 (Trixie)"
platforms: ["linux"]
url: "https://new.carta.tech/std::valarray/3cxx"
---

# std::valarray(3cxx)

Smart array designed to support numeric processing.

## NAME

std::valarray\< \_Tp \> - Smart array designed to support numeric processing.

## SYNOPSIS

`#include <valarray>`

### Public Types

**typedef** \_Tp **value\_type**\

### Public Member Functions

**valarray** () noexcept\
 Construct an empty array.  template\<**class** **\_Dom** \> **valarray** (const \_Expr\< **\_Dom**, \_Tp \> &\_\_e)\
 **valarray** (const \_Tp &, size\_t)\
 Construct an array with *n* elements initialized to *t*.  template\<**typename** \_Tp \> **valarray** (const \_Tp \***\_\_restrict\_\_** \_\_p, size\_t \_\_n)\
 **valarray** (const \_Tp \***\_\_restrict\_\_**, size\_t)\
 Construct an array initialized to the first *n* elements of *t*.  **valarray** (const **gslice\_array**\< \_Tp \> &)\
 Construct an array with the same size and values in *ga*.  **valarray** (const **indirect\_array**\< \_Tp \> &)\
 Construct an array with the same size and values in *ia*.  **valarray** (const **mask\_array**\< \_Tp \> &)\
 Construct an array with the same size and values in *ma*.  **valarray** (const **slice\_array**\< \_Tp \> &)\
 Construct an array with the same size and values in *sa*.  **valarray** (const **valarray** &)\
 Copy constructor.  template\<**typename** \_Tp \> **valarray** (const **valarray**\< \_Tp \> &**\_\_v**)\
 **valarray** (**initializer\_list**\< \_Tp \>)\
 Construct an array with an initializer\_list of values.  **valarray** (size\_t)\
 Construct an array with *n* elements.  **valarray** (**valarray** &&) noexcept\
 Move constructor.  template\<**typename** \_Tp \> **valarray** (**valarray**\< \_Tp \> &&**\_\_v**) noexcept\
 \_Expr\< \_ValFunClos\< \_ValArray, \_Tp \>, \_Tp \> **apply** (\_Tp **\_\_func**(\_Tp)) const\
 Apply a function to the array.  \_Expr\< \_RefFunClos\< \_ValArray, \_Tp \>, \_Tp \> **apply** (\_Tp **\_\_func**(const \_Tp &)) const\
 Apply a function to the array.  **valarray**\< \_Tp \> **cshift** (int \_\_n) const\
 Return a rotated array.  \_Tp **max** () const\
 Return the maximum element using operator\<().  \_Tp **min** () const\
 Return the minimum element using operator\<().  \_UnaryOp\< \_\_logical\_not \>::\_Rt **operator!** () const\
 Return a new valarray by applying unary ! to each element.  template\<**class** **\_Dom** \> **valarray**\< \_Tp \> & **operator%=** (const \_Expr\< **\_Dom**, \_Tp \> &)\
 **valarray**\< \_Tp \> & **operator%=** (const \_Tp &)\
 Set each element e of array to e % *t*.  **valarray**\< \_Tp \> & **operator%=** (const **valarray**\< \_Tp \> &)\
 Modulo elements of array by corresponding elements of *v*.  template\<**class** **\_Dom** \> **valarray**\< \_Tp \> & **operator&=** (const \_Expr\< **\_Dom**, \_Tp \> &)\
 **valarray**\< \_Tp \> & **operator&=** (const \_Tp &)\
 Set each element e of array to e & *t*.  **valarray**\< \_Tp \> & **operator&=** (const **valarray**\< \_Tp \> &)\
 Logical and corresponding elements of *v* with elements of array.  template\<**class** **\_Dom** \> **valarray**\< \_Tp \> & **operator\*=** (const \_Expr\< **\_Dom**, \_Tp \> &)\
 **valarray**\< \_Tp \> & **operator\*=** (const \_Tp &)\
 Multiply each element of array by *t*.  **valarray**\< \_Tp \> & **operator\*=** (const **valarray**\< \_Tp \> &)\
 Multiply elements of array by corresponding elements of *v*.  \_UnaryOp\< \_\_unary\_plus \>::\_Rt **operator+** () const\
 Return a new valarray by applying unary + to each element.  template\<**class** **\_Dom** \> **valarray**\< \_Tp \> & **operator+=** (const \_Expr\< **\_Dom**, \_Tp \> &)\
 **valarray**\< \_Tp \> & **operator+=** (const \_Tp &)\
 Add *t* to each element of array.  **valarray**\< \_Tp \> & **operator+=** (const **valarray**\< \_Tp \> &)\
 Add corresponding elements of *v* to elements of array.  \_UnaryOp\< \_\_negate \>::\_Rt **operator-** () const\
 Return a new valarray by applying unary - to each element.  template\<**class** **\_Dom** \> **valarray**\< \_Tp \> & **operator-=** (const \_Expr\< **\_Dom**, \_Tp \> &)\
 **valarray**\< \_Tp \> & **operator-=** (const \_Tp &)\
 Subtract *t* to each element of array.  **valarray**\< \_Tp \> & **operator-=** (const **valarray**\< \_Tp \> &)\
 Subtract corresponding elements of *v* from elements of array.  template\<**class** **\_Dom** \> **valarray**\< \_Tp \> & **operator/=** (const \_Expr\< **\_Dom**, \_Tp \> &)\
 **valarray**\< \_Tp \> & **operator/=** (const \_Tp &)\
 Divide each element of array by *t*.  **valarray**\< \_Tp \> & **operator/=** (const **valarray**\< \_Tp \> &)\
 Divide elements of array by corresponding elements of *v*.  template\<**class** **\_Dom** \> **valarray**\< \_Tp \> & **operator\<\<=** (const \_Expr\< **\_Dom**, \_Tp \> &)\
 **valarray**\< \_Tp \> & **operator\<\<=** (const \_Tp &)\
 Left shift each element e of array by *t* bits.  **valarray**\< \_Tp \> & **operator\<\<=** (const **valarray**\< \_Tp \> &)\
 Left shift elements of array by corresponding elements of *v*.  template\<**class** **\_Dom** \> **valarray**\< \_Tp \> & **operator=** (const \_Expr\< **\_Dom**, \_Tp \> &)\
 **valarray**\< \_Tp \> & **operator=** (const \_Tp &\_\_t)\
 Assign elements to a value.  **valarray**\< \_Tp \> & **operator=** (const **gslice\_array**\< \_Tp \> &**\_\_ga**)\
 Assign elements to an array subset.  **valarray**\< \_Tp \> & **operator=** (const **indirect\_array**\< \_Tp \> &**\_\_ia**)\
 Assign elements to an array subset.  **valarray**\< \_Tp \> & **operator=** (const **mask\_array**\< \_Tp \> &**\_\_ma**)\
 Assign elements to an array subset.  **valarray**\< \_Tp \> & **operator=** (const **slice\_array**\< \_Tp \> &**\_\_sa**)\
 Assign elements to an array subset.  **valarray**\< \_Tp \> & **operator=** (const **valarray**\< \_Tp \> &**\_\_v**)\
 Assign elements to an array.  **valarray** & **operator=** (**initializer\_list**\< \_Tp \> **\_\_l**)\
 Assign elements to an initializer\_list.  **valarray**\< \_Tp \> & **operator=** (**valarray**\< \_Tp \> &&**\_\_v**) noexcept\
 Move assign elements to an array.  template\<**class** **\_Dom** \> **valarray**\< \_Tp \> & **operator\>\>=** (const \_Expr\< **\_Dom**, \_Tp \> &)\
 **valarray**\< \_Tp \> & **operator\>\>=** (const \_Tp &)\
 Right shift each element e of array by *t* bits.  **valarray**\< \_Tp \> & **operator\>\>=** (const **valarray**\< \_Tp \> &)\
 Right shift elements of array by corresponding elements of *v*.  **gslice\_array**\< \_Tp \> **operator\[\]** (const **gslice** &**\_\_s**)\
 Return a reference to an array subset.  \_Expr\< \_GClos\< \_ValArray, \_Tp \>, \_Tp \> **operator\[\]** (const **gslice** &**\_\_s**) const\
 Return an array subset.  **mask\_array**\< \_Tp \> **operator\[\]** (const **valarray**\< bool \> &**\_\_m**)\
 Return a reference to an array subset.  **valarray**\< \_Tp \> **operator\[\]** (const **valarray**\< bool \> &**\_\_m**) const\
 Return an array subset.  **indirect\_array**\< \_Tp \> **operator\[\]** (const **valarray**\< size\_t \> &\_\_i)\
 Return a reference to an array subset.  \_Expr\< \_IClos\< \_ValArray, \_Tp \>, \_Tp \> **operator\[\]** (const **valarray**\< size\_t \> &\_\_i) const\
 Return an array subset.  \_Tp & **operator\[\]** (size\_t \_\_i) noexcept\
 const \_Tp & **operator\[\]** (size\_t) const noexcept\
 **slice\_array**\< \_Tp \> **operator\[\]** (**slice** **\_\_s**)\
 Return a reference to an array subset.  \_Expr\< \_SClos\< \_ValArray, \_Tp \>, \_Tp \> **operator\[\]** (**slice** **\_\_s**) const\
 Return an array subset.  template\<**class** **\_Dom** \> **valarray**\< \_Tp \> & **operator^=** (const \_Expr\< **\_Dom**, \_Tp \> &)\
 **valarray**\< \_Tp \> & **operator^=** (const \_Tp &)\
 Set each element e of array to e ^ *t*.  **valarray**\< \_Tp \> & **operator^=** (const **valarray**\< \_Tp \> &)\
 Logical xor corresponding elements of *v* with elements of array.  template\<**class** **\_Dom** \> **valarray**\< \_Tp \> & **operator\|=** (const \_Expr\< **\_Dom**, \_Tp \> &)\
 **valarray**\< \_Tp \> & **operator\|=** (const \_Tp &)\
 Set each element e of array to e \| *t*.  **valarray**\< \_Tp \> & **operator\|=** (const **valarray**\< \_Tp \> &)\
 Logical or corresponding elements of *v* with elements of array.  \_UnaryOp\< \_\_bitwise\_not \>::\_Rt **operator~** () const\
 Return a new valarray by applying unary ~ to each element.  **void** **resize** (size\_t **\_\_size**, \_Tp \_\_c=\_Tp())\
 Resize array.  **valarray**\< \_Tp \> **shift** (int \_\_n) const\
 Return a shifted array.  size\_t **size** () const\
 Return the number of elements in array.  \_Tp **sum** () const\
 Return the sum of all elements in the array.  **void** **swap** (**valarray**\< \_Tp \> &**\_\_v**) noexcept\
 Swap.

### Friends

**struct** **\_Array\< \_Tp \>**\

## Detailed Description

### template\<class \_Tp\>

class std::valarray\< \_Tp \>"Smart array designed to support numeric processing.

A valarray is an array that provides constraints intended to allow for effective optimization of numeric array processing by reducing the aliasing that can result from pointer representations. It represents a one-dimensional array from which different multidimensional subsets can be accessed and modified.

**Template Parameters**

*\_Tp* Type of object in the array.

## Constructor & Destructor Documentation

### template\<class \_Tp \> std::valarray\< \_Tp \>::valarray (const \_Tp \* \_\_restrict\_\_, size\_t)

Construct an array initialized to the first *n* elements of *t*.

### template\<class \_Tp \> std::valarray\< \_Tp \>::valarray (const valarray\< \_Tp \> &)

Copy constructor.

### template\<class \_Tp \> std::valarray\< \_Tp \>::valarray (valarray\< \_Tp \> &&)` [noexcept]`

Move constructor.

## Member Function Documentation

### template\<class \_Tp \> \_UnaryOp\< \_\_logical\_not \>::\_Rt std::valarray\< \_Tp \>::operator! () const

Return a new valarray by applying unary ! to each element.

### template\<class \_Tp \> valarray\< \_Tp \> & std::valarray\< \_Tp \>::operator%= (const \_Tp &)

Set each element e of array to e % *t*.

### template\<class \_Tp \> valarray\< \_Tp \> & std::valarray\< \_Tp \>::operator%= (const valarray\< \_Tp \> &)

Modulo elements of array by corresponding elements of *v*.

### template\<class \_Tp \> valarray\< \_Tp \> & std::valarray\< \_Tp \>::operator&= (const \_Tp &)

Set each element e of array to e & *t*.

### template\<class \_Tp \> valarray\< \_Tp \> & std::valarray\< \_Tp \>::operator&= (const valarray\< \_Tp \> &)

Logical and corresponding elements of *v* with elements of array.

### template\<class \_Tp \> valarray\< \_Tp \> & std::valarray\< \_Tp \>::operator\*= (const \_Tp &)

Multiply each element of array by *t*.

### template\<class \_Tp \> valarray\< \_Tp \> & std::valarray\< \_Tp \>::operator\*= (const valarray\< \_Tp \> &)

Multiply elements of array by corresponding elements of *v*.

### template\<class \_Tp \> \_UnaryOp\< \_\_unary\_plus \>::\_Rt std::valarray\< \_Tp \>::operator+ () const

Return a new valarray by applying unary + to each element.

### template\<class \_Tp \> valarray\< \_Tp \> & std::valarray\< \_Tp \>::operator+= (const \_Tp &)

Add *t* to each element of array.

### template\<class \_Tp \> valarray\< \_Tp \> & std::valarray\< \_Tp \>::operator+= (const valarray\< \_Tp \> &)

Add corresponding elements of *v* to elements of array.

### template\<class \_Tp \> \_UnaryOp\< \_\_negate \>::\_Rt std::valarray\< \_Tp \>::operator- () const

Return a new valarray by applying unary - to each element.

### template\<class \_Tp \> valarray\< \_Tp \> & std::valarray\< \_Tp \>::operator-= (const \_Tp &)

Subtract *t* to each element of array.

### template\<class \_Tp \> valarray\< \_Tp \> & std::valarray\< \_Tp \>::operator-= (const valarray\< \_Tp \> &)

Subtract corresponding elements of *v* from elements of array.

### template\<class \_Tp \> valarray\< \_Tp \> & std::valarray\< \_Tp \>::operator/= (const \_Tp &)

Divide each element of array by *t*.

### template\<class \_Tp \> valarray\< \_Tp \> & std::valarray\< \_Tp \>::operator/= (const valarray\< \_Tp \> &)

Divide elements of array by corresponding elements of *v*.

### template\<class \_Tp \> valarray\< \_Tp \> & std::valarray\< \_Tp \>::operator\<\<= (const \_Tp &)

Left shift each element e of array by *t* bits.

### template\<class \_Tp \> valarray\< \_Tp \> & std::valarray\< \_Tp \>::operator\<\<= (const valarray\< \_Tp \> &)

Left shift elements of array by corresponding elements of *v*.

### template\<class \_Tp \> valarray\< \_Tp \> & std::valarray\< \_Tp \>::operator\>\>= (const \_Tp &)

Right shift each element e of array by *t* bits.

### template\<class \_Tp \> valarray\< \_Tp \> & std::valarray\< \_Tp \>::operator\>\>= (const valarray\< \_Tp \> &)

Right shift elements of array by corresponding elements of *v*.

### template\<class \_Tp \> valarray\< \_Tp \> & std::valarray\< \_Tp \>::operator^= (const \_Tp &)

Set each element e of array to e ^ *t*.

### template\<class \_Tp \> valarray\< \_Tp \> & std::valarray\< \_Tp \>::operator^= (const valarray\< \_Tp \> &)

Logical xor corresponding elements of *v* with elements of array.

### template\<class \_Tp \> valarray\< \_Tp \> & std::valarray\< \_Tp \>::operator\|= (const \_Tp &)

Set each element e of array to e \| *t*.

### template\<class \_Tp \> valarray\< \_Tp \> & std::valarray\< \_Tp \>::operator\|= (const valarray\< \_Tp \> &)

Logical or corresponding elements of *v* with elements of array.

### template\<class \_Tp \> \_UnaryOp\< \_\_bitwise\_not \>::\_Rt std::valarray\< \_Tp \>::operator~ () const

Return a new valarray by applying unary ~ to each element.

## Author

Generated automatically by Doxygen for libstdc++ from the source code.