![[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: ================================================================================
1.11 ! bertrand 3: RPL/2 (R) version 4.0.18
1.1 bertrand 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: {
1.5 bertrand 483: struct_descripteur_fichier *descripteur;
1.1 bertrand 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:
1.5 bertrand 535: if ((*descripteur).type != 'C')
536: {
537: liberation(s_etat_processus, s_objet_argument);
538:
539: (*s_etat_processus).erreur_execution = d_ex_erreur_type_fichier;
540: return;
541: }
542:
543: if (fflush((*descripteur).descripteur_c) != 0)
1.1 bertrand 544: {
545: liberation(s_etat_processus, s_objet_argument);
546:
547: (*s_etat_processus).erreur_execution =
548: d_ex_erreur_acces_fichier;
549: return;
550: }
551: }
552: else
553: {
554: liberation(s_etat_processus, s_objet_argument);
555:
556: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
557: return;
558: }
559:
560: liberation(s_etat_processus, s_objet_argument);
561:
562: return;
563: }
564:
565:
566: /*
567: ================================================================================
568: Fonction 'scale'
569: ================================================================================
570: Entrées :
571: --------------------------------------------------------------------------------
572: Sorties :
573: --------------------------------------------------------------------------------
574: Effets de bord : néant
575: ================================================================================
576: */
577:
578: void
579: instruction_scale(struct_processus *s_etat_processus)
580: {
581: /*
582: * Prend comme argument une liste
583: */
584:
585: long nombre_arguments_principaux;
586: long nombre_arguments_auxiliaires;
587:
588: struct_liste_chainee *l_element_courant;
589: struct_liste_chainee *l_element_courant_auxiliaire;
590:
591: struct_objet *s_objet_argument;
592: struct_objet *s_objet_auxiliaire;
593:
594: unsigned char *tampon;
595:
596: (*s_etat_processus).erreur_execution = d_ex;
597:
598: if ((*s_etat_processus).affichage_arguments == 'Y')
599: {
600: printf("\n SCALE ");
601:
602: if ((*s_etat_processus).langue == 'F')
603: {
604: printf("(définition de l'échelle)\n\n");
605: }
606: else
607: {
608: printf("(scale definition)\n\n");
609: }
610:
611: printf(" 1: %s\n\n", d_LST);
612:
613: if ((*s_etat_processus).langue == 'F')
614: {
615: printf(" Utilisation :\n\n");
616: }
617: else
618: {
619: printf(" Usage:\n\n");
620: }
621:
622: printf(" { { Xmin Xmax } { Ymin Ymax } { Zmin Zmax } } SCALE\n");
623: printf(" { \"AUTOMATIC\" { Ymin Ymax } } SCALE\n");
624:
625: return;
626: }
627: else if ((*s_etat_processus).test_instruction == 'Y')
628: {
629: (*s_etat_processus).nombre_arguments = -1;
630: return;
631: }
632:
633: if (test_cfsf(s_etat_processus, 31) == d_vrai)
634: {
635: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
636: {
637: return;
638: }
639: }
640:
641: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
642: &s_objet_argument) == d_erreur)
643: {
644: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
645: return;
646: }
647:
648: if ((*s_objet_argument).type == LST)
649: {
650: l_element_courant = (struct_liste_chainee *) (*s_objet_argument).objet;
651: nombre_arguments_principaux = 0;
652:
653: while(l_element_courant != NULL)
654: {
655: nombre_arguments_principaux++;
656: l_element_courant = (*l_element_courant).suivant;
657: }
658:
659: if ((nombre_arguments_principaux != 2) &&
660: (nombre_arguments_principaux != 3))
661: {
662: liberation(s_etat_processus, s_objet_argument);
663:
664: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
665: return;
666: }
667:
668: l_element_courant = (struct_liste_chainee *) (*s_objet_argument).objet;
669: nombre_arguments_principaux = 0;
670:
671: while(l_element_courant != NULL)
672: {
673: nombre_arguments_principaux++;
674:
675: if ((*(*l_element_courant).donnee).type == LST)
676: {
677: l_element_courant_auxiliaire = (struct_liste_chainee *)
678: (*(*l_element_courant).donnee).objet;
679: nombre_arguments_auxiliaires = 0;
680:
681: while(l_element_courant_auxiliaire != NULL)
682: {
683: l_element_courant_auxiliaire =
684: (*l_element_courant_auxiliaire).suivant;
685: nombre_arguments_auxiliaires++;
686: }
687:
688: if (nombre_arguments_auxiliaires != 2)
689: {
690: liberation(s_etat_processus, s_objet_argument);
691:
692: (*s_etat_processus).erreur_execution =
693: d_ex_argument_invalide;
694: return;
695: }
696:
697: l_element_courant_auxiliaire = (struct_liste_chainee *)
698: (*(*l_element_courant).donnee).objet;
699: nombre_arguments_auxiliaires = 0;
700:
701: while(l_element_courant_auxiliaire != NULL)
702: {
703: nombre_arguments_auxiliaires++;
704:
705: if (((*(*l_element_courant_auxiliaire).donnee).type ==
706: RPN) || (
707: (*(*l_element_courant_auxiliaire).donnee)
708: .type == ALG) ||
709: ((*(*l_element_courant_auxiliaire).donnee)
710: .type == NOM))
711: {
712: if (evaluation(s_etat_processus,
713: (*l_element_courant_auxiliaire).donnee, 'N')
714: == d_erreur)
715: {
716: liberation(s_etat_processus, s_objet_argument);
717:
718: return;
719: }
720:
721: if (depilement(s_etat_processus,
722: &((*s_etat_processus).l_base_pile),
723: &s_objet_auxiliaire) == d_erreur)
724: {
725: liberation(s_etat_processus, s_objet_argument);
726:
727: (*s_etat_processus).erreur_execution =
728: d_ex_manque_argument;
729: return;
730: }
731:
732: liberation(s_etat_processus,
733: (*l_element_courant_auxiliaire).donnee);
734: (*l_element_courant_auxiliaire).donnee =
735: s_objet_auxiliaire;
736: }
737:
738: if ((*(*l_element_courant_auxiliaire).donnee).type == INT)
739: {
740: switch(nombre_arguments_principaux)
741: {
742: case 1 :
743: {
744: if (nombre_arguments_auxiliaires == 1)
745: {
746: if ((*s_etat_processus).systeme_axes == 0)
747: {
748: (*s_etat_processus).x_min = (real8)
749: (*((integer8 *) (*
750: (*l_element_courant_auxiliaire)
751: .donnee).objet));
752: }
753: else
754: {
755: (*s_etat_processus).x2_min = (real8)
756: (*((integer8 *) (*
757: (*l_element_courant_auxiliaire)
758: .donnee).objet));
759: }
760: }
761: else if (nombre_arguments_auxiliaires == 2)
762: {
763: if ((*s_etat_processus).systeme_axes == 0)
764: {
765: (*s_etat_processus).x_max = (real8)
766: (*((integer8 *) (*
767: (*l_element_courant_auxiliaire)
768: .donnee).objet));
769: (*s_etat_processus)
770: .echelle_automatique_x = d_faux;
771: }
772: else
773: {
774: (*s_etat_processus).x2_max = (real8)
775: (*((integer8 *) (*
776: (*l_element_courant_auxiliaire)
777: .donnee).objet));
778: (*s_etat_processus)
779: .echelle_automatique_x2
780: = d_faux;
781: }
782: }
783: else
784: {
785: liberation(s_etat_processus,
786: s_objet_argument);
787:
788: (*s_etat_processus).erreur_execution =
789: d_ex_argument_invalide;
790: return;
791: }
792:
793: break;
794: }
795:
796: case 2 :
797: {
798: if (nombre_arguments_auxiliaires == 1)
799: {
800: if ((*s_etat_processus).systeme_axes == 0)
801: {
802: (*s_etat_processus).y_min = (real8)
803: (*((integer8 *) (*
804: (*l_element_courant_auxiliaire)
805: .donnee).objet));
806: }
807: else
808: {
809: (*s_etat_processus).y2_min = (real8)
810: (*((integer8 *) (*
811: (*l_element_courant_auxiliaire)
812: .donnee).objet));
813: }
814: }
815: else if (nombre_arguments_auxiliaires == 2)
816: {
817: if ((*s_etat_processus).systeme_axes == 0)
818: {
819: (*s_etat_processus).y_max = (real8)
820: (*((integer8 *) (*
821: (*l_element_courant_auxiliaire)
822: .donnee).objet));
823:
824: (*s_etat_processus)
825: .echelle_automatique_y = d_faux;
826: }
827: else
828: {
829: (*s_etat_processus).y2_max = (real8)
830: (*((integer8 *) (*
831: (*l_element_courant_auxiliaire)
832: .donnee).objet));
833:
834: (*s_etat_processus)
835: .echelle_automatique_y2
836: = d_faux;
837: }
838: }
839: else
840: {
841: liberation(s_etat_processus,
842: s_objet_argument);
843:
844: (*s_etat_processus).erreur_execution =
845: d_ex_argument_invalide;
846: return;
847: }
848:
849: break;
850: }
851:
852: case 3 :
853: {
854: if (nombre_arguments_auxiliaires == 1)
855: {
856: if ((*s_etat_processus).systeme_axes == 0)
857: {
858: (*s_etat_processus).z_min = (real8)
859: (*((integer8 *) (*
860: (*l_element_courant_auxiliaire)
861: .donnee).objet));
862: }
863: else
864: {
865: (*s_etat_processus).z2_min = (real8)
866: (*((integer8 *) (*
867: (*l_element_courant_auxiliaire)
868: .donnee).objet));
869: }
870: }
871: else if (nombre_arguments_auxiliaires == 2)
872: {
873: if ((*s_etat_processus).systeme_axes == 0)
874: {
875: (*s_etat_processus).z_max = (real8)
876: (*((integer8 *) (*
877: (*l_element_courant_auxiliaire)
878: .donnee).objet));
879:
880: (*s_etat_processus)
881: .echelle_automatique_z = d_faux;
882: }
883: else
884: {
885: (*s_etat_processus).z2_max = (real8)
886: (*((integer8 *) (*
887: (*l_element_courant_auxiliaire)
888: .donnee).objet));
889:
890: (*s_etat_processus)
891: .echelle_automatique_z
892: = d_faux;
893: }
894: }
895: else
896: {
897: liberation(s_etat_processus,
898: s_objet_argument);
899:
900: (*s_etat_processus).erreur_execution =
901: d_ex_argument_invalide;
902: return;
903: }
904:
905: break;
906: }
907:
908: default :
909: {
910: liberation(s_etat_processus, s_objet_argument);
911:
912: (*s_etat_processus).erreur_execution =
913: d_ex_argument_invalide;
914: return;
915: }
916: }
917: }
918: else if ((*(*l_element_courant_auxiliaire)
919: .donnee).type == REL)
920: {
921: switch(nombre_arguments_principaux)
922: {
923: case 1 :
924: {
925: if (nombre_arguments_auxiliaires == 1)
926: {
927: if ((*s_etat_processus).systeme_axes == 0)
928: {
929: (*s_etat_processus).x_min =
930: (*((real8 *) (*
931: (*l_element_courant_auxiliaire)
932: .donnee).objet));
933: }
934: else
935: {
936: (*s_etat_processus).x2_min =
937: (*((real8 *) (*
938: (*l_element_courant_auxiliaire)
939: .donnee).objet));
940: }
941: }
942: else if (nombre_arguments_auxiliaires == 2)
943: {
944: if ((*s_etat_processus).systeme_axes == 0)
945: {
946: (*s_etat_processus).x_max =
947: (*((real8 *) (*
948: (*l_element_courant_auxiliaire)
949: .donnee).objet));
950:
951: (*s_etat_processus)
952: .echelle_automatique_x = d_faux;
953: }
954: else
955: {
956: (*s_etat_processus).x2_max =
957: (*((real8 *) (*
958: (*l_element_courant_auxiliaire)
959: .donnee).objet));
960:
961: (*s_etat_processus)
962: .echelle_automatique_x2
963: = d_faux;
964: }
965: }
966: else
967: {
968: liberation(s_etat_processus,
969: s_objet_argument);
970:
971: (*s_etat_processus).erreur_execution =
972: d_ex_argument_invalide;
973: return;
974: }
975:
976: break;
977: }
978:
979: case 2 :
980: {
981: if (nombre_arguments_auxiliaires == 1)
982: {
983: if ((*s_etat_processus).systeme_axes == 0)
984: {
985: (*s_etat_processus).y_min =
986: (*((real8 *) (*
987: (*l_element_courant_auxiliaire)
988: .donnee).objet));
989: }
990: else
991: {
992: (*s_etat_processus).y2_min =
993: (*((real8 *) (*
994: (*l_element_courant_auxiliaire)
995: .donnee).objet));
996: }
997: }
998: else if (nombre_arguments_auxiliaires == 2)
999: {
1000: if ((*s_etat_processus).systeme_axes == 0)
1001: {
1002: (*s_etat_processus).y_max =
1003: (*((real8 *) (*
1004: (*l_element_courant_auxiliaire)
1005: .donnee).objet));
1006:
1007: (*s_etat_processus)
1008: .echelle_automatique_y = d_faux;
1009: }
1010: else
1011: {
1012: (*s_etat_processus).y2_max =
1013: (*((real8 *) (*
1014: (*l_element_courant_auxiliaire)
1015: .donnee).objet));
1016:
1017: (*s_etat_processus)
1018: .echelle_automatique_y2
1019: = d_faux;
1020: }
1021: }
1022: else
1023: {
1024: liberation(s_etat_processus,
1025: s_objet_argument);
1026:
1027: (*s_etat_processus).erreur_execution =
1028: d_ex_argument_invalide;
1029: return;
1030: }
1031:
1032: break;
1033: }
1034:
1035: case 3 :
1036: {
1037: if (nombre_arguments_auxiliaires == 1)
1038: {
1039: if ((*s_etat_processus).systeme_axes == 0)
1040: {
1041: (*s_etat_processus).z_min =
1042: (*((real8 *) (*
1043: (*l_element_courant_auxiliaire)
1044: .donnee).objet));
1045: }
1046: else
1047: {
1048: (*s_etat_processus).z2_min =
1049: (*((real8 *) (*
1050: (*l_element_courant_auxiliaire)
1051: .donnee).objet));
1052: }
1053: }
1054: else if (nombre_arguments_auxiliaires == 2)
1055: {
1056: if ((*s_etat_processus).systeme_axes == 0)
1057: {
1058: (*s_etat_processus).z_max =
1059: (*((real8 *) (*
1060: (*l_element_courant_auxiliaire)
1061: .donnee).objet));
1062:
1063: (*s_etat_processus)
1064: .echelle_automatique_z = d_faux;
1065: }
1066: else
1067: {
1068: (*s_etat_processus).z2_max =
1069: (*((real8 *) (*
1070: (*l_element_courant_auxiliaire)
1071: .donnee).objet));
1072:
1073: (*s_etat_processus)
1074: .echelle_automatique_z2
1075: = d_faux;
1076: }
1077: }
1078: else
1079: {
1080: liberation(s_etat_processus,
1081: s_objet_argument);
1082:
1083: (*s_etat_processus).erreur_execution =
1084: d_ex_argument_invalide;
1085: return;
1086: }
1087:
1088: break;
1089: }
1090:
1091: default :
1092: {
1093: liberation(s_etat_processus, s_objet_argument);
1094:
1095: (*s_etat_processus).erreur_execution =
1096: d_ex_argument_invalide;
1097: return;
1098: }
1099: }
1100: }
1101:
1102: l_element_courant_auxiliaire =
1103: (*l_element_courant_auxiliaire).suivant;
1104: }
1105: }
1106: else if ((*(*l_element_courant).donnee).type == CHN)
1107: {
1108: tampon = conversion_majuscule((unsigned char *)
1109: (*(*l_element_courant).donnee).objet);
1110:
1111: if (tampon == NULL)
1112: {
1113: (*s_etat_processus).erreur_systeme =
1114: d_es_allocation_memoire;
1115: return;
1116: }
1117:
1118: if (strcmp(tampon, "AUTOMATIC") == 0)
1119: {
1120: switch(nombre_arguments_principaux)
1121: {
1122: case 1 :
1123: {
1124: if ((*s_etat_processus).systeme_axes == 0)
1125: {
1126: (*s_etat_processus).echelle_automatique_x
1127: = d_vrai;
1128: }
1129: else
1130: {
1131: (*s_etat_processus).echelle_automatique_x2
1132: = d_vrai;
1133: }
1134:
1135: break;
1136: }
1137:
1138: case 2 :
1139: {
1140: if ((*s_etat_processus).systeme_axes == 0)
1141: {
1142: (*s_etat_processus).echelle_automatique_y
1143: = d_vrai;
1144: }
1145: else
1146: {
1147: (*s_etat_processus).echelle_automatique_y2
1148: = d_vrai;
1149: }
1150:
1151: break;
1152: }
1153:
1154: case 3 :
1155: {
1156: if ((*s_etat_processus).systeme_axes == 0)
1157: {
1158: (*s_etat_processus).echelle_automatique_z
1159: = d_vrai;
1160: }
1161: else
1162: {
1163: (*s_etat_processus).echelle_automatique_z2
1164: = d_vrai;
1165: }
1166:
1167: break;
1168: }
1169:
1170: default :
1171: {
1172: liberation(s_etat_processus, s_objet_argument);
1173: free(tampon);
1174:
1175: (*s_etat_processus).erreur_execution =
1176: d_ex_argument_invalide;
1177: return;
1178: }
1179: }
1180: }
1181: else
1182: {
1183: liberation(s_etat_processus, s_objet_argument);
1184: free(tampon);
1185:
1186: (*s_etat_processus).erreur_execution =
1187: d_ex_argument_invalide;
1188: return;
1189: }
1190:
1191: free(tampon);
1192: }
1193: else
1194: {
1195: liberation(s_etat_processus, s_objet_argument);
1196:
1197: (*s_etat_processus).erreur_execution =
1198: d_ex_erreur_type_argument;
1199: return;
1200: }
1201:
1202: l_element_courant = (*l_element_courant).suivant;
1203: }
1204: }
1205: else
1206: {
1207: liberation(s_etat_processus, s_objet_argument);
1208:
1209: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
1210: return;
1211: }
1212:
1213: liberation(s_etat_processus, s_objet_argument);
1214:
1215: if (test_cfsf(s_etat_processus, 52) == d_faux)
1216: {
1217: if ((*s_etat_processus).fichiers_graphiques != NULL)
1218: {
1219: appel_gnuplot(s_etat_processus, 'N');
1220: }
1221: }
1222:
1223: return;
1224: }
1225:
1226:
1227: /*
1228: ================================================================================
1229: Fonction 'scls'
1230: ================================================================================
1231: Entrées :
1232: --------------------------------------------------------------------------------
1233: Sorties :
1234: --------------------------------------------------------------------------------
1235: Effets de bord : néant
1236: ================================================================================
1237: */
1238:
1239: void
1240: instruction_scls(struct_processus *s_etat_processus)
1241: {
1242: logical1 presence_variable;
1243: logical1 matrice_entiere;
1244:
1245: long i;
1246:
1247: real8 valeur_courante;
1248:
1249: struct_objet *s_objet_statistique;
1250:
1251: unsigned long j;
1252:
1253: (*s_etat_processus).erreur_execution = d_ex;
1254:
1255: if ((*s_etat_processus).affichage_arguments == 'Y')
1256: {
1257: printf("\n SCLS ");
1258:
1259: if ((*s_etat_processus).langue == 'F')
1260: {
1261: printf("(échelle automatique d'un nuage de points)\n\n");
1262: printf(" Aucun argument\n");
1263: }
1264: else
1265: {
1266: printf("(auto scale scatter plot)\n\n");
1267: printf(" No argument\n");
1268: }
1269:
1270: return;
1271: }
1272: else if ((*s_etat_processus).test_instruction == 'Y')
1273: {
1274: (*s_etat_processus).nombre_arguments = -1;
1275: return;
1276: }
1277:
1278: if (test_cfsf(s_etat_processus, 31) == d_vrai)
1279: {
1280: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
1281: {
1282: return;
1283: }
1284: }
1285:
1286: /*
1287: * Vérification de la présence de la matrice statistique
1288: */
1289:
1290: if (recherche_variable(s_etat_processus, ds_sdat) == d_faux)
1291: {
1292: /*
1293: * Aucune variable ds_sdat n'existe.
1294: */
1295:
1296: (*s_etat_processus).erreur_execution = d_ex_absence_observations;
1297: (*s_etat_processus).erreur_systeme = d_es;
1298:
1299: return;
1300: }
1301:
1302: i = (*s_etat_processus).position_variable_courante;
1303: presence_variable = d_faux;
1304:
1305: while(i >= 0)
1306: {
1307: if ((strcmp((*s_etat_processus).s_liste_variables[i].nom,
1308: ds_sdat) == 0) && ((*s_etat_processus)
1309: .s_liste_variables[i].niveau == 1))
1310: {
1311: presence_variable = d_vrai;
1312: break;
1313: }
1314:
1315: i--;
1316: }
1317:
1318: if (presence_variable == d_faux)
1319: {
1320: (*s_etat_processus).erreur_execution = d_ex_absence_observations;
1321: return;
1322: }
1323:
1324: if ((*s_etat_processus).s_liste_variables[i].objet == NULL)
1325: {
1326: (*s_etat_processus).erreur_execution = d_ex_variable_partagee;
1327: return;
1328: }
1329:
1330: s_objet_statistique = (*s_etat_processus).s_liste_variables[i].objet;
1331:
1332: if ((*s_objet_statistique).type == MIN)
1333: {
1334: matrice_entiere = d_vrai;
1335: }
1336: else if ((*s_objet_statistique).type == MRL)
1337: {
1338: matrice_entiere = d_faux;
1339: }
1340: else
1341: {
1342: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
1343: return;
1344: }
1345:
1346: switch((*((struct_matrice *) (*s_objet_statistique).objet)).nombre_colonnes)
1347: {
1348: /*
1349: * Une colonne
1350: */
1351:
1352: case 1 :
1353: {
1354: (*s_etat_processus).erreur_execution = d_ex_dimensions_invalides;
1355: break;
1356: }
1357:
1358: /*
1359: * Deux colonnes ou plus
1360: */
1361:
1362: default :
1363: {
1364: if (((*s_etat_processus).colonne_statistique_1 < 1) ||
1365: ((*s_etat_processus).colonne_statistique_2 < 1) ||
1366: ((*s_etat_processus).colonne_statistique_1 > (integer8)
1367: (*((struct_matrice *) (*s_objet_statistique).objet))
1368: .nombre_colonnes) ||
1369: ((*s_etat_processus).colonne_statistique_2 > (integer8)
1370: (*((struct_matrice *) (*s_objet_statistique).objet))
1371: .nombre_colonnes))
1372: {
1373: (*s_etat_processus).erreur_execution =
1374: d_ex_observations_inexistantes;
1375: return;
1376: }
1377:
1378: if (matrice_entiere == d_vrai)
1379: {
1380: if ((*s_etat_processus).systeme_axes == 0)
1381: {
1382: (*s_etat_processus).x_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).x_max = (*s_etat_processus).x_min;
1387: }
1388: else
1389: {
1390: (*s_etat_processus).x2_min = (real8) ((integer8 **)
1391: (*((struct_matrice *) (*s_objet_statistique).objet))
1392: .tableau)[0][(*s_etat_processus)
1393: .colonne_statistique_1 - 1];
1394: (*s_etat_processus).x2_max = (*s_etat_processus).x2_min;
1395: }
1396:
1397: if ((*s_etat_processus).systeme_axes == 0)
1398: {
1399: (*s_etat_processus).y_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).y_max = (*s_etat_processus).y_min;
1404: }
1405: else
1406: {
1407: (*s_etat_processus).y2_min = (real8) ((integer8 **)
1408: (*((struct_matrice *) (*s_objet_statistique).objet))
1409: .tableau)[0][(*s_etat_processus)
1410: .colonne_statistique_2 - 1];
1411: (*s_etat_processus).y2_max = (*s_etat_processus).y2_min;
1412: }
1413: }
1414: else
1415: {
1416: if ((*s_etat_processus).systeme_axes == 0)
1417: {
1418: (*s_etat_processus).x_min = ((real8 **)
1419: (*((struct_matrice *) (*s_objet_statistique).objet))
1420: .tableau)[0][(*s_etat_processus)
1421: .colonne_statistique_1 - 1];
1422: (*s_etat_processus).x_max = (*s_etat_processus).x_min;
1423: }
1424: else
1425: {
1426: (*s_etat_processus).x2_min = ((real8 **)
1427: (*((struct_matrice *) (*s_objet_statistique).objet))
1428: .tableau)[0][(*s_etat_processus)
1429: .colonne_statistique_1 - 1];
1430: (*s_etat_processus).x2_max = (*s_etat_processus).x2_min;
1431: }
1432:
1433: if ((*s_etat_processus).systeme_axes == 0)
1434: {
1435: (*s_etat_processus).y_min = ((real8 **)
1436: (*((struct_matrice *) (*s_objet_statistique).objet))
1437: .tableau)[0][(*s_etat_processus)
1438: .colonne_statistique_2 - 1];
1439: (*s_etat_processus).y_max = (*s_etat_processus).y_min;
1440: }
1441: else
1442: {
1443: (*s_etat_processus).y2_min = ((real8 **)
1444: (*((struct_matrice *) (*s_objet_statistique).objet))
1445: .tableau)[0][(*s_etat_processus)
1446: .colonne_statistique_2 - 1];
1447: (*s_etat_processus).y2_max = (*s_etat_processus).y2_min;
1448: }
1449: }
1450:
1451: for(j = 1; j < (*((struct_matrice *) (*s_objet_statistique).objet))
1452: .nombre_lignes; j++)
1453: {
1454: if (matrice_entiere == d_vrai)
1455: {
1456: valeur_courante = (real8) ((integer8 **)
1457: (*((struct_matrice *) (*s_objet_statistique).objet))
1458: .tableau)[j][(*s_etat_processus)
1459: .colonne_statistique_1 - 1];
1460:
1461: if ((*s_etat_processus).systeme_axes == 0)
1462: {
1463: if (valeur_courante < (*s_etat_processus).x_min)
1464: {
1465: (*s_etat_processus).x_min = valeur_courante;
1466: }
1467:
1468: if (valeur_courante > (*s_etat_processus).x_max)
1469: {
1470: (*s_etat_processus).x_max = valeur_courante;
1471: }
1472: }
1473: else
1474: {
1475: if (valeur_courante < (*s_etat_processus).x2_min)
1476: {
1477: (*s_etat_processus).x2_min = valeur_courante;
1478: }
1479:
1480: if (valeur_courante > (*s_etat_processus).x2_max)
1481: {
1482: (*s_etat_processus).x2_max = valeur_courante;
1483: }
1484: }
1485:
1486: valeur_courante = (real8) ((integer8 **)
1487: (*((struct_matrice *) (*s_objet_statistique).objet))
1488: .tableau)[j][(*s_etat_processus)
1489: .colonne_statistique_2 - 1];
1490:
1491: if ((*s_etat_processus).systeme_axes == 0)
1492: {
1493: if (valeur_courante < (*s_etat_processus).y_min)
1494: {
1495: (*s_etat_processus).y_min = valeur_courante;
1496: }
1497:
1498: if (valeur_courante > (*s_etat_processus).y_max)
1499: {
1500: (*s_etat_processus).y_max = valeur_courante;
1501: }
1502: }
1503: else
1504: {
1505: if (valeur_courante < (*s_etat_processus).y2_min)
1506: {
1507: (*s_etat_processus).y2_min = valeur_courante;
1508: }
1509:
1510: if (valeur_courante > (*s_etat_processus).y2_max)
1511: {
1512: (*s_etat_processus).y2_max = valeur_courante;
1513: }
1514: }
1515: }
1516: else
1517: {
1518: valeur_courante = ((real8 **)
1519: (*((struct_matrice *) (*s_objet_statistique).objet))
1520: .tableau)[j][(*s_etat_processus)
1521: .colonne_statistique_1 - 1];
1522:
1523: if ((*s_etat_processus).systeme_axes == 0)
1524: {
1525: if (valeur_courante < (*s_etat_processus).x_min)
1526: {
1527: (*s_etat_processus).x_min = valeur_courante;
1528: }
1529:
1530: if (valeur_courante > (*s_etat_processus).x_max)
1531: {
1532: (*s_etat_processus).x_max = valeur_courante;
1533: }
1534: }
1535: else
1536: {
1537: if (valeur_courante < (*s_etat_processus).x2_min)
1538: {
1539: (*s_etat_processus).x2_min = valeur_courante;
1540: }
1541:
1542: if (valeur_courante > (*s_etat_processus).x2_max)
1543: {
1544: (*s_etat_processus).x2_max = valeur_courante;
1545: }
1546: }
1547:
1548: valeur_courante = ((real8 **)
1549: (*((struct_matrice *) (*s_objet_statistique).objet))
1550: .tableau)[j][(*s_etat_processus)
1551: .colonne_statistique_2 - 1];
1552:
1553: if ((*s_etat_processus).systeme_axes == 0)
1554: {
1555: if (valeur_courante < (*s_etat_processus).y_min)
1556: {
1557: (*s_etat_processus).y_min = valeur_courante;
1558: }
1559:
1560: if (valeur_courante > (*s_etat_processus).y_max)
1561: {
1562: (*s_etat_processus).y_max = valeur_courante;
1563: }
1564: }
1565: else
1566: {
1567: if (valeur_courante < (*s_etat_processus).y2_min)
1568: {
1569: (*s_etat_processus).y2_min = valeur_courante;
1570: }
1571:
1572: if (valeur_courante > (*s_etat_processus).y2_max)
1573: {
1574: (*s_etat_processus).y2_max = valeur_courante;
1575: }
1576: }
1577: }
1578: }
1579:
1580: break;
1581: }
1582: }
1583:
1584: return;
1585: }
1586:
1587:
1588: /*
1589: ================================================================================
1590: Fonction 'spar'
1591: ================================================================================
1592: Entrées :
1593: --------------------------------------------------------------------------------
1594: Sorties :
1595: --------------------------------------------------------------------------------
1596: Effets de bord : néant
1597: ================================================================================
1598: */
1599:
1600: void
1601: instruction_spar(struct_processus *s_etat_processus)
1602: {
1603: logical1 presence_matrice_statistique;
1604: logical1 presence_variable;
1605:
1606: long i;
1607:
1608: struct_liste_chainee *l_ancienne_base;
1609: struct_liste_chainee *l_nouvelle_base;
1610:
1611: struct_objet *s_objet_resultat;
1612:
1613: /*
1614: * { { Dimensions de SIGMA } X Y }
1615: */
1616:
1617: (*s_etat_processus).erreur_execution = d_ex;
1618:
1619: if ((*s_etat_processus).affichage_arguments == 'Y')
1620: {
1621: printf("\n SPAR ");
1622:
1623: if ((*s_etat_processus).langue == 'F')
1624: {
1625: printf("(paramètres statistiques)\n\n");
1626: }
1627: else
1628: {
1629: printf("(statistical parameters)\n\n");
1630: }
1631:
1632: printf("-> 1: %s\n", d_LST);
1633:
1634: return;
1635: }
1636: else if ((*s_etat_processus).test_instruction == 'Y')
1637: {
1638: (*s_etat_processus).nombre_arguments = -1;
1639: return;
1640: }
1641:
1642: if (test_cfsf(s_etat_processus, 31) == d_vrai)
1643: {
1644: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
1645: {
1646: return;
1647: }
1648: }
1649:
1650: if ((s_objet_resultat = allocation(s_etat_processus, LST)) == NULL)
1651: {
1652: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1653: return;
1654: }
1655:
1656: (*s_objet_resultat).objet = NULL;
1657: l_ancienne_base = (*s_objet_resultat).objet;
1658:
1659: // Colonne 2
1660:
1661: if ((l_nouvelle_base = malloc(sizeof(struct_liste_chainee))) == NULL)
1662: {
1663: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1664: return;
1665: }
1666:
1667: if (((*l_nouvelle_base).donnee = allocation(s_etat_processus, INT))
1668: == NULL)
1669: {
1670: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1671: return;
1672: }
1673:
1674: (*l_nouvelle_base).suivant = l_ancienne_base;
1675: (*((integer8 *) (*(*l_nouvelle_base).donnee).objet)) =
1676: (*s_etat_processus).colonne_statistique_2;
1677: (*s_objet_resultat).objet = l_nouvelle_base;
1678: l_ancienne_base = (*s_objet_resultat).objet;
1679:
1680: // Colonne 1
1681:
1682: if ((l_nouvelle_base = allocation_maillon(s_etat_processus)) == NULL)
1683: {
1684: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1685: return;
1686: }
1687:
1688: if (((*l_nouvelle_base).donnee = allocation(s_etat_processus, INT))
1689: == NULL)
1690: {
1691: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1692: return;
1693: }
1694:
1695: (*l_nouvelle_base).suivant = l_ancienne_base;
1696: (*((integer8 *) (*(*l_nouvelle_base).donnee).objet)) =
1697: (*s_etat_processus).colonne_statistique_1;
1698: (*s_objet_resultat).objet = l_nouvelle_base;
1699: l_ancienne_base = (*s_objet_resultat).objet;
1700:
1701: // Dimensions de la matrice statistique
1702:
1703: if ((l_nouvelle_base = allocation_maillon(s_etat_processus)) == NULL)
1704: {
1705: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1706: return;
1707: }
1708:
1709: if (((*l_nouvelle_base).donnee = allocation(s_etat_processus, NON))
1710: == NULL)
1711: {
1712: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1713: return;
1714: }
1715:
1716: if (recherche_variable(s_etat_processus, ds_sdat) == d_faux)
1717: {
1718: /*
1719: * Aucune variable SIGMA
1720: */
1721:
1722: (*s_etat_processus).erreur_systeme = d_es;
1723: (*s_etat_processus).erreur_execution = d_ex;
1724: presence_matrice_statistique = d_faux;
1725: }
1726: else
1727: {
1728: /*
1729: * Il existe une variable locale SIGMA. Reste à vérifier l'existence
1730: * d'une variable SIGMA globale...
1731: */
1732:
1733: i = (*s_etat_processus).position_variable_courante;
1734: presence_variable = d_faux;
1735:
1736: while(i >= 0)
1737: {
1738: if ((strcmp((*s_etat_processus).s_liste_variables[i].nom,
1739: ds_sdat) == 0) && ((*s_etat_processus)
1740: .s_liste_variables[i].niveau == 1))
1741: {
1742: presence_variable = d_vrai;
1743: break;
1744: }
1745:
1746: i--;
1747: }
1748:
1749: if (presence_variable == d_faux)
1750: {
1751: presence_matrice_statistique = d_faux;
1752: }
1753: else
1754: {
1755: if ((*s_etat_processus).s_liste_variables[i].objet == NULL)
1756: {
1757: (*s_etat_processus).erreur_execution = d_ex_variable_partagee;
1758: return;
1759: }
1760:
1761: presence_matrice_statistique = d_vrai;
1762: (*s_etat_processus).position_variable_courante = i;
1763: }
1764: }
1765:
1766: if (presence_matrice_statistique == d_faux)
1767: {
1768: if (((*(*l_nouvelle_base).donnee).objet = malloc(12 *
1769: sizeof(unsigned char))) == NULL)
1770: {
1771: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1772: return;
1773: }
1774:
1775: (*(*l_nouvelle_base).donnee).type = CHN;
1776: strcpy((unsigned char *) (*(*l_nouvelle_base).donnee).objet,
1777: "UNAVAILABLE");
1778: }
1779: else
1780: {
1781: if (((*((*s_etat_processus).s_liste_variables
1782: [(*s_etat_processus).position_variable_courante].objet))
1783: .type != MIN) && ((*((*s_etat_processus)
1784: .s_liste_variables[(*s_etat_processus)
1785: .position_variable_courante].objet)).type != MRL))
1786: {
1787: if (((*(*l_nouvelle_base).donnee).objet = malloc(9 *
1788: sizeof(unsigned char))) == NULL)
1789: {
1790: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1791: return;
1792: }
1793:
1794: (*(*l_nouvelle_base).donnee).type = CHN;
1795: strcpy((unsigned char *) (*(*l_nouvelle_base).donnee).objet,
1796: "DISABLED");
1797: }
1798: else
1799: {
1800: (*(*l_nouvelle_base).donnee).type = LST;
1801:
1802: if (((*(*l_nouvelle_base).donnee).objet =
1803: allocation_maillon(s_etat_processus)) == NULL)
1804: {
1805: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1806: return;
1807: }
1808:
1809: if (((*((struct_liste_chainee *) (*(*l_nouvelle_base).donnee)
1810: .objet)).donnee = allocation(s_etat_processus, INT))
1811: == NULL)
1812: {
1813: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1814: return;
1815: }
1816:
1817: (*((integer8 *) (*((*((struct_liste_chainee *) (*(*l_nouvelle_base)
1818: .donnee).objet)).donnee)).objet)) = (*((struct_matrice *)
1819: (*((*s_etat_processus).s_liste_variables
1820: [(*s_etat_processus).position_variable_courante].objet))
1821: .objet)).nombre_lignes;
1822:
1823: if (((*((struct_liste_chainee *) (*(*l_nouvelle_base).donnee)
1824: .objet)).suivant = allocation_maillon(s_etat_processus))
1825: == NULL)
1826: {
1827: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1828: return;
1829: }
1830:
1831: (*(*((struct_liste_chainee *) (*(*l_nouvelle_base).donnee).objet))
1832: .suivant).suivant = NULL;
1833:
1834: if (((*(*((struct_liste_chainee *) (*(*l_nouvelle_base).donnee)
1835: .objet)).suivant).donnee = allocation(s_etat_processus,
1836: INT)) == NULL)
1837: {
1838: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1839: return;
1840: }
1841:
1842: (*((integer8 *) (*((*(*((struct_liste_chainee *)
1843: (*(*l_nouvelle_base).donnee).objet)).suivant).donnee))
1844: .objet)) = (*((struct_matrice *) (*((*s_etat_processus)
1845: .s_liste_variables[(*s_etat_processus)
1846: .position_variable_courante].objet)).objet))
1847: .nombre_colonnes;
1848: }
1849: }
1850:
1851: (*l_nouvelle_base).suivant = l_ancienne_base;
1852: (*s_objet_resultat).objet = l_nouvelle_base;
1853:
1854: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1855: s_objet_resultat) == d_erreur)
1856: {
1857: return;
1858: }
1859:
1860: return;
1861: }
1862:
1863: // vim: ts=4