1: /*
2: ================================================================================
3: RPL/2 (R) version 4.0.16
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 'legv'
29: ================================================================================
30: Entrées : pointeur sur une structure struct_processus
31: --------------------------------------------------------------------------------
32: Sorties :
33: --------------------------------------------------------------------------------
34: Effets de bord : néant
35: ================================================================================
36: */
37:
38: void
39: instruction_legv(struct_processus *s_etat_processus)
40: {
41: struct_objet *s_objet_argument;
42: struct_objet *s_objet_resultat_1;
43: struct_objet *s_objet_resultat_2;
44:
45: (*s_etat_processus).erreur_execution = d_ex;
46:
47: if ((*s_etat_processus).affichage_arguments == 'Y')
48: {
49: printf("\n LEGV ");
50:
51: if ((*s_etat_processus).langue == 'F')
52: {
53: printf("(valeurs et vecteurs propres gauches)\n\n");
54: }
55: else
56: {
57: printf("(eigenvalues and left eigenvectors)\n\n");
58: }
59:
60: printf(" 1: %s, %s, %s\n", d_MIN, d_MRL, d_MCX);
61: printf("-> 2: %s\n", d_MCX);
62: printf(" 1: %s\n", d_VCX);
63:
64: return;
65: }
66: else if ((*s_etat_processus).test_instruction == 'Y')
67: {
68: (*s_etat_processus).nombre_arguments = -1;
69: return;
70: }
71:
72: if (test_cfsf(s_etat_processus, 31) == d_vrai)
73: {
74: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
75: {
76: return;
77: }
78: }
79:
80: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
81: &s_objet_argument) == d_erreur)
82: {
83: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
84: return;
85: }
86:
87: /*
88: --------------------------------------------------------------------------------
89: L'argument est une matrice carrée
90: --------------------------------------------------------------------------------
91: */
92:
93: if (((*s_objet_argument).type == MIN) ||
94: ((*s_objet_argument).type == MRL) ||
95: ((*s_objet_argument).type == MCX))
96: {
97: if ((*((struct_matrice *) (*s_objet_argument).objet)).nombre_lignes !=
98: (*((struct_matrice *) (*s_objet_argument).objet))
99: .nombre_colonnes)
100: {
101: liberation(s_etat_processus, s_objet_argument);
102:
103: (*s_etat_processus).erreur_execution = d_ex_dimensions_invalides;
104: return;
105: }
106:
107: if ((s_objet_resultat_1 = allocation(s_etat_processus, VCX)) == NULL)
108: {
109: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
110: return;
111: }
112:
113: if ((s_objet_resultat_2 = allocation(s_etat_processus, MCX)) == NULL)
114: {
115: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
116: return;
117: }
118:
119: valeurs_propres(s_etat_processus,
120: (struct_matrice *) (*s_objet_argument).objet,
121: (struct_vecteur *) (*s_objet_resultat_1).objet,
122: (struct_matrice *) (*s_objet_resultat_2).objet, NULL);
123:
124: if ((*s_etat_processus).erreur_systeme != d_es)
125: {
126: return;
127: }
128:
129: if (((*s_etat_processus).exception != d_ep) ||
130: ((*s_etat_processus).erreur_execution != d_ex))
131: {
132: liberation(s_etat_processus, s_objet_argument);
133: liberation(s_etat_processus, s_objet_resultat_1);
134: liberation(s_etat_processus, s_objet_resultat_2);
135: return;
136: }
137: }
138:
139: /*
140: --------------------------------------------------------------------------------
141: Type incompatible
142: --------------------------------------------------------------------------------
143: */
144:
145: else
146: {
147: liberation(s_etat_processus, s_objet_argument);
148:
149: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
150: return;
151: }
152:
153: liberation(s_etat_processus, s_objet_argument);
154:
155: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
156: s_objet_resultat_2) == d_erreur)
157: {
158: return;
159: }
160:
161: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
162: s_objet_resultat_1) == d_erreur)
163: {
164: return;
165: }
166:
167: return;
168: }
169:
170:
171: /*
172: ================================================================================
173: Fonction 'lsq'
174: ================================================================================
175: Entrées : pointeur sur une structure struct_processus
176: --------------------------------------------------------------------------------
177: Sorties :
178: --------------------------------------------------------------------------------
179: Effets de bord : néant
180: ================================================================================
181: */
182:
183: void
184: instruction_lsq(struct_processus *s_etat_processus)
185: {
186: struct_objet *s_objet_argument_1;
187: struct_objet *s_objet_argument_2;
188: struct_objet *s_objet_resultat;
189:
190: struct_matrice s_matrice_tampon_b;
191: struct_matrice s_matrice_tampon_x;
192:
193: unsigned long i;
194:
195: (*s_etat_processus).erreur_execution = d_ex;
196:
197: if ((*s_etat_processus).affichage_arguments == 'Y')
198: {
199: printf("\n LSQ ");
200:
201: if ((*s_etat_processus).langue == 'F')
202: {
203: printf("(moindres carrés)\n\n");
204: }
205: else
206: {
207: printf("(least squares)\n\n");
208: }
209:
210: printf(" 2: %s, %s\n", d_VIN, d_VRL);
211: printf(" 1: %s, %s\n", d_MIN, d_MRL);
212: printf("-> 1: %s\n\n", d_VRL);
213:
214: printf(" 2: %s, %s, %s\n", d_VIN, d_VRL, d_VCX);
215: printf(" 1: %s, %s, %s\n", d_MIN, d_MRL, d_MCX);
216: printf("-> 1: %s\n\n", d_VCX);
217:
218: printf(" 2: %s, %s\n", d_MIN, d_MRL);
219: printf(" 1: %s, %s\n", d_MIN, d_MRL);
220: printf("-> 1: %s\n\n", d_MRL);
221:
222: printf(" 2: %s, %s, %s\n", d_MIN, d_MRL, d_MCX);
223: printf(" 1: %s, %s, %s\n", d_MIN, d_MRL, d_MCX);
224: printf("-> 1: %s\n", d_MCX);
225:
226: return;
227: }
228: else if ((*s_etat_processus).test_instruction == 'Y')
229: {
230: (*s_etat_processus).nombre_arguments = -1;
231: return;
232: }
233:
234: if (test_cfsf(s_etat_processus, 31) == d_vrai)
235: {
236: if (empilement_pile_last(s_etat_processus, 2) == d_erreur)
237: {
238: return;
239: }
240: }
241:
242: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
243: &s_objet_argument_1) == d_erreur)
244: {
245: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
246: return;
247: }
248:
249: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
250: &s_objet_argument_2) == d_erreur)
251: {
252: liberation(s_etat_processus, s_objet_argument_1);
253:
254: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
255: return;
256: }
257:
258: /*
259: --------------------------------------------------------------------------------
260: Vecteur et matrice
261: --------------------------------------------------------------------------------
262: */
263:
264: /*
265: * Résultat réel
266: */
267:
268: if ((((*s_objet_argument_1).type == MIN) ||
269: ((*s_objet_argument_1).type == MRL)) &&
270: (((*s_objet_argument_2).type == VIN) ||
271: ((*s_objet_argument_2).type == VRL)))
272: {
273: if ((*((struct_vecteur *) (*s_objet_argument_2).objet)).taille !=
274: (*((struct_matrice *) (*s_objet_argument_1).objet))
275: .nombre_lignes)
276: {
277: liberation(s_etat_processus, s_objet_argument_1);
278: liberation(s_etat_processus, s_objet_argument_2);
279:
280: (*s_etat_processus).erreur_execution = d_ex_dimensions_invalides;
281: return;
282: }
283:
284: if ((*s_objet_argument_2).type == VIN)
285: {
286: s_matrice_tampon_b.type = 'I';
287: s_matrice_tampon_b.nombre_lignes = (*((struct_vecteur *)
288: (*s_objet_argument_2).objet)).taille;
289: s_matrice_tampon_b.nombre_colonnes = 1;
290:
291: if ((s_matrice_tampon_b.tableau = malloc(s_matrice_tampon_b
292: .nombre_lignes * sizeof(integer8 *))) == NULL)
293: {
294: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
295: return;
296: }
297:
298: for(i = 0; i < s_matrice_tampon_b.nombre_lignes; i++)
299: {
300: if ((((integer8 **) s_matrice_tampon_b.tableau)[i] =
301: malloc(sizeof(integer8))) == NULL)
302: {
303: (*s_etat_processus).erreur_systeme =
304: d_es_allocation_memoire;
305: return;
306: }
307:
308: ((integer8 **) s_matrice_tampon_b.tableau)[i][0] =
309: ((integer8 *) (*((struct_vecteur *)
310: (*s_objet_argument_2).objet)).tableau)[i];
311: }
312: }
313: else
314: {
315: s_matrice_tampon_b.type = 'R';
316: s_matrice_tampon_b.nombre_lignes = (*((struct_vecteur *)
317: (*s_objet_argument_2).objet)).taille;
318: s_matrice_tampon_b.nombre_colonnes = 1;
319:
320: if ((s_matrice_tampon_b.tableau = malloc(s_matrice_tampon_b
321: .nombre_lignes * sizeof(real8 *))) == NULL)
322: {
323: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
324: return;
325: }
326:
327: for(i = 0; i < s_matrice_tampon_b.nombre_lignes; i++)
328: {
329: if ((((real8 **) s_matrice_tampon_b.tableau)[i] =
330: malloc(sizeof(real8))) == NULL)
331: {
332: (*s_etat_processus).erreur_systeme =
333: d_es_allocation_memoire;
334: return;
335: }
336:
337: ((real8 **) s_matrice_tampon_b.tableau)[i][0] =
338: ((real8 *) (*((struct_vecteur *)
339: (*s_objet_argument_2).objet)).tableau)[i];
340: }
341: }
342:
343: moindres_carres(s_etat_processus,
344: (struct_matrice *) (*s_objet_argument_1).objet,
345: &s_matrice_tampon_b, &s_matrice_tampon_x);
346:
347: if ((*s_objet_argument_2).type == VIN)
348: {
349: for(i = 0; i < s_matrice_tampon_b.nombre_lignes; i++)
350: {
351: free(((integer8 **) s_matrice_tampon_b.tableau)[i]);
352: }
353: }
354: else
355: {
356: for(i = 0; i < s_matrice_tampon_b.nombre_lignes; i++)
357: {
358: free(((real8 **) s_matrice_tampon_b.tableau)[i]);
359: }
360: }
361:
362: free(s_matrice_tampon_b.tableau);
363:
364: if ((*s_etat_processus).erreur_systeme != d_es)
365: {
366: return;
367: }
368:
369: if (((*s_etat_processus).exception != d_ep) ||
370: ((*s_etat_processus).erreur_execution != d_ex))
371: {
372: liberation(s_etat_processus, s_objet_argument_1);
373: liberation(s_etat_processus, s_objet_argument_2);
374: return;
375: }
376:
377: if ((s_objet_resultat = allocation(s_etat_processus, VRL)) == NULL)
378: {
379: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
380: return;
381: }
382:
383: (*((struct_vecteur *) (*s_objet_resultat).objet)).taille =
384: s_matrice_tampon_x.nombre_lignes;
385:
386: if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau =
387: malloc((*((struct_vecteur *) (*s_objet_resultat).objet)).taille
388: * sizeof(real8))) == NULL)
389: {
390: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
391: return;
392: }
393:
394: for(i = 0; i < (*((struct_vecteur *) (*s_objet_resultat).objet)).taille;
395: i++)
396: {
397: ((real8 *) (*((struct_vecteur *) (*s_objet_resultat).objet))
398: .tableau)[i] = ((real8 **) s_matrice_tampon_x.tableau)
399: [i][0];
400: free(((real8 **) s_matrice_tampon_x.tableau)[i]);
401: }
402:
403: free(s_matrice_tampon_x.tableau);
404: }
405:
406: /*
407: * Résultat complexe
408: */
409:
410: else if ((((*s_objet_argument_1).type == MCX) &&
411: (((*s_objet_argument_2).type == VIN) ||
412: ((*s_objet_argument_2).type == VRL) ||
413: ((*s_objet_argument_2).type == VCX))) ||
414: (((*s_objet_argument_2).type == VCX) &&
415: (((*s_objet_argument_1).type == MIN) ||
416: ((*s_objet_argument_1).type == MRL))))
417: {
418: if ((*((struct_vecteur *) (*s_objet_argument_2).objet)).taille !=
419: (*((struct_matrice *) (*s_objet_argument_1).objet))
420: .nombre_lignes)
421: {
422: liberation(s_etat_processus, s_objet_argument_1);
423: liberation(s_etat_processus, s_objet_argument_2);
424:
425: (*s_etat_processus).erreur_execution = d_ex_dimensions_invalides;
426: return;
427: }
428:
429: if ((*s_objet_argument_2).type == VIN)
430: {
431: s_matrice_tampon_b.type = 'I';
432: s_matrice_tampon_b.nombre_lignes = (*((struct_vecteur *)
433: (*s_objet_argument_2).objet)).taille;
434: s_matrice_tampon_b.nombre_colonnes = 1;
435:
436: if ((s_matrice_tampon_b.tableau = malloc(s_matrice_tampon_b
437: .nombre_lignes * sizeof(integer8 *))) == NULL)
438: {
439: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
440: return;
441: }
442:
443: for(i = 0; i < s_matrice_tampon_b.nombre_lignes; i++)
444: {
445: if ((((integer8 **) s_matrice_tampon_b.tableau)[i] =
446: malloc(sizeof(integer8))) == NULL)
447: {
448: (*s_etat_processus).erreur_systeme =
449: d_es_allocation_memoire;
450: return;
451: }
452:
453: ((integer8 **) s_matrice_tampon_b.tableau)[i][0] =
454: ((integer8 *) (*((struct_vecteur *)
455: (*s_objet_argument_2).objet)).tableau)[i];
456: }
457: }
458: else if ((*s_objet_argument_2).type == VRL)
459: {
460: s_matrice_tampon_b.type = 'R';
461: s_matrice_tampon_b.nombre_lignes = (*((struct_vecteur *)
462: (*s_objet_argument_2).objet)).taille;
463: s_matrice_tampon_b.nombre_colonnes = 1;
464:
465: if ((s_matrice_tampon_b.tableau = malloc(s_matrice_tampon_b
466: .nombre_lignes * sizeof(real8 *))) == NULL)
467: {
468: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
469: return;
470: }
471:
472: for(i = 0; i < s_matrice_tampon_b.nombre_lignes; i++)
473: {
474: if ((((real8 **) s_matrice_tampon_b.tableau)[i] =
475: malloc(sizeof(real8))) == NULL)
476: {
477: (*s_etat_processus).erreur_systeme =
478: d_es_allocation_memoire;
479: return;
480: }
481:
482: ((real8 **) s_matrice_tampon_b.tableau)[i][0] =
483: ((real8 *) (*((struct_vecteur *)
484: (*s_objet_argument_2).objet)).tableau)[i];
485: }
486: }
487: else
488: {
489: s_matrice_tampon_b.type = 'C';
490: s_matrice_tampon_b.nombre_lignes = (*((struct_vecteur *)
491: (*s_objet_argument_2).objet)).taille;
492: s_matrice_tampon_b.nombre_colonnes = 1;
493:
494: if ((s_matrice_tampon_b.tableau = malloc(s_matrice_tampon_b
495: .nombre_lignes * sizeof(struct_complexe16 *))) == NULL)
496: {
497: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
498: return;
499: }
500:
501: for(i = 0; i < s_matrice_tampon_b.nombre_lignes; i++)
502: {
503: if ((((struct_complexe16 **) s_matrice_tampon_b.tableau)[i] =
504: malloc(sizeof(struct_complexe16))) == NULL)
505: {
506: (*s_etat_processus).erreur_systeme =
507: d_es_allocation_memoire;
508: return;
509: }
510:
511: ((struct_complexe16 **) s_matrice_tampon_b.tableau)[i][0]
512: .partie_reelle = ((struct_complexe16 *)
513: (*((struct_vecteur *) (*s_objet_argument_2).objet))
514: .tableau)[i].partie_reelle;
515: ((struct_complexe16 **) s_matrice_tampon_b.tableau)[i][0]
516: .partie_imaginaire = ((struct_complexe16 *)
517: (*((struct_vecteur *) (*s_objet_argument_2).objet))
518: .tableau)[i].partie_imaginaire;
519: }
520: }
521:
522: moindres_carres(s_etat_processus,
523: (struct_matrice *) (*s_objet_argument_1).objet,
524: &s_matrice_tampon_b, &s_matrice_tampon_x);
525:
526: if ((*s_objet_argument_2).type == VIN)
527: {
528: for(i = 0; i < s_matrice_tampon_b.nombre_lignes; i++)
529: {
530: free(((integer8 **) s_matrice_tampon_b.tableau)[i]);
531: }
532: }
533: else if ((*s_objet_argument_2).type == VRL)
534: {
535: for(i = 0; i < s_matrice_tampon_b.nombre_lignes; i++)
536: {
537: free(((real8 **) s_matrice_tampon_b.tableau)[i]);
538: }
539: }
540: else
541: {
542: for(i = 0; i < s_matrice_tampon_b.nombre_lignes; i++)
543: {
544: free(((struct_complexe16 **) s_matrice_tampon_b.tableau)[i]);
545: }
546: }
547:
548: free(s_matrice_tampon_b.tableau);
549:
550: if ((*s_etat_processus).erreur_systeme != d_es)
551: {
552: return;
553: }
554:
555: if (((*s_etat_processus).exception != d_ep) ||
556: ((*s_etat_processus).erreur_execution != d_ex))
557: {
558: liberation(s_etat_processus, s_objet_argument_1);
559: liberation(s_etat_processus, s_objet_argument_2);
560: return;
561: }
562:
563: if ((s_objet_resultat = allocation(s_etat_processus, VCX)) == NULL)
564: {
565: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
566: return;
567: }
568:
569: (*((struct_vecteur *) (*s_objet_resultat).objet)).taille =
570: s_matrice_tampon_x.nombre_lignes;
571:
572: if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau =
573: malloc((*((struct_vecteur *) (*s_objet_resultat).objet)).taille
574: * sizeof(struct_complexe16))) == NULL)
575: {
576: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
577: return;
578: }
579:
580: for(i = 0; i < (*((struct_vecteur *) (*s_objet_resultat).objet)).taille;
581: i++)
582: {
583: ((struct_complexe16 *) (*((struct_vecteur *) (*s_objet_resultat)
584: .objet)).tableau)[i].partie_reelle = ((struct_complexe16 **)
585: s_matrice_tampon_x.tableau)[i][0].partie_reelle;
586: ((struct_complexe16 *) (*((struct_vecteur *) (*s_objet_resultat)
587: .objet)).tableau)[i].partie_imaginaire =
588: ((struct_complexe16 **) s_matrice_tampon_x.tableau)[i][0]
589: .partie_imaginaire;
590: free(((real8 **) s_matrice_tampon_x.tableau)[i]);
591: }
592:
593: free(s_matrice_tampon_x.tableau);
594: }
595:
596: /*
597: --------------------------------------------------------------------------------
598: Matrices
599: --------------------------------------------------------------------------------
600: */
601:
602: /*
603: * Résultat réel
604: */
605:
606: else if ((((*s_objet_argument_1).type == MIN) ||
607: ((*s_objet_argument_1).type == MRL)) &&
608: (((*s_objet_argument_2).type == MIN) ||
609: ((*s_objet_argument_2).type == MRL)))
610: {
611: if ((*((struct_matrice *) (*s_objet_argument_2).objet)).nombre_lignes !=
612: (*((struct_matrice *) (*s_objet_argument_1).objet))
613: .nombre_lignes)
614: {
615: liberation(s_etat_processus, s_objet_argument_1);
616: liberation(s_etat_processus, s_objet_argument_2);
617:
618: (*s_etat_processus).erreur_execution = d_ex_dimensions_invalides;
619: return;
620: }
621:
622: moindres_carres(s_etat_processus,
623: (struct_matrice *) (*s_objet_argument_1).objet,
624: (struct_matrice *) (*s_objet_argument_2).objet,
625: &s_matrice_tampon_x);
626:
627: if ((*s_etat_processus).erreur_systeme != d_es)
628: {
629: return;
630: }
631:
632: if (((*s_etat_processus).exception != d_ep) ||
633: ((*s_etat_processus).erreur_execution != d_ex))
634: {
635: liberation(s_etat_processus, s_objet_argument_1);
636: liberation(s_etat_processus, s_objet_argument_2);
637: return;
638: }
639:
640: if ((s_objet_resultat = allocation(s_etat_processus, MRL)) == NULL)
641: {
642: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
643: return;
644: }
645:
646: (*((struct_matrice *) (*s_objet_resultat).objet)).nombre_lignes =
647: s_matrice_tampon_x.nombre_lignes;
648: (*((struct_matrice *) (*s_objet_resultat).objet)).nombre_colonnes =
649: s_matrice_tampon_x.nombre_colonnes;
650: (*((struct_matrice *) (*s_objet_resultat).objet)).tableau =
651: s_matrice_tampon_x.tableau;
652: }
653:
654: /*
655: * Résultat complexe
656: */
657:
658: else if ((((*s_objet_argument_1).type == MCX) &&
659: (((*s_objet_argument_2).type == MIN) ||
660: ((*s_objet_argument_2).type == MRL) ||
661: ((*s_objet_argument_2).type == MCX))) ||
662: (((*s_objet_argument_2).type == MCX) &&
663: (((*s_objet_argument_1).type == MIN) ||
664: ((*s_objet_argument_1).type == MRL))))
665: {
666: if ((*((struct_matrice *) (*s_objet_argument_2).objet)).nombre_lignes !=
667: (*((struct_matrice *) (*s_objet_argument_1).objet))
668: .nombre_lignes)
669: {
670: liberation(s_etat_processus, s_objet_argument_1);
671: liberation(s_etat_processus, s_objet_argument_2);
672:
673: (*s_etat_processus).erreur_execution = d_ex_dimensions_invalides;
674: return;
675: }
676:
677: moindres_carres(s_etat_processus,
678: (struct_matrice *) (*s_objet_argument_1).objet,
679: (struct_matrice *) (*s_objet_argument_2).objet,
680: &s_matrice_tampon_x);
681:
682: if ((*s_etat_processus).erreur_systeme != d_es)
683: {
684: return;
685: }
686:
687: if (((*s_etat_processus).exception != d_ep) ||
688: ((*s_etat_processus).erreur_execution != d_ex))
689: {
690: liberation(s_etat_processus, s_objet_argument_1);
691: liberation(s_etat_processus, s_objet_argument_2);
692: return;
693: }
694:
695: if ((s_objet_resultat = allocation(s_etat_processus, MCX)) == NULL)
696: {
697: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
698: return;
699: }
700:
701: (*((struct_matrice *) (*s_objet_resultat).objet)).nombre_lignes =
702: s_matrice_tampon_x.nombre_lignes;
703: (*((struct_matrice *) (*s_objet_resultat).objet)).nombre_colonnes =
704: s_matrice_tampon_x.nombre_colonnes;
705: (*((struct_matrice *) (*s_objet_resultat).objet)).tableau =
706: s_matrice_tampon_x.tableau;
707: }
708:
709: /*
710: --------------------------------------------------------------------------------
711: Types icompatibles avec la fonction LSQ
712: --------------------------------------------------------------------------------
713: */
714:
715: else
716: {
717: liberation(s_etat_processus, s_objet_argument_1);
718: liberation(s_etat_processus, s_objet_argument_2);
719:
720: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
721: return;
722: }
723:
724: liberation(s_etat_processus, s_objet_argument_1);
725: liberation(s_etat_processus, s_objet_argument_2);
726:
727: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
728: s_objet_resultat) == d_erreur)
729: {
730: return;
731: }
732:
733: return;
734: }
735:
736:
737: /*
738: ================================================================================
739: Fonction 'logscale'
740: ================================================================================
741: Entrées : pointeur sur une structure struct_processus
742: --------------------------------------------------------------------------------
743: Sorties :
744: --------------------------------------------------------------------------------
745: Effets de bord : néant
746: ================================================================================
747: */
748:
749: void
750: instruction_logscale(struct_processus *s_etat_processus)
751: {
752: logical1 presence[3];
753: logical1 systeme_auxiliaire;
754: logical1 systeme_principal;
755:
756: struct_liste_chainee *l_element_courant;
757:
758: struct_objet *s_objet;
759:
760: unsigned char *tampon;
761:
762: (*s_etat_processus).erreur_execution = d_ex;
763:
764: if ((*s_etat_processus).affichage_arguments == 'Y')
765: {
766: printf("\n LOGSCALE ");
767:
768: if ((*s_etat_processus).langue == 'F')
769: {
770: printf("(définition des axes)\n\n");
771: }
772: else
773: {
774: printf("(definitions of axes)\n\n");
775: }
776:
777: printf(" 1: %s\n\n", d_LST);
778:
779: printf(" 1: %s\n", d_NOM);
780:
781: if ((*s_etat_processus).langue == 'F')
782: {
783: printf(" Utilisation :\n\n");
784: }
785: else
786: {
787: printf(" Usage:\n\n");
788: }
789:
790: printf(" { X Z } LOGSCALE\n");
791: printf(" 'Y' LOGSCALE\n");
792:
793: return;
794: }
795: else if ((*s_etat_processus).test_instruction == 'Y')
796: {
797: (*s_etat_processus).nombre_arguments = -1;
798: return;
799: }
800:
801: if ((*s_etat_processus).l_base_pile == NULL)
802: {
803: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
804: return;
805: }
806:
807: if (test_cfsf(s_etat_processus, 31) == d_vrai)
808: {
809: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
810: {
811: return;
812: }
813: }
814:
815: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
816: &s_objet) == d_erreur)
817: {
818: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
819: return;
820: }
821:
822: if ((*s_objet).type == NOM)
823: {
824: tampon = conversion_majuscule((*((struct_nom *) (*s_objet).objet)).nom);
825:
826: if (tampon == NULL)
827: {
828: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
829: return;
830: }
831:
832: if ((strcmp(tampon, "X") != 0) && (strcmp(tampon, "Y") != 0) &&
833: (strcmp(tampon, "Z") != 0))
834: {
835: liberation(s_etat_processus, s_objet);
836:
837: free(tampon);
838:
839: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
840: return;
841: }
842:
843: if (tampon[0] == 'X')
844: {
845: (*s_etat_processus).echelle_log_x = d_vrai;
846: }
847: else if (tampon[0] == 'Y')
848: {
849: (*s_etat_processus).echelle_log_y = d_vrai;
850: }
851: else
852: {
853: (*s_etat_processus).echelle_log_z = d_vrai;
854: }
855:
856: free(tampon);
857: }
858: else if ((*s_objet).type == LST)
859: {
860: if ((*s_etat_processus).systeme_axes == 0)
861: {
862: systeme_principal = d_vrai;
863: systeme_auxiliaire = d_faux;
864: }
865: else
866: {
867: systeme_principal = d_faux;
868: systeme_auxiliaire = d_vrai;
869: }
870:
871: presence[0] = d_faux;
872: presence[1] = d_faux;
873: presence[2] = d_faux;
874:
875: l_element_courant = (struct_liste_chainee *) (*s_objet).objet;
876:
877: if (l_element_courant == NULL)
878: {
879: if (systeme_principal == d_vrai)
880: {
881: (*s_etat_processus).echelle_log_x = d_faux;
882: (*s_etat_processus).echelle_log_y = d_faux;
883: (*s_etat_processus).echelle_log_z = d_faux;
884: }
885: else
886: {
887: (*s_etat_processus).echelle_log_x2 = d_faux;
888: (*s_etat_processus).echelle_log_y2 = d_faux;
889: (*s_etat_processus).echelle_log_z2 = d_faux;
890: }
891: }
892: else
893: {
894: while(l_element_courant != NULL)
895: {
896: if ((*(*l_element_courant).donnee).type != NOM)
897: {
898: liberation(s_etat_processus, s_objet);
899:
900: (*s_etat_processus).erreur_execution =
901: d_ex_argument_invalide;
902: return;
903: }
904:
905: tampon = conversion_majuscule((*((struct_nom *)
906: (*(*l_element_courant).donnee).objet)).nom);
907:
908: if ((strcmp(tampon, "X") != 0) && (strcmp(tampon, "Y") != 0) &&
909: (strcmp(tampon, "Z") != 0))
910: {
911: liberation(s_etat_processus, s_objet);
912: free(tampon);
913:
914: (*s_etat_processus).erreur_execution =
915: d_ex_argument_invalide;
916: return;
917: }
918:
919: if (tampon[0] == 'X')
920: {
921: if (presence[0] == d_vrai)
922: {
923: liberation(s_etat_processus, s_objet);
924: free(tampon);
925:
926: (*s_etat_processus).erreur_execution =
927: d_ex_argument_invalide;
928: return;
929: }
930:
931: if (systeme_principal == d_vrai)
932: {
933: (*s_etat_processus).echelle_log_x = d_vrai;
934: }
935:
936: if (systeme_auxiliaire == d_vrai)
937: {
938: (*s_etat_processus).echelle_log_x2 = d_vrai;
939: }
940:
941: presence[0] = d_vrai;
942: }
943: else if (tampon[0] == 'Y')
944: {
945: if (presence[1] == d_vrai)
946: {
947: liberation(s_etat_processus, s_objet);
948: free(tampon);
949:
950: (*s_etat_processus).erreur_execution =
951: d_ex_argument_invalide;
952: return;
953: }
954:
955: if (systeme_principal == d_vrai)
956: {
957: (*s_etat_processus).echelle_log_y = d_vrai;
958: }
959:
960: if (systeme_auxiliaire == d_vrai)
961: {
962: (*s_etat_processus).echelle_log_y2 = d_vrai;
963: }
964:
965: presence[1] = d_vrai;
966: }
967: else
968: {
969: if (presence[2] == d_vrai)
970: {
971: liberation(s_etat_processus, s_objet);
972: free(tampon);
973:
974: (*s_etat_processus).erreur_execution =
975: d_ex_argument_invalide;
976: return;
977: }
978:
979: if (systeme_principal == d_vrai)
980: {
981: (*s_etat_processus).echelle_log_z = d_vrai;
982: }
983:
984: if (systeme_auxiliaire == d_vrai)
985: {
986: (*s_etat_processus).echelle_log_z2 = d_vrai;
987: }
988:
989: presence[2] = d_vrai;
990: }
991:
992: l_element_courant = (*l_element_courant).suivant;
993: free(tampon);
994: }
995: }
996: }
997: else
998: {
999: liberation(s_etat_processus, s_objet);
1000:
1001: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
1002: return;
1003: }
1004:
1005: liberation(s_etat_processus, s_objet);
1006:
1007: if (test_cfsf(s_etat_processus, 52) == d_faux)
1008: {
1009: if ((*s_etat_processus).fichiers_graphiques != NULL)
1010: {
1011: appel_gnuplot(s_etat_processus, 'N');
1012: }
1013: }
1014:
1015: return;
1016: }
1017:
1018: // vim: ts=4
CVSweb interface <joel.bertrand@systella.fr>
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to instructions_l3.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [local] / rpl / src