std::gslice

class gslice;

std::gslice est la classe de sélection qui identifie un sous-ensemble d'indices std::valarray définis par un ensemble multi-niveaux de pas et de tailles. Les objets de type std::gslice peuvent être utilisés comme indices avec les operator[] de valarray pour sélectionner, par exemple, les colonnes d'un tableau multidimensionnel représenté comme un valarray.

Étant donné la valeur de départ s, une liste de pas ij et une liste de tailles dj, un std::gslice construit à partir de ces valeurs sélectionne l'ensemble des indices kj = s + Σj (ij * dj).

Par exemple, un gslice avec l'indice de départ 3, les pas {19,4,1} et les longueurs {2,4,3} génère l'ensemble suivant de 24=2*4*3 indices :

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

Il est possible de construire des objets std::gslice qui sélectionnent certains indices plus d'une fois : si l'exemple ci-dessus avait utilisé les pas {1,1,1}, les indices auraient été {3, 4, 5, 4, 5, 6, ...}. De tels gslices ne peuvent être utilisés qu'en arguments de la version const de std::valarray::operator[], sinon le comportement est indéfini.

Fonctions membres

Exemple

#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 = // tableau 3D : 2 x 4 x 3 éléments
        {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 << "Tableau 2x4x3 initial :\n";
    test_print(v, 2, 4, 3);
    // met à jour chaque valeur des premières colonnes des deux plans
    v[std::gslice(0, {2, 4}, {4 * 3, 3})] = 1; // deux strides de niveau un de 12 éléments
                                               // puis quatre strides de niveau deux de 3 éléments
    // soustrait la troisième colonne de la deuxième colonne dans le 1er plan
    v[std::gslice(1, {1, 4}, {4 * 3, 3})] -= v[std::gslice(2, {1, 4}, {4 * 3, 3})];
    std::cout << "\n" "Après les opérations sur les colonnes :\n";
    test_print(v, 2, 4, 3);
}

Tableau 2x4x3 initial :
111 112 113   211 212 213
121 122 123   221 222 223
131 132 133   231 232 233
141 142 143   241 242 243
Après les opérations sur les colonnes :
1 -1 113   1 212 213
1 -1 123   1 222 223
1 -1 133   1 232 233
1 -1 143   1 242 243

Rapports de défauts

Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

Voir aussi