Annotation of rpl/src/statistiques.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 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
CVSweb interface <joel.bertrand@systella.fr>
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to statistiques.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [local] / rpl / src