1: /*
2: ================================================================================
3: RPL/2 (R) version 4.1.13
4: Copyright (C) 1989-2013 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: integer8 i;
51: integer8 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(((size_t) (*s_matrice)
65: .nombre_colonnes) * 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(((size_t) (*s_matrice)
107: .nombre_colonnes) * sizeof(real8))) == NULL)
108: {
109: free(s_vecteur);
110: return NULL;
111: }
112:
113: if ((colonne = (real8 *) malloc(((size_t) (*s_matrice)
114: .nombre_lignes) * 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(((size_t) (*s_matrice)
153: .nombre_colonnes) * sizeof(real8))) == NULL)
154: {
155: free(s_vecteur);
156: return NULL;
157: }
158:
159: if ((colonne = (real8 *) malloc(((size_t) (*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: integer8 position_1, integer8 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: integer8 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(((size_t) (*s_matrice)
285: .nombre_lignes) * 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(((size_t) (*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, integer8 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: integer8 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(((size_t) (*s_matrice)
443: .nombre_lignes) * 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(((size_t) (*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: integer8 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(((size_t) (*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: integer8 i;
620: integer8 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(((size_t) (*s_matrice).nombre_lignes) *
637: sizeof(real8))) == 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(((size_t) (*s_moyenne).taille) *
653: sizeof(real8))) == 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(((size_t) (*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: integer8 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: integer8 colonne_1, integer8 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: integer8 i;
808: integer8 nombre_observations;
809:
810: (*erreur) = d_absence_erreur;
811:
812: if ((vecteur = (real8 *) malloc(((size_t) (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) /
831: ((real8) nombre_observations);
832:
833: if (erreur_memoire == d_vrai)
834: {
835: (*erreur) = d_erreur;
836: return 0;
837: }
838:
839: for(i = 0; i < nombre_observations; i++)
840: {
841: vecteur[i] = ((real8 **) (*s_matrice).tableau)[i][colonne_2];
842: }
843:
844: moyenne_colonne_2 = sommation_vecteur_reel(vecteur,
845: &nombre_observations, &erreur_memoire) /
846: ((real8) nombre_observations);
847:
848: if (erreur_memoire == d_vrai)
849: {
850: (*erreur) = d_erreur;
851: return 0;
852: }
853:
854: for(i = 0; i < nombre_observations; i++)
855: {
856: vecteur[i] = (((real8 **) (*s_matrice).tableau)[i][colonne_1] -
857: moyenne_colonne_1) * (((real8 **) (*s_matrice).tableau)
858: [i][colonne_2] - moyenne_colonne_2);
859: }
860:
861: numerateur = sommation_vecteur_reel(vecteur, &nombre_observations,
862: &erreur_memoire);
863:
864: if (erreur_memoire == d_vrai)
865: {
866: (*erreur) = d_erreur;
867: return 0;
868: }
869:
870: for(i = 0; i < nombre_observations; i++)
871: {
872: vecteur[i] = (((real8 **) (*s_matrice).tableau)[i][colonne_1] -
873: moyenne_colonne_1) * (((real8 **) (*s_matrice).tableau)
874: [i][colonne_1] - moyenne_colonne_1);
875: }
876:
877: denominateur = sommation_vecteur_reel(vecteur, &nombre_observations,
878: &erreur_memoire);
879:
880: if (erreur_memoire == d_vrai)
881: {
882: (*erreur) = d_erreur;
883: return 0;
884: }
885:
886: for(i = 0; i < nombre_observations; i++)
887: {
888: vecteur[i] = (((real8 **) (*s_matrice).tableau)[i][colonne_2] -
889: moyenne_colonne_2) * (((real8 **) (*s_matrice).tableau)
890: [i][colonne_2] - moyenne_colonne_2);
891: }
892:
893: denominateur *= sommation_vecteur_reel(vecteur, &nombre_observations,
894: &erreur_memoire);
895:
896: if (erreur_memoire == d_vrai)
897: {
898: (*erreur) = d_erreur;
899: return 0;
900: }
901:
902: denominateur = sqrt(denominateur);
903: }
904: else
905: {
906: for(i = 0; i < nombre_observations; i++)
907: {
908: vecteur[i] = (real8) ((integer8 **) (*s_matrice).tableau)
909: [i][colonne_1];
910: }
911:
912: moyenne_colonne_1 = sommation_vecteur_reel(vecteur,
913: &nombre_observations, &erreur_memoire) /
914: ((real8) nombre_observations);
915:
916: if (erreur_memoire == d_vrai)
917: {
918: (*erreur) = d_erreur;
919: return 0;
920: }
921:
922: for(i = 0; i < nombre_observations; i++)
923: {
924: vecteur[i] = (real8) ((integer8 **) (*s_matrice).tableau)
925: [i][colonne_2];
926: }
927:
928: moyenne_colonne_2 = sommation_vecteur_reel(vecteur,
929: &nombre_observations, &erreur_memoire) /
930: ((real8) nombre_observations);
931:
932: if (erreur_memoire == d_vrai)
933: {
934: (*erreur) = d_erreur;
935: return 0;
936: }
937:
938: for(i = 0; i < nombre_observations; i++)
939: {
940: vecteur[i] = (((real8) ((integer8 **) (*s_matrice).tableau)
941: [i][colonne_1]) - moyenne_colonne_1) * (((real8)
942: ((integer8 **) (*s_matrice).tableau)
943: [i][colonne_2]) - moyenne_colonne_2);
944: }
945:
946: numerateur = sommation_vecteur_reel(vecteur, &nombre_observations,
947: &erreur_memoire);
948:
949: if (erreur_memoire == d_vrai)
950: {
951: (*erreur) = d_erreur;
952: return 0;
953: }
954:
955: for(i = 0; i < nombre_observations; i++)
956: {
957: vecteur[i] = (((real8) ((integer8 **) (*s_matrice).tableau)
958: [i][colonne_1]) - moyenne_colonne_1) * (((real8)
959: ((integer8 **) (*s_matrice).tableau)
960: [i][colonne_1]) - moyenne_colonne_1);
961: }
962:
963: denominateur = sommation_vecteur_reel(vecteur, &nombre_observations,
964: &erreur_memoire);
965:
966: if (erreur_memoire == d_vrai)
967: {
968: (*erreur) = d_erreur;
969: return 0;
970: }
971:
972: for(i = 0; i < nombre_observations; i++)
973: {
974: vecteur[i] = (((real8) ((integer8 **) (*s_matrice).tableau)
975: [i][colonne_2]) - moyenne_colonne_2) * (((real8)
976: ((integer8 **) (*s_matrice).tableau)
977: [i][colonne_2]) - moyenne_colonne_2);
978: }
979:
980: denominateur *= sommation_vecteur_reel(vecteur, &nombre_observations,
981: &erreur_memoire);
982:
983: if (erreur_memoire == d_vrai)
984: {
985: (*erreur) = d_erreur;
986: return 0;
987: }
988:
989: denominateur = sqrt(denominateur);
990: }
991:
992: free(vecteur);
993:
994: return numerateur / denominateur;
995: }
996:
997:
998: /*
999: ================================================================================
1000: Fonction réalisant la covariance de deux colonnes la matrice statistique
1001: ================================================================================
1002: Entrées : pointeur sur une matrice entière ou réelle
1003: --------------------------------------------------------------------------------
1004: Sorties :
1005: --------------------------------------------------------------------------------
1006: Effets de bord : néant
1007: ================================================================================
1008: */
1009:
1010: real8
1011: covariance_statistique(struct_matrice *s_matrice, integer8 colonne_1,
1012: integer8 colonne_2, unsigned char type, logical1 *erreur)
1013: {
1014: logical1 erreur_memoire;
1015:
1016: real8 denominateur;
1017: real8 moyenne_colonne_1;
1018: real8 moyenne_colonne_2;
1019: real8 numerateur;
1020: real8 *vecteur;
1021:
1022: integer8 i;
1023: integer8 nombre_observations;
1024:
1025: (*erreur) = d_absence_erreur;
1026:
1027: if ((vecteur = (real8 *) malloc(((size_t) (nombre_observations =
1028: (*s_matrice).nombre_lignes)) * sizeof(real8))) == NULL)
1029: {
1030: (*erreur) = d_erreur;
1031: return 0;
1032: }
1033:
1034: colonne_1--;
1035: colonne_2--;
1036:
1037: if (type == 'E')
1038: {
1039: denominateur = ((real8) nombre_observations) - 1;
1040: }
1041: else
1042: {
1043: denominateur = ((real8) nombre_observations);
1044: }
1045:
1046: if ((*s_matrice).type == 'R')
1047: {
1048: for(i = 0; i < nombre_observations; i++)
1049: {
1050: vecteur[i] = ((real8 **) (*s_matrice).tableau)[i][colonne_1];
1051: }
1052:
1053: moyenne_colonne_1 = sommation_vecteur_reel(vecteur,
1054: &nombre_observations, &erreur_memoire) /
1055: ((real8) nombre_observations);
1056:
1057: if (erreur_memoire == d_vrai)
1058: {
1059: (*erreur) = d_erreur;
1060: return 0;
1061: }
1062:
1063: for(i = 0; i < nombre_observations; i++)
1064: {
1065: vecteur[i] = ((real8 **) (*s_matrice).tableau)[i][colonne_2];
1066: }
1067:
1068: moyenne_colonne_2 = sommation_vecteur_reel(vecteur,
1069: &nombre_observations, &erreur_memoire) /
1070: ((real8) nombre_observations);
1071:
1072: if (erreur_memoire == d_vrai)
1073: {
1074: (*erreur) = d_erreur;
1075: return 0;
1076: }
1077:
1078: for(i = 0; i < nombre_observations; i++)
1079: {
1080: vecteur[i] = (((real8 **) (*s_matrice).tableau)[i][colonne_1] -
1081: moyenne_colonne_1) * (((real8 **) (*s_matrice).tableau)
1082: [i][colonne_2] - moyenne_colonne_2);
1083: }
1084:
1085: numerateur = sommation_vecteur_reel(vecteur, &nombre_observations,
1086: &erreur_memoire);
1087:
1088: if (erreur_memoire == d_vrai)
1089: {
1090: (*erreur) = d_erreur;
1091: return 0;
1092: }
1093: }
1094: else
1095: {
1096: for(i = 0; i < nombre_observations; i++)
1097: {
1098: vecteur[i] = (real8) ((integer8 **) (*s_matrice).tableau)
1099: [i][colonne_1];
1100: }
1101:
1102: moyenne_colonne_1 = sommation_vecteur_reel(vecteur,
1103: &nombre_observations, &erreur_memoire) /
1104: ((real8) nombre_observations);
1105:
1106: if (erreur_memoire == d_vrai)
1107: {
1108: (*erreur) = d_erreur;
1109: return 0;
1110: }
1111:
1112: for(i = 0; i < nombre_observations; i++)
1113: {
1114: vecteur[i] = (real8) ((integer8 **) (*s_matrice).tableau)
1115: [i][colonne_2];
1116: }
1117:
1118: moyenne_colonne_2 = sommation_vecteur_reel(vecteur,
1119: &nombre_observations, &erreur_memoire) /
1120: ((real8) nombre_observations);
1121:
1122: if (erreur_memoire == d_vrai)
1123: {
1124: (*erreur) = d_erreur;
1125: return 0;
1126: }
1127:
1128: for(i = 0; i < nombre_observations; i++)
1129: {
1130: vecteur[i] = (((real8) ((integer8 **) (*s_matrice).tableau)
1131: [i][colonne_1]) - moyenne_colonne_1) * (((real8)
1132: ((integer8 **) (*s_matrice).tableau)
1133: [i][colonne_2]) - moyenne_colonne_2);
1134: }
1135:
1136: numerateur = sommation_vecteur_reel(vecteur, &nombre_observations,
1137: &erreur_memoire);
1138:
1139: if (erreur_memoire == d_vrai)
1140: {
1141: (*erreur) = d_erreur;
1142: return 0;
1143: }
1144: }
1145:
1146: free(vecteur);
1147:
1148: return numerateur / denominateur;
1149: }
1150:
1151: // 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