← Back to branch summary

~ubuntu-branches/ubuntu/precise/code-saturne/precise

« back to all changes in this revision

Viewing changes to preprocessor/util/ecs_tab.c

  • Committer: Package Import Robot
  • Author(s): Sylvestre Ledru
  • Date: 2011-11-24 00:00:08 UTC
  • mfrom: (6.1.9 sid)
  • Revision ID: package-import@ubuntu.com-20111124000008-2vo99e38267942q5
Tags: 2.1.0-3
Install a missing file

Show diffs side-by-side

added added

removed removed

Lines of Context:
preprocessor/util/ecs_tab.c
 
1
/*============================================================================
 
2
 *  Définitions des fonctions
 
3
 *   associées à la structure `tab_t' décrivant un tableau
 
4
 *============================================================================*/
 
5
 
 
6
/*
 
7
  This file is part of Code_Saturne, a general-purpose CFD tool.
 
8
 
 
9
  Copyright (C) 1998-2011 EDF S.A.
 
10
 
 
11
  This program is free software; you can redistribute it and/or modify it under
 
12
  the terms of the GNU General Public License as published by the Free Software
 
13
  Foundation; either version 2 of the License, or (at your option) any later
 
14
  version.
 
15
 
 
16
  This program is distributed in the hope that it will be useful, but WITHOUT
 
17
  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 
18
  FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
 
19
  details.
 
20
 
 
21
  You should have received a copy of the GNU General Public License along with
 
22
  this program; if not, write to the Free Software Foundation, Inc., 51 Franklin
 
23
  Street, Fifth Floor, Boston, MA 02110-1301, USA.
 
24
*/
 
25
 
 
26
 
 
27
/*============================================================================
 
28
 *                                 Visibilité
 
29
 *============================================================================*/
 
30
 
 
31
/*----------------------------------------------------------------------------
 
32
 *  Fichiers `include' librairie standard C
 
33
 *----------------------------------------------------------------------------*/
 
34
 
 
35
#include <assert.h>
 
36
#include <stdio.h>
 
37
#include <stdarg.h>
 
38
#include <string.h>
 
39
 
 
40
 
 
41
/*----------------------------------------------------------------------------
 
42
 *  Fichiers `include' visibles du  paquetage courant
 
43
 *----------------------------------------------------------------------------*/
 
44
 
 
45
#include "ecs_def.h"
 
46
#include "ecs_mem.h"
 
47
 
 
48
 
 
49
/*----------------------------------------------------------------------------
 
50
 *  Fichier  `include' du  paquetage courant associe au fichier courant
 
51
 *----------------------------------------------------------------------------*/
 
52
 
 
53
#include "ecs_tab.h"
 
54
 
 
55
 
 
56
/*============================================================================
 
57
 *                              Fonctions privées
 
58
 *============================================================================*/
 
59
 
 
60
/*----------------------------------------------------------------------------
 
61
 *    Fonction de descente d'un arbre binaire pour le tri lexicographique
 
62
 *  d'un vecteur d'entiers (voir ecs_int_table_ord).
 
63
 *----------------------------------------------------------------------------*/
 
64
 
 
65
static void
 
66
ecs_loc_tab_int__desc_arbre(const ecs_int_t  *val_tab,
 
67
                            ecs_int_t         ltree,
 
68
                            ecs_int_t         ntree,
 
69
                            ecs_int_t        *elem_ord)
 
70
{
 
71
  ecs_int_t ktree;
 
72
  ecs_int_t i_save, p1, p2;
 
73
 
 
74
  i_save = *(elem_ord+ltree);
 
75
 
 
76
  while (ltree <= (ntree/2)) {
 
77
 
 
78
    ktree = (2*ltree)+1;
 
79
 
 
80
    if (ktree < ntree - 1) {
 
81
 
 
82
      p1 = *(elem_ord+ktree+1);
 
83
      p2 = *(elem_ord+ktree);
 
84
 
 
85
      if (*(val_tab+p1) > *(val_tab+p2)) ktree++;
 
86
    }
 
87
 
 
88
    if (ktree >= ntree) break;
 
89
 
 
90
    p1 = i_save;
 
91
    p2 = *(elem_ord+ktree);
 
92
 
 
93
    if (*(val_tab+p1) >= *(val_tab+p2)) break;
 
94
 
 
95
    *(elem_ord+ltree) = *(elem_ord+ktree);
 
96
    ltree = ktree;
 
97
 
 
98
  }
 
99
 
 
100
  *(elem_ord+ltree) = i_save;
 
101
}
 
