Annotation of rpl/src/instructions_l3.c, revision 1.1
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 '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