operator+,-,*,/,%,&,|,^,<<,>>,&&,|| (std::valarray)

 

C++

Compiler-Unterstützung

Freestanding und gehostet

Sprache

Standardbibliothek

Header der Standardbibliothek

Benannte Anforderungen

Feature-Test-Makros (C++20)

Bibliothek für Sprachunterstützung

Konzepte-Bibliothek (C++20)

Diagnostik-Bibliothek

Speicherverwaltungsbibliothek

Metaprogrammierungsbibliothek (C++11)

Allgemeine Dienstprogramme-Bibliothek

Container-Bibliothek

Iterator-Bibliothek

Ranges-Bibliothek (C++20)

Algorithmen-Bibliothek

Bibliothek für Zeichenketten

Textverarbeitungsbibliothek

Numerik-Bibliothek

Datums- und Zeitbibliothek

Ein-/Ausgabe-Bibliothek

Dateisystembibliothek (C++17)

Unterstützung für nebenläufige Programmierung (C++11)

Ausführungssteuerungsbibliothek (C++26)

Technische Spezifikationen

Symbolverzeichnis

Externe Bibliotheken

 

Numerik-Bibliothek

Allgemeine mathematische Funktionen
Mathematische Spezialfunktionen (C++17)
Mathematische Konstanten (C++20)
Grundlegende lineare Algebra-Algorithmen (C++26)
Datenparallele Typen (SIMD) (C++26)
Gleitkomma-Umgebung (C++11)
Komplexe Zahlen
Numerische Arrays (valarray)
Pseudozufallszahlengenerierung
Bit-Manipulation (C++20)
Faktoroperationen
gcd (C++17)	lcm (C++17)
Interpolationen
midpoint (C++20)	lerp (C++20)
Sättigungsarithmetik
add_sat (C++26) sub_sat (C++26) saturate_cast (C++26)	mul_sat (C++26) div_sat (C++26)
Generische numerische Operationen
iota (C++11) ranges::iota (C++23) accumulate inner_product adjacent_difference    partial_sum	reduce (C++17) transform_reduce (C++17) inclusive_scan (C++17) exclusive_scan (C++17) transform_inclusive_scan (C++17) transform_exclusive_scan (C++17)

 

std::valarray

Memberfunktionen
valarray::valarray valarray::~valarray valarray::operator= valarray::operator[] valarray::swap valarray::size valarray::resize valarray::sum valarray::min valarray::max valarray::shift valarray::cshift valarray::apply	valarray::operator+valarray::operator-valarray::operator~valarray::operator! valarray::operator+=valarray::operator-=valarray::operator*=valarray::operator/=valarray::operator%=valarray::operator&=valarray::operator|=valarray::operator^=valarray::operator<<=valarray::operator>>=
Nicht-Member-Funktionen
swap(C++11) begin(C++11)   end(C++11) abs exp log log10 pow sqrt sin cos tan asin acos atan atan2 sinh cosh tanh	operator*operator/operator%operator+operator-operator^operator&operator|operator<<operator>>operator&&operator|| operator==operator!=operator<operator>operator<=operator>=
Hilfsklassen
slice_array gslice_array indirect_array	slice gslice mask_array
Deduktionsanleitungen (seit C++17)

 

