Standard library header <valarray>

From cppreference.net

< cpp ‎ | header

Dieser Header ist Teil der numeric Bibliothek.

Inhaltsverzeichnis

Includes

<initializer_list>

(C++11)

std::initializer_list Klassentemplate

Klassen

valarray

Numerische Arrays und Array-Ausschnitte
(Klassentemplate)

slice

BLAS-ähnlicher Ausschnitt eines valarray: Startindex, Länge, Schrittweite
(Klasse)

slice_array

Stellvertreter für eine Teilmenge eines valarray nach Anwendung eines slice
(Klassentemplate)

gslice

verallgemeinerter Ausschnitt eines valarray: Startindex, Menge von Längen, Menge von Schrittwerten
(Klasse)

gslice_array

Stellvertreter für eine Teilmenge eines valarray nach Anwendung eines gslice
(Klassentemplate)

mask_array

Stellvertreter für eine Teilmenge eines valarray nach Anwendung einer booleschen Maske


          operator[]

(Klassentemplate)

indirect_array

Stellvertreter für eine Teilmenge eines valarray nach Anwendung des indirekten


          operator[]

(Klassentemplate)

Funktionen

Operationen

std::swap (std::valarray)

(C++11)

spezialisiert den std::swap Algorithmus
(Funktionsschablone)

std::begin (std::valarray)

(C++11)

überlädt std::begin
(Funktions-Template)

std::end (std::valarray)

(C++11)

spezialisiert std::end
(Funktions-Template)

operator+ operator- operator* operator/ operator% operator& operator| operator^ operator<< operator>> operator&& operator||

wendet binäre Operatoren auf jedes Element von zwei valarrays oder einem valarray und einem Wert an
(Funktionsschablone)

operator== operator!= operator< operator<= operator> operator>=

vergleicht zwei valarrays oder ein valarray mit einem Wert
(Funktionsschablone)

abs (std::valarray)

wendet die Funktion abs auf jedes Element des valarray an
(Funktions-Template)

Exponentialfunktionen

exp (std::valarray)

wendet die Funktion std::exp auf jedes Element des valarray an
(Funktions-Template)

log (std::valarray)

wendet die Funktion std::log auf jedes Element des valarray an
(Funktions-Template)

log10 (std::valarray)

wendet die Funktion std::log10 auf jedes Element des valarray an
(Funktions-Template)

Potenzfunktionen

pow (std::valarray)

wendet die Funktion std::pow auf zwei valarrays oder ein valarray und einen Wert an
(Funktions-Template)

sqrt (std::valarray)

wendet die Funktion std::sqrt auf jedes Element des valarray an
(Funktions-Template)

Trigonometrische Funktionen

sin (std::valarray)

wendet die Funktion std::sin auf jedes Element des valarray an
(Funktions-Template)

cos (std::valarray)

wendet die Funktion std::cos auf jedes Element des valarray an
(Funktions-Template)

tan (std::valarray)

wendet die Funktion std::tan auf jedes Element des valarray an
(Funktions-Template)

asin (std::valarray)

wendet die Funktion std::asin auf jedes Element des valarray an
(Funktions-Template)

acos (std::valarray)

wendet die Funktion std::acos auf jedes Element des valarray an
(Funktions-Template)

atan (std::valarray)

wendet die Funktion std::atan auf jedes Element des valarray an
(Funktions-Template)

atan2 (std::valarray)

wendet die Funktion std::atan2 auf ein valarray und einen Wert an
(Funktions-Template)

Hyperbolische Funktionen

sinh (std::valarray)

wendet die Funktion std::sinh auf jedes Element des valarray an
(Funktions-Template)

cosh (std::valarray)

wendet die Funktion std::cosh auf jedes Element des valarray an
(Funktions-Template)

tanh (std::valarray)

wendet die Funktion std::tanh auf jedes Element des valarray an
(Funktions-Template)

Übersicht

#include <initializer_list>
namespace std {
  template<class T> class valarray;         // Ein Array vom Typ T
  class slice;                              // ein BLAS-ähnlicher Ausschnitt aus einem Array
  template<class T> class slice_array;
  class gslice;                             // ein generalisierter Ausschnitt aus einem Array
  template<class T> class gslice_array;
  template<class T> class mask_array;       // ein maskiertes Array
  template<class T> class indirect_array;   // ein indirektes 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);
}

Klassentemplate std::valarray

namespace std {
  template<class T> class valarray {
  public:
    using value_type = T;
    // Konstruieren/Zerstören
    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();
    // Zuweisung
    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>&);
    // Elementzugriff
    const T&          operator[](size_t) const;
    T&                operator[](size_t);
    // Teilmengenoperationen
    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>&);
    // unäre Operatoren
    valarray operator+() const;
    valarray operator-() const;
    valarray operator~() const;
    valarray<bool> operator!() const;
    // zusammengesetzte Zuweisung
    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&);
    // Memberfunktionen
    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>;
}

Klasse 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);
  };
}

**Anmerkung:** Der gesamte Inhalt innerhalb des `

`-Tags ist C++-Code und wurde gemäß den Anweisungen nicht übersetzt. Da der Code keine beschreibenden Textelemente enthält, die übersetzt werden müssten, bleibt die Ausgabe identisch mit der Eingabe.

Klassentemplate 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;     // wie durch die Deklaration des Kopierkonstruktors oben impliziert
  };
}

Klasse 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;
  };
}

Klassentemplate 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;    // wie durch die Deklaration des Kopierkonstruktors oben impliziert
  };
}

Klassentemplate 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;      // wie durch die Deklaration des Kopierkonstruktors oben impliziert
  };
}

Klassentemplate 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;  // wie durch die Deklaration des Kopierkonstruktors oben impliziert
  };
}

Fehlerberichte

Die folgenden verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.

DR	Angewendet auf	Verhalten wie veröffentlicht	Korrigiertes Verhalten
LWG 125	C++98	der Rückgabetyp von `valarray<T>::operator!()` war valarray < T > in der Synopsis	korrigiert zu valarray < bool >

Compiler support
Freestanding and hosted
Language
Standard library
Standard library headers
Named requirements
Feature test macros (C++20)
Language support library
Concepts library (C++20)
Diagnostics library
Memory management library
Metaprogramming library (C++11)
General utilities library
Containers library
Iterators library
Ranges library (C++20)
Algorithms library
Strings library
Text processing library
Numerics library
Date and time library
Input/output library
Filesystem library (C++17)
Concurrency support library (C++11)
Execution control library (C++26)
Technical specifications
Symbols index
External libraries

cppreference.net

Namespaces

Variants

Standard library header <valarray>

Inhaltsverzeichnis

Includes

Klassen

Funktionen

Operationen

Exponentialfunktionen

Potenzfunktionen

Trigonometrische Funktionen

Hyperbolische Funktionen

Übersicht

Klassentemplate std::valarray

Klasse std::slice

Klassentemplate std::slice_array

Klasse std::gslice

Klassentemplate std::gslice_array

Klassentemplate std::mask_array

Klassentemplate std::indirect_array

Fehlerberichte