102
 
 
103
/*----------------------------------------------------------------------------
 
104
 *    Fonction de descente d'un arbre binaire pour le tri lexicographique
 
105
 *  d'un vecteur de chaînes de caractères (voir ecs_char_table_ord).
 
106
 *----------------------------------------------------------------------------*/
 
107
 
 
108
static void
 
109
ecs_loc_tab_char__desc_arbre(char              **val_tab,
 
110
                             ecs_int_t           ltree,
 
111
                             const ecs_int_t     ntree,
 
112
                             ecs_int_t          *elem_ord)
 
113
{
 
114
  ecs_int_t ktree;
 
115
  ecs_int_t i_save, p1, p2;
 
116
 
 
117
  i_save = *(elem_ord+ltree);
 
118
 
 
119
  while (ltree <= (ntree/2)) {
 
120
 
 
121
    ktree = (2*ltree)+1;
 
122
 
 
123
    if (ktree < ntree - 1) {
 
124
 
 
125
      p1 = *(elem_ord+ktree+1);
 
126
      p2 = *(elem_ord+ktree);
 
127
 
 
128
      if (strcmp(*(val_tab+p1), *(val_tab+p2)) > 0) ktree++;
 
129
    }
 
130
 
 
131
    if (ktree >= ntree) break;
 
132
 
 
133
    p1 = i_save;
 
134
    p2 = *(elem_ord+ktree);
 
135
 
 
136
    if (strcmp(*(val_tab+p1), *(val_tab+p2)) >= 0) break;
 
137
 
 
138
    *(elem_ord+ltree) = *(elem_ord+ktree);
 
139
    ltree = ktree;
 
140
 
 
141
  }
 
142
 
 
143
  *(elem_ord+ltree) = i_save;
 
144
}
 
145
 
 
146
/*============================================================================
 
147
 *                             Fonctions publiques
 
148
 *============================================================================*/
 
149
 
 
150
/*----------------------------------------------------------------------------
 
151
 *  Fonction qui crée un tableau de dimension donnée
 
152
 *----------------------------------------------------------------------------*/
 
153
 
 
154
ecs_tab_int_t
 
155
ecs_tab_int__cree(size_t  dim_tab)
 
