-
Notifications
You must be signed in to change notification settings - Fork 16
/
valarray.txt
139 lines (120 loc) · 8.64 KB
/
valarray.txt
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
VALARRAY
HEADER ==> #<valarray>
valarray <WVAR> #Classe ressemblant à un array de nombres, optimisée
#pour les opérations arithmétiques.
#Les éléments sont de type WVAR (en général des nombres)
VALARRAY([WVAL, #Instantie un VALARRAY composé de SIZE_T_VAL (par défaut
[SIZE_T_VAL]]) #0) éléments WVAL (par défaut WVAR construit avec son
#constructor par défaut, 0 donc pour des nombres)
VALARRAY(ADR, SIZ_T_VAL)#Instantie un VALARRAY composé de SIZE_T_VAL éléments,
#copiés à partir de ceux commençant à ADR. ADR doit être
#de même type que WVAR. Il s'agit donc souvent d'un
#array de nombre.
VALARRAY(TEMP_VALARRAY) #Instantie un VALARRAY égal à TEMP_VALARRAY.
VALARRAY = VALARRAY2 #Assigne tous les éléments de VALARRAY2 ou TEMP_VALARRAY
VALARRAY = TEMP_VALARRAY#à VALARRAY. Si les tailles ne correspondent pas, cela
#peut produire des choses étranges.
VALARRAY = WVAL #Tous les éléments de VALARRAY deviennent WVAL.
slice #Classe désignant une sélection dans un valarray.
#Il n'est pas lié à un valarray en particulier, et peut
#donc être utilisé par plusieurs valarrays.
#Un slice peut par exemple se traduire par : "le 1er,
#3ème et 5ème élément d'un valarray, quel qu'il soit".
#Leur seule utilisation est avec l'opérateur [ ].
SLICE() #Instantie un SLICE ne sélectionnant rien
SLICE(SIZE_T_VAL, #Instantie un SLICE sélectionnant l'élément numéro
SIZ_T_VAL2, SIZE_T_VAL3)#SIZE_T_VAL d'un valarray, quel qu'il soit, ainsi que
#les SIZE_T_VAL2 - 1 éléments suivants, selon un pas de
#SIZE_T_VAL3 éléments. SIZE_T_VAL3 peut être négatif
#(mais si la slice en vient à sélectionner dont la
#position est négative, cela provoquera un buffer
#overflow)
#Il faut prendre garde lorsque l'on utilise un valarray
#avec une slice que la slice ne sélectionne pas des
#éléments out of range.
SLICE.start() #Renvoie le point de départ de SLICE, c'est-à-dire le
#SIZE_T_VAL de sa construction.
SLICE.size() #Renvoie la size de SLICE, c'est-à-dire le SIZ_T_VAL2 de
#sa construction.
SLICE.stride() #Renvoie le pas de SLICE, c'est-à-dire le SIZE_T_VAL3 de
#sa construction.
gslice #Classe désignant une sélection dans un valarray.
#Cette sélection est opérée de manière plus complexe que
#slice.
GSLICE() #Instantie un GSLICE ne sélectionnant rien
GSLICE(SIZE_T_VAL, #Il doit s'agir de SIZE_T_VALARRAY, contenant uniquement
VALARRAY1, VALARRAY2) #deux SIZE_T_VAL. Par convention, on dira que :
# - VALARRAY1 contient deux éléments, dans l'ordre :
# VAL1a et VAL1b
# - VALARRAY2 contient deux éléments, dans l'ordre :
# VAL2a et VAL2b
#Dans un premier temps, des éléments sont sélectionnés
#à l'aide d'un SLICE(SIZE_T_VAL, VAL1a, VAL2a). Puis
#chacun de ces éléments est le point de départ d'un
#autre SLICE(SIZE_T_VAL, VAL1b, VAL2b). L'ensemble des
#éléments finalement sélectionnés consitue la GSLICE_VAL
GSLICE.start() #Renvoie le point de départ de GSLICE, c'est-à-dire le
#SIZE_T_VAL de sa construction.
GSLICE.size() #Renvoie la size de GSLICE, c'est-à-dire le VALARRAY1
#de sa construction.
GSLICE.stride() #Renvoie le pas de GSLICE, c'est-à-dire le VALARRAY2 de
#sa construction.
slice_array #"Sorte" de valarrays renvoyées toutes par l'utilisation
gslice_array #de [ ] sur un VALARRAY. Leur constructors sont private,
mask_array #et leur seule utilisation est comme argument du
indirect_array #constructor ou de l'operator= d'un VALARRAY, qui crée
#une copie, cette fois réel VALARRAY, de ces "valarrays
#intermédiaires".
TEMP_VALARRAY #Terme commun pour SLICE_ARRAY, GSLICE_ARRAY, MASK_ARRAY
#et INDIRECT_ARRAY
OPERATIONS ARITHMETIQUES#Toutes les opérations arithmétiques, binaires et les
==> #tests sont possibles entre deux VALARRAY ou entre un
#VALARRAY et un WVAL :
# - S'il s'agit de deux VALARRAY, chacun de leur
# membres respectif sont comparés/opérés, ils doivent
# avoir la même taille, sinon cela peut poser des
# problèmes.
# - S'il s'agit d'un VALARRAY et d'un WVAL, chaque
# élément de VALARRAY est comparé/opéré avec WVAL.
#Toutes ces opérations renvoient un VALARRAY_VAL.
#Les tests de comparaison renvoient donc eux aussi un
#VALARRAY_VAL, contenant les valeurs de vérité de chaque
#test.
OPERATIONS MATHEMATIQUES#Par ailleurs toutes les fonctions de <cmath> sont
==> #overloadées pour prendre en argument un VALARRAY, ce
#qui a pour effet d'appliquer la fonction à chaque
#élément. Par exemple :
# - abs(VALARRAY)
#Fait un abs() sur chaque élément.
VALARRAY[SIZE_T_VAL] #Renvoie une référence de l'élement numéro SIZE_T_VAL de
#VALARRAY.
VALARRAY[SLICE] #Renvoie un SLICE_ARRAY dont les éléments sont ceux
#sélectionnés par SLICE.
VALARRAY[GSLICE] #Renvoie un GSLICE_ARRAY dont les éléments sont ceux
#sélectionnés par GSLICE.
VALARRAY[BOOL_VALARRAY] #Renvoie un MASK_ARRAY sélectionnant les éléments dans
#VALARRAY qui correspondent à un true dans l'élément à
#la même position dans BOOL_VALARRAY.
VALARRAY[SIZE_T_VALARAY]#Renvoie un INDIRECT_ARRAY : chaque élément dans
#SIZE_T_VALARRAY est l'index dans VALARRAY de l'élément
#à placer dans INDIRECT_ARRAY.
VALARRAY.min() #Renvoie la valeur minimale de VALARRAY.
VALARRAY.max() #Renvoie la valeur maximale de VALARRAY.
VALARRAY.sum() #Renvoie la somme de tous les éléments de VALARRAY.
VALARRAY.size() #Renvoie le nombre d'éléments de VALARRAY.
VALARRAY.resize #Fait que le nombre d'éléments de VALARRAY devient
(SIZE_T_VAL[, WVAL]) #SIZE_T_VAL. Tous les éléments sont remplacés par des
#WVAL (par défaut WVAR construit avec son constructor
#par défaut)
VALARRAY.cshift(INT_VAL)#Renvoie un VALARRAY_VAL obtenue par la rotation des
#éléments de VALARRAY de INT_VAL éléments vers la gauche
VALARRAY.shift(INT_VAL) #Comme cshift(), sauf que les éléments qui entrent dans
#la rotation ne sont pas ceux qui sont sortis de la
#rotation mais des WVAL construits avec leur constructor
#par défaut.
VALARRAY.apply(FONC_ADR)#Renvoie un VALARRAY_VAL obtenue par l'application de
#FONC_VAR à chaque élément de VALARRAY.
#FONC_VAR est de type WVAR et prend un seul WVAR en
#argument.