← Back to branch summary

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

« back to all changes in this revision

Viewing changes to preprocessor/base/ecs_table.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/base/ecs_table.c
 
1
/*============================================================================
 
2
 *  Définitions des fonctions de base
 
3
 *   associées à la structure `ecs_table_t' décrivant une table
 
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
 
 
29
/*============================================================================
 
30
 *                                 Visibilité
 
31
 *============================================================================*/
 
32
 
 
33
/*----------------------------------------------------------------------------
 
34
 *  Fichiers `include' librairie standard C
 
35
 *----------------------------------------------------------------------------*/
 
36
 
 
37
#include <assert.h>
 
38
#include <stdio.h>
 
39
#include <string.h> /* strcpy() */
 
40
 
 
41
 
 
42
/*----------------------------------------------------------------------------
 
43
 *  Fichiers `include' visibles du  paquetage global "Utilitaire"
 
44
 *----------------------------------------------------------------------------*/
 
45
 
 
46
#include "ecs_def.h"
 
47
#include "ecs_fic.h"
 
48
#include "ecs_mem.h"
 
49
 
 
50
 
 
51
/*----------------------------------------------------------------------------
 
52
 *  Fichiers `include' visibles des paquetages visibles
 
53
 *----------------------------------------------------------------------------*/
 
54
 
 
55
#include "ecs_descr_chaine.h"
 
56
#include "ecs_descr.h"
 
57
 
 
58
 
 
59
/*----------------------------------------------------------------------------
 
60
 *  Fichiers `include' visibles du  paquetage courant
 
61
 *----------------------------------------------------------------------------*/
 
62
 
 
63
 
 
64
/*----------------------------------------------------------------------------
 
65
 *  Fichier  `include' du  paquetage courant associé au fichier courant
 
66
 *----------------------------------------------------------------------------*/
 
67
 
 
68
#include "ecs_table.h"
 
69
 
 
70
 
 
71
/*----------------------------------------------------------------------------
 
72
 *  Fichiers `include' privés   du  paquetage courant
 
73
 *----------------------------------------------------------------------------*/
 
74
 
 
75
#include "ecs_table_priv.h"
 
76
 
 
77
 
 
78
/*============================================================================
 
79
 *                              Fonctions privées
 
80
 *============================================================================*/
 
81
 
 
82
/*----------------------------------------------------------------------------
 
83
 *  Fonction d'impression d'une table avec position réglée en ASCII
 
84
 *----------------------------------------------------------------------------*/
 
85
 
 
86
static void
 
87
_imprime_pos_pas(FILE             *fic_imp,
 
88
                 size_t            nbr_ent,
 
89
                 size_t            pos_pas,
 
90
                 const ecs_int_t   val_int[],
 
91
                 size_t            nbr_imp)
 
92
{
 
93
  /* Variables locales */
 
94
 
 
95
  size_t  ient;
 
96
  size_t  iloc;
 
97
 
 
98
  size_t  ind_ent_1 = 0;
 
99
  size_t  ind_ent_2;
 
100
 
 
101
  char pos_str[32]; /* Largement surdimensionné pour contenir une
 
102
                       chaîne de type [%10d], un entier "long" pouvant
 
103
                       nécessiter un format plus large */
 
104
 
 
105
  /* Instructions */
 
106
 
 
107
  assert(val_int != NULL);
 
108
 
 
109
  ind_ent_2 = ECS_MIN(nbr_ent, nbr_imp);
 
110
 
 
111
 
 
112
  /* Impression des valeurs */
 
113
  /*========================*/
 
114
 
 
115
  while (1) {
 
116
 
 
117
    for (ient = ind_ent_1; ient < ind_ent_2; ient++) {
 
118
 
 
119
      if (pos_pas == 1) {
 
120
 
 
121
        fprintf(fic_imp, "%50s %12lu %12ld" "\n",
 
122
                " ", (unsigned long)(ient+1),
 
123
                (long)val_int[ient]);
 
124
 
 
125
      }
 
126
      else if (pos_pas > 1) {
 
127
 
 
128
        sprintf(pos_str, "[%d]", (int)(pos_pas*ient + 1));
 
129
 
 
130
        fprintf(fic_imp, "%37s %12lu %12s %12ld" "\n",
 
131
                " ", (unsigned long)(ient+1), pos_str,
 
132
                (long)val_int[pos_pas*ient]);
 
133
 
 
134
        for (iloc = 1; iloc < pos_pas; iloc++)
 
135
          fprintf(fic_imp, "%63s %12ld" "\n",
 
136
                  " ", (long)val_int[pos_pas*ient + iloc]);
 
137
 
 
138
      }
 
139
    }
 
140
 
 
141
    if (ind_ent_2 == nbr_ent)
 
142
      break;
 
143
 
 
144
    ind_ent_1 = ECS_MAX(nbr_ent - nbr_imp, nbr_imp);
 
145
 
 
146
    if (ind_ent_1 > ind_ent_2)
 
147
 
 
148
      fprintf(fic_imp,
 
149
              "%77s", "............\n");
 
150
 
 
151
    ind_ent_2 = nbr_ent;
 
152
 
 
153
  }
 
154
}
 
155
 
 
156
 
 
157
/*----------------------------------------------------------------------------
 
158
 *  Fonction d'impression d'une table avec position non réglée en ASCII
 
159
 *  (Table entier uniquement)
 
160
 *----------------------------------------------------------------------------*/
 
161
 
 
162
static void
 
163
_imprime_pos_tab(FILE             *fic_imp,
 
164
                 size_t            nbr_ent,
 
165
                 ecs_size_t        pos_tab[],
 
166
                 const ecs_int_t   val_tab[],
 
167
                 size_t            nbr_imp)
 
