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