std:: gslice
|
Défini dans l'en-tête
<valarray>
|
||
|
class
gslice
;
|
||
std::gslice
est la classe de sélection qui identifie un sous-ensemble d'indices de
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 l'opérateur
operator
[
]
du valarray pour sélectionner, par exemple, les colonnes d'un tableau multidimensionnel représenté comme un
valarray
.
Étant donné la valeur initiale
s
, une liste de pas
i
j
et une liste de tailles
d
j
, un
std::gslice
construit à partir de ces valeurs sélectionne l'ensemble des indices
k
j
=s+Σ
j
(i
j
d
j
)
.
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 précédent utilisait 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 tant qu'arguments pour la version constante de
std::valarray::operator[]
, sinon le comportement est indéfini.
Table des matières |
Fonctions membres
|
(constructor)
|
construit une tranche générique
(fonction membre publique) |
|
start
size
stride
|
retourne les paramètres de la tranche
(fonction membre publique) |
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) | |
Construit une nouvelle tranche générique.
Paramètres
| start | - | la position du premier élément |
| sizes | - | un tableau définissant le nombre d'éléments dans chaque dimension |
| strides | - | un tableau définissant le nombre de positions entre les éléments successifs dans chaque dimension |
| other | - | une autre tranche à copier |
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) | |
Retourne les paramètres passés au slice lors de la construction - respectivement start, size et stride.
Paramètres
(aucun)
Valeur de retour
Les paramètres du slice - respectivement start, size et stride.
Complexité
Constante.
Exemple
Illustre l'utilisation des gslices pour adresser les colonnes d'un tableau 3D :
#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); }
Sortie :
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.
| DR | Applicable à | Comportement publié | Comportement corrigé |
|---|---|---|---|
| LWG 543 | C++98 | il n'était pas clair si une tranche générique construite par défaut est utilisable | elle est utilisable (comme un sous-ensemble vide) |
Voir aussi
|
obtenir/définir un élément, une tranche ou un masque de valarray
(fonction membre publique) |
|
|
tranche de type BLAS d'un valarray : index de départ, longueur, pas
(classe) |
|
|
proxy vers un sous-ensemble d'un valarray après application d'un gslice
(modèle de classe) |