![[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|
Return to statistiques.c CVS log | Up to [local] / rpl / src |
1.1 bertrand 1: /*
2: ================================================================================
1.25 ! bertrand 3: RPL/2 (R) version 4.1.1
1.15 bertrand 4: Copyright (C) 1989-2011 Dr. BERTRAND Joël
1.1 bertrand 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:
1.11 bertrand 23: #include "rpl-conv.h"
1.1 bertrand 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