168
{
 
169
  /* Variables locales */
 
170
 
 
171
  size_t  ient;
 
172
  size_t  iloc;
 
173
 
 
174
  size_t  ind_ent_1 = 0;
 
175
  size_t  ind_ent_2;
 
176
 
 
177
  size_t  nbr_loc;
 
178
 
 
179
 
 
180
  /* Instructions */
 
181
 
 
182
  assert(pos_tab != NULL);
 
183
 
 
184
  ind_ent_2 = ECS_MIN(nbr_ent, nbr_imp);
 
185
 
 
186
 
 
187
 
 
188
  /* Impression des valeurs */
 
189
  /*========================*/
 
190
 
 
191
  while (1) {
 
192
 
 
193
    for (ient = ind_ent_1; ient < ind_ent_2; ient++) {
 
194
 
 
195
      nbr_loc = pos_tab[ient + 1] - pos_tab[ient];
 
196
 
 
197
      if (nbr_loc > 0)
 
198
        fprintf(fic_imp, "%37s %12lu %12lu %12ld\n",
 
199
                " ", (unsigned long)(ient+1),
 
200
                (unsigned long)pos_tab[ient],
 
201
                (long)val_tab[pos_tab[ient] - 1]);
 
202
      else
 
203
        fprintf(fic_imp, "%37s %12lu %12lu\n",
 
204
                " ", (unsigned long)(ient+1),
 
205
                (unsigned long)pos_tab[ient]);
 
206
 
 
207
      for (iloc = 1; iloc < nbr_loc; iloc++)
 
208
        fprintf(fic_imp, "%63s %12ld\n",
 
209
                " ", (long)val_tab[pos_tab[ient] + iloc - 1]);
 
210
 
 
211
    }
 
212
 
 
213
    if (ind_ent_2 == nbr_ent)
 
214
      break;
 
215
 
 
216
    ind_ent_1 = ECS_MAX(nbr_ent - nbr_imp, nbr_imp);
 
217
 
 
218
    if (ind_ent_1 > ind_ent_2)
 
219
 
 
220
      fprintf(fic_imp,
 
221
              "%77s", "............\n");
 
222
 
 
223
    ind_ent_2 = nbr_ent;
 
224
 
 
225
  }
 
226
 
 
227
  fprintf(fic_imp, "%50s %12lu\n",
 
228
          " ", (unsigned long)pos_tab[nbr_ent]);
 
229
}
 
230
 
 
231
/*----------------------------------------------------------------------------
 
232
 *  Fonction qui concatène dans une table réceptrice donnée,
 
233
 *   une table à concaténer donnée
 
234
 *
 
235
 *  La concaténation de 2 tables consiste à concaténer :
 
236
 *  - les tables des positions des 2 tables;
 
237
 *  - les tables des valeurs   des 2 tables;
 
238
 *  - les listes chaînées des descripteurs des 2 tables
 
239
 *    (nécessaire uniquement pour des tables de type "attribut")
 
240
 *
 
241
 *  Les autres membres de la table réceptrice ne sont pas modifiés
 
242
 *----------------------------------------------------------------------------*/
 
243
 
 
244
static void
 
245
_table__concatene(ecs_table_t  *table_recept,
 
246
                  ecs_table_t  *table_concat)
 
247
{
 
248
  size_t    ipos;
 
249
  size_t    ival;
 
250
  size_t    nbr_elt_recept;
 
251
  size_t    nbr_val_recept;
 
252
  size_t    nbr_val_concat;
 
253
  size_t    pos_recept_fin;
 
254
 
 
255
  ecs_descr_t  *descr_concat_copie;
 
256
  ecs_tab_int_t tab_renum_descr;
 
257
 
 
258
  /*xxxxxxxxxxxxxxxxxxxxxxxxxxx Instructions xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
 
259
 
 
260
  assert(table_recept != NULL);
 
261
  assert(table_concat != NULL);
 
262
 
 
263
  /* Dimensions avant concaténation */
 
264
 
 
265
  nbr_elt_recept = table_recept->nbr;
 
266
  nbr_val_recept = ecs_table__ret_val_nbr(table_recept);
 
267
  nbr_val_concat = ecs_table__ret_val_nbr(table_concat);
 
268
 
 
269
  /* Pour les attributs,                                 */
 
270
  /*  il faut renuméroter les descripteurs               */
 
271
  /*  et propager ces nouvelles valeurs sur les éléments */
 
272
 
 
273
  tab_renum_descr.nbr = 0;
 
274
  tab_renum_descr.val = NULL;
 
275
 
 
276
  if (table_concat->descr != NULL) {
 
277
 
 
278
    /* Unification des descripteurs d'attributs */
 
279
 
 
280
    descr_concat_copie = ecs_descr_chaine__copie(table_concat->descr);
 
281
 
 
282
    tab_renum_descr = ecs_descr_chaine__concatene(&table_recept->descr,
 
283
                                                  &descr_concat_copie);
 
284
  }
 
285
 
 
286
  /* Membres restant à modifier pour la table receptrice : */
 
287
  /* - `nbr_elt'                                           */
 
288
  /* - `pos*'                                              */
 
289
  /* - `val*'                                              */
 
290
 
 
291
  table_recept->nbr += table_concat->nbr;
 
292
 
 
293
  /* Traitement de la table des positions; si l'on n'a pas
 
294
     une REGLE identique de part et d'autre, on doit la reconstruire */
 
295
 
 
296
  /* Si l'on a un pas identique de part et d'autre, on n'a rien à faire */
 
297
 
 
298
  if (   table_recept->pos != NULL
 
299
      || table_concat->pos != NULL
 
300
      || table_recept->pas != table_concat->pas) {
 
301
 
 
302
    /* 1ère étape : construire ou agrandir le tableau des positions,
 
303
       et le remplir des valeurs de la table initiale */
 
304
 
 
305
    if (table_recept->pos == NULL) {
 
306
 
 
307
      ECS_MALLOC(table_recept->pos, table_recept->nbr + 1, ecs_size_t);
 
308
      table_recept->pos[0] = 1;
 
309
      for (ipos = 0; ipos <= nbr_elt_recept; ipos++)
 
310
        table_recept->pos[ipos] = (table_recept->pas * ipos) + 1;
 
311
 
 
312
    }
 
313
    else
 
314
      ECS_REALLOC(table_recept->pos, table_recept->nbr + 1, ecs_size_t);
 
315
 
 
316
    /* 2ème étape : ajouter les positions à concaténer */
 
317
 
 
318
    pos_recept_fin = table_recept->pos[nbr_elt_recept];
 
319
 
 
320
    if (table_concat->pos == NULL) {
 
321
 
 
322
      for (ipos = 1; ipos <= table_concat->nbr; ipos++)
 
323
        table_recept->pos[nbr_elt_recept + ipos]
 
324
          = pos_recept_fin + (ipos * table_concat->pas);
 
325
 
 
326
    }
 
327
    else { /* if (table_concat->pos != NULL) */
 
328
 
 
329
      for (ipos = 1; ipos <= table_concat->nbr; ipos++)
 
330
        table_recept->pos[nbr_elt_recept + ipos]
 
331
          = pos_recept_fin - 1 + table_concat->pos[ipos];
 
332
 
 
333
    }
 
334
 
 
335
  }
 
336
 
 
337
  if (table_recept->pos != NULL)
 
338
    table_recept->pas = 0;
 
339
 
 
340
  /* Traitement de la table des valeurs */
 
341
  /*------------------------------------*/
 
342
 
 
343
  /* On concatène les tables de valeurs,
 
344
     en renumérotant éventuellement des attributs */
 
345
 
 
346
  if (table_recept->nbr > 0) {
 
347
 
 
348
    /* 1ère étape : construire ou agrandir le tableau des valeurs,
 
349
       et le remplir des valeurs de la table initiale */
 
350
 
 
351
    if (nbr_elt_recept == 0) {
 
352
      assert(table_recept->val == NULL);
 
353
      ECS_MALLOC(table_recept->val,
 
354
                 nbr_val_recept + nbr_val_concat,
 
355
                 ecs_int_t);
 
356
    }
 
357
    else {
 
358
      assert(table_recept->val != NULL);
 
359
      ECS_REALLOC(table_recept->val,
 
360
                  nbr_val_recept + nbr_val_concat,
 
361
                  ecs_int_t);
 
362
    }
 
363
 
 
364
    /* 2ème étape : ajouter les valeurs à concaténer, en les renumérotant,
 
365
       si nécessaire */
 
366
 
 
367
    if (tab_renum_descr.nbr == 0 && nbr_val_concat > 0)
 
368
 
 
369
      memcpy(((ecs_int_t *)table_recept->val) + nbr_val_recept,
 
370
             table_concat->val,
 
371
             nbr_val_concat * sizeof(ecs_int_t));
 
372
 
 
373
    else {
 
374
 
 
375
      ecs_int_t *tab_val_recept = table_recept->val;
 
376
      ecs_int_t *tab_val_concat = table_concat->val;
 
377
 
 
378
      for (ival = 0; ival < nbr_val_concat; ival++)
 
379
        tab_val_recept[nbr_val_recept + ival]
 
380
          = tab_renum_descr.val[ECS_ABS(tab_val_concat[ival]) - 1] + 1;
 
381
 
 
382
    }
 
383
 
 
384
  } /* Fin de la concaténation des tables de valeurs */
 
385
 
 
386
 
 
387
  /* Suppression du tableau de renumérotation des descripteurs */
 
388
 
 
389
  if (tab_renum_descr.nbr > 0)
 
390
    ECS_FREE(tab_renum_descr.val);
 
391
}
 
