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