Definiert in der Header-Datei <valarray>
template< class T > std::valarray<T> operator+ ( const std::valarray<T>& lhs, const std::valarray<T>& rhs ); template< class T > std::valarray<T> operator- ( const std::valarray<T>& lhs, const std::valarray<T>& rhs ); template< class T > std::valarray<T> operator* ( const std::valarray<T>& lhs, const std::valarray<T>& rhs ); template< class T > std::valarray<T> operator/ ( const std::valarray<T>& lhs, const std::valarray<T>& rhs ); template< class T > std::valarray<T> operator% ( const std::valarray<T>& lhs, const std::valarray<T>& rhs ); template< class T > std::valarray<T> operator& ( const std::valarray<T>& lhs, const std::valarray<T>& rhs ); template< class T > std::valarray<T> operator| ( const std::valarray<T>& lhs, const std::valarray<T>& rhs ); template< class T > std::valarray<T> operator^ ( const std::valarray<T>& lhs, const std::valarray<T>& rhs ); template< class T > std::valarray<T> operator<<( const std::valarray<T>& lhs, const std::valarray<T>& rhs ); template< class T > std::valarray<T> operator>>( const std::valarray<T>& lhs, const std::valarray<T>& rhs ); template< class T > std::valarray<bool> operator&&( const std::valarray<T>& lhs, const std::valarray<T>& rhs ); template< class T > std::valarray<bool> operator||( const std::valarray<T>& lhs, const std::valarray<T>& rhs );	(1)
template< class T > std::valarray<T> operator+ ( const typename std::valarray<T>::value_type & val,                              const std::valarray<T>& rhs ); template< class T > std::valarray<T> operator- ( const typename std::valarray<T>::value_type & val,                              const std::valarray<T>& rhs ); template< class T > std::valarray<T> operator* ( const typename std::valarray<T>::value_type & val,                              const std::valarray<T>& rhs ); template< class T > std::valarray<T> operator/ ( const typename std::valarray<T>::value_type & val,                              const std::valarray<T>& rhs ); template< class T > std::valarray<T> operator% ( const typename std::valarray<T>::value_type & val,                              const std::valarray<T>& rhs ); template< class T > std::valarray<T> operator& ( const typename std::valarray<T>::value_type & val,                              const std::valarray<T>& rhs ); template< class T > std::valarray<T> operator| ( const typename std::valarray<T>::value_type & val,                              const std::valarray<T>& rhs ); template< class T > std::valarray<T> operator^ ( const typename std::valarray<T>::value_type & val,                              const std::valarray<T>& rhs ); template< class T > std::valarray<T> operator<<( const typename std::valarray<T>::value_type & val,                              const std::valarray<T>& rhs ); template< class T > std::valarray<T> operator>>( const typename std::valarray<T>::value_type & val,                              const std::valarray<T>& rhs ); template< class T > std::valarray<bool> operator&&( const typename std::valarray<T>::value_type & val,                                 const std::valarray<T>& rhs ); template< class T > std::valarray<bool> operator||( const typename std::valarray<T>::value_type & val,                                 const std::valarray<T>& rhs );	(2)
template< class T > std::valarray<T> operator+ ( const std::valarray<T>& lhs,                              const typename std::valarray<T>::value_type & val ); template< class T > std::valarray<T> operator- ( const std::valarray<T>& lhs,                              const typename std::valarray<T>::value_type & val ); template< class T > std::valarray<T> operator* ( const std::valarray<T>& lhs,                              const typename std::valarray<T>::value_type & val ); template< class T > std::valarray<T> operator/ ( const std::valarray<T>& lhs,                              const typename std::valarray<T>::value_type & val ); template< class T > std::valarray<T> operator% ( const std::valarray<T>& lhs,                              const typename std::valarray<T>::value_type & val ); template< class T > std::valarray<T> operator& ( const std::valarray<T>& lhs,                              const typename std::valarray<T>::value_type & val ); template< class T > std::valarray<T> operator| ( const std::valarray<T>& lhs,                              const typename std::valarray<T>::value_type & val ); template< class T > std::valarray<T> operator^ ( const std::valarray<T>& lhs,                              const typename std::valarray<T>::value_type & val ); template< class T > std::valarray<T> operator<<( const std::valarray<T>& lhs,                              const typename std::valarray<T>::value_type & val ); template< class T > std::valarray<T> operator>>( const std::valarray<T>& lhs,                              const typename std::valarray<T>::value_type & val ); template< class T > std::valarray<bool> operator&&( const std::valarray<T>& lhs,                                 const typename std::valarray<T>::value_type & val ); template< class T > std::valarray<bool> operator||( const std::valarray<T>& lhs,                                 const typename std::valarray<T>::value_type & val );	(3)

Wendet binäre Operatoren auf jedes Element zweier valarrays oder auf ein valarray und einen Wert an.