392
 
 
393
/*============================================================================
 
394
 *                             Fonctions publiques
 
395
 *============================================================================*/
 
396
 
 
397
/*----------------------------------------------------------------------------
 
398
 *  Fonction qui crée une structure `ecs_table_t'
 
399
 *
 
400
 *  La structure devient propriétaire des tableaux tab_pos et tab_val
 
401
 *   fournis en argument.
 
402
 *
 
403
 *   nbr      : Nombre d'éléments à remplir
 
404
 *   pas      : Pas des positions  si REGLE
 
405
 *   pos      : Positions de la table si non REGLE
 
406
 *   val      : Valeurs de la table
 
407
 *   descr    : Pointeur sur le descripteur
 
408
 *   statut_e : Statut dans une transformation
 
409
 *----------------------------------------------------------------------------*/
 
410
 
 
411
ecs_table_t *
 
412
ecs_table__cree(size_t                nbr,
 
413
                size_t                pas,
 
414
                ecs_size_t           *pos,
 
415
                ecs_int_t            *val,
 
416
                ecs_descr_t          *descr)
 
417
{
 
418
  ecs_table_t  *this_table;
 
419
 
 
420
  /*xxxxxxxxxxxxxxxxxxxxxxxxxxx Instructions xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
 
421
 
 
422
  /* Allocation de la structure `ecs_table_t' */
 
423
  /*------------------------------------------*/
 
424
 
 
425
  ECS_MALLOC(this_table, 1, ecs_table_t);
 
426
 
 
427
  this_table->nbr = nbr;
 
428
 
 
429
  /* Définition des positions des valeurs (itérateur) */
 
430
  /*--------------------------------------------------*/
 
431
 
 
432
  this_table->pas = pas;
 
433
  this_table->pos = pos;
 
434
 
 
435
  ecs_table__pos_en_regle(this_table);
 
436
 
 
437
  /* Définition de la table des valeurs (conteneur) */
 
438
  /*------------------------------------------------*/
 
439
 
 
440
  this_table->val = val;
 
441
 
 
442
  /* Affectation du descripteur de table */
 
443
  /*-------------------------------------*/
 
444
 
 
445
  this_table->descr = descr;
 
446
 
 
447
  return this_table;
 
448
}
 
449
 
 
450
/*----------------------------------------------------------------------------
 
451
 *  Fonction qui crée une structure `ecs_table_t'
 
452
 *
 
453
 *   nbr      : Nombre d'éléments à remplir
 
454
 *   nbr_val  : Nombre de valeurs à remplir
 
455
 *----------------------------------------------------------------------------*/
 
456
 
 
457
ecs_table_t *
 
458
ecs_table__alloue(size_t  nbr,
 
459
                  size_t  nbr_val)
 
460
{
 
461
  ecs_table_t  *this_table;
 
462
 
 
463
  /*xxxxxxxxxxxxxxxxxxxxxxxxxxx Instructions xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
 
464
 
 
465
  /* Allocation de la structure `ecs_table_t' */
 
466
  /*------------------------------------------*/
 
467
 
 
468
  ECS_MALLOC(this_table, 1, ecs_table_t);
 
469
 
 
470
  this_table->nbr = nbr;
 
471
 
 
472
  /* Définition des positions des valeurs (itérateur) */
 
473
  /*--------------------------------------------------*/
 
474
 
 
475
  this_table->pas = 0;
 
476
 
 
477
  ECS_MALLOC(this_table->pos, nbr + 1, ecs_size_t);
 
478
 
 
479
  /* Définition de la table des valeurs (conteneur) */
 
480
  /*------------------------------------------------*/
 
481
 
 
482
  ECS_MALLOC(this_table->val, nbr_val, ecs_int_t);
 
483
 
 
484
  /* Affectation du descripteur de table */
 
485
  /*-------------------------------------*/
 
486
 
 
487
  this_table->descr = NULL;
 
488
 
 
489
  return this_table;
 
490
}
 
491
 
 
492
/*----------------------------------------------------------------------------
 
493
 *  Fonction libérant une structure `ecs_table_t' donnée en argument.
 
494
 *----------------------------------------------------------------------------*/
 
495
 
 
496
void
 
497
ecs_table__detruit(ecs_table_t  **this_table)
 
