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