forked from gleu/pgdocs_fr
/
seg.xml
400 lines (360 loc) · 13.1 KB
/
seg.xml
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
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
<?xml version="1.0" encoding="UTF-8"?>
<!-- Dernière modification
le $Date$
par $Author$
révision $Revision$ -->
<sect1 id="seg">
<title>seg</title>
<indexterm zone="seg">
<primary>seg</primary>
</indexterm>
<para>
Ce module code le type de données <type>seg</type> pour représenter
des segments de ligne ou des intervalles de nombres à virgule flottante.
<type>seg</type> peut représenter l'incertitude des points
extrèmes d'un intervalle, ce qui le rend particulièrement utile pour représenter
des mesures de laboratoires.
</para>
<sect2>
<title>Explications</title>
<para>
La géométrie des mesures est habituellement plus complexe qu'un point
dans un continuum numérique. Une mesure est habituellement un segment
de ce continuum avec des limites non définissables. Les mesures
apparaissent comme des intervalles à cause de ce côté incertain et
du hasard, ainsi qu'à cause du fait que la valeur mesurée peut
naturellement être un intervalle indiquant certaines conditions comme
une échelle de température pour la stabilité d'une protéine.
</para>
<para>
En utilisant le bon sens, il apparaît plus agréable de stocker de telles
données sous la forme d'intervalle, plutôt que sous la forme d'une paire
de nombres. En pratique, c'est même plus efficace dans la plupart des
applications.
</para>
<para>
En allant plus loin, le côté souple des limites suggère que l'utilisation
des types de données numériques traditionnels amène en fait une certaine
perte d'informations. Pensez à ceci : votre instrument lit
6.50, et vous saisissez cette valeur dans la base de données.
Qu'obtenez-vous en la récupérant ? Regardez :
<programlisting>
test=> select 6.50 :: float8 as "pH";
pH
---
6.5
(1 row)
</programlisting>
Dans le monde des mesures, 6.50 n'est pas identique à 6.5. La différence
pourrait même être critique. Les personnes ayant réalisé l'expérience
écrivent habituellement (et publient) les chiffres qu'ils connaissent.
6.50 est en fait un intervalle incertain compris dans un intervalle
plus grand et encore plus incertain, 6.5, le point central étant
(probablement) la seule fonctionnalité commune qu'ils partagent. Nous
ne voulons pas que de telles différences de données apparaissent de
façon identique.
</para>
<para>
La conclusion ? il est agréable d'avoir un type de données spécial
qui peut enregistrer les limites d'un intervalle avec une précision
variable arbitraire. Variable dans le sens où chaque élément de données
enregistre sa propre précision.
</para>
<para>
Vérifiez ceci :
<programlisting>
test=> select '6.25 .. 6.50'::seg as "pH";
pH
------------
6.25 .. 6.50
(1 row)
</programlisting>
</para>
</sect2>
<sect2>
<title>Syntaxe</title>
<para>
La représentation externe d'un intervalle se forme en utilisant un ou deux
nombres à virgule flottante joint par l'opérateur d'échelle
(<literal>..</literal> ou <literal>...</literal>). Sinon, il peut être
spécifié comme un point central plus ou moins une déviation.
Des indicateurs optionels (<literal><</literal>,
<literal>></literal> et <literal>~</literal>) peuvent aussi être stockés.
(Néanmoins, ces indicateurs sont ignorés par la logique interne.)
</para>
<para>
Dans la table suivante, <replaceable>x</replaceable>,
<replaceable>y</replaceable> et <replaceable>delta</replaceable> dénotent
des nombres à virgule flottante. <replaceable>x</replaceable> et
<replaceable>y</replaceable>, mais pas <replaceable>delta</replaceable>,
peuvent être précédés par un indicateur de certitude :
</para>
<table>
<title>Représentations externes de <type>seg</type></title>
<tgroup cols="2">
<tbody>
<row>
<entry><literal><replaceable>x</replaceable></literal></entry>
<entry>Valeur seule (intervalle de longueur zéro)
</entry>
</row>
<row>
<entry><literal><replaceable>x</replaceable> .. <replaceable>y</replaceable></literal></entry>
<entry>Intervalle de <replaceable>x</replaceable> à <replaceable>y</replaceable>
</entry>
</row>
<row>
<entry><literal><replaceable>x</replaceable> (+-) <replaceable>delta</replaceable></literal></entry>
<entry>Intervalle de <replaceable>x</replaceable> - <replaceable>delta</replaceable> à
<replaceable>x</replaceable> + <replaceable>delta</replaceable>
</entry>
</row>
<row>
<entry><literal><replaceable>x</replaceable> ..</literal></entry>
<entry>Intervalle ouvert avec une limite inférieure <replaceable>x</replaceable>
</entry>
</row>
<row>
<entry><literal>.. <replaceable>x</replaceable></literal></entry>
<entry>Intervalle ouvert avec une limite supérieure <replaceable>x</replaceable>
</entry>
</row>
</tbody>
</tgroup>
</table>
<table>
<title>Exemples d'entrées valides de type <type>seg</type></title>
<tgroup cols="2">
<tbody>
<row>
<entry><literal>5.0</literal></entry>
<entry>
Crée un segment de longueur zéro (un point si vous préférez)
</entry>
</row>
<row>
<entry><literal>~5.0</literal></entry>
<entry>
Crée un segment de taille nulle et enregistre
<literal>~</literal> dans les données. <literal>~</literal> est ignoré
par les opérations <type>seg</type> mais conservé en commentaire.
</entry>
</row>
<row>
<entry><literal><5.0</literal></entry>
<entry>
Crée un point à 5.0. <literal><</literal> est ignoré mais conservé
en commentaire.
</entry>
</row>
<row>
<entry><literal>>5.0</literal></entry>
<entry>
Crée un point à 5.0. <literal>></literal> est ignoré mais conservé
en commentaire.
</entry>
</row>
<row>
<entry><literal>5(+-)0.3</literal></entry>
<entry>
Crée un intervalle <literal>4.7 .. 5.3</literal>.
Notez que la notation <literal>(+-)</literal> n'est pas conservée.
</entry>
</row>
<row>
<entry><literal>50 .. </literal></entry>
<entry>Tout ce qui supérieur ou égal à 50</entry>
</row>
<row>
<entry><literal>.. 0</literal></entry>
<entry>Tout ce qui est inférieur ou égal à 0</entry>
</row>
<row>
<entry><literal>1.5e-2 .. 2E-2 </literal></entry>
<entry>Crée un intervalle <literal>0.015 .. 0.02</literal></entry>
</row>
<row>
<entry><literal>1 ... 2</literal></entry>
<entry>
Identifique à <literal>1...2</literal>, ou <literal>1 .. 2</literal>,
ou <literal>1..2</literal>
(les espaces autour de l'opérateur d'échelle sont ignorés)
</entry>
</row>
</tbody>
</tgroup>
</table>
<para>
Comme <literal>...</literal> est largement utilisé dans les sources de
données, il est autorisé comme autre orthographe possible de
<literal>..</literal>. Malheureusement, ceci crée une ambiguité pour
l'analyseur : la limite supérieure dans <literal>0...23</literal> est
<literal>23</literal> ou <literal>0.23</literal>. Ceci se résout en
réclamant au moins un chiffre avant le point décimal dans tous les nombres
de type <type>seg</type>.
</para>
<para>
Comme vérification, <type>seg</type> rejette les intervalles dont la limite
inférieure est supérieure à la limite supérieure, par exemple
<literal>5 .. 2</literal>.
</para>
</sect2>
<sect2>
<title>Précision</title>
<para>
Les valeurs <type>seg</type> sont stockés en interne sous la forme de paires
de nombres en virgule flottante de 32 bits. Cela signifie que les nombres
avec plus de sept chiffres significatifs sont tronqués.
</para>
<para>
Les nombres avec moins ou avec exactement sept chiffres significatifs
conservent leur précision originale. C'est-à-dire que, si votre requête
renvoie 0.00, vous serez sûr que les zéros qui suivent ne sont pas des
conséquences du formatage : elles reflètent la précision de la donnée
originale. Le nombre de zéro au début n'affectent pas la précision :
deux chiffres significatifs sont considérés pour la valeur 0.0067.
</para>
</sect2>
<sect2>
<title>Utilisation</title>
<para>
Le module <filename>seg</filename> inclut une classe d'opérateur pour les
index GiST dans le cas des valeurs <type>seg</type>. Les opérateurs
supportés par la classe d'opérateur GiST incluent :
</para>
<itemizedlist>
<listitem>
<programlisting>
[a, b] << [c, d] est à gauche de
</programlisting>
<para>
[a, b] est entièrement à gauche de [c, d]. Autrement dit,
[a, b] << [c, d] est vérifié si b < c
</para>
</listitem>
<listitem>
<programlisting>
[a, b] >> [c, d] est à droite de
</programlisting>
<para>
[a, b] est entièrement à droite de [c, d]. Autrement dit,
[a, b] >> [c, d] est vérifié si a > d
</para>
</listitem>
<listitem>
<programlisting>
[a, b] &< [c, d] Couvre une partie ou est à gauche de
</programlisting>
<para>
Cela se lit mieux de cette façon <quote>ne s'étend pas à droite de</quote>.
C'est vrai quand b <= d.
</para>
</listitem>
<listitem>
<programlisting>
[a, b] &> [c, d] Couvre une partie ou est à droite de
</programlisting>
<para>
Cela se lit mieux de cette façon <quote>ne s'étend pas à gauche de</quote>.
C'est vrai quand a >= c.
</para>
</listitem>
<listitem>
<programlisting>
[a, b] = [c, d] Identique à
</programlisting>
<para>
Les segments [a, b] et [c, d] sont identiques, autrement dit a == b
et c == d
</para>
</listitem>
<listitem>
<programlisting>
[a, b] && [c, d] Couvre une partie
</programlisting>
<para>
Les segments [a, b] et [c, d] se chevauchent en partie.
</para>
</listitem>
<listitem>
<programlisting>
[a, b] @> [c, d] Contient
</programlisting>
<para>
Le segment [a, b] contient le segment [c, d], autrement dit
a <= c et b >= d
</para>
</listitem>
<listitem>
<programlisting>
[a, b] <@ [c, d] Est contenu dans
</programlisting>
<para>
Le segment [a, b] est contenu dans [c, d], autrement dit
a >= c et b <= d
</para>
</listitem>
</itemizedlist>
<para>
(Avant PostgreSQL 8.2, les opérateurs de contenance @> et <@ étaient
appelés respectivement @ et ~. Ces noms sont toujours disponibles mais sont
déclarés obsolètes et seront supprimés un jour. Notez que les anciens noms
sont inversés par rapport à la convention suivie par les types de données
géométriques !)
</para>
<para>
Les opérateurs B-tree standard sont aussi fournis, par exemple :
<programlisting>
[a, b] < [c, d] Plus petit que
[a, b] > [c, d] Plus grand que
</programlisting>
Ces opérateurs n'ont pas vraiment de sens sauf en ce qui concerne le tri.
Ces opérateurs comparent en premier (a) à (c) et, s'ils sont égaux,
comparent (b) à (d). Cela fait un bon tri dans la plupart des cas, ce qui
est utile si vous voulez utiliser ORDER BY avec ce type.
</para>
</sect2>
<sect2>
<title>Notes</title>
<para>
Pour des exemples d'utilisation, voir les tests de régression
<filename>sql/seg.sql</filename>.
</para>
<para>
Le mécanisme qui convertit <literal>(+-)</literal> en échelles standards
n'est pas entièrement précis pour déterminer le nombre de chiffres
significatifs pour les limites. Par exemple, si vous ajoutez un chiffre
supplémentaire à la limite basse si l'intervalle résultat inclut une
puissance de dix :
<programlisting>
postgres=> select '10(+-)1'::seg as seg;
seg
---------
9.0 .. 11 -- should be: 9 .. 11
</programlisting>
</para>
<para>
La performance d'un index R-tree peut dépendre largement de l'ordre des
valeurs en entrée. Il pourrait être très utile de trier la table en entrée
sur la colonne <type>seg</type> ; voir le script
<filename>sort-segments.pl</filename> pour un exemple.
</para>
</sect2>
<sect2>
<title>Crédits</title>
<para>
Auteur original : Gene Selkov, Jr. <email>selkovjr@mcs.anl.gov</email>,
Mathematics and Computer Science Division, Argonne National Laboratory.
</para>
<para>
Mes remerciements vont principalement au professeur Joe Hellerstein
(<ulink url="http://db.cs.berkeley.edu/~jmh/"></ulink>) pour avoir élucidé
l'idée centrale de GiST (<ulink
url="http://gist.cs.berkeley.edu/"></ulink>). Mes remerciements aussi aux
développeurs de PostgreSQL pour m'avoir permis de créer mon propre monde
et de pouvoir y vivre sans pertubation. Argonne Lab et le département
américain de l'énergie ont aussi toute ma gratitude pour les années de
support dans ma recherche sur les bases de données.
</para>
</sect2>
</sect1>