![]() ![]() | ![]() |
Passage de la branche 4.1 en branche stable.
1: /* 2: ================================================================================ 3: RPL/2 (R) version 4.1.0 4: Copyright (C) 1989-2011 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 réalisant la somme de la matrice statistique 29: ================================================================================ 30: Entrées : pointeur sur une matrice entière ou réelle 31: -------------------------------------------------------------------------------- 32: Sorties : renvoie NULL s'il y a defaut de mémoire 33: -------------------------------------------------------------------------------- 34: Effets de bord : néant 35: ================================================================================ 36: */ 37: 38: struct_vecteur * 39: sommation_statistique(struct_matrice *s_matrice) 40: { 41: integer8 *cumul_entier; 42: 43: logical1 erreur_memoire; 44: logical1 resultat_entier; 45: 46: real8 *colonne; 47: 48: struct_vecteur *s_vecteur; 49: 50: unsigned long i; 51: unsigned long j; 52: 53: if ((s_vecteur = (struct_vecteur *) malloc(sizeof(struct_vecteur))) == NULL) 54: { 55: return NULL; 56: } 57: 58: /* 59: * Calculs en virgule fixe 60: */ 61: 62: if ((*s_matrice).type == 'I') 63: { 64: if ((cumul_entier = (integer8 *) malloc((*s_matrice).nombre_colonnes * 65: sizeof(integer8))) == NULL) 66: { 67: free(s_vecteur); 68: return NULL; 69: } 70: 71: for(j = 0; j < (*s_matrice).nombre_colonnes; cumul_entier[j++] = 0); 72: 73: for(resultat_entier = d_vrai, i = 0; (i < (*s_matrice).nombre_lignes) 74: && (resultat_entier == d_vrai); i++) 75: { 76: for(j = 0; (j < (*s_matrice).nombre_colonnes) && 77: (resultat_entier == d_vrai); j++) 78: { 79: if (depassement_addition(&(cumul_entier[j]), &(((integer8 **) 80: (*s_matrice).tableau)[i][j]), &(cumul_entier[j])) 81: == d_erreur) 82: { 83: resultat_entier = d_faux; 84: } 85: } 86: } 87: 88: if (resultat_entier == d_vrai) 89: { 90: /* 91: * Pas de dépassement 92: */ 93: 94: (*s_vecteur).type = 'I'; 95: (*s_vecteur).taille = (*s_matrice).nombre_colonnes; 96: (*s_vecteur).tableau = cumul_entier; 97: } 98: else 99: { 100: /* 101: * Dépassement... Refaire le calcul en virgule flottante 102: */ 103: 104: free(cumul_entier); 105: 106: if (((*s_vecteur).tableau = malloc((*s_matrice).nombre_colonnes * 107: sizeof(real8))) == NULL) 108: { 109: free(s_vecteur); 110: return NULL; 111: } 112: 113: if ((colonne = (real8 *) malloc((*s_matrice).nombre_lignes * 114: sizeof(real8))) == NULL) 115: { 116: free(s_vecteur); 117: return NULL; 118: } 119: 120: for(j = 0; j < (*s_matrice).nombre_colonnes; j++) 121: { 122: for(i = 0; i < (*s_matrice).nombre_lignes; i++) 123: { 124: colonne[i] = (real8) ((integer8 **) 125: (*s_matrice).tableau)[i][j]; 126: } 127: 128: ((real8 *) (*s_vecteur).tableau)[j] = sommation_vecteur_reel( 129: colonne, &((*s_matrice).nombre_lignes), 130: &erreur_memoire); 131: 132: if (erreur_memoire == d_vrai) 133: { 134: free(s_vecteur); 135: return NULL; 136: } 137: } 138: 139: free(colonne); 140: 141: (*s_vecteur).type = 'R'; 142: (*s_vecteur).taille = (*s_matrice).nombre_colonnes; 143: } 144: } 145: 146: /* 147: * Calculs en virgule flottante 148: */ 149: 150: else if ((*s_matrice).type == 'R') 151: { 152: if (((*s_vecteur).tableau = malloc((*s_matrice).nombre_colonnes * 153: sizeof(real8))) == NULL) 154: { 155: free(s_vecteur); 156: return NULL; 157: } 158: 159: if ((colonne = (real8 *) malloc((*s_matrice).nombre_lignes * 160: sizeof(real8))) == NULL) 161: { 162: free(s_vecteur); 163: return NULL; 164: } 165: 166: for(j = 0; j < (*s_matrice).nombre_colonnes; j++) 167: { 168: for(i = 0; i < (*s_matrice).nombre_lignes; i++) 169: { 170: colonne[i] = ((real8 **) (*s_matrice).tableau)[i][j]; 171: } 172: 173: ((real8 *) (*s_vecteur).tableau)[j] = sommation_vecteur_reel( 174: colonne, &((*s_matrice).nombre_lignes), &erreur_memoire); 175: 176: if (erreur_memoire == d_vrai) 177: { 178: free(s_vecteur); 179: return NULL; 180: } 181: } 182: 183: free(colonne); 184: 185: (*s_vecteur).type = 'R'; 186: (*s_vecteur).taille = (*s_matrice).nombre_colonnes; 187: } 188: 189: return s_vecteur; 190: } 191: 192: 193: /* 194: ================================================================================ 195: Fonction réalisant la somme des produits d'une colonne de la matrice 196: statistique par une autre colonne 197: ================================================================================ 198: Entrées : pointeur sur une matrice entière ou réelle 199: -------------------------------------------------------------------------------- 200: Sorties : renvoie NULL s'il y a defaut de mémoire 201: -------------------------------------------------------------------------------- 202: Effets de bord : néant 203: ================================================================================ 204: */ 205: 206: struct_vecteur * 207: sommation_produits_colonnes_statistiques(struct_matrice *s_matrice, 208: unsigned long position_1, unsigned long position_2) 209: { 210: integer8 *cumul_entier; 211: integer8 tampon; 212: 213: logical1 erreur_memoire; 214: logical1 resultat_entier; 215: 216: real8 *colonne; 217: 218: struct_vecteur *s_vecteur; 219: 220: unsigned long i; 221: 222: if ((s_vecteur = (struct_vecteur *) malloc(sizeof(struct_vecteur))) == NULL) 223: { 224: return NULL; 225: } 226: 227: position_1--; 228: position_2--; 229: 230: /* 231: * Calculs en virgule fixe 232: */ 233: 234: if ((*s_matrice).type == 'I') 235: { 236: if ((cumul_entier = (integer8 *) malloc(sizeof(integer8))) == NULL) 237: { 238: free(s_vecteur); 239: return NULL; 240: } 241: 242: (*cumul_entier) = 0; 243: 244: for(resultat_entier = d_vrai, i = 0; (i < (*s_matrice).nombre_lignes) 245: && (resultat_entier == d_vrai); i++) 246: { 247: if (depassement_multiplication(&(((integer8 **) (*s_matrice) 248: .tableau)[i][position_1]), &(((integer8 **) (*s_matrice) 249: .tableau)[i][position_2]), &tampon) == d_erreur) 250: { 251: resultat_entier = d_faux; 252: } 253: else if (depassement_addition(cumul_entier, &tampon, cumul_entier) 254: == d_erreur) 255: { 256: resultat_entier = d_faux; 257: } 258: } 259: 260: if (resultat_entier == d_vrai) 261: { 262: /* 263: * Pas de dépassement 264: */ 265: 266: (*s_vecteur).type = 'I'; 267: (*s_vecteur).taille = 1; 268: (*s_vecteur).tableau = cumul_entier; 269: } 270: else 271: { 272: /* 273: * Dépassement... Refaire le calcul en virgule flottante 274: */ 275: 276: free(cumul_entier); 277: 278: if (((*s_vecteur).tableau = malloc(sizeof(real8))) == NULL) 279: { 280: free(s_vecteur); 281: return NULL; 282: } 283: 284: if ((colonne = (real8 *) malloc((*s_matrice).nombre_lignes * 285: sizeof(real8))) == NULL) 286: { 287: free(s_vecteur); 288: return NULL; 289: } 290: 291: for(i = 0; i < (*s_matrice).nombre_lignes; i++) 292: { 293: colonne[i] = ((real8) ((integer8 **) 294: (*s_matrice).tableau)[i][position_1]) * 295: ((real8) ((integer8 **) (*s_matrice).tableau) 296: [i][position_2]); 297: } 298: 299: (*((real8 *) (*s_vecteur).tableau)) = sommation_vecteur_reel( 300: colonne, &((*s_matrice).nombre_lignes), 301: &erreur_memoire); 302: 303: if (erreur_memoire == d_vrai) 304: { 305: free(s_vecteur); 306: return NULL; 307: } 308: 309: free(colonne); 310: 311: (*s_vecteur).type = 'R'; 312: (*s_vecteur).taille = 1; 313: } 314: } 315: 316: /* 317: * Calculs en virgule flottante 318: */ 319: 320: else if ((*s_matrice).type == 'R') 321: { 322: if (((*s_vecteur).tableau = malloc(sizeof(real8))) == NULL) 323: { 324: free(s_vecteur); 325: return NULL; 326: } 327: 328: if ((colonne = (real8 *) malloc((*s_matrice).nombre_lignes * 329: sizeof(real8))) == NULL) 330: { 331: free(s_vecteur); 332: return NULL; 333: } 334: 335: for(i = 0; i < (*s_matrice).nombre_lignes; i++) 336: { 337: colonne[i] = ((real8 **) (*s_matrice).tableau)[i][position_1] 338: * ((real8 **) (*s_matrice).tableau)[i][position_2]; 339: } 340: 341: (*((real8 *) (*s_vecteur).tableau)) = sommation_vecteur_reel( 342: colonne, &((*s_matrice).nombre_lignes), &erreur_memoire); 343: 344: if (erreur_memoire == d_vrai) 345: { 346: free(s_vecteur); 347: return NULL; 348: } 349: 350: free(colonne); 351: 352: (*s_vecteur).type = 'R'; 353: (*s_vecteur).taille = 1; 354: } 355: 356: return s_vecteur; 357: } 358: 359: 360: /* 361: ================================================================================ 362: Fonction réalisant la somme d'une colonne de la matrice statistique 363: ================================================================================ 364: Entrées : pointeur sur une matrice entière ou réelle 365: -------------------------------------------------------------------------------- 366: Sorties : renvoie NULL s'il y a defaut de mémoire 367: -------------------------------------------------------------------------------- 368: Effets de bord : néant 369: ================================================================================ 370: */ 371: 372: struct_vecteur * 373: sommation_colonne_statistique(struct_matrice *s_matrice, unsigned long position) 374: { 375: integer8 *cumul_entier; 376: 377: logical1 erreur_memoire; 378: logical1 resultat_entier; 379: 380: real8 *colonne; 381: 382: struct_vecteur *s_vecteur; 383: 384: unsigned long i; 385: 386: if ((s_vecteur = (struct_vecteur *) malloc(sizeof(struct_vecteur))) == NULL) 387: { 388: return NULL; 389: } 390: 391: position--; 392: 393: /* 394: * Calculs en virgule fixe 395: */ 396: 397: if ((*s_matrice).type == 'I') 398: { 399: if ((cumul_entier = (integer8 *) malloc(sizeof(integer8))) == NULL) 400: { 401: free(s_vecteur); 402: return NULL; 403: } 404: 405: (*cumul_entier) = 0; 406: 407: for(resultat_entier = d_vrai, i = 0; (i < (*s_matrice).nombre_lignes) 408: && (resultat_entier == d_vrai); i++) 409: { 410: if (depassement_addition(cumul_entier, &(((integer8 **) 411: (*s_matrice).tableau)[i][position]), cumul_entier) 412: == d_erreur) 413: { 414: resultat_entier = d_faux; 415: } 416: } 417: 418: if (resultat_entier == d_vrai) 419: { 420: /* 421: * Pas de dépassement 422: */ 423: 424: (*s_vecteur).type = 'I'; 425: (*s_vecteur).taille = 1; 426: (*s_vecteur).tableau = cumul_entier; 427: } 428: else 429: { 430: /* 431: * Dépassement... Refaire le calcul en virgule flottante 432: */ 433: 434: free(cumul_entier); 435: 436: if (((*s_vecteur).tableau = malloc(sizeof(real8))) == NULL) 437: { 438: free(s_vecteur); 439: return NULL; 440: } 441: 442: if ((colonne = (real8 *) malloc((*s_matrice).nombre_lignes * 443: sizeof(real8))) == NULL) 444: { 445: free(s_vecteur); 446: return NULL; 447: } 448: 449: for(i = 0; i < (*s_matrice).nombre_lignes; i++) 450: { 451: colonne[i] = (real8) ((integer8 **) 452: (*s_matrice).tableau)[i][position]; 453: } 454: 455: (*((real8 *) (*s_vecteur).tableau)) = sommation_vecteur_reel( 456: colonne, &((*s_matrice).nombre_lignes), 457: &erreur_memoire); 458: 459: if (erreur_memoire == d_vrai) 460: { 461: free(s_vecteur); 462: return NULL; 463: } 464: 465: free(colonne); 466: 467: (*s_vecteur).type = 'R'; 468: (*s_vecteur).taille = 1; 469: } 470: } 471: 472: /* 473: * Calculs en virgule flottante 474: */ 475: 476: else if ((*s_matrice).type == 'R') 477: { 478: if (((*s_vecteur).tableau = malloc(sizeof(real8))) == NULL) 479: { 480: free(s_vecteur); 481: return NULL; 482: } 483: 484: if ((colonne = (real8 *) malloc((*s_matrice).nombre_lignes * 485: sizeof(real8))) == NULL) 486: { 487: free(s_vecteur); 488: return NULL; 489: } 490: 491: for(i = 0; i < (*s_matrice).nombre_lignes; i++) 492: { 493: colonne[i] = ((real8 **) (*s_matrice).tableau)[i][position]; 494: } 495: 496: (*((real8 *) (*s_vecteur).tableau)) = sommation_vecteur_reel( 497: colonne, &((*s_matrice).nombre_lignes), &erreur_memoire); 498: 499: if (erreur_memoire == d_vrai) 500: { 501: free(s_vecteur); 502: return NULL; 503: } 504: 505: free(colonne); 506: 507: (*s_vecteur).type = 'R'; 508: (*s_vecteur).taille = 1; 509: } 510: 511: return s_vecteur; 512: } 513: 514: 515: /* 516: ================================================================================ 517: Fonction réalisant la moyenne de la matrice statistique 518: ================================================================================ 519: Entrées : pointeur sur une matrice entière ou réelle 520: -------------------------------------------------------------------------------- 521: Sorties : renvoie NULL s'il y a defaut de mémoire 522: -------------------------------------------------------------------------------- 523: Effets de bord : néant 524: ================================================================================ 525: */ 526: 527: struct_vecteur * 528: moyenne_statistique(struct_matrice *s_matrice) 529: { 530: integer8 *tampon; 531: 532: logical1 resultat_entier; 533: 534: struct_vecteur *s_vecteur; 535: 536: unsigned long i; 537: 538: if ((s_vecteur = sommation_statistique(s_matrice)) == NULL) 539: { 540: return NULL; 541: } 542: 543: if ((*s_vecteur).type == 'R') 544: { 545: for(i = 0; i < (*s_vecteur).taille; i++) 546: { 547: ((real8 *) (*s_vecteur).tableau)[i] /= ((real8) 548: (*s_matrice).nombre_lignes); 549: } 550: } 551: else 552: { 553: resultat_entier = d_vrai; 554: 555: for(i = 0; i < (*s_vecteur).taille; i++) 556: { 557: if ((((integer8 *) (*s_vecteur).tableau)[i] % 558: (*s_matrice).nombre_lignes) != 0) 559: { 560: resultat_entier = d_faux; 561: break; 562: } 563: } 564: 565: if (resultat_entier == d_vrai) 566: { 567: for(i = 0; i < (*s_vecteur).taille; i++) 568: { 569: ((integer8 *) (*s_vecteur).tableau)[i] /= ((integer8) 570: (*s_matrice).nombre_lignes); 571: } 572: } 573: else 574: { 575: tampon = (*s_vecteur).tableau; 576: 577: if (((*s_vecteur).tableau = malloc((*s_vecteur).taille * 578: sizeof(real8))) == NULL) 579: { 580: return NULL; 581: } 582: 583: for(i = 0; i < (*s_vecteur).taille; i++) 584: { 585: ((real8 *) (*s_vecteur).tableau)[i] = ((real8) tampon[i]) / 586: ((real8) (*s_matrice).nombre_lignes); 587: } 588: 589: (*s_vecteur).type = 'R'; 590: free(tampon); 591: } 592: } 593: 594: return s_vecteur; 595: } 596: 597: 598: /* 599: ================================================================================ 600: Fonction réalisant la variance de la matrice statistique 601: ================================================================================ 602: Entrées : pointeur sur une matrice entière ou réelle et type. 603: Type vaut 'E' ou 'P' selon qu'il s'agit de statistiques sur un échantillon 604: ou sur la population entière. 605: -------------------------------------------------------------------------------- 606: Sorties : renvoie NULL s'il y a defaut de mémoire 607: -------------------------------------------------------------------------------- 608: Effets de bord : néant 609: ================================================================================ 610: */ 611: 612: struct_vecteur * 613: variance_statistique(struct_matrice *s_matrice, unsigned char type) 614: { 615: integer8 *tampon; 616: 617: logical1 erreur_memoire; 618: 619: unsigned long i; 620: unsigned long j; 621: 622: real8 *cumul; 623: 624: struct_vecteur *s_moyenne; 625: struct_vecteur *s_variance; 626: 627: if ((s_moyenne = moyenne_statistique(s_matrice)) == NULL) 628: { 629: return NULL; 630: } 631: 632: /* 633: * Le résultat de cette fonction est toujours réel. 634: */ 635: 636: if ((cumul = (real8 *) malloc((*s_matrice).nombre_lignes * sizeof(real8))) 637: == NULL) 638: { 639: return NULL; 640: } 641: 642: if ((s_variance = (struct_vecteur *) malloc(sizeof(struct_vecteur))) 643: == NULL) 644: { 645: return NULL; 646: } 647: 648: if ((*s_moyenne).type == 'I') 649: { 650: tampon = (*s_moyenne).tableau; 651: 652: if (((*s_moyenne).tableau = malloc((*s_moyenne).taille * sizeof(real8))) 653: == NULL) 654: { 655: return NULL; 656: } 657: 658: for(i = 0; i < (*s_moyenne).taille; i++) 659: { 660: ((real8 *) (*s_moyenne).tableau)[i] = (real8) (tampon[i]); 661: } 662: 663: (*s_moyenne).type = 'R'; 664: free(tampon); 665: } 666: 667: if (((*s_variance).tableau = malloc((*s_matrice).nombre_colonnes * 668: sizeof(real8))) == NULL) 669: { 670: return NULL; 671: } 672: 673: if ((*s_matrice).type == 'I') 674: { 675: for(j = 0; j < (*s_matrice).nombre_colonnes; j++) 676: { 677: for(i = 0; i < (*s_matrice).nombre_lignes; i++) 678: { 679: cumul[i] = (((real8) ((integer8 **) (*s_matrice).tableau) 680: [i][j]) - ((real8 *) (*s_moyenne).tableau)[j]) * 681: (((real8) ((integer8 **) (*s_matrice).tableau)[i][j]) - 682: ((real8 *) (*s_moyenne).tableau)[j]); 683: } 684: 685: ((real8 *) (*s_variance).tableau)[j] = sommation_vecteur_reel( 686: cumul, &((*s_matrice).nombre_lignes), &erreur_memoire); 687: 688: if (erreur_memoire == d_vrai) 689: { 690: return NULL; 691: } 692: 693: if (type == 'E') 694: { 695: ((real8 *) (*s_variance).tableau)[j] /= (real8) 696: ((*s_matrice).nombre_lignes - 1); 697: } 698: else 699: { 700: ((real8 *) (*s_variance).tableau)[j] /= (real8) 701: (*s_matrice).nombre_lignes; 702: } 703: } 704: } 705: else 706: { 707: for(j = 0; j < (*s_matrice).nombre_colonnes; j++) 708: { 709: for(i = 0; i < (*s_matrice).nombre_lignes; i++) 710: { 711: cumul[i] = (((real8 **) (*s_matrice).tableau)[i][j] - 712: ((real8 *) (*s_moyenne).tableau)[j]) * 713: (((real8 **) (*s_matrice).tableau)[i][j] - 714: ((real8 *) (*s_moyenne).tableau)[j]); 715: } 716: 717: ((real8 *) (*s_variance).tableau)[j] = sommation_vecteur_reel( 718: cumul, &((*s_matrice).nombre_lignes), &erreur_memoire); 719: 720: if (erreur_memoire == d_vrai) 721: { 722: return NULL; 723: } 724: 725: if (type == 'E') 726: { 727: ((real8 *) (*s_variance).tableau)[j] /= (real8) 728: ((*s_matrice).nombre_lignes - 1); 729: } 730: else 731: { 732: ((real8 *) (*s_variance).tableau)[j] /= (real8) 733: (*s_matrice).nombre_lignes; 734: } 735: } 736: } 737: 738: free((*s_moyenne).tableau); 739: free(s_moyenne); 740: free(cumul); 741: 742: (*s_variance).type = 'R'; 743: (*s_variance).taille = (*s_matrice).nombre_colonnes; 744: 745: return s_variance; 746: } 747: 748: 749: /* 750: ================================================================================ 751: Fonction réalisant l'écart-type de la matrice statistique 752: ================================================================================ 753: Entrées : pointeur sur une matrice entière ou réelle 754: -------------------------------------------------------------------------------- 755: Sorties : renvoie NULL s'il y a defaut de mémoire 756: -------------------------------------------------------------------------------- 757: Effets de bord : néant 758: ================================================================================ 759: */ 760: 761: struct_vecteur * 762: ecart_type_statistique(struct_matrice *s_matrice, unsigned char type) 763: { 764: struct_vecteur *s_vecteur; 765: 766: unsigned long i; 767: 768: if ((s_vecteur = variance_statistique(s_matrice, type)) == NULL) 769: { 770: return NULL; 771: } 772: 773: for(i = 0; i < (*s_vecteur).taille; i++) 774: { 775: ((real8 *) (*s_vecteur).tableau)[i] = sqrt(((real8 *) 776: (*s_vecteur).tableau)[i]); 777: } 778: 779: return s_vecteur; 780: } 781: 782: 783: /* 784: ================================================================================ 785: Fonction réalisant la corrélation de deux colonnes la matrice statistique 786: ================================================================================ 787: Entrées : pointeur sur une matrice entière ou réelle 788: -------------------------------------------------------------------------------- 789: Sorties : 790: -------------------------------------------------------------------------------- 791: Effets de bord : néant 792: ================================================================================ 793: */ 794: 795: real8 796: correlation_statistique(struct_matrice *s_matrice, 797: unsigned long colonne_1, unsigned long colonne_2, logical1 *erreur) 798: { 799: logical1 erreur_memoire; 800: 801: real8 denominateur; 802: real8 moyenne_colonne_1; 803: real8 moyenne_colonne_2; 804: real8 numerateur; 805: real8 *vecteur; 806: 807: unsigned long i; 808: unsigned long nombre_observations; 809: 810: (*erreur) = d_absence_erreur; 811: 812: if ((vecteur = (real8 *) malloc((nombre_observations = 813: (*s_matrice).nombre_lignes) * sizeof(real8))) == NULL) 814: { 815: (*erreur) = d_erreur; 816: return 0; 817: } 818: 819: colonne_1--; 820: colonne_2--; 821: 822: if ((*s_matrice).type == 'R') 823: { 824: for(i = 0; i < nombre_observations; i++) 825: { 826: vecteur[i] = ((real8 **) (*s_matrice).tableau)[i][colonne_1]; 827: } 828: 829: moyenne_colonne_1 = sommation_vecteur_reel(vecteur, 830: &nombre_observations, &erreur_memoire) / nombre_observations; 831: 832: if (erreur_memoire == d_vrai) 833: { 834: (*erreur) = d_erreur; 835: return 0; 836: } 837: 838: for(i = 0; i < nombre_observations; i++) 839: { 840: vecteur[i] = ((real8 **) (*s_matrice).tableau)[i][colonne_2]; 841: } 842: 843: moyenne_colonne_2 = sommation_vecteur_reel(vecteur, 844: &nombre_observations, &erreur_memoire) / nombre_observations; 845: 846: if (erreur_memoire == d_vrai) 847: { 848: (*erreur) = d_erreur; 849: return 0; 850: } 851: 852: for(i = 0; i < nombre_observations; i++) 853: { 854: vecteur[i] = (((real8 **) (*s_matrice).tableau)[i][colonne_1] - 855: moyenne_colonne_1) * (((real8 **) (*s_matrice).tableau) 856: [i][colonne_2] - moyenne_colonne_2); 857: } 858: 859: numerateur = sommation_vecteur_reel(vecteur, &nombre_observations, 860: &erreur_memoire); 861: 862: if (erreur_memoire == d_vrai) 863: { 864: (*erreur) = d_erreur; 865: return 0; 866: } 867: 868: for(i = 0; i < nombre_observations; i++) 869: { 870: vecteur[i] = (((real8 **) (*s_matrice).tableau)[i][colonne_1] - 871: moyenne_colonne_1) * (((real8 **) (*s_matrice).tableau) 872: [i][colonne_1] - moyenne_colonne_1); 873: } 874: 875: denominateur = sommation_vecteur_reel(vecteur, &nombre_observations, 876: &erreur_memoire); 877: 878: if (erreur_memoire == d_vrai) 879: { 880: (*erreur) = d_erreur; 881: return 0; 882: } 883: 884: for(i = 0; i < nombre_observations; i++) 885: { 886: vecteur[i] = (((real8 **) (*s_matrice).tableau)[i][colonne_2] - 887: moyenne_colonne_2) * (((real8 **) (*s_matrice).tableau) 888: [i][colonne_2] - moyenne_colonne_2); 889: } 890: 891: denominateur *= sommation_vecteur_reel(vecteur, &nombre_observations, 892: &erreur_memoire); 893: 894: if (erreur_memoire == d_vrai) 895: { 896: (*erreur) = d_erreur; 897: return 0; 898: } 899: 900: denominateur = sqrt(denominateur); 901: } 902: else 903: { 904: for(i = 0; i < nombre_observations; i++) 905: { 906: vecteur[i] = (real8) ((integer8 **) (*s_matrice).tableau) 907: [i][colonne_1]; 908: } 909: 910: moyenne_colonne_1 = sommation_vecteur_reel(vecteur, 911: &nombre_observations, &erreur_memoire) / nombre_observations; 912: 913: if (erreur_memoire == d_vrai) 914: { 915: (*erreur) = d_erreur; 916: return 0; 917: } 918: 919: for(i = 0; i < nombre_observations; i++) 920: { 921: vecteur[i] = (real8) ((integer8 **) (*s_matrice).tableau) 922: [i][colonne_2]; 923: } 924: 925: moyenne_colonne_2 = sommation_vecteur_reel(vecteur, 926: &nombre_observations, &erreur_memoire) / nombre_observations; 927: 928: if (erreur_memoire == d_vrai) 929: { 930: (*erreur) = d_erreur; 931: return 0; 932: } 933: 934: for(i = 0; i < nombre_observations; i++) 935: { 936: vecteur[i] = (((real8) ((integer8 **) (*s_matrice).tableau) 937: [i][colonne_1]) - moyenne_colonne_1) * (((real8) 938: ((integer8 **) (*s_matrice).tableau) 939: [i][colonne_2]) - moyenne_colonne_2); 940: } 941: 942: numerateur = sommation_vecteur_reel(vecteur, &nombre_observations, 943: &erreur_memoire); 944: 945: if (erreur_memoire == d_vrai) 946: { 947: (*erreur) = d_erreur; 948: return 0; 949: } 950: 951: for(i = 0; i < nombre_observations; i++) 952: { 953: vecteur[i] = (((real8) ((integer8 **) (*s_matrice).tableau) 954: [i][colonne_1]) - moyenne_colonne_1) * (((real8) 955: ((integer8 **) (*s_matrice).tableau) 956: [i][colonne_1]) - moyenne_colonne_1); 957: } 958: 959: denominateur = sommation_vecteur_reel(vecteur, &nombre_observations, 960: &erreur_memoire); 961: 962: if (erreur_memoire == d_vrai) 963: { 964: (*erreur) = d_erreur; 965: return 0; 966: } 967: 968: for(i = 0; i < nombre_observations; i++) 969: { 970: vecteur[i] = (((real8) ((integer8 **) (*s_matrice).tableau) 971: [i][colonne_2]) - moyenne_colonne_2) * (((real8) 972: ((integer8 **) (*s_matrice).tableau) 973: [i][colonne_2]) - moyenne_colonne_2); 974: } 975: 976: denominateur *= sommation_vecteur_reel(vecteur, &nombre_observations, 977: &erreur_memoire); 978: 979: if (erreur_memoire == d_vrai) 980: { 981: (*erreur) = d_erreur; 982: return 0; 983: } 984: 985: denominateur = sqrt(denominateur); 986: } 987: 988: free(vecteur); 989: 990: return numerateur / denominateur; 991: } 992: 993: 994: /* 995: ================================================================================ 996: Fonction réalisant la covariance de deux colonnes la matrice statistique 997: ================================================================================ 998: Entrées : pointeur sur une matrice entière ou réelle 999: -------------------------------------------------------------------------------- 1000: Sorties : 1001: -------------------------------------------------------------------------------- 1002: Effets de bord : néant 1003: ================================================================================ 1004: */ 1005: 1006: real8 1007: covariance_statistique(struct_matrice *s_matrice, 1008: unsigned long colonne_1, unsigned long colonne_2, 1009: unsigned char type, logical1 *erreur) 1010: { 1011: logical1 erreur_memoire; 1012: 1013: real8 denominateur; 1014: real8 moyenne_colonne_1; 1015: real8 moyenne_colonne_2; 1016: real8 numerateur; 1017: real8 *vecteur; 1018: 1019: unsigned long i; 1020: unsigned long nombre_observations; 1021: 1022: (*erreur) = d_absence_erreur; 1023: 1024: if ((vecteur = (real8 *) malloc((nombre_observations = 1025: (*s_matrice).nombre_lignes) * sizeof(real8))) == NULL) 1026: { 1027: (*erreur) = d_erreur; 1028: return 0; 1029: } 1030: 1031: colonne_1--; 1032: colonne_2--; 1033: 1034: if (type == 'E') 1035: { 1036: denominateur = nombre_observations - 1; 1037: } 1038: else 1039: { 1040: denominateur = nombre_observations; 1041: } 1042: 1043: if ((*s_matrice).type == 'R') 1044: { 1045: for(i = 0; i < nombre_observations; i++) 1046: { 1047: vecteur[i] = ((real8 **) (*s_matrice).tableau)[i][colonne_1]; 1048: } 1049: 1050: moyenne_colonne_1 = sommation_vecteur_reel(vecteur, 1051: &nombre_observations, &erreur_memoire) / nombre_observations; 1052: 1053: if (erreur_memoire == d_vrai) 1054: { 1055: (*erreur) = d_erreur; 1056: return 0; 1057: } 1058: 1059: for(i = 0; i < nombre_observations; i++) 1060: { 1061: vecteur[i] = ((real8 **) (*s_matrice).tableau)[i][colonne_2]; 1062: } 1063: 1064: moyenne_colonne_2 = sommation_vecteur_reel(vecteur, 1065: &nombre_observations, &erreur_memoire) / nombre_observations; 1066: 1067: if (erreur_memoire == d_vrai) 1068: { 1069: (*erreur) = d_erreur; 1070: return 0; 1071: } 1072: 1073: for(i = 0; i < nombre_observations; i++) 1074: { 1075: vecteur[i] = (((real8 **) (*s_matrice).tableau)[i][colonne_1] - 1076: moyenne_colonne_1) * (((real8 **) (*s_matrice).tableau) 1077: [i][colonne_2] - moyenne_colonne_2); 1078: } 1079: 1080: numerateur = sommation_vecteur_reel(vecteur, &nombre_observations, 1081: &erreur_memoire); 1082: 1083: if (erreur_memoire == d_vrai) 1084: { 1085: (*erreur) = d_erreur; 1086: return 0; 1087: } 1088: } 1089: else 1090: { 1091: for(i = 0; i < nombre_observations; i++) 1092: { 1093: vecteur[i] = (real8) ((integer8 **) (*s_matrice).tableau) 1094: [i][colonne_1]; 1095: } 1096: 1097: moyenne_colonne_1 = sommation_vecteur_reel(vecteur, 1098: &nombre_observations, &erreur_memoire) / nombre_observations; 1099: 1100: if (erreur_memoire == d_vrai) 1101: { 1102: (*erreur) = d_erreur; 1103: return 0; 1104: } 1105: 1106: for(i = 0; i < nombre_observations; i++) 1107: { 1108: vecteur[i] = (real8) ((integer8 **) (*s_matrice).tableau) 1109: [i][colonne_2]; 1110: } 1111: 1112: moyenne_colonne_2 = sommation_vecteur_reel(vecteur, 1113: &nombre_observations, &erreur_memoire) / nombre_observations; 1114: 1115: if (erreur_memoire == d_vrai) 1116: { 1117: (*erreur) = d_erreur; 1118: return 0; 1119: } 1120: 1121: for(i = 0; i < nombre_observations; i++) 1122: { 1123: vecteur[i] = (((real8) ((integer8 **) (*s_matrice).tableau) 1124: [i][colonne_1]) - moyenne_colonne_1) * (((real8) 1125: ((integer8 **) (*s_matrice).tableau) 1126: [i][colonne_2]) - moyenne_colonne_2); 1127: } 1128: 1129: numerateur = sommation_vecteur_reel(vecteur, &nombre_observations, 1130: &erreur_memoire); 1131: 1132: if (erreur_memoire == d_vrai) 1133: { 1134: (*erreur) = d_erreur; 1135: return 0; 1136: } 1137: } 1138: 1139: free(vecteur); 1140: 1141: return numerateur / denominateur; 1142: } 1143: 1144: // vim: ts=4