498
{
 
499
  /*xxxxxxxxxxxxxxxxxxxxxxxxxxx Instructions xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
 
500
 
 
501
  if (this_table == NULL)
 
502
    return;
 
503
 
 
504
  if (*this_table == NULL)
 
505
    return;
 
506
 
 
507
  /* Libération du contenu de la structure `ecs_table_t' */
 
508
  /*=================================================*/
 
509
 
 
510
  /* Libération de la structure des positions */
 
511
  /*------------------------------------------*/
 
512
 
 
513
  if ((*this_table)->pos != NULL)
 
514
    ECS_FREE((*this_table)->pos);
 
515
 
 
516
  /* Libération de la structure des valeurs */
 
517
  /*----------------------------------------*/
 
518
 
 
519
  if ((*this_table)->val != NULL)
 
520
    ECS_FREE((*this_table)->val);
 
521
 
 
522
  /* Libération du descripteur de table */
 
523
  /*------------------------------------*/
 
524
 
 
525
  /* Appel à la fonction de libération d'un descripteur de table */
 
526
 
 
527
  if ((*this_table)->descr != NULL)
 
528
    ecs_descr_chaine__detruit(&((*this_table)->descr));
 
529
 
 
530
  /* Libération de la structure `ecs_table_t' */
 
531
  /*==========================================*/
 
532
 
 
533
  ECS_FREE(*this_table);
 
534
}
 
535
 
 
536
/*----------------------------------------------------------------------------
 
537
 *  Fonction qui convertit, si possible,
 
538
 *   le tableau des positions d'une table en REGLE
 
539
 *----------------------------------------------------------------------------*/
 
540
 
 
541
void
 
542
ecs_table__pos_en_regle(ecs_table_t  *this_table)
 