156
{
 
157
  ecs_tab_int_t tab;
 
158
 
 
159
  /*xxxxxxxxxxxxxxxxxxxxxxxxxxx Instructions xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
 
160
 
 
161
  tab.nbr = dim_tab;
 
162
  ECS_MALLOC(tab.val, tab.nbr, ecs_int_t);
 
163
 
 
164
  return tab;
 
165
}
 
166
 
 
167
/*----------------------------------------------------------------------------
 
168
 *  Fonction qui crée un tableau de dimension donnée
 
169
 *   et initialise les valeurs avec une constante
 
170
 *----------------------------------------------------------------------------*/
 
171
 
 
172
ecs_tab_int_t
 
173
ecs_tab_int__cree_init(size_t     dim_tab,
 
174
                       ecs_int_t  val_init)
 
175
{
 
176
  size_t      itab;
 
177
  ecs_tab_int_t tab;
 
178
 
 
179
  /*xxxxxxxxxxxxxxxxxxxxxxxxxxx Instructions xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
 
180
 
 
181
  tab = ecs_tab_int__cree(dim_tab);
 
182
 
 
183
  for (itab = 0; itab < tab.nbr; itab++)
 
184
    tab.val[itab] = val_init;
 
185
 
 
186
  return tab;
 
187
}
 
188
 
 
189
/*----------------------------------------------------------------------------
 
190
 *  Fonction qui transforme le tableau donné en son inverse
 
191
 *----------------------------------------------------------------------------
 
192
 *
 
193
 * Exemple :
 
194
 * -------
 
195
 *                          .---.---.---.---.---.---.
 
196
 *     Tableau en entrée :  | 2 | 5 | 4 | 3 | 0 | 1 |
 
197
 *                          `---'---'---'---'---'---'
 
198
 *                            0   1   2   3   4   5
 
199
 *
 
200
 *                          .---.---.---.---.---.---.
 
201
 *     Tableau en sortie :  | 4 | 5 | 0 | 3 | 2 | 1 |
 
202
 *                          `---'---'---'---'---'---'
 
203
 *                            0   1   2   3   4   5
 
204
 *
 
205
 *----------------------------------------------------------------------------*/
 
206
 
 
207
void
 
208
ecs_tab_int__inverse(ecs_tab_int_t  *this_tab)
 
209
{
 
210
  size_t      itab   ;
 
211
  ecs_int_t * val_tab;
 
212
 
 
213
  /*xxxxxxxxxxxxxxxxxxxxxxxxxxx Instructions xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
 
214
 
 
215
  assert(this_tab->nbr != 0);
 
216
  assert(this_tab->val != NULL);
 
217
 
 
218
  ECS_MALLOC(val_tab, this_tab->nbr, ecs_int_t);
 
219
 
 
220
  for (itab = 0; itab < this_tab->nbr; itab++)
 
221
    val_tab[itab] = this_tab->val[itab];
 
222
 
 
223
  for (itab = 0; itab < this_tab->nbr; itab++)
 
224
    this_tab->val[val_tab[itab]] = itab;
 
225
 
 
226
  ECS_FREE(val_tab);
 
227
}
 
228
 
 
229
/*----------------------------------------------------------------------------
 
230
 *  Fonction de tri lexicographique d'un vecteur d'entiers.
 
231
 *
 
232
 *  La liste n'est pas modifiée directement,
 
233
 *   mais on construit un vecteur de renumérotation,
 
234
 *   afin de pouvoir appliquer cette renumérotation à d'autres tableaux
 
235
 *
 
236
 *  Le tri utilise est de type "heapsort", de complexité O(nlog(n)).
 
237
 *  Les éléments sont rangés en ordre croissant.
 
238
 *----------------------------------------------------------------------------*/
 
239
 
 
240
void
 
241
ecs_tab_int__trie(const ecs_tab_int_t  this_vect,
 
242
                  ecs_tab_int_t        vect_renum)
 
243
{
 
244
  ecs_int_t    i, i_save;
 
245
 
 
246
  /*xxxxxxxxxxxxxxxxxxxxxxxxxxx Instructions xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
 
247
 
 
248
  /* Création de l'arbre binaire vec_renum->val_tab[vect_renum->nbr] */
 
249
 
 
250
  for (i = (this_vect.nbr / 2) - 1; i >= 0; i--) {
 
251
 
 
252
    ecs_loc_tab_int__desc_arbre(this_vect.val,
 
253
                                i,
 
254
                                this_vect.nbr,
 
255
                                vect_renum.val);
 
256
  }
 
257
 
 
258
  /* Tri de l'arbre binaire */
 
259
 
 
260
  for (i = this_vect.nbr - 1; i > 0; i--) {
 
261
 
 
262
    i_save                = *(vect_renum.val    );
 
263
    *(vect_renum.val    ) = *(vect_renum.val + i);
 
264
    *(vect_renum.val + i) = i_save               ;
 
265
 
 
266
 
 
267
    ecs_loc_tab_int__desc_arbre(this_vect.val,
 
268
                                0,
 
269
                                i,
 
270
                                vect_renum.val);
 
271
  }
 
272
}
 
273
 
 
274
/*----------------------------------------------------------------------------
 
275
 *  Fonction de tri lexicographique d'un vecteur de chaînes de caractères
 
276
 *
 
277
 *  La liste n'est pas modifiée directement,
 
278
 *   mais on construit un vecteur de renumérotation,
 
279
 *   afin de pouvoir appliquer cette renumérotation à d'autres tableaux
 
280
 *
 
281
 *  Le tri utilise est de type "heapsort", de complexité O(nlog(n)).
 
282
 *  Les éléments sont rangés en ordre croissant.
 
283
 *----------------------------------------------------------------------------*/
 
284
 
 
285
void
 
286
ecs_tab_char__trie(const ecs_tab_char_t  this_vect,
 
287
                   ecs_tab_int_t         vect_renum)
 
288
{
 
289
  ecs_int_t    i, i_save;
 
290
 
 
291
  /*xxxxxxxxxxxxxxxxxxxxxxxxxxx Instructions xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
 
292
 
 
293
  /* Création de l'arbre binaire vec_renum->val_tab[vect_renum->nbr] */
 
294
 
 
295
  for (i = (this_vect.nbr / 2) - 1; i >= 0; i--) {
 
296
 
 
297
    ecs_loc_tab_char__desc_arbre(this_vect.val,
 
298
                                 i,
 
299
                                 this_vect.nbr,
 
300
                                 vect_renum.val);
 
301
  }
 
302
 
 
303
  /* Tri de l'arbre binaire */
 
304
 
 
305
  for (i = this_vect.nbr - 1; i > 0; i--) {
 
306
 
 
307
    i_save                = *(vect_renum.val    );
 
308
    *(vect_renum.val    ) = *(vect_renum.val + i);
 
309
    *(vect_renum.val + i) = i_save               ;
 
310
 
 
311
    ecs_loc_tab_char__desc_arbre(this_vect.val,
 
312
                                 0,
 
313
                                 i,
 
314
                                 vect_renum.val);
 
315
  }
 
316
}
 
317
 
 
318
/*----------------------------------------------------------------------------
 
319
 *  Fonction qui trie un vecteur d'entiers donné
 
320
 *   en renvoyant le vecteur trié
 
321
 *
 
322
 *  La fonction détermine aussi le vecteur de renumérotation des indices
 
323
 *  (pour des indices commençant à `0')
 
324
 *----------------------------------------------------------------------------*/
 
325
 
 
326
ecs_tab_int_t
 
327
ecs_tab_int__trie_et_renvoie(const ecs_tab_int_t  this_vect,
 
328
                             ecs_tab_int_t        vect_renum)
 
329
{
 
330
  size_t      ival;
 
331
  ecs_tab_int_t vect_trie;
 
332
 
 
333
  /*xxxxxxxxxxxxxxxxxxxxxxxxxxx Instructions xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
 
334
 
 
335
  for (ival = 0; ival < this_vect.nbr; ival++)
 
336
    vect_renum.val[ival] = ival;
 
337
 
 
338
  ecs_tab_int__trie(this_vect ,
 
339
                    vect_renum );
 
340
 
 
341
  ECS_MALLOC(vect_trie.val, this_vect.nbr, ecs_int_t);
 
342
  vect_trie.nbr = this_vect.nbr;
 
343
 
 
344
  for (ival = 0; ival < this_vect.nbr; ival++)
 
345
    vect_trie.val[ival] = this_vect.val[vect_renum.val[ival]];
 
346
 
 
347
  return vect_trie;
 
348
}
 
349
 
 
350
/*----------------------------------------------------------------------------
 
351
 *  Fonction qui trie un vecteur de chaînes de caractères donné
 
352
 *   en renvoyant le vecteur trié. Les chaînes ne sont pas dupliquées,
 
353
 *   seuls les pointeurs sont copiés.
 
354
 *
 
355
 *  La fonction détermine aussi le vecteur de renumérotation des indices
 
356
 *  (pour des indices commençant à `0')
 
357
 *----------------------------------------------------------------------------*/
 
358
 
 
359
ecs_tab_char_t
 
360
ecs_tab_char__trie_et_renvoie(const ecs_tab_char_t  this_vect,
 
361
                              ecs_tab_int_t         vect_renum)
 
362
{
 
363
  size_t      ival;
 
364
  ecs_tab_char_t vect_trie;
 
365
 
 
366
  /*xxxxxxxxxxxxxxxxxxxxxxxxxxx Instructions xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
 
367
 
 
368
  for (ival = 0; ival < this_vect.nbr; ival++)
 
369
    vect_renum.val[ival] = ival;
 
370
 
 
371
  ecs_tab_char__trie(this_vect ,
 
372
                     vect_renum );
 
373
 
 
374
  ECS_MALLOC(vect_trie.val, this_vect.nbr, char *);
 
375
  vect_trie.nbr = this_vect.nbr;
 
376
 
 
377
  for (ival = 0; ival < this_vect.nbr; ival++)
 
378
    vect_trie.val[ival] = this_vect.val[vect_renum.val[ival]];
 
379
 
 
380
  return vect_trie;
 
381
}
 
382
 
 
383
/*----------------------------------------------------------------------------
 
384
 *  Fonction qui compacte un vecteur de chaînes de caractères donné
 
385
 *   en renvoyant le vecteur compacté; les chaînes ne sont pas dupliquées,
 
386
 *   seuls les pointeurs sont copiés.
 
387
 *
 
388
 *  Le vecteur d'origine doit être trié.
 
389
 *----------------------------------------------------------------------------*/
 
390
 
 
391
ecs_tab_char_t
 
392
ecs_tab_char__compacte(const ecs_tab_char_t  this_vect)
 
393
{
 
394
  size_t         ival;
 
395
  size_t         ival_last;
 
396
 
 
397
  ecs_tab_char_t vect_compact ;
 
398
 
 
399
  /*xxxxxxxxxxxxxxxxxxxxxxxxxxx Instructions xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
 
400
 
 
401
  ECS_MALLOC(vect_compact.val, this_vect.nbr, char *);
 
402
  vect_compact.nbr = this_vect.nbr;
 
403
 
 
404
  if (this_vect.nbr == 0)
 
405
    return vect_compact;
 
406
 
 
407
  ival_last = 0;
 
408
  vect_compact.val[0] = this_vect.val[0];
 
409
 
 
410
  for (ival = 1; ival < this_vect.nbr; ival++) {
 
411
 
 
412
    if (strcmp(this_vect.val[ival], vect_compact.val[ival_last]) != 0) {
 
413
 
 
414
      vect_compact.val[++ival_last] = this_vect.val[ival];
 
415
 
 
416
    }
 
417
  }
 
418
 
 
419
  vect_compact.nbr = ival_last + 1;
 
420
  ECS_REALLOC(vect_compact.val,
 
421
              vect_compact.nbr, char *);
 
422
 
 
423
  return vect_compact;
 
424
}
 
425
 
 
426
/*----------------------------------------------------------------------------
 
427
 *  Fonction de recherche d'une collection d'entiers
 
428
 *   dans une autre collection d'entiers strictement ordonnée.
 
429
 *   (Méthode de recherche dichotomique)
 
430
 *
 
431
 *  La fonction détermine un vecteur d'indices correspondant
 
432
 *   à la position des entiers dans le vecteur ou est faite la recherche
 
433
 *  Si un entier n'est pas contenu dans le vecteur,
 
434
 *   on lui adresse un "indice" `-1'
 
435
 *----------------------------------------------------------------------------*/
 
436
 
 
437
void
 
438
ecs_tab_int__recherche(ecs_tab_int_t  this_vect_rec,
 
439
                       ecs_tab_int_t  vect_ord,
 
440
                       ecs_tab_int_t  vect_ind)
 
441
{
 
442
  ecs_int_t   val_rec;   /* Valeur de l'entier  à rechercher                 */
 
443
  size_t      irec;      /* Indice de boucle sur les entiers à rechercher    */
 
444
 
 
445
  ecs_int_t   mid;       /* Valeur au centre dans l'intervalle de recherche  */
 
446
  ecs_int_t   left;      /* Valeur à gauche dans l'intervalle de recherche   */
 
447
  ecs_int_t   right;     /* Valeur à droite dans la recherche dichotomique   */
 
448
 
 
449
  /*xxxxxxxxxxxxxxxxxxxxxxxxxxx Instructions xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
 
450
 
 
451
  for (irec = 0; irec < this_vect_rec.nbr; irec++) {
 
452
 
 
453
    val_rec = *(this_vect_rec.val + irec);
 
454
 
 
455
    if (val_rec <= vect_ord.val[0])
 
456
      *(vect_ind.val + irec) = 0;
 
457
 
 
458
    else if (val_rec > vect_ord.val[vect_ord.nbr - 1])
 
459
      *(vect_ind.val + irec) = vect_ord.nbr;
 
460
 
 
461
    else {
 
462
 
 
463
      left  = 0;
 
464
      right = vect_ord.nbr - 1;
 
465
 
 
466
      while ((right - left) > 1) {
 
467
 
 
468
        mid = (right + left) / 2;  /* Division entière */
 
469
        if (val_rec <= vect_ord.val[mid])
 
470
          right = mid;
 
471
        else
 
472
          left  = mid;
 
473
 
 
474
      }
 
475
 
 
476
      *(vect_ind.val + irec) = right;
 
477
 
 
478
    }
 
479
 
 
480
    if (   *(vect_ind.val + irec) >= (ecs_int_t)(vect_ord.nbr)
 
481
        || val_rec != vect_ord.val[*(vect_ind.val + irec)] ) {
 
482
 
 
483
      /* Échec de la recherche :                                 */
 
484
      /*  l'élément `val_rec' n'a pas été trouvé dans le vecteur */
 
485
      /* => on affecte une valeur `-1'                           */
 
486
 
 
487
      *(vect_ind.val + irec) = -1;
 
488
 
 
489
    }
 
490
 
 
491
  } /* Fin de la boucle sur les éléments de la liste à rechercher */
 
492
}
 
493
 
 
494
/*----------------------------------------------------------------------------
 
495
 *  Fonction de construction du tableau de remplacement référence -> indice
 
496
 *   Si bool_copie est à true, on alloue et on renvoie une copie de
 
497
 *   tab_att_reference, qui n'est pas modifie; sinon, tab_att_reference est
 
498
 *   transforme.
 
499
 *----------------------------------------------------------------------------*/
 
500
 
 
501
ecs_tab_int_t
 
502
ecs_tab_int__ref_en_indice(ecs_tab_int_t        tab_att_reference,
 
503
                           const ecs_tab_int_t  tab_val_idx,
 
504
                           bool                 bool_copie)
 
505
{
 
506
  size_t         ival;
 
507
 
 
508
  ecs_tab_int_t  tab_ind_ref_ord;
 
509
  ecs_tab_int_t  tab_renum;
 
510
  ecs_tab_int_t  tab_trie;
 
511
 
 
512
  ecs_tab_int_t  tab_ind_reference;
 
513
 
 
514
  /*xxxxxxxxxxxxxxxxxxxxxxxxxxx Instructions xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
 
515
 
 
516
  /* Allocations et initialisations */
 
517
 
 
518
  tab_ind_reference.nbr = tab_att_reference.nbr;
 
519
 
 
520
  if (bool_copie == true)
 
521
    ECS_MALLOC(tab_ind_reference.val, tab_ind_reference.nbr, ecs_int_t);
 
522
 
 
523
  else
 
524
    tab_ind_reference.val = tab_att_reference.val;
 
525
 
 
526
  tab_ind_ref_ord.nbr = tab_ind_reference.nbr;
 
527
  ECS_MALLOC(tab_ind_ref_ord.val, tab_ind_ref_ord.nbr, ecs_int_t);
 
528
 
 
529
  tab_renum.nbr = tab_val_idx.nbr;
 
530
  ECS_MALLOC(tab_renum.val, tab_renum.nbr,  ecs_int_t);
 
531
 
 
532
  /* renumérotation de vec_idx_sous_ent->val_tab  */
 
533
 
 
534
  tab_trie = ecs_tab_int__trie_et_renvoie(tab_val_idx,
 
535
                                          tab_renum);
 
536
 
 
537
  ecs_tab_int__recherche(tab_att_reference,
 
538
                         tab_trie,
 
539
                         tab_ind_ref_ord);
 
540
 
 
541
  ECS_FREE(tab_trie.val);
 
542
 
 
543
  for (ival = 0; ival < tab_ind_reference.nbr; ival++)
 
544
    tab_ind_reference.val[ival] = tab_renum.val[tab_ind_ref_ord.val[ival]];
 
545
 
 
546
  /* Libération de mémoire */
 
547
 
 
548
  ECS_FREE(tab_renum.val);
 
549
  ECS_FREE(tab_ind_ref_ord.val);
 
550
 
 
551
  /* Retour */
 
552
 
 
553
  return tab_ind_reference;
 
554
}
 
555
 
 
556
/*----------------------------------------------------------------------------*/
 
557