std::gslice

 

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>
class gslice;

std::gslice ist die Selektor-Klasse, die eine Teilmenge von std::valarray-Indizes identifiziert, die durch eine mehrstufige Menge von Schrittweiten und Größen definiert ist. Objekte vom Typ std::gslice können als Indizes mit dem operator[] von valarray verwendet werden, um beispielsweise Spalten eines mehrdimensionalen Arrays, das als valarray dargestellt wird, auszuwählen.

Gegeben den Startwert s, eine Liste von Schrittweiten ij und eine Liste von Größen dj, wählt ein std::gslice, das aus diesen Werten konstruiert wird, die Menge der Indizes kj=s+Σj(ijdj) aus.

Zum Beispiel erzeugt ein gslice mit Startindex 3, Schrittweiten {19,4,1} und Längen {2,4,3} die folgende Menge von 24=2*4*3 Indizes

3 + 0*19 + 0*4 + 0*1 = 3,
3 + 0*19 + 0*4 + 1*1 = 4,
3 + 0*19 + 0*4 + 2*1 = 5,
3 + 0*19 + 1*4 + 0*1 = 7,
3 + 0*19 + 1*4 + 1*1 = 8,
3 + 0*19 + 1*4 + 2*1 = 9,
3 + 0*19 + 2*4 + 0*1 = 11,
...
3 + 1*19 + 3*4 + 1*1 = 35,
3 + 1*19 + 3*4 + 2*1 = 36

Es ist möglich, std::gslice-Objekte zu konstruieren, die einige Indizes mehrfach auswählen: Wenn das obige Beispiel die Schrittweiten {1,1,1} verwendet hätte, wären die Indizes {3, 4, 5, 4, 5, 6, ...} gewesen. Solche gslices dürfen nur als Argumente für die konstante Version von std::valarray::operator[] verwendet werden, andernfalls ist das Verhalten undefiniert.

Member functions

(Konstruktor)	konstruiert einen generischen Slice (öffentliche Memberfunktion)
startsizestride	gibt die Parameter des Slices zurück (öffentliche Memberfunktion)

std::gslice::gslice

gslice()	(1)
gslice( std::size_t start, const std::valarray<std::size_t>& sizes,                            const std::valarray<std::size_t>& strides );	(2)
gslice( const gslice& other );	(3)

Konstruiert einen neuen generischen Slice.

1) Default-Konstruktor. Äquivalent zu gslice(0, std::valarray<std::size_t(), std::valarray<std::size_t()). Dieser Konstruktor existiert nur, um die Konstruktion von Arrays von Slices zu ermöglichen.

2) Konstruiert einen neuen Slice mit den Parametern start, sizes, strides.

3) Konstruiert eine Kopie von other.

Parameter

start	-	die Position des ersten Elements
Größen	-	ein Array, das die Anzahl der Elemente in jeder Dimension definiert
Schrittweiten	-	ein Array, das die Anzahl der Positionen zwischen aufeinanderfolgenden Elementen in jeder Dimension definiert
Sonstiges	-	ein anderer Slice zum Kopieren

std::slice::start, size, stride

std::size_t start() const;	(1)
std::valarray<std::size_t> size() const;	(2)
std::valarray<std::size_t> stride() const;	(3)

Gibt die beim Konstruieren übergebenen Parameter des Slices zurück - start, sizes und strides.

Parameter

(keine)

Rückgabewert

Die Parameter des Slices - start, sizes und strides.

Komplexität

Konstant.

Example

Demonstriert die Verwendung von gslices zum Adressieren von Spalten eines 3D-Arrays

Führen Sie diesen Code aus

#include <iostream>
#include <valarray>
 
void test_print(std::valarray<int>& v, int planes, int rows, int cols)
{
    for (int r = 0; r < rows; ++r)
    {
        for (int z = 0; z < planes; ++z)
        {
            for (int c = 0; c < cols; ++c)
                std::cout << v[z * rows * cols + r * cols + c] << ' ';
            std::cout << "  ";
        }
        std::cout << '\n';
    }
}
 
int main()
{
    std::valarray<int> v = // 3d array: 2 x 4 x 3 elements
        {111,112,113 , 121,122,123 , 131,132,133 , 141,142,143,
         211,212,213 , 221,222,223 , 231,232,233 , 241,242,243};
    // int ar3d[2][4][3]
    std::cout << "Initial 2x4x3 array:\n";
    test_print(v, 2, 4, 3);
 
    // update every value in the first columns of both planes
    v[std::gslice(0, {2, 4}, {4 * 3, 3})] = 1; // two level one strides of 12 elements
                                               // then four level two strides of 3 elements
 
    // subtract the third column from the second column in the 1st plane
    v[std::gslice(1, {1, 4}, {4 * 3, 3})] -= v[std::gslice(2, {1, 4}, {4 * 3, 3})];
 
    std::cout << "\n" "After column operations:\n";
    test_print(v, 2, 4, 3);
}

Ausgabe

Initial 2x4x3 array:
111 112 113   211 212 213
121 122 123   221 222 223
131 132 133   231 232 233
141 142 143   241 242 243
 
After column operations:
1 -1 113   1 212 213
1 -1 123   1 222 223
1 -1 133   1 232 233
1 -1 143   1 242 243

Defect reports

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 543	C++98	es war unklar, ob ein standardkonstruierter generischer Slice verwendbar ist	er ist verwendbar (als leere Teilmenge)

See also

operator[]	liest/schreibt Array-Element, Slice oder Maske (public member function)
slice	BLAS-ähnlicher Slice eines Valarrays: Startindex, Länge, Schrittweite (class)
gslice_array	Proxy für eine Teilmenge eines Valarrays nach Anwendung eines gslice (class template)