543
{
 
544
  size_t      ipos;
 
545
  size_t      pos_pas;
 
546
  bool        bool_regle;
 
547
 
 
548
  /*xxxxxxxxxxxxxxxxxxxxxxxxxxx Instructions xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
 
549
 
 
550
  assert(this_table != NULL);
 
551
 
 
552
  bool_regle = true;
 
553
 
 
554
  if (this_table->pos != NULL && this_table->nbr > 0) {
 
555
 
 
556
    this_table->pas = 0;
 
557
 
 
558
    pos_pas = this_table->pos[1] - this_table->pos[0];
 
559
 
 
560
    for (ipos = 1; ipos < this_table->nbr; ipos++) {
 
561
 
 
562
      if (this_table->pos[ipos + 1] - this_table->pos[ipos] != pos_pas) {
 
563
        bool_regle = false;
 
564
        break;
 
565
      }
 
566
 
 
567
    }
 
568
 
 
569
    if (bool_regle == true) {
 
570
 
 
571
      this_table->pas = pos_pas;
 
572
 
 
573
      ECS_FREE(this_table->pos);
 
574
 
 
575
    }
 
576
  }
 
577
 
 
578
}
 
579
 
 
580
/*----------------------------------------------------------------------------
 
581
 *  Fonction qui construit, si nécessaire, un tableau des positions à
 
582
 *   partir d'une REGLE.
 
583
 *----------------------------------------------------------------------------*/
 
584
 
 
585
void
 
586
ecs_table__regle_en_pos(ecs_table_t  *this_table)
 
587
{
 
588
  size_t ipos;
 
589
  ecs_size_t *tab_pos;
 
590
 
 
591
  /*xxxxxxxxxxxxxxxxxxxxxxxxxxx Instructions xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
 
592
 
 
593
  assert(this_table != NULL);
 
594
 
 
595
  if (this_table->pos == NULL) {
 
596
 
 
597
    ECS_MALLOC(tab_pos, this_table->nbr + 1, ecs_size_t);
 
598
 
 
599
    for (ipos = 0; ipos <= this_table->nbr; ipos++)
 
600
      tab_pos[ipos] = (ipos * this_table->pas) + 1;
 
601
 
 
602
    this_table->pos = tab_pos;
 
603
  }
 
604
}
 
605
 
 
606
/*----------------------------------------------------------------------------
 
607
 *  Fonction qui libère, si possible, le tableau des positions d'une table.
 
608
 *  Ce tableau ne doit pas avoir été modifié.
 
609
 *----------------------------------------------------------------------------*/
 
610
 
 
611
void
 
612
ecs_table__libere_pos(ecs_table_t  *this_table)
 
613
{
 
614
  /*xxxxxxxxxxxxxxxxxxxxxxxxxxx Instructions xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
 
615
 
 
616
  assert(this_table != NULL);
 
617
 
 
618
  if (this_table->pas != 0 && this_table->pos != NULL)
 
619
    ECS_FREE(this_table->pos);
 
620
}
 
621
 
 
622
/*----------------------------------------------------------------------------
 
623
 *  Fonction imprimant le contenu d'une structure `ecs_table_t' donnée
 
624
 *   sur le flux décrit par la structure `FILE'
 
625
 *----------------------------------------------------------------------------*/
 
626
 
 
627
void
 
628
ecs_table__imprime(const ecs_table_t  *this_table,
 
629
                   size_t              imp_col,
 
630
                   size_t              nbr_imp,
 
631
                   FILE               *fic_imp)
 
632
{
 
633
  /*xxxxxxxxxxxxxxxxxxxxxxxxxxx Instructions xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
 
634
 
 
635
  assert(this_table   != NULL);
 
636
  assert(fic_imp      != NULL);
 
637
 
 
638
  imp_col++;
 
639
 
 
640
  /* Impression des tables d'information de la table */
 
641
  /*-------------------------------------------------*/
 
642
 
 
643
  ecs_fic__imprime_val(fic_imp, imp_col, "nbr_elt", ECS_TYPE_size_t,
 
644
                       &this_table->nbr);
 
645
 
 
646
  ecs_fic__imprime_val(fic_imp, imp_col, "pos_pas", ECS_TYPE_size_t,
 
647
                       &this_table->pas);
 
648
 
 
649
  ecs_fic__imprime_ptr(fic_imp, imp_col, "pos_tab", this_table->pos);
 
650
  ecs_fic__imprime_ptr(fic_imp, imp_col, "val_tab", this_table->val);
 
651
 
 
652
 
 
653
  /* Impression des positions et des valeurs */
 
654
  /*-----------------------------------------*/
 
655
 
 
656
  if (this_table->pos == NULL && this_table->val != NULL)
 
657
    _imprime_pos_pas(fic_imp,
 
658
                     this_table->nbr,
 
659
                     this_table->pas,
 
660
                     this_table->val,
 
661
                     nbr_imp);
 
662
 
 
663
  else if (this_table->pos != NULL)
 
664
    _imprime_pos_tab(fic_imp,
 
665
                     this_table->nbr,
 
666
                     this_table->pos,
 
667
                     this_table->val,
 
668
                     nbr_imp);
 
669
 
 
670
  /* Impression de la liste chaînée des descripteurs */
 
671
  /*-------------------------------------------------*/
 
672
 
 
673
  /* Impression du pointeur sur le descripteur de tête */
 
674
 
 
675
  ecs_fic__imprime_val(fic_imp, imp_col, "descr_tete", ECS_TYPE_void,
 
676
                       this_table->descr);
 
677
 
 
678
  if (this_table->descr != NULL) {
 
679
 
 
680
    /* Appel à la fonction d'impression d'une chaîne de descripteurs de table */
 
681
 
 
682
    ecs_descr_chaine__imprime(this_table->descr,
 
683
                              imp_col + 1,
 
684
                              fic_imp);
 
685
  }
 
686
 
 
687
}
 
688
 
 
689
/*----------------------------------------------------------------------------
 
690
 *  Fonction qui renvoie la taille en octets d'une structure `ecs_table_t'
 
691
 *----------------------------------------------------------------------------*/
 
692
 
 
693
size_t
 
694
ecs_table__ret_taille(const ecs_table_t  *this_table)
 
695
{
 
696
  size_t        nbr_val;
 
697
  size_t        taille;
 
698
 
 
699
  /*xxxxxxxxxxxxxxxxxxxxxxxxxxx Instructions xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
 
700
 
 
701
  if (this_table == NULL)
 
702
    return 0;
 
703
 
 
704
  taille = sizeof(*this_table);
 
705
 
 
706
  if (this_table->pos != NULL)
 
707
    taille += (sizeof(ecs_int_t) * (this_table->nbr + 1));
 
708
 
 
709
  if (this_table->val != NULL) {
 
710
    nbr_val = ecs_table__ret_val_nbr(this_table);
 
711
    taille += (sizeof(ecs_int_t) * nbr_val);
 
712
  }
 
713
 
 
714
  if (this_table->descr != NULL)
 
715
    taille += ecs_descr_chaine__ret_taille(this_table->descr);
 
716
 
 
717
  return taille;
 
718
}
 
719
 
 
720
/*----------------------------------------------------------------------------
 
721
 *  Fonction qui renvoie une table entièrement réallouée
 
722
 *   dont le contenu est copié à partir de la table donnée
 
723
 *
 
724
 *  Le membre donnant le lien sur une table suivant `l_table_sui'
 
725
 *   n'est pas copié et est mis à `NULL'
 
726
 *----------------------------------------------------------------------------*/
 
727
 
 
728
ecs_table_t *
 
729
ecs_table__copie(ecs_table_t  *table_init)
 
730
{
 
731
  size_t        nbr_val;
 
732
  ecs_table_t * this_table;
 
733
 
 
734
  /*xxxxxxxxxxxxxxxxxxxxxxxxxxx Instructions xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
 
735
 
 
736
  assert(table_init != NULL);
 
737
 
 
738
  ECS_MALLOC(this_table, 1, ecs_table_t);
 
739
 
 
740
  this_table->nbr = table_init->nbr;
 
741
 
 
742
  this_table->pas = table_init->pas;
 
743
 
 
744
  if (table_init->pos != NULL) {
 
745
    ECS_MALLOC(this_table->pos, table_init->nbr + 1, ecs_size_t);
 
746
    memcpy(this_table->pos,
 
747
           table_init->pos,
 
748
           (table_init->nbr + 1) * sizeof(ecs_size_t));
 
749
  }
 
750
  else
 
751
    this_table->pos = NULL;
 
752
 
 
753
  if (table_init->val != NULL) {
 
754
    nbr_val = ecs_table__ret_val_nbr(table_init);
 
755
    ECS_MALLOC(this_table->val, nbr_val, ecs_int_t);
 
756
    memcpy(this_table->val,
 
757
           table_init->val,
 
758
           sizeof(ecs_int_t) * nbr_val);
 
759
  }
 
760
  else
 
761
    this_table->val = NULL;
 
762
 
 
763
  this_table->descr  = ecs_descr_chaine__copie(table_init->descr);
 
764
 
 
765
  return this_table;
 
766
}
 
767
 
 
768
/*----------------------------------------------------------------------------
 
769
 *  Fonction qui créé une structure `ecs_table_t'
 
770
 *   à partir d'un tableau `tab_elt' contenant les valeurs de la table.
 
771
 *
 
772
 *  Si un élément n'a pas de valeur associée, la valeur correspondante
 
773
 *   dans `tab_elt' est `0'
 
774
 *----------------------------------------------------------------------------*/
 
775
 
 
776
ecs_table_t *
 
777
ecs_table__transforme_tableau(size_t                nbr_elt,
 
778
                              const ecs_int_t      *tab_elt,
 
779
                              ecs_descr_t          *descr)
 
780
{
 
781
  ecs_size_t *pos_tab;
 
782
  ecs_int_t *val_tab;
 
783
  size_t cpt_val;
 
784
  size_t ielt;
 
785
 
 
786
  ecs_table_t * this_table;
 
787
 
 
788
  /*xxxxxxxxxxxxxxxxxxxxxxxxxxx Instructions xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
 
789
 
 
790
  assert(nbr_elt != 0);
 
791
  assert(tab_elt != NULL);
 
792
 
 
793
  /* Allocation de la structure `ecs_table_t' */
 
794
  /*--------------------------------------*/
 
795
 
 
796
  ECS_MALLOC(this_table, 1, ecs_table_t);
 
797
 
 
798
  this_table->nbr = nbr_elt;
 
799
 
 
800
  /* Construction des tableaux de positions et de valeurs */
 
801
  /*------------------------------------------------------*/
 
802
 
 
803
  ECS_MALLOC(pos_tab, nbr_elt + 1, ecs_size_t);
 
804
  ECS_MALLOC(val_tab, nbr_elt    , ecs_int_t);
 
805
 
 
806
  pos_tab[0] = 1;
 
807
  cpt_val    = 0;
 
808
 
 
809
  for (ielt = 0; ielt < nbr_elt; ielt++) {
 
810
 
 
811
    if (tab_elt[ielt] != 0) {
 
812
      pos_tab[ielt + 1]  = pos_tab[ielt] + 1;
 
813
      val_tab[cpt_val++] = tab_elt[ielt];
 
814
    }
 
815
    else
 
816
      pos_tab[ielt + 1]  = pos_tab[ielt];
 
817
 
 
818
  }
 
819
 
 
820
  ECS_REALLOC(val_tab, cpt_val, ecs_int_t);
 
821
 
 
822
  /* Création de la table des positions des valeurs (itérateur) */
 
823
  /*------------------------------------------------------------*/
 
824
 
 
825
  this_table->pas = 0;
 
826
  this_table->pos = pos_tab;
 
827
 
 
828
  ecs_table__pos_en_regle(this_table);
 
829
 
 
830
  /* Création de la table des valeurs (conteneur) */
 
831
  /*----------------------------------------------*/
 
832
 
 
833
  this_table->val = val_tab;
 
834
 
 
835
  /* Affectation du descripteur de table */
 
836
  /*-------------------------------------*/
 
837
 
 
838
  this_table->descr = descr;
 
839
 
 
840
  return this_table;
 
841
}
 
842
 
 
843
/*----------------------------------------------------------------------------
 
844
 *  Fonction renvoyant le nombre d'éléments associés à une table donnée
 
845
 *----------------------------------------------------------------------------*/
 
846
 
 
847
size_t
 
848
ecs_table__ret_elt_nbr(const ecs_table_t  *this_table)
 
849
{
 
850
  size_t retval = 0;
 
851
 
 
852
  /*xxxxxxxxxxxxxxxxxxxxxxxxxxx Instructions xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
 
853
 
 
854
  if (this_table != NULL)
 
855
    retval = this_table->nbr;
 
856
 
 
857
  return retval;
 
858
}
 
859
 
 
860
 
 
861
/*----------------------------------------------------------------------------
 
862
 *  Fonction renvoyant le nombre de valeurs associées à une table donnée
 
863
 *----------------------------------------------------------------------------*/
 
864
 
 
865
size_t
 
866
 ecs_table__ret_val_nbr(const ecs_table_t  *this_table)
 
867
{
 
868
  size_t  nbr_val;
 
869
 
 
870
  /*xxxxxxxxxxxxxxxxxxxxxxxxxxx Instructions xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
 
871
 
 
872
  assert(this_table   != NULL);
 
873
 
 
874
  if (this_table->pos != NULL)
 
875
    nbr_val = this_table->pos[this_table->nbr] - 1;
 
876
  else
 
877
    nbr_val = (this_table->pas * this_table->nbr);
 
878
 
 
879
  return nbr_val;
 
880
}
 
881
 
 
882
/*----------------------------------------------------------------------------
 
883
 *  Fonction retournant le nombre de descripteurs d'une table donnée
 
884
 *----------------------------------------------------------------------------*/
 
885
 
 
886
size_t
 
887
ecs_table__ret_descr_nbr(const ecs_table_t  *this_table)
 
888
{
 
889
  assert(this_table != NULL);
 
890
 
 
891
  return ecs_descr_chaine__ret_nbr(this_table->descr);
 
892
}
 
893
 
 
894
/*----------------------------------------------------------------------------
 
895
 *  Fonction libérant un pointeur sur le tableau des positions d'une
 
896
 *   structure `ecs_table_t' donnée.
 
897
 *
 
898
 *  Si les positions correspondent à une REGLE, le tableau est libéré.
 
899
 *   Sinon, il est conservé par la structure ecs_table_t.
 
900
 *----------------------------------------------------------------------------*/
 
901
 
 
902
void
 
903
ecs_table__libere_pos_tab(const ecs_table_t  *this_table,
 
904
                          ecs_size_t         *pos_tab)
 
905
{
 
906
  /*xxxxxxxxxxxxxxxxxxxxxxxxxxx Instructions xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
 
907
 
 
908
  assert(this_table != NULL);
 
909
  assert(this_table->pos == NULL || this_table->pos == pos_tab);
 
910
 
 
911
  if (this_table->pos == NULL)
 
912
    ECS_FREE(pos_tab);
 
913
}
 
914
 
 
915
/*----------------------------------------------------------------------------
 
916
 *  Fonction qui concatène deux tables, et supprime la table à concaténer
 
917
 *----------------------------------------------------------------------------*/
 
918
 
 
919
void
 
920
ecs_table__concatene(ecs_table_t  **this_table,
 
921
                     ecs_table_t  **concat_table,
 
922
                     size_t         nbr_elt_init,
 
923
                     size_t         nbr_elt_concat)
 
924
{
 
925
  /*xxxxxxxxxxxxxxxxxxxxxxxxxxx Instructions xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
 
926
 
 
927
  assert(this_table != NULL);
 
928
  assert(concat_table != NULL);
 
929
 
 
930
  /* ------------------------------------------------------------------ */
 
931
  /* PARTIE REALISEE PENDANT LA FUSION                                  */
 
932
  /* ------------------------------------------------------------------ */
 
933
  /*    Si la table n'existe pas dans l'entité de maillage à concaténer */
 
934
  /* et si c'est une table de type "attribut"                           */
 
935
  /* (pour lequel tous les éléments doivent être renseignes)            */
 
936
  /* on initialise les valeurs de l'attribut pour la table à concaténer */
 
937
  /* ------------------------------------------------------------------ */
 
938
 
 
939
  /* La table existe dans l'entité de maillage à concaténer */
 
940
 
 
941
  if (*concat_table != NULL) {
 
942
 
 
943
    /* On le concatène */
 
944
 
 
945
    if (*this_table != NULL) {
 
946
      _table__concatene(*this_table, *concat_table);
 
947
      ecs_table__detruit(concat_table);
 
948
    }
 
949
    else {
 
950
      ecs_table__prolonge(*concat_table,
 
951
                          nbr_elt_init,
 
952
                          0);
 
953
      *this_table = *concat_table;
 
954
      *concat_table = NULL;
 
955
    }
 
956
  }
 
957
 
 
958
  /* La table n'existe pas dans l'entité de maillage à concaténer */
 
959
 
 
960
  else {
 
961
    ecs_table__prolonge(*this_table,
 
962
                        0,
 
963
                        nbr_elt_concat);
 
964
 
 
965
  } /* Fin : boucle sur les tables de l'entité de maillage receptrice */
 
966
}
 
967
 
 
968
/*----------------------------------------------------------------------------
 
969
 *  Fonction qui prolonge une table réceptrice donné
 
970
 *
 
971
 *  Il s'agit en fait de concaténer la table avec une table vide. Seule la
 
972
 *  table des positions est modifiée. Les autres membres de la structure de
 
973
 *  la table réceptrice ne sont pas modifiés.
 
974
 *----------------------------------------------------------------------------*/
 
975
 
 
976
void
 
977
ecs_table__prolonge(ecs_table_t  *this_table,
 
978
                    size_t        nbr_elt_prec,
 
979
                    size_t        nbr_elt_suiv)
 
980
{
 
981
  size_t      ipos;
 
982
  size_t      nbr_elt_ini;
 
983
  ecs_int_t   pos_fin;
 
984
  bool        bool_pos_ini;
 
985
 
 
986
  /*xxxxxxxxxxxxxxxxxxxxxxxxxxx Instructions xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
 
987
 
 
988
  if (this_table == NULL)
 
989
    return;
 
990
 
 
991
  ecs_table__regle_en_pos(this_table);
 
992
 
 
993
  nbr_elt_ini = this_table->nbr;
 
994
 
 
995
#if defined(SX) && defined(_SX) /* NEC SX compiler may bug on : operator */
 
996
  if (this_table->pos != NULL)
 
997
    bool_pos_ini = true;
 
998
  else
 
999
    bool_pos_ini = false;
 
1000
#else
 
1001
  bool_pos_ini = (this_table->pos != NULL) ? true : false;
 
1002
#endif
 
1003
 
 
1004
  /* Mise à jour du nombre d'éléments */
 
1005
 
 
1006
  this_table->nbr += nbr_elt_prec + nbr_elt_suiv;
 
1007
 
 
1008
  /* Si la table n'est pas déjà vide, la table des positions ne
 
1009
     correspondra pas à une REGLE, et devra être construite */
 
1010
 
 
1011
  if (this_table->pos != NULL || this_table->pas != 0) {
 
1012
 
 
1013
    ECS_REALLOC(this_table->pos, this_table->nbr + 1, ecs_size_t);
 
1014
 
 
1015
    if (bool_pos_ini == true) {
 
1016
      memmove(this_table->pos + (nbr_elt_prec * sizeof(ecs_int_t)),
 
1017
              this_table->pos,
 
1018
              (this_table->nbr + 1) * sizeof(ecs_int_t));
 
1019
    }
 
1020
    else {
 
1021
      for (ipos = 0; ipos <= nbr_elt_ini; ipos++)
 
1022
        this_table->pos[nbr_elt_prec + ipos]
 
1023
          = (ipos * this_table->pas) + 1;
 
1024
    }
 
1025
 
 
1026
    this_table->pos[0] = 1;
 
1027
 
 
1028
    for (ipos = 0; ipos < nbr_elt_prec; ipos++)
 
1029
      this_table->pos[ipos + 1] = 1;
 
1030
 
 
1031
    pos_fin = this_table->pos[nbr_elt_prec + nbr_elt_ini];
 
1032
    for (ipos = 0; ipos < nbr_elt_suiv; ipos++)
 
1033
      this_table->pos[nbr_elt_prec + nbr_elt_ini + ipos + 1] = pos_fin;
 
1034
 
 
1035
  }
 
1036
 
 
1037
  ecs_table__pos_en_regle(this_table);
 
1038
}
 
1039
 
 
1040
/*----------------------------------------------------------------------------
 
1041
 *  Fonction réalisant la transformation d'un table
 
1042
 *   en appliquant directement le vecteur de transformation donné
 
1043
 *   sur ses positions
 
1044
 *
 
1045
 *  Le nombre de valeurs transformées doit être égal
 
1046
 *  au nombre de valeurs avant transformation
 
1047
 *----------------------------------------------------------------------------*/
 
1048
 
 
1049
void
 
1050
ecs_table__transforme_pos(ecs_table_t          *this_table,
 
1051
                          size_t                nbr_elt_ref,
 
1052
                          const ecs_tab_int_t   vect_transf)
 
1053
{
 
1054
  ecs_table_t  *table_ref;
 
1055
  size_t       nbr_val_ref;
 
1056
  ecs_int_t    ival;
 
1057
  size_t       ielt_ref;
 
1058
  size_t       ielt_transf;
 
1059
  size_t       ival_ref;
 
1060
  ecs_int_t    elt_nbr_val;
 
1061
  ecs_int_t    pre_pos;
 
1062
  ecs_int_t    cpt_val;
 
1063
 
 
1064
  /*xxxxxxxxxxxxxxxxxxxxxxxxxxx Instructions xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
 
1065
 
 
1066
  if (this_table == NULL)
 
1067
    return;
 
1068
 
 
1069
  ecs_table__regle_en_pos(this_table);
 
1070
 
 
1071
  assert(vect_transf.nbr == nbr_elt_ref);
 
1072
  assert(this_table->nbr == nbr_elt_ref);
 
1073
 
 
1074
  nbr_val_ref = ecs_table__ret_val_nbr(this_table);
 
1075
 
 
1076
  table_ref = ecs_table__alloue(nbr_elt_ref, nbr_val_ref);
 
1077
 
 
1078
  for (ielt_ref = 0; ielt_ref < nbr_elt_ref + 1; ielt_ref++)
 
1079
    table_ref->pos[ielt_ref] = this_table->pos[ielt_ref];
 
1080
 
 
1081
  for (ival_ref = 0; ival_ref < nbr_val_ref; ival_ref++)
 
1082
    table_ref->val[ival_ref] = this_table->val[ival_ref];
 
1083
 
 
1084
  this_table->pos[0] = 1;
 
1085
 
 
1086
  cpt_val = 0;
 
1087
 
 
1088
  for (ielt_transf = 0; ielt_transf < nbr_elt_ref; ielt_transf++) {
 
1089
 
 
1090
    pre_pos = table_ref->pos[vect_transf.val[ielt_transf]];
 
1091
 
 
1092
    elt_nbr_val
 
1093
      = table_ref->pos[vect_transf.val[ielt_transf] + 1] - pre_pos;
 
1094
 
 
1095
    this_table->pos[ielt_transf + 1]
 
1096
      = this_table->pos[ielt_transf] + elt_nbr_val;
 
1097
 
 
1098
    for (ival = 0; ival < elt_nbr_val; ival++) {
 
1099
 
 
1100
      this_table->val[cpt_val++]
 
1101
        = table_ref->val[pre_pos - 1 + ival];
 
1102
 
 
1103
    }
 
1104
  }
 
1105
 
 
1106
  ecs_table__detruit(&table_ref);
 
1107
 
 
1108
  ecs_table__pos_en_regle(this_table);
 
1109
}
 
1110
 
 
1111
/*----------------------------------------------------------------------------
 
1112
 *  Fonction qui incrémente les valeurs d'une table donnée
 
1113
 *   d'une constante donnée
 
1114
 *----------------------------------------------------------------------------*/
 
1115
 
 
1116
void
 
1117
ecs_table__incremente_val(ecs_table_t      *this_table,
 
1118
                          const ecs_int_t   increment)
 
1119
{
 
1120
  size_t     nbr_val;
 
1121
  size_t     ival;
 
1122
 
 
1123
  /*xxxxxxxxxxxxxxxxxxxxxxxxxxx Instructions xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
 
1124
 
 
1125
  if (this_table == NULL)
 
1126
    return;
 
1127
 
 
1128
  nbr_val = ecs_table__ret_val_nbr(this_table);
 
1129
 
 
1130
  for (ival = 0; ival < nbr_val; ival++) {
 
1131
 
 
1132
    if (this_table->val[ival] > 0)
 
1133
      this_table->val[ival] += increment;
 
1134
    else if (this_table->val[ival] < 0)
 
1135
      this_table->val[ival] -= increment;
 
1136
  }
 
1137
}
 
1138
 
 
1139
/*----------------------------------------------------------------------------
 
1140
 *  Fonction réalisant la transformation d'un vecteur indexé
 
1141
 *   en appliquant directement le vecteur de transformation donné
 
1142
 *   sur les valeurs associées à ses éléments
 
1143
 *----------------------------------------------------------------------------*/
 
1144
 
 
1145
void
 
1146
ecs_table__renumerote(ecs_table_t          *this_table,
 
1147
                      const ecs_tab_int_t   vect_transf,
 
1148
                      const ecs_tab_int_t   signe_elt)
 
1149
{
 
1150
  ecs_table_t *table_ref;
 
1151
  size_t       nbr_val_ref;
 
1152
  ecs_int_t    val_ref;
 
1153
  ecs_int_t    sgn_ref;
 
1154
  size_t       ival_ref;
 
1155
 
 
1156
  /*xxxxxxxxxxxxxxxxxxxxxxxxxxx Instructions xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
 
1157
 
 
1158
  if (this_table == NULL)
 
1159
    return;
 
1160
 
 
1161
  nbr_val_ref = ecs_table__ret_val_nbr(this_table);
 
1162
 
 
1163
  table_ref = ecs_table__alloue(0, nbr_val_ref);
 
1164
 
 
1165
  for (ival_ref = 0; ival_ref < nbr_val_ref; ival_ref++)
 
1166
    table_ref->val[ival_ref] = this_table->val[ival_ref];
 
1167
 
 
1168
  for (ival_ref = 0; ival_ref < nbr_val_ref; ival_ref++) {
 
1169
 
 
1170
    val_ref = ECS_ABS(table_ref->val[ival_ref]);
 
1171
    sgn_ref = table_ref->val[ival_ref] / val_ref;
 
1172
 
 
1173
    this_table->val[ival_ref]  = vect_transf.val[val_ref - 1] + 1;
 
1174
 
 
1175
    this_table->val[ival_ref] *= signe_elt.val[val_ref - 1] * sgn_ref;
 
1176
 
 
1177
  }
 
1178
 
 
1179
  ecs_table__detruit(&table_ref);
 
1180
}
 
1181
 
 
1182
/*----------------------------------------------------------------------------
 
1183
 *  Fonction qui détermine une nouvelle table à partir d'une table de
 
1184
 *   référence en extrayant de ce dernier les éléments sélectionnés
 
1185
 *   par le tableau de booléens
 
1186
 *----------------------------------------------------------------------------*/
 
1187
 
 
1188
ecs_table_t *
 
1189
ecs_table__extrait(ecs_table_t            *table_ref,
 
1190
                   const ecs_tab_bool_t    bool_elt_select)
 
1191
{
 
1192
  size_t        cpt_elt_new;
 
1193
  size_t        cpt_val_new;
 
1194
  size_t        cpt_val_old_new;
 
1195
  size_t        nbr_elt_ref;
 
1196
  size_t        nbr_val_ref;
 
1197
  size_t        pos_ref_inf;
 
1198
  size_t        pos_ref_sup;
 
1199
 
 
1200
  size_t        ielt_ref;
 
1201
  size_t        ipos_ref;
 
1202
 
 
1203
  ecs_table_t  *table_new;
 
1204
 
 
1205
  /*xxxxxxxxxxxxxxxxxxxxxxxxxxx Instructions xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
 
1206
 
 
1207
  ecs_table__regle_en_pos(table_ref);
 
1208
 
 
1209
  nbr_elt_ref = table_ref->nbr;
 
1210
  nbr_val_ref = ecs_table__ret_val_nbr(table_ref);
 
1211
 
 
1212
  table_new = ecs_table__alloue(nbr_elt_ref,
 
1213
                                nbr_val_ref);
 
1214
 
 
1215
  /* Extraction de la table */
 
1216
 
 
1217
  nbr_elt_ref = table_ref->nbr;
 
1218
  nbr_val_ref = ecs_table__ret_val_nbr(table_ref);
 
1219
 
 
1220
  table_new->pos[0] = 1;
 
1221
  cpt_elt_new           = 0;
 
1222
  cpt_val_new           = 0;
 
1223
  cpt_val_old_new       = 0;
 
1224
 
 
1225
  for (ielt_ref = 0; ielt_ref < nbr_elt_ref; ielt_ref++) {
 
1226
 
 
1227
    if (bool_elt_select.val[ielt_ref] == true) {
 
1228
 
 
1229
      /* L'élément est à extraire */
 
1230
 
 
1231
      pos_ref_inf = table_ref->pos[ielt_ref    ] - 1;
 
1232
      pos_ref_sup = table_ref->pos[ielt_ref + 1] - 1;
 
1233
 
 
1234
      for (ipos_ref = pos_ref_inf; ipos_ref < pos_ref_sup; ipos_ref++)
 
1235
        table_new->val[cpt_val_new++] = table_ref->val[ipos_ref];
 
1236
 
 
1237
      table_new->pos[cpt_elt_new + 1] = cpt_val_new + 1;
 
1238
 
 
1239
      cpt_elt_new++;
 
1240
 
 
1241
    }
 
1242
  }
 
1243
 
 
1244
  ECS_REALLOC(table_new->pos, cpt_elt_new + 1, ecs_size_t);
 
1245
  ECS_REALLOC(table_new->val, cpt_val_new,     ecs_int_t);
 
1246
 
 
1247
  table_new->nbr = cpt_elt_new;
 
1248
 
 
1249
  ecs_table__pos_en_regle(table_ref);
 
1250
 
 
1251
  return table_new;
 
1252
}
 
1253
 
 
1254
/*----------------------------------------------------------------------------*/