![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to instructions_s6.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [local] / rpl / src|
Return to instructions_s6.c CVS log | Up to [local] / rpl / src |
1.1 bertrand 1: /*
2: ================================================================================
3: RPL/2 (R) version 4.0.9
4: Copyright (C) 1989-2010 Dr. BERTRAND Joël
5:
6: This file is part of RPL/2.
7:
8: RPL/2 is free software; you can redistribute it and/or modify it
9: under the terms of the CeCILL V2 License as published by the french
10: CEA, CNRS and INRIA.
11:
12: RPL/2 is distributed in the hope that it will be useful, but WITHOUT
13: ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
14: FITNESS FOR A PARTICULAR PURPOSE. See the CeCILL V2 License
15: for more details.
16:
17: You should have received a copy of the CeCILL License
18: along with RPL/2. If not, write to info@cecill.info.
19: ================================================================================
20: */
21:
22:
23: #include "rpl.conv.h"
24:
25:
26: /*
27: ================================================================================
28: Fonction 'sdev'
29: ================================================================================
30: Entrées :
31: --------------------------------------------------------------------------------
32: Sorties :
33: --------------------------------------------------------------------------------
34: Effets de bord : néant
35: ================================================================================
36: */
37:
38: void
39: instruction_sdev(struct_processus *s_etat_processus)
40: {
41: logical1 presence_variable;
42:
43: long i;
44:
45: struct_objet *s_objet_statistique;
46: struct_objet *s_objet_resultat;
47: struct_objet *s_objet_temporaire;
48:
49: unsigned long nombre_colonnes;
50:
51: (*s_etat_processus).erreur_execution = d_ex;
52:
53: if ((*s_etat_processus).affichage_arguments == 'Y')
54: {
55: printf("\n SDEV ");
56:
57: if ((*s_etat_processus).langue == 'F')
58: {
59: printf("(écart-type)\n\n");
60: }
61: else
62: {
63: printf("(standard deviation)\n\n");
64: }
65:
66: printf("-> 1: %s, %s, %s, %s\n", d_INT, d_REL, d_VIN, d_VRL);
67:
68: return;
69: }
70: else if ((*s_etat_processus).test_instruction == 'Y')
71: {
72: (*s_etat_processus).nombre_arguments = -1;
73: return;
74: }
75:
76: if (test_cfsf(s_etat_processus, 31) == d_vrai)
77: {
78: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
79: {
80: return;
81: }
82: }
83:
84: /*
85: * Recherche d'une variable globale référencée par SIGMA
86: */
87:
88: if (recherche_variable(s_etat_processus, ds_sdat) == d_faux)
89: {
90: /*
91: * Aucune variable SIGMA
92: */
93:
94: (*s_etat_processus).erreur_systeme = d_es;
95: (*s_etat_processus).erreur_execution = d_ex_absence_observations;
96: return;
97: }
98: else
99: {
100: /*
101: * Il existe une variable locale SIGMA. Reste à vérifier l'existence
102: * d'une variable SIGMA globale...
103: */
104:
105: i = (*s_etat_processus).position_variable_courante;
106: presence_variable = d_faux;
107:
108: while(i >= 0)
109: {
110: if ((strcmp((*s_etat_processus).s_liste_variables[i].nom,
111: ds_sdat) == 0) && ((*s_etat_processus)
112: .s_liste_variables[i].niveau == 1))
113: {
114: presence_variable = d_vrai;
115: break;
116: }
117:
118: i--;
119: }
120:
121: if (presence_variable == d_faux)
122: {
123: (*s_etat_processus).erreur_execution = d_ex_absence_observations;
124: return;
125: }
126: else
127: {
128: (*s_etat_processus).position_variable_courante = i;
129:
130: if ((*s_etat_processus).s_liste_variables[i].objet == NULL)
131: {
132: (*s_etat_processus).erreur_execution = d_ex_variable_partagee;
133: return;
134: }
135:
136: if (((*((*s_etat_processus).s_liste_variables
137: [(*s_etat_processus).position_variable_courante].objet))
138: .type != MIN) && ((*((*s_etat_processus)
139: .s_liste_variables[(*s_etat_processus)
140: .position_variable_courante].objet)).type != MRL))
141: {
142: (*s_etat_processus).erreur_execution =
143: d_ex_matrice_statistique_invalide;
144: return;
145: }
146:
147: nombre_colonnes = (*((struct_matrice *) (*((*s_etat_processus)
148: .s_liste_variables[(*s_etat_processus)
149: .position_variable_courante].objet)).objet))
150: .nombre_colonnes;
151: }
152: }
153:
154: s_objet_statistique = ((*s_etat_processus).s_liste_variables
155: [(*s_etat_processus).position_variable_courante]).objet;
156:
157: if (((*s_objet_statistique).type == MIN) ||
158: ((*s_objet_statistique).type == MRL))
159: {
160: if ((*((struct_matrice *) (*s_objet_statistique).objet)).nombre_lignes
161: <= 1)
162: {
163: (*s_etat_processus).erreur_execution =
164: d_ex_statistiques_echantillon;
165: return;
166: }
167:
168: if ((s_objet_resultat = allocation(s_etat_processus, NON)) == NULL)
169: {
170: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
171: return;
172: }
173:
174: if (((*s_objet_resultat).objet = ecart_type_statistique(
175: (struct_matrice *) (*s_objet_statistique).objet, 'E')) == NULL)
176: {
177: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
178: return;
179: }
180:
181: if (nombre_colonnes == 1)
182: {
183: if ((*((struct_vecteur *) (*s_objet_resultat).objet)).type == 'I')
184: {
185: (*s_objet_resultat).type = VIN;
186: s_objet_temporaire = s_objet_resultat;
187:
188: if ((s_objet_resultat = allocation(s_etat_processus, INT))
189: == NULL)
190: {
191: (*s_etat_processus).erreur_systeme =
192: d_es_allocation_memoire;
193: return;
194: }
195:
196: (*((integer8 *) (*s_objet_resultat).objet)) =
197: ((integer8 *) (*((struct_vecteur *)
198: (*s_objet_temporaire).objet)).tableau)[0];
199:
200: liberation(s_etat_processus, s_objet_temporaire);
201: }
202: else
203: {
204: (*s_objet_resultat).type = VRL;
205: s_objet_temporaire = s_objet_resultat;
206:
207: if ((s_objet_resultat = allocation(s_etat_processus, REL))
208: == NULL)
209: {
210: (*s_etat_processus).erreur_systeme =
211: d_es_allocation_memoire;
212: return;
213: }
214:
215: (*((real8 *) (*s_objet_resultat).objet)) =
216: ((real8 *) (*((struct_vecteur *)
217: (*s_objet_temporaire).objet)).tableau)[0];
218:
219: liberation(s_etat_processus, s_objet_temporaire);
220: }
221: }
222: else
223: {
224: if ((*((struct_vecteur *) (*s_objet_resultat).objet)).type == 'I')
225: {
226: (*s_objet_resultat).type = VIN;
227: }
228: else
229: {
230: (*s_objet_resultat).type = VRL;
231: }
232: }
233:
234: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
235: s_objet_resultat) == d_erreur)
236: {
237: return;
238: }
239: }
240: else
241: {
242: (*s_etat_processus).erreur_execution =
243: d_ex_matrice_statistique_invalide;
244: return;
245: }
246:
247: return;
248: }
249:
250:
251: /*
252: ================================================================================
253: Fonction 'schur'
254: ================================================================================
255: Entrées :
256: --------------------------------------------------------------------------------
257: Sorties :
258: --------------------------------------------------------------------------------
259: Effets de bord : néant
260: ================================================================================
261: */
262:
263: void
264: instruction_schur(struct_processus *s_etat_processus)
265: {
266: struct_matrice *s_matrice;
267:
268: struct_objet *s_copie_argument;
269: struct_objet *s_objet_argument;
270: struct_objet *s_objet_resultat;
271:
272: (*s_etat_processus).erreur_execution = d_ex;
273:
274: if ((*s_etat_processus).affichage_arguments == 'Y')
275: {
276: printf("\n SCHUR ");
277:
278: if ((*s_etat_processus).langue == 'F')
279: {
280: printf("(décomposition de Schur)\n\n");
281: }
282: else
283: {
284: printf("(Schur decomposition)\n\n");
285: }
286:
287: printf(" 1: %s, %s, %s\n", d_MIN, d_MRL, d_MCX);
288: printf("-> 2: %s, %s\n", d_MRL, d_MCX);
289: printf(" 1: %s, %s\n", d_MRL, d_MCX);
290:
291: return;
292: }
293: else if ((*s_etat_processus).test_instruction == 'Y')
294: {
295: (*s_etat_processus).nombre_arguments = -1;
296: return;
297: }
298:
299: if (test_cfsf(s_etat_processus, 31) == d_vrai)
300: {
301: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
302: {
303: return;
304: }
305: }
306:
307: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
308: &s_objet_argument) == d_erreur)
309: {
310: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
311: return;
312: }
313:
314: /*
315: --------------------------------------------------------------------------------
316: Décomposition de Schur réelle
317: --------------------------------------------------------------------------------
318: */
319:
320: if (((*s_objet_argument).type == MIN) ||
321: ((*s_objet_argument).type == MRL))
322: {
323: if ((s_copie_argument = copie_objet(s_etat_processus,
324: s_objet_argument, 'Q')) == NULL)
325: {
326: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
327: return;
328: }
329:
330: liberation(s_etat_processus, s_objet_argument);
331: s_objet_argument = s_copie_argument;
332:
333: if ((*((struct_matrice *) (*s_objet_argument).objet)).nombre_lignes !=
334: (*((struct_matrice *) (*s_objet_argument).objet))
335: .nombre_colonnes)
336: {
337: liberation(s_etat_processus, s_objet_argument);
338:
339: (*s_etat_processus).erreur_execution = d_ex_dimensions_invalides;
340: return;
341: }
342:
343: if ((s_matrice = malloc(sizeof(struct_matrice)))
344: == NULL)
345: {
346: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
347: return;
348: }
349:
350: factorisation_schur(s_etat_processus, (*s_objet_argument).objet,
351: &s_matrice);
352:
353: if ((*s_etat_processus).erreur_systeme != d_es)
354: {
355: return;
356: }
357:
358: if (((*s_etat_processus).exception != d_ep) ||
359: ((*s_etat_processus).erreur_execution != d_ex))
360: {
361: free(s_matrice);
362: liberation(s_etat_processus, s_objet_argument);
363: return;
364: }
365:
366: if ((s_objet_resultat = allocation(s_etat_processus, NON)) == NULL)
367: {
368: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
369: return;
370: }
371:
372: (*s_objet_resultat).objet = s_matrice;
373: (*s_objet_resultat).type = MRL;
374: (*s_objet_argument).type = MRL;
375: }
376:
377: /*
378: --------------------------------------------------------------------------------
379: Décomposition de Schur complexe
380: --------------------------------------------------------------------------------
381: */
382:
383: else if ((*s_objet_argument).type == MCX)
384: {
385: if ((s_copie_argument = copie_objet(s_etat_processus,
386: s_objet_argument, 'Q')) == NULL)
387: {
388: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
389: return;
390: }
391:
392: liberation(s_etat_processus, s_objet_argument);
393: s_objet_argument = s_copie_argument;
394:
395: if ((*((struct_matrice *) (*s_objet_argument).objet)).nombre_lignes !=
396: (*((struct_matrice *) (*s_objet_argument).objet))
397: .nombre_colonnes)
398: {
399: liberation(s_etat_processus, s_objet_argument);
400:
401: (*s_etat_processus).erreur_execution = d_ex_dimensions_invalides;
402: return;
403: }
404:
405: if ((s_matrice = malloc(sizeof(struct_matrice)))
406: == NULL)
407: {
408: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
409: return;
410: }
411:
412: factorisation_schur(s_etat_processus, (*s_objet_argument).objet,
413: &s_matrice);
414:
415: if ((*s_etat_processus).erreur_systeme != d_es)
416: {
417: return;
418: }
419:
420: if (((*s_etat_processus).exception != d_ep) ||
421: ((*s_etat_processus).erreur_execution != d_ex))
422: {
423: free(s_matrice);
424: liberation(s_etat_processus, s_objet_argument);
425: return;
426: }
427:
428: if ((s_objet_resultat = allocation(s_etat_processus, NON)) == NULL)
429: {
430: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
431: return;
432: }
433:
434: (*s_objet_resultat).objet = s_matrice;
435: (*s_objet_resultat).type = MCX;
436: }
437:
438: /*
439: --------------------------------------------------------------------------------
440: Type d'argument invalide
441: --------------------------------------------------------------------------------
442: */
443:
444: else
445: {
446: liberation(s_etat_processus, s_objet_argument);
447:
448: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
449: return;
450: }
451:
452: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
453: s_objet_argument) == d_erreur)
454: {
455: return;
456: }
457:
458: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
459: s_objet_resultat) == d_erreur)
460: {
461: return;
462: }
463:
464: return;
465: }
466:
467:
468: /*
469: ================================================================================
470: Fonction 'sync'
471: ================================================================================
472: Entrées :
473: --------------------------------------------------------------------------------
474: Sorties :
475: --------------------------------------------------------------------------------
476: Effets de bord : néant
477: ================================================================================
478: */
479:
480: void
481: instruction_sync(struct_processus *s_etat_processus)
482: {
483: file *descripteur;
484:
485: struct_objet *s_objet_argument;
486:
487: (*s_etat_processus).erreur_execution = d_ex;
488:
489: if ((*s_etat_processus).affichage_arguments == 'Y')
490: {
491: printf("\n SYNC ");
492:
493: if ((*s_etat_processus).langue == 'F')
494: {
495: printf("(synchronisation d'un fichier)\n\n");
496: }
497: else
498: {
499: printf("(synchronising a file)\n\n");
500: }
501:
502: printf(" 1: %s\n", d_FCH);
503:
504: return;
505: }
506: else if ((*s_etat_processus).test_instruction == 'Y')
507: {
508: (*s_etat_processus).nombre_arguments = -1;
509: return;
510: }
511:
512: if (test_cfsf(s_etat_processus, 31) == d_vrai)
513: {
514: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
515: {
516: return;
517: }
518: }
519:
520: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
521: &s_objet_argument) == d_erreur)
522: {
523: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
524: return;
525: }
526:
527: if ((*s_objet_argument).type == FCH)
528: {
529: if ((descripteur = descripteur_fichier(s_etat_processus,
530: (struct_fichier *) (*s_objet_argument).objet)) == NULL)
531: {
532: return;
533: }
534:
535: if (fflush(descripteur) != 0)
536: {
537: liberation(s_etat_processus, s_objet_argument);
538:
539: (*s_etat_processus).erreur_execution =
540: d_ex_erreur_acces_fichier;
541: return;
542: }
543: }
544: else
545: {
546: liberation(s_etat_processus, s_objet_argument);
547:
548: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
549: return;
550: }
551:
552: liberation(s_etat_processus, s_objet_argument);
553:
554: return;
555: }
556:
557:
558: /*
559: ================================================================================
560: Fonction 'scale'
561: ================================================================================
562: Entrées :
563: --------------------------------------------------------------------------------
564: Sorties :
565: --------------------------------------------------------------------------------
566: Effets de bord : néant
567: ================================================================================
568: */
569:
570: void
571: instruction_scale(struct_processus *s_etat_processus)
572: {
573: /*
574: * Prend comme argument une liste
575: */
576:
577: long nombre_arguments_principaux;
578: long nombre_arguments_auxiliaires;
579:
580: struct_liste_chainee *l_element_courant;
581: struct_liste_chainee *l_element_courant_auxiliaire;
582:
583: struct_objet *s_objet_argument;
584: struct_objet *s_objet_auxiliaire;
585:
586: unsigned char *tampon;
587:
588: (*s_etat_processus).erreur_execution = d_ex;
589:
590: if ((*s_etat_processus).affichage_arguments == 'Y')
591: {
592: printf("\n SCALE ");
593:
594: if ((*s_etat_processus).langue == 'F')
595: {
596: printf("(définition de l'échelle)\n\n");
597: }
598: else
599: {
600: printf("(scale definition)\n\n");
601: }
602:
603: printf(" 1: %s\n\n", d_LST);
604:
605: if ((*s_etat_processus).langue == 'F')
606: {
607: printf(" Utilisation :\n\n");
608: }
609: else
610: {
611: printf(" Usage:\n\n");
612: }
613:
614: printf(" { { Xmin Xmax } { Ymin Ymax } { Zmin Zmax } } SCALE\n");
615: printf(" { \"AUTOMATIC\" { Ymin Ymax } } SCALE\n");
616:
617: return;
618: }
619: else if ((*s_etat_processus).test_instruction == 'Y')
620: {
621: (*s_etat_processus).nombre_arguments = -1;
622: return;
623: }
624:
625: if (test_cfsf(s_etat_processus, 31) == d_vrai)
626: {
627: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
628: {
629: return;
630: }
631: }
632:
633: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
634: &s_objet_argument) == d_erreur)
635: {
636: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
637: return;
638: }
639:
640: if ((*s_objet_argument).type == LST)
641: {
642: l_element_courant = (struct_liste_chainee *) (*s_objet_argument).objet;
643: nombre_arguments_principaux = 0;
644:
645: while(l_element_courant != NULL)
646: {
647: nombre_arguments_principaux++;
648: l_element_courant = (*l_element_courant).suivant;
649: }
650:
651: if ((nombre_arguments_principaux != 2) &&
652: (nombre_arguments_principaux != 3))
653: {
654: liberation(s_etat_processus, s_objet_argument);
655:
656: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
657: return;
658: }
659:
660: l_element_courant = (struct_liste_chainee *) (*s_objet_argument).objet;
661: nombre_arguments_principaux = 0;
662:
663: while(l_element_courant != NULL)
664: {
665: nombre_arguments_principaux++;
666:
667: if ((*(*l_element_courant).donnee).type == LST)
668: {
669: l_element_courant_auxiliaire = (struct_liste_chainee *)
670: (*(*l_element_courant).donnee).objet;
671: nombre_arguments_auxiliaires = 0;
672:
673: while(l_element_courant_auxiliaire != NULL)
674: {
675: l_element_courant_auxiliaire =
676: (*l_element_courant_auxiliaire).suivant;
677: nombre_arguments_auxiliaires++;
678: }
679:
680: if (nombre_arguments_auxiliaires != 2)
681: {
682: liberation(s_etat_processus, s_objet_argument);
683:
684: (*s_etat_processus).erreur_execution =
685: d_ex_argument_invalide;
686: return;
687: }
688:
689: l_element_courant_auxiliaire = (struct_liste_chainee *)
690: (*(*l_element_courant).donnee).objet;
691: nombre_arguments_auxiliaires = 0;
692:
693: while(l_element_courant_auxiliaire != NULL)
694: {
695: nombre_arguments_auxiliaires++;
696:
697: if (((*(*l_element_courant_auxiliaire).donnee).type ==
698: RPN) || (
699: (*(*l_element_courant_auxiliaire).donnee)
700: .type == ALG) ||
701: ((*(*l_element_courant_auxiliaire).donnee)
702: .type == NOM))
703: {
704: if (evaluation(s_etat_processus,
705: (*l_element_courant_auxiliaire).donnee, 'N')
706: == d_erreur)
707: {
708: liberation(s_etat_processus, s_objet_argument);
709:
710: return;
711: }
712:
713: if (depilement(s_etat_processus,
714: &((*s_etat_processus).l_base_pile),
715: &s_objet_auxiliaire) == d_erreur)
716: {
717: liberation(s_etat_processus, s_objet_argument);
718:
719: (*s_etat_processus).erreur_execution =
720: d_ex_manque_argument;
721: return;
722: }
723:
724: liberation(s_etat_processus,
725: (*l_element_courant_auxiliaire).donnee);
726: (*l_element_courant_auxiliaire).donnee =
727: s_objet_auxiliaire;
728: }
729:
730: if ((*(*l_element_courant_auxiliaire).donnee).type == INT)
731: {
732: switch(nombre_arguments_principaux)
733: {
734: case 1 :
735: {
736: if (nombre_arguments_auxiliaires == 1)
737: {
738: if ((*s_etat_processus).systeme_axes == 0)
739: {
740: (*s_etat_processus).x_min = (real8)
741: (*((integer8 *) (*
742: (*l_element_courant_auxiliaire)
743: .donnee).objet));
744: }
745: else
746: {
747: (*s_etat_processus).x2_min = (real8)
748: (*((integer8 *) (*
749: (*l_element_courant_auxiliaire)
750: .donnee).objet));
751: }
752: }
753: else if (nombre_arguments_auxiliaires == 2)
754: {
755: if ((*s_etat_processus).systeme_axes == 0)
756: {
757: (*s_etat_processus).x_max = (real8)
758: (*((integer8 *) (*
759: (*l_element_courant_auxiliaire)
760: .donnee).objet));
761: (*s_etat_processus)
762: .echelle_automatique_x = d_faux;
763: }
764: else
765: {
766: (*s_etat_processus).x2_max = (real8)
767: (*((integer8 *) (*
768: (*l_element_courant_auxiliaire)
769: .donnee).objet));
770: (*s_etat_processus)
771: .echelle_automatique_x2
772: = d_faux;
773: }
774: }
775: else
776: {
777: liberation(s_etat_processus,
778: s_objet_argument);
779:
780: (*s_etat_processus).erreur_execution =
781: d_ex_argument_invalide;
782: return;
783: }
784:
785: break;
786: }
787:
788: case 2 :
789: {
790: if (nombre_arguments_auxiliaires == 1)
791: {
792: if ((*s_etat_processus).systeme_axes == 0)
793: {
794: (*s_etat_processus).y_min = (real8)
795: (*((integer8 *) (*
796: (*l_element_courant_auxiliaire)
797: .donnee).objet));
798: }
799: else
800: {
801: (*s_etat_processus).y2_min = (real8)
802: (*((integer8 *) (*
803: (*l_element_courant_auxiliaire)
804: .donnee).objet));
805: }
806: }
807: else if (nombre_arguments_auxiliaires == 2)
808: {
809: if ((*s_etat_processus).systeme_axes == 0)
810: {
811: (*s_etat_processus).y_max = (real8)
812: (*((integer8 *) (*
813: (*l_element_courant_auxiliaire)
814: .donnee).objet));
815:
816: (*s_etat_processus)
817: .echelle_automatique_y = d_faux;
818: }
819: else
820: {
821: (*s_etat_processus).y2_max = (real8)
822: (*((integer8 *) (*
823: (*l_element_courant_auxiliaire)
824: .donnee).objet));
825:
826: (*s_etat_processus)
827: .echelle_automatique_y2
828: = d_faux;
829: }
830: }
831: else
832: {
833: liberation(s_etat_processus,
834: s_objet_argument);
835:
836: (*s_etat_processus).erreur_execution =
837: d_ex_argument_invalide;
838: return;
839: }
840:
841: break;
842: }
843:
844: case 3 :
845: {
846: if (nombre_arguments_auxiliaires == 1)
847: {
848: if ((*s_etat_processus).systeme_axes == 0)
849: {
850: (*s_etat_processus).z_min = (real8)
851: (*((integer8 *) (*
852: (*l_element_courant_auxiliaire)
853: .donnee).objet));
854: }
855: else
856: {
857: (*s_etat_processus).z2_min = (real8)
858: (*((integer8 *) (*
859: (*l_element_courant_auxiliaire)
860: .donnee).objet));
861: }
862: }
863: else if (nombre_arguments_auxiliaires == 2)
864: {
865: if ((*s_etat_processus).systeme_axes == 0)
866: {
867: (*s_etat_processus).z_max = (real8)
868: (*((integer8 *) (*
869: (*l_element_courant_auxiliaire)
870: .donnee).objet));
871:
872: (*s_etat_processus)
873: .echelle_automatique_z = d_faux;
874: }
875: else
876: {
877: (*s_etat_processus).z2_max = (real8)
878: (*((integer8 *) (*
879: (*l_element_courant_auxiliaire)
880: .donnee).objet));
881:
882: (*s_etat_processus)
883: .echelle_automatique_z
884: = d_faux;
885: }
886: }
887: else
888: {
889: liberation(s_etat_processus,
890: s_objet_argument);
891:
892: (*s_etat_processus).erreur_execution =
893: d_ex_argument_invalide;
894: return;
895: }
896:
897: break;
898: }
899:
900: default :
901: {
902: liberation(s_etat_processus, s_objet_argument);
903:
904: (*s_etat_processus).erreur_execution =
905: d_ex_argument_invalide;
906: return;
907: }
908: }
909: }
910: else if ((*(*l_element_courant_auxiliaire)
911: .donnee).type == REL)
912: {
913: switch(nombre_arguments_principaux)
914: {
915: case 1 :
916: {
917: if (nombre_arguments_auxiliaires == 1)
918: {
919: if ((*s_etat_processus).systeme_axes == 0)
920: {
921: (*s_etat_processus).x_min =
922: (*((real8 *) (*
923: (*l_element_courant_auxiliaire)
924: .donnee).objet));
925: }
926: else
927: {
928: (*s_etat_processus).x2_min =
929: (*((real8 *) (*
930: (*l_element_courant_auxiliaire)
931: .donnee).objet));
932: }
933: }
934: else if (nombre_arguments_auxiliaires == 2)
935: {
936: if ((*s_etat_processus).systeme_axes == 0)
937: {
938: (*s_etat_processus).x_max =
939: (*((real8 *) (*
940: (*l_element_courant_auxiliaire)
941: .donnee).objet));
942:
943: (*s_etat_processus)
944: .echelle_automatique_x = d_faux;
945: }
946: else
947: {
948: (*s_etat_processus).x2_max =
949: (*((real8 *) (*
950: (*l_element_courant_auxiliaire)
951: .donnee).objet));
952:
953: (*s_etat_processus)
954: .echelle_automatique_x2
955: = d_faux;
956: }
957: }
958: else
959: {
960: liberation(s_etat_processus,
961: s_objet_argument);
962:
963: (*s_etat_processus).erreur_execution =
964: d_ex_argument_invalide;
965: return;
966: }
967:
968: break;
969: }
970:
971: case 2 :
972: {
973: if (nombre_arguments_auxiliaires == 1)
974: {
975: if ((*s_etat_processus).systeme_axes == 0)
976: {
977: (*s_etat_processus).y_min =
978: (*((real8 *) (*
979: (*l_element_courant_auxiliaire)
980: .donnee).objet));
981: }
982: else
983: {
984: (*s_etat_processus).y2_min =
985: (*((real8 *) (*
986: (*l_element_courant_auxiliaire)
987: .donnee).objet));
988: }
989: }
990: else if (nombre_arguments_auxiliaires == 2)
991: {
992: if ((*s_etat_processus).systeme_axes == 0)
993: {
994: (*s_etat_processus).y_max =
995: (*((real8 *) (*
996: (*l_element_courant_auxiliaire)
997: .donnee).objet));
998:
999: (*s_etat_processus)
1000: .echelle_automatique_y = d_faux;
1001: }
1002: else
1003: {
1004: (*s_etat_processus).y2_max =
1005: (*((real8 *) (*
1006: (*l_element_courant_auxiliaire)
1007: .donnee).objet));
1008:
1009: (*s_etat_processus)
1010: .echelle_automatique_y2
1011: = d_faux;
1012: }
1013: }
1014: else
1015: {
1016: liberation(s_etat_processus,
1017: s_objet_argument);
1018:
1019: (*s_etat_processus).erreur_execution =
1020: d_ex_argument_invalide;
1021: return;
1022: }
1023:
1024: break;
1025: }
1026:
1027: case 3 :
1028: {
1029: if (nombre_arguments_auxiliaires == 1)
1030: {
1031: if ((*s_etat_processus).systeme_axes == 0)
1032: {
1033: (*s_etat_processus).z_min =
1034: (*((real8 *) (*
1035: (*l_element_courant_auxiliaire)
1036: .donnee).objet));
1037: }
1038: else
1039: {
1040: (*s_etat_processus).z2_min =
1041: (*((real8 *) (*
1042: (*l_element_courant_auxiliaire)
1043: .donnee).objet));
1044: }
1045: }
1046: else if (nombre_arguments_auxiliaires == 2)
1047: {
1048: if ((*s_etat_processus).systeme_axes == 0)
1049: {
1050: (*s_etat_processus).z_max =
1051: (*((real8 *) (*
1052: (*l_element_courant_auxiliaire)
1053: .donnee).objet));
1054:
1055: (*s_etat_processus)
1056: .echelle_automatique_z = d_faux;
1057: }
1058: else
1059: {
1060: (*s_etat_processus).z2_max =
1061: (*((real8 *) (*
1062: (*l_element_courant_auxiliaire)
1063: .donnee).objet));
1064:
1065: (*s_etat_processus)
1066: .echelle_automatique_z2
1067: = d_faux;
1068: }
1069: }
1070: else
1071: {
1072: liberation(s_etat_processus,
1073: s_objet_argument);
1074:
1075: (*s_etat_processus).erreur_execution =
1076: d_ex_argument_invalide;
1077: return;
1078: }
1079:
1080: break;
1081: }
1082:
1083: default :
1084: {
1085: liberation(s_etat_processus, s_objet_argument);
1086:
1087: (*s_etat_processus).erreur_execution =
1088: d_ex_argument_invalide;
1089: return;
1090: }
1091: }
1092: }
1093:
1094: l_element_courant_auxiliaire =
1095: (*l_element_courant_auxiliaire).suivant;
1096: }
1097: }
1098: else if ((*(*l_element_courant).donnee).type == CHN)
1099: {
1100: tampon = conversion_majuscule((unsigned char *)
1101: (*(*l_element_courant).donnee).objet);
1102:
1103: if (tampon == NULL)
1104: {
1105: (*s_etat_processus).erreur_systeme =
1106: d_es_allocation_memoire;
1107: return;
1108: }
1109:
1110: if (strcmp(tampon, "AUTOMATIC") == 0)
1111: {
1112: switch(nombre_arguments_principaux)
1113: {
1114: case 1 :
1115: {
1116: if ((*s_etat_processus).systeme_axes == 0)
1117: {
1118: (*s_etat_processus).echelle_automatique_x
1119: = d_vrai;
1120: }
1121: else
1122: {
1123: (*s_etat_processus).echelle_automatique_x2
1124: = d_vrai;
1125: }
1126:
1127: break;
1128: }
1129:
1130: case 2 :
1131: {
1132: if ((*s_etat_processus).systeme_axes == 0)
1133: {
1134: (*s_etat_processus).echelle_automatique_y
1135: = d_vrai;
1136: }
1137: else
1138: {
1139: (*s_etat_processus).echelle_automatique_y2
1140: = d_vrai;
1141: }
1142:
1143: break;
1144: }
1145:
1146: case 3 :
1147: {
1148: if ((*s_etat_processus).systeme_axes == 0)
1149: {
1150: (*s_etat_processus).echelle_automatique_z
1151: = d_vrai;
1152: }
1153: else
1154: {
1155: (*s_etat_processus).echelle_automatique_z2
1156: = d_vrai;
1157: }
1158:
1159: break;
1160: }
1161:
1162: default :
1163: {
1164: liberation(s_etat_processus, s_objet_argument);
1165: free(tampon);
1166:
1167: (*s_etat_processus).erreur_execution =
1168: d_ex_argument_invalide;
1169: return;
1170: }
1171: }
1172: }
1173: else
1174: {
1175: liberation(s_etat_processus, s_objet_argument);
1176: free(tampon);
1177:
1178: (*s_etat_processus).erreur_execution =
1179: d_ex_argument_invalide;
1180: return;
1181: }
1182:
1183: free(tampon);
1184: }
1185: else
1186: {
1187: liberation(s_etat_processus, s_objet_argument);
1188:
1189: (*s_etat_processus).erreur_execution =
1190: d_ex_erreur_type_argument;
1191: return;
1192: }
1193:
1194: l_element_courant = (*l_element_courant).suivant;
1195: }
1196: }
1197: else
1198: {
1199: liberation(s_etat_processus, s_objet_argument);
1200:
1201: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
1202: return;
1203: }
1204:
1205: liberation(s_etat_processus, s_objet_argument);
1206:
1207: if (test_cfsf(s_etat_processus, 52) == d_faux)
1208: {
1209: if ((*s_etat_processus).fichiers_graphiques != NULL)
1210: {
1211: appel_gnuplot(s_etat_processus, 'N');
1212: }
1213: }
1214:
1215: return;
1216: }
1217:
1218:
1219: /*
1220: ================================================================================
1221: Fonction 'scls'
1222: ================================================================================
1223: Entrées :
1224: --------------------------------------------------------------------------------
1225: Sorties :
1226: --------------------------------------------------------------------------------
1227: Effets de bord : néant
1228: ================================================================================
1229: */
1230:
1231: void
1232: instruction_scls(struct_processus *s_etat_processus)
1233: {
1234: logical1 presence_variable;
1235: logical1 matrice_entiere;
1236:
1237: long i;
1238:
1239: real8 valeur_courante;
1240:
1241: struct_objet *s_objet_statistique;
1242:
1243: unsigned long j;
1244:
1245: (*s_etat_processus).erreur_execution = d_ex;
1246:
1247: if ((*s_etat_processus).affichage_arguments == 'Y')
1248: {
1249: printf("\n SCLS ");
1250:
1251: if ((*s_etat_processus).langue == 'F')
1252: {
1253: printf("(échelle automatique d'un nuage de points)\n\n");
1254: printf(" Aucun argument\n");
1255: }
1256: else
1257: {
1258: printf("(auto scale scatter plot)\n\n");
1259: printf(" No argument\n");
1260: }
1261:
1262: return;
1263: }
1264: else if ((*s_etat_processus).test_instruction == 'Y')
1265: {
1266: (*s_etat_processus).nombre_arguments = -1;
1267: return;
1268: }
1269:
1270: if (test_cfsf(s_etat_processus, 31) == d_vrai)
1271: {
1272: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
1273: {
1274: return;
1275: }
1276: }
1277:
1278: /*
1279: * Vérification de la présence de la matrice statistique
1280: */
1281:
1282: if (recherche_variable(s_etat_processus, ds_sdat) == d_faux)
1283: {
1284: /*
1285: * Aucune variable ds_sdat n'existe.
1286: */
1287:
1288: (*s_etat_processus).erreur_execution = d_ex_absence_observations;
1289: (*s_etat_processus).erreur_systeme = d_es;
1290:
1291: return;
1292: }
1293:
1294: i = (*s_etat_processus).position_variable_courante;
1295: presence_variable = d_faux;
1296:
1297: while(i >= 0)
1298: {
1299: if ((strcmp((*s_etat_processus).s_liste_variables[i].nom,
1300: ds_sdat) == 0) && ((*s_etat_processus)
1301: .s_liste_variables[i].niveau == 1))
1302: {
1303: presence_variable = d_vrai;
1304: break;
1305: }
1306:
1307: i--;
1308: }
1309:
1310: if (presence_variable == d_faux)
1311: {
1312: (*s_etat_processus).erreur_execution = d_ex_absence_observations;
1313: return;
1314: }
1315:
1316: if ((*s_etat_processus).s_liste_variables[i].objet == NULL)
1317: {
1318: (*s_etat_processus).erreur_execution = d_ex_variable_partagee;
1319: return;
1320: }
1321:
1322: s_objet_statistique = (*s_etat_processus).s_liste_variables[i].objet;
1323:
1324: if ((*s_objet_statistique).type == MIN)
1325: {
1326: matrice_entiere = d_vrai;
1327: }
1328: else if ((*s_objet_statistique).type == MRL)
1329: {
1330: matrice_entiere = d_faux;
1331: }
1332: else
1333: {
1334: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
1335: return;
1336: }
1337:
1338: switch((*((struct_matrice *) (*s_objet_statistique).objet)).nombre_colonnes)
1339: {
1340: /*
1341: * Une colonne
1342: */
1343:
1344: case 1 :
1345: {
1346: (*s_etat_processus).erreur_execution = d_ex_dimensions_invalides;
1347: break;
1348: }
1349:
1350: /*
1351: * Deux colonnes ou plus
1352: */
1353:
1354: default :
1355: {
1356: if (((*s_etat_processus).colonne_statistique_1 < 1) ||
1357: ((*s_etat_processus).colonne_statistique_2 < 1) ||
1358: ((*s_etat_processus).colonne_statistique_1 > (integer8)
1359: (*((struct_matrice *) (*s_objet_statistique).objet))
1360: .nombre_colonnes) ||
1361: ((*s_etat_processus).colonne_statistique_2 > (integer8)
1362: (*((struct_matrice *) (*s_objet_statistique).objet))
1363: .nombre_colonnes))
1364: {
1365: (*s_etat_processus).erreur_execution =
1366: d_ex_observations_inexistantes;
1367: return;
1368: }
1369:
1370: if (matrice_entiere == d_vrai)
1371: {
1372: if ((*s_etat_processus).systeme_axes == 0)
1373: {
1374: (*s_etat_processus).x_min = (real8) ((integer8 **)
1375: (*((struct_matrice *) (*s_objet_statistique).objet))
1376: .tableau)[0][(*s_etat_processus)
1377: .colonne_statistique_1 - 1];
1378: (*s_etat_processus).x_max = (*s_etat_processus).x_min;
1379: }
1380: else
1381: {
1382: (*s_etat_processus).x2_min = (real8) ((integer8 **)
1383: (*((struct_matrice *) (*s_objet_statistique).objet))
1384: .tableau)[0][(*s_etat_processus)
1385: .colonne_statistique_1 - 1];
1386: (*s_etat_processus).x2_max = (*s_etat_processus).x2_min;
1387: }
1388:
1389: if ((*s_etat_processus).systeme_axes == 0)
1390: {
1391: (*s_etat_processus).y_min = (real8) ((integer8 **)
1392: (*((struct_matrice *) (*s_objet_statistique).objet))
1393: .tableau)[0][(*s_etat_processus)
1394: .colonne_statistique_2 - 1];
1395: (*s_etat_processus).y_max = (*s_etat_processus).y_min;
1396: }
1397: else
1398: {
1399: (*s_etat_processus).y2_min = (real8) ((integer8 **)
1400: (*((struct_matrice *) (*s_objet_statistique).objet))
1401: .tableau)[0][(*s_etat_processus)
1402: .colonne_statistique_2 - 1];
1403: (*s_etat_processus).y2_max = (*s_etat_processus).y2_min;
1404: }
1405: }
1406: else
1407: {
1408: if ((*s_etat_processus).systeme_axes == 0)
1409: {
1410: (*s_etat_processus).x_min = ((real8 **)
1411: (*((struct_matrice *) (*s_objet_statistique).objet))
1412: .tableau)[0][(*s_etat_processus)
1413: .colonne_statistique_1 - 1];
1414: (*s_etat_processus).x_max = (*s_etat_processus).x_min;
1415: }
1416: else
1417: {
1418: (*s_etat_processus).x2_min = ((real8 **)
1419: (*((struct_matrice *) (*s_objet_statistique).objet))
1420: .tableau)[0][(*s_etat_processus)
1421: .colonne_statistique_1 - 1];
1422: (*s_etat_processus).x2_max = (*s_etat_processus).x2_min;
1423: }
1424:
1425: if ((*s_etat_processus).systeme_axes == 0)
1426: {
1427: (*s_etat_processus).y_min = ((real8 **)
1428: (*((struct_matrice *) (*s_objet_statistique).objet))
1429: .tableau)[0][(*s_etat_processus)
1430: .colonne_statistique_2 - 1];
1431: (*s_etat_processus).y_max = (*s_etat_processus).y_min;
1432: }
1433: else
1434: {
1435: (*s_etat_processus).y2_min = ((real8 **)
1436: (*((struct_matrice *) (*s_objet_statistique).objet))
1437: .tableau)[0][(*s_etat_processus)
1438: .colonne_statistique_2 - 1];
1439: (*s_etat_processus).y2_max = (*s_etat_processus).y2_min;
1440: }
1441: }
1442:
1443: for(j = 1; j < (*((struct_matrice *) (*s_objet_statistique).objet))
1444: .nombre_lignes; j++)
1445: {
1446: if (matrice_entiere == d_vrai)
1447: {
1448: valeur_courante = (real8) ((integer8 **)
1449: (*((struct_matrice *) (*s_objet_statistique).objet))
1450: .tableau)[j][(*s_etat_processus)
1451: .colonne_statistique_1 - 1];
1452:
1453: if ((*s_etat_processus).systeme_axes == 0)
1454: {
1455: if (valeur_courante < (*s_etat_processus).x_min)
1456: {
1457: (*s_etat_processus).x_min = valeur_courante;
1458: }
1459:
1460: if (valeur_courante > (*s_etat_processus).x_max)
1461: {
1462: (*s_etat_processus).x_max = valeur_courante;
1463: }
1464: }
1465: else
1466: {
1467: if (valeur_courante < (*s_etat_processus).x2_min)
1468: {
1469: (*s_etat_processus).x2_min = valeur_courante;
1470: }
1471:
1472: if (valeur_courante > (*s_etat_processus).x2_max)
1473: {
1474: (*s_etat_processus).x2_max = valeur_courante;
1475: }
1476: }
1477:
1478: valeur_courante = (real8) ((integer8 **)
1479: (*((struct_matrice *) (*s_objet_statistique).objet))
1480: .tableau)[j][(*s_etat_processus)
1481: .colonne_statistique_2 - 1];
1482:
1483: if ((*s_etat_processus).systeme_axes == 0)
1484: {
1485: if (valeur_courante < (*s_etat_processus).y_min)
1486: {
1487: (*s_etat_processus).y_min = valeur_courante;
1488: }
1489:
1490: if (valeur_courante > (*s_etat_processus).y_max)
1491: {
1492: (*s_etat_processus).y_max = valeur_courante;
1493: }
1494: }
1495: else
1496: {
1497: if (valeur_courante < (*s_etat_processus).y2_min)
1498: {
1499: (*s_etat_processus).y2_min = valeur_courante;
1500: }
1501:
1502: if (valeur_courante > (*s_etat_processus).y2_max)
1503: {
1504: (*s_etat_processus).y2_max = valeur_courante;
1505: }
1506: }
1507: }
1508: else
1509: {
1510: valeur_courante = ((real8 **)
1511: (*((struct_matrice *) (*s_objet_statistique).objet))
1512: .tableau)[j][(*s_etat_processus)
1513: .colonne_statistique_1 - 1];
1514:
1515: if ((*s_etat_processus).systeme_axes == 0)
1516: {
1517: if (valeur_courante < (*s_etat_processus).x_min)
1518: {
1519: (*s_etat_processus).x_min = valeur_courante;
1520: }
1521:
1522: if (valeur_courante > (*s_etat_processus).x_max)
1523: {
1524: (*s_etat_processus).x_max = valeur_courante;
1525: }
1526: }
1527: else
1528: {
1529: if (valeur_courante < (*s_etat_processus).x2_min)
1530: {
1531: (*s_etat_processus).x2_min = valeur_courante;
1532: }
1533:
1534: if (valeur_courante > (*s_etat_processus).x2_max)
1535: {
1536: (*s_etat_processus).x2_max = valeur_courante;
1537: }
1538: }
1539:
1540: valeur_courante = ((real8 **)
1541: (*((struct_matrice *) (*s_objet_statistique).objet))
1542: .tableau)[j][(*s_etat_processus)
1543: .colonne_statistique_2 - 1];
1544:
1545: if ((*s_etat_processus).systeme_axes == 0)
1546: {
1547: if (valeur_courante < (*s_etat_processus).y_min)
1548: {
1549: (*s_etat_processus).y_min = valeur_courante;
1550: }
1551:
1552: if (valeur_courante > (*s_etat_processus).y_max)
1553: {
1554: (*s_etat_processus).y_max = valeur_courante;
1555: }
1556: }
1557: else
1558: {
1559: if (valeur_courante < (*s_etat_processus).y2_min)
1560: {
1561: (*s_etat_processus).y2_min = valeur_courante;
1562: }
1563:
1564: if (valeur_courante > (*s_etat_processus).y2_max)
1565: {
1566: (*s_etat_processus).y2_max = valeur_courante;
1567: }
1568: }
1569: }
1570: }
1571:
1572: break;
1573: }
1574: }
1575:
1576: return;
1577: }
1578:
1579:
1580: /*
1581: ================================================================================
1582: Fonction 'spar'
1583: ================================================================================
1584: Entrées :
1585: --------------------------------------------------------------------------------
1586: Sorties :
1587: --------------------------------------------------------------------------------
1588: Effets de bord : néant
1589: ================================================================================
1590: */
1591:
1592: void
1593: instruction_spar(struct_processus *s_etat_processus)
1594: {
1595: logical1 presence_matrice_statistique;
1596: logical1 presence_variable;
1597:
1598: long i;
1599:
1600: struct_liste_chainee *l_ancienne_base;
1601: struct_liste_chainee *l_nouvelle_base;
1602:
1603: struct_objet *s_objet_resultat;
1604:
1605: /*
1606: * { { Dimensions de SIGMA } X Y }
1607: */
1608:
1609: (*s_etat_processus).erreur_execution = d_ex;
1610:
1611: if ((*s_etat_processus).affichage_arguments == 'Y')
1612: {
1613: printf("\n SPAR ");
1614:
1615: if ((*s_etat_processus).langue == 'F')
1616: {
1617: printf("(paramètres statistiques)\n\n");
1618: }
1619: else
1620: {
1621: printf("(statistical parameters)\n\n");
1622: }
1623:
1624: printf("-> 1: %s\n", d_LST);
1625:
1626: return;
1627: }
1628: else if ((*s_etat_processus).test_instruction == 'Y')
1629: {
1630: (*s_etat_processus).nombre_arguments = -1;
1631: return;
1632: }
1633:
1634: if (test_cfsf(s_etat_processus, 31) == d_vrai)
1635: {
1636: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
1637: {
1638: return;
1639: }
1640: }
1641:
1642: if ((s_objet_resultat = allocation(s_etat_processus, LST)) == NULL)
1643: {
1644: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1645: return;
1646: }
1647:
1648: (*s_objet_resultat).objet = NULL;
1649: l_ancienne_base = (*s_objet_resultat).objet;
1650:
1651: // Colonne 2
1652:
1653: if ((l_nouvelle_base = malloc(sizeof(struct_liste_chainee))) == NULL)
1654: {
1655: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1656: return;
1657: }
1658:
1659: if (((*l_nouvelle_base).donnee = allocation(s_etat_processus, INT))
1660: == NULL)
1661: {
1662: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1663: return;
1664: }
1665:
1666: (*l_nouvelle_base).suivant = l_ancienne_base;
1667: (*((integer8 *) (*(*l_nouvelle_base).donnee).objet)) =
1668: (*s_etat_processus).colonne_statistique_2;
1669: (*s_objet_resultat).objet = l_nouvelle_base;
1670: l_ancienne_base = (*s_objet_resultat).objet;
1671:
1672: // Colonne 1
1673:
1674: if ((l_nouvelle_base = allocation_maillon(s_etat_processus)) == NULL)
1675: {
1676: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1677: return;
1678: }
1679:
1680: if (((*l_nouvelle_base).donnee = allocation(s_etat_processus, INT))
1681: == NULL)
1682: {
1683: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1684: return;
1685: }
1686:
1687: (*l_nouvelle_base).suivant = l_ancienne_base;
1688: (*((integer8 *) (*(*l_nouvelle_base).donnee).objet)) =
1689: (*s_etat_processus).colonne_statistique_1;
1690: (*s_objet_resultat).objet = l_nouvelle_base;
1691: l_ancienne_base = (*s_objet_resultat).objet;
1692:
1693: // Dimensions de la matrice statistique
1694:
1695: if ((l_nouvelle_base = allocation_maillon(s_etat_processus)) == NULL)
1696: {
1697: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1698: return;
1699: }
1700:
1701: if (((*l_nouvelle_base).donnee = allocation(s_etat_processus, NON))
1702: == NULL)
1703: {
1704: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1705: return;
1706: }
1707:
1708: if (recherche_variable(s_etat_processus, ds_sdat) == d_faux)
1709: {
1710: /*
1711: * Aucune variable SIGMA
1712: */
1713:
1714: (*s_etat_processus).erreur_systeme = d_es;
1715: (*s_etat_processus).erreur_execution = d_ex;
1716: presence_matrice_statistique = d_faux;
1717: }
1718: else
1719: {
1720: /*
1721: * Il existe une variable locale SIGMA. Reste à vérifier l'existence
1722: * d'une variable SIGMA globale...
1723: */
1724:
1725: i = (*s_etat_processus).position_variable_courante;
1726: presence_variable = d_faux;
1727:
1728: while(i >= 0)
1729: {
1730: if ((strcmp((*s_etat_processus).s_liste_variables[i].nom,
1731: ds_sdat) == 0) && ((*s_etat_processus)
1732: .s_liste_variables[i].niveau == 1))
1733: {
1734: presence_variable = d_vrai;
1735: break;
1736: }
1737:
1738: i--;
1739: }
1740:
1741: if (presence_variable == d_faux)
1742: {
1743: presence_matrice_statistique = d_faux;
1744: }
1745: else
1746: {
1747: if ((*s_etat_processus).s_liste_variables[i].objet == NULL)
1748: {
1749: (*s_etat_processus).erreur_execution = d_ex_variable_partagee;
1750: return;
1751: }
1752:
1753: presence_matrice_statistique = d_vrai;
1754: (*s_etat_processus).position_variable_courante = i;
1755: }
1756: }
1757:
1758: if (presence_matrice_statistique == d_faux)
1759: {
1760: if (((*(*l_nouvelle_base).donnee).objet = malloc(12 *
1761: sizeof(unsigned char))) == NULL)
1762: {
1763: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1764: return;
1765: }
1766:
1767: (*(*l_nouvelle_base).donnee).type = CHN;
1768: strcpy((unsigned char *) (*(*l_nouvelle_base).donnee).objet,
1769: "UNAVAILABLE");
1770: }
1771: else
1772: {
1773: if (((*((*s_etat_processus).s_liste_variables
1774: [(*s_etat_processus).position_variable_courante].objet))
1775: .type != MIN) && ((*((*s_etat_processus)
1776: .s_liste_variables[(*s_etat_processus)
1777: .position_variable_courante].objet)).type != MRL))
1778: {
1779: if (((*(*l_nouvelle_base).donnee).objet = malloc(9 *
1780: sizeof(unsigned char))) == NULL)
1781: {
1782: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1783: return;
1784: }
1785:
1786: (*(*l_nouvelle_base).donnee).type = CHN;
1787: strcpy((unsigned char *) (*(*l_nouvelle_base).donnee).objet,
1788: "DISABLED");
1789: }
1790: else
1791: {
1792: (*(*l_nouvelle_base).donnee).type = LST;
1793:
1794: if (((*(*l_nouvelle_base).donnee).objet =
1795: allocation_maillon(s_etat_processus)) == NULL)
1796: {
1797: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1798: return;
1799: }
1800:
1801: if (((*((struct_liste_chainee *) (*(*l_nouvelle_base).donnee)
1802: .objet)).donnee = allocation(s_etat_processus, INT))
1803: == NULL)
1804: {
1805: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1806: return;
1807: }
1808:
1809: (*((integer8 *) (*((*((struct_liste_chainee *) (*(*l_nouvelle_base)
1810: .donnee).objet)).donnee)).objet)) = (*((struct_matrice *)
1811: (*((*s_etat_processus).s_liste_variables
1812: [(*s_etat_processus).position_variable_courante].objet))
1813: .objet)).nombre_lignes;
1814:
1815: if (((*((struct_liste_chainee *) (*(*l_nouvelle_base).donnee)
1816: .objet)).suivant = allocation_maillon(s_etat_processus))
1817: == NULL)
1818: {
1819: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1820: return;
1821: }
1822:
1823: (*(*((struct_liste_chainee *) (*(*l_nouvelle_base).donnee).objet))
1824: .suivant).suivant = NULL;
1825:
1826: if (((*(*((struct_liste_chainee *) (*(*l_nouvelle_base).donnee)
1827: .objet)).suivant).donnee = allocation(s_etat_processus,
1828: INT)) == NULL)
1829: {
1830: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1831: return;
1832: }
1833:
1834: (*((integer8 *) (*((*(*((struct_liste_chainee *)
1835: (*(*l_nouvelle_base).donnee).objet)).suivant).donnee))
1836: .objet)) = (*((struct_matrice *) (*((*s_etat_processus)
1837: .s_liste_variables[(*s_etat_processus)
1838: .position_variable_courante].objet)).objet))
1839: .nombre_colonnes;
1840: }
1841: }
1842:
1843: (*l_nouvelle_base).suivant = l_ancienne_base;
1844: (*s_objet_resultat).objet = l_nouvelle_base;
1845:
1846: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1847: s_objet_resultat) == d_erreur)
1848: {
1849: return;
1850: }
1851:
1852: return;
1853: }
1854:
1855: // vim: ts=4