1) Die Operatoren arbeiten auf valarrays gleicher Größe und geben ein valarray derselben Größe wie die Parameter zurück, wobei die Operation auf jedes Element der beiden Argumente angewendet wird.

2,3) Wendet den Operator zwischen jedem Element des valarrays und dem Skalar an.

Parameter

rhs	-	ein numerisches Array
lhs	-	ein numerisches Array
val	-	ein Wert vom Typ T

Rückgabewert

Ein valarray derselben Größe wie der Parameter.

Hinweis

Das Verhalten ist undefiniert, wenn die beiden Argumente valarrays mit unterschiedlichen Größen sind.

Die Funktion kann mit einem anderen Rückgabetyp als std::valarray implementiert werden. In diesem Fall hat der Ersatztyp die folgenden Eigenschaften

• Alle const-Mitgliedsfunktionen von std::valarray sind vorhanden.
• std::valarray, std::slice_array, std::gslice_array, std::mask_array und std::indirect_array können aus dem Ersatztyp konstruiert werden.
• Für jede Funktion, die ein const std::valarray<T>& als Argument nimmt (außer begin() und end())(seit C++11), werden identische Funktionen hinzugefügt, die die Ersatztypen nehmen;
• Für jede Funktion, die zwei Argumente vom Typ const std::valarray<T>& annimmt, werden identische Funktionen hinzugefügt, die jede Kombination aus const std::valarray<T>& und Ersatztypen annehmen.
• Der Rückgabetyp fügt nicht mehr als zwei Ebenen von Template-Verschachtelung über den am tiefsten verschachtelten Argumenttyp hinaus hinzu.

Beispiel

Findet reelle Wurzeln mehrerer quadratischer Gleichungen.

Führen Sie diesen Code aus

#include <cstddef>
#include <iostream>
#include <valarray>
 
int main()
{
    std::valarray<double> a(1, 8);
    std::valarray<double> b{1, 2, 3, 4, 5, 6, 7, 8};
    std::valarray<double> c = -b;
    // literals must also be of type T until LWG3074 (double in this case)
    std::valarray<double> d = std::sqrt(b * b - 4.0 * a * c);
    std::valarray<double> x1 = 2.0 * c / (-b + d);
    std::valarray<double> x2 = 2.0 * c / (-b - d);
    std::cout << "quadratic equation:  root 1:    root 2:   b: c:\n";
    for (std::size_t i = 0; i < a.size(); ++i)
        std::cout << a[i] << "\u00B7x\u00B2 + " << b[i] << "\u00B7x + "
                  << c[i] << " = 0  " << std::fixed << x1[i]
                  << "  " << x2[i] << std::defaultfloat
                  << "  " << -x1[i] - x2[i]
                  << "  " << x1[i] * x2[i] << '\n';
}

Ausgabe

quadratic equation:  root 1:    root 2:   b: c:
1·x² + 1·x + -1 = 0  -1.618034  0.618034  1  -1
1·x² + 2·x + -2 = 0  -2.732051  0.732051  2  -2
1·x² + 3·x + -3 = 0  -3.791288  0.791288  3  -3
1·x² + 4·x + -4 = 0  -4.828427  0.828427  4  -4
1·x² + 5·x + -5 = 0  -5.854102  0.854102  5  -5
1·x² + 6·x + -6 = 0  -6.872983  0.872983  6  -6
1·x² + 7·x + -7 = 0  -7.887482  0.887482  7  -7
1·x² + 8·x + -8 = 0  -8.898979  0.898979  8  -8

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 3074	C++98	T wird sowohl aus dem Skalar als auch aus dem valarray für (2,3) abgeleitet, was Aufrufe mit gemischten Typen ausschließt	nur T aus dem valarray ableiten

Siehe auch

operator+operator-operator~operator!	wendet einen unären arithmetischen Operator auf jedes Element des Valarrays an (public member function)
operator+=operator-=operator*=operator/=operator%=operator&=operator|=operator^=operator<<=operator>>=	wendet einen zusammengesetzten Zuweisungsoperator auf jedes Element des Valarrays an (public member function)