STD::VALARRAY(3cxx)

📦
version 14-20240412 · 19 versions
, in ubuntu noble

💖 NAME 💖

Okay so bestie, this is std::valarray< _Tp > from manual section 3cxx — the smart array designed to support numeric processing ✨. That's the name and the whole vibe, periodt 💅.

✨ SYNOPSIS ✨

#include <valarray>

🎀 Public Types 🎀

  • typedef _Tp value_type — the value type of the array, no cap 💖

👑 Public Member Functions 👑

This is the full member-function roster, bestie — every overload is invited to the group chat 💅.

  • valarray () noexcept — constructs an empty array. Empty-array main character energy 🫶
  • template<class _Dom > valarray (const _Expr< _Dom, _Tp > &__e) — the _Expr constructor overload; the manual gives no extra one-liner here, but it's on the list and it counts 🌸
  • valarray (const _Tp &, size_t) — constructs an array with n elements initialized to t ✨
  • template<typename _Tp > valarray (const _Tp *__restrict__ __p, size_t __n) — the pointer-plus-size template constructor; manual has no extra description, but we are not leaving it out 📌
  • valarray (const _Tp *__restrict__, size_t) — constructs an array initialized to the first n elements of t — pointer girlie behavior 🌸
  • valarray (const gslice_array< _Tp > &) — constructs an array with the same size and values in ga 🎀
  • valarray (const indirect_array< _Tp > &) — constructs an array with the same size and values in ia 🦋
  • valarray (const mask_array< _Tp > &) — constructs an array with the same size and values in ma 💜
  • valarray (const slice_array< _Tp > &) — constructs an array with the same size and values in sa 🌈
  • valarray (const valarray &) — copy constructor. Copy-paste but make it classy 💅
  • valarray (initializer_list< _Tp >) — constructs an array with an initializer_list of values 🍓
  • valarray (size_t) — constructs an array with n elements ✨
  • valarray (valarray &&) noexcept — move constructor. Bye, but make it official 👋
  • _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, but this overload takes const _Tp & 💅
  • valarray< _Tp > cshift (int __n) const — returns a rotated array — circular shift slay 🌀
  • _Tp max () const — returns the maximum element using operator<() 👑
  • _Tp min () const — returns the minimum element using operator<() 🥺
  • _UnaryOp< __logical_not >::_Rt operator! () const — returns a new valarray by applying unary ! to each element 😭
  • template<class _Dom > valarray< _Tp > & operator%= (const _Expr< _Dom, _Tp > &) — the _Expr overload for %=; no extra description in the manual, but it's still invited 💅
  • valarray< _Tp > & operator%= (const _Tp &) — sets 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 > &) — the _Expr overload for &=; manual leaves this one description-less, we respect the mystery 🫶
  • valarray< _Tp > & operator&= (const _Tp &) — sets 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 > &) — the _Expr overload for *=; no extra blurb in the original, but it's on the roster 💅
  • 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 — returns a new valarray by applying unary + to each element ✨
  • template<class _Dom > valarray< _Tp > & operator+= (const _Expr< _Dom, _Tp > &) — the _Expr overload for +=; no extra description, still iconic 👑
  • 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 — returns a new valarray by applying unary - to each element 💅
  • template<class _Dom > valarray< _Tp > & operator-= (const _Expr< _Dom, _Tp > &) — the _Expr overload for -=; manual has no extra one-liner, but it's here 🫶
  • valarray< _Tp > & operator-= (const _Tp &) — subtract t from 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 > &) — the _Expr overload for /=; no extra description in the manual, but it's not getting left out 🌸
  • 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 > &) — the _Expr overload for <<=; manual leaves it description-less, we still love her 💅
  • 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 > &) — the _Expr assignment overload; no extra description in the manual, but it's on the list 🫶
  • 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 > &) — the _Expr overload for >>=; no extra description in the original, but she's here 💅
  • 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 — no extra description in the manual, but it's the size_t reference access and it's here 💅
  • const _Tp & operator[] (size_t) const noexcept — no extra description, const size_t access, still iconic 👑
  • 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 > &) — the _Expr overload for ^=; no extra description in the manual, but it stays 💅
  • 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 > &) — the _Expr overload for |=; manual gives no extra one-liner, still invited 🫶
  • 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 — returns a new valarray by applying unary ~ to each element 💅
  • void resize (size_t __size, _Tp __c=_Tp()) — resize array. The default for __c is _Tp() 🫶
  • 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. Periodt 💅

🦋 Friends 🦋

  • struct _Array< _Tp > — friend struct, no extra description in the manual; it's in the friend list, bestie 🫶

💖 Detailed Description 💖

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

Okay so 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. Slay, honestly 💅.

🌈 Template Parameters 🌈

  • _Tp — Type of object in the array. That's the template parameter, bestie ✨

🧚 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 — constructor documentation, but make it cute 🌸.

💖 Member Function Documentation 💖

okay bestie, this is the part where all the operators live — every single one of them, and yes there are a LOT, so buckle up 🎀. Two flavours of almost everything: one that takes a single value t (scalar mode, it hits every element) and one that takes another valarray v (element-by-element mode, position by position). Keep your eyes on which is which, iykyk ✨

  • template<class _Tp > _UnaryOp< __logical_not >::_Rt std::valarray< _Tp >::operator! () const — bestie this one doesn't touch the original at all, it hands you back a brand new valarray made 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 the elements of array by the corresponding elements of v, literally matchy-matchy 💅
  • 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 the corresponding elements of v with the elements of array, no cap ✨
  • 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 the elements of array by the corresponding elements of v 🦋
  • template<class _Tp > _UnaryOp< __unary_plus >::_Rt std::valarray< _Tp >::operator+ () const — returns a whole new valarray, built by applying unary + to each element, main character energy 👑
  • 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 the corresponding elements of v to the elements of array, cute and paired 💜
  • template<class _Tp > _UnaryOp< __negate >::_Rt std::valarray< _Tp >::operator- () const — new valarray, unary - applied to every element, iconic 😭
  • template<class _Tp > valarray< _Tp > & std::valarray< _Tp >::operator-= (const _Tp &) — subtract t from each element of array 🌈
  • template<class _Tp > valarray< _Tp > & std::valarray< _Tp >::operator-= (const valarray< _Tp > &) — subtract the corresponding elements of v from the 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 the elements of array by the 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 the elements of array by the 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 the elements of array by the 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 the corresponding elements of v with the 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 the corresponding elements of v with the elements of array, periodt 👑
  • template<class _Tp > _UnaryOp< __bitwise_not >::_Rt std::valarray< _Tp >::operator~ () const — last one bestie!! returns a fresh new valarray by applying unary ~ to each element 🎀✨
lowkey notice that the unary ones (!, +, -, ~) are const and give you back a new valarray, while the compound-assignment ones (%=, &=, *=, +=, -=, /=, <<=, >>=, ^=, |=) hand you back a valarray< _Tp > & and mutate in place. vibe check passed 💖

🌟 Author 🌟

Generated automatically by Doxygen for libstdc++ from the source code. yes bestie, a robot wrote this one, not me — I just gave it the group-chat glow-up 💫

and that's the whole page, we ate and left zero crumbs 🍓 this little beauty comes to you courtesy of libstdc++, and it's the std::valarray< _Tp >(3cxx) page — go forth and vectorize your little heart out, ily, bye 💜🦋🎀

📦 where this page comes from