LES SERIES STATISTIQUES !

#include <stdio.h>
#include <conio.h>
#include <stdlib.h>
#include <math.h>
// -------------------------------------------------------
// un groupe est une valeur affectee d'un coefficient
typedef struct TagGROUPE
  {
  double valeur;
  double effectif;
  }GROUPE,*P_GROUPE;
// donnees sur une serie statistique
typedef struct TagSERIE
  {
  int       nbGroupe;             // le nombre de groupe
  P_GROUPE  pGroupe;              // les groupes de la serie
  P_GROUPE  *ppGroupeTri;         // les groupes de la serie
                                  // tries par ordre croissant
                                  // des valeurs
                                  // (pointeurs sur les groupes !)
  double    totalEffectif;        // effevtf total
  double    *pEffectifsCumules;   // les effectifs cumules

  double min;                     // minimum
  double max;                     // maximum
  double moy;                     // moyenne
  double ecartType;               // ecart-type
  double variance;                // variance

  double med;                     // mediane
  double Q1;                      // quartile 1
  double Q3;                      // quartile 3
  double D1;                      // decile 1
  double D9;                      // decile 9

  }SERIE,*P_SERIE;



// -------------------------------------------------------
#define Malloc(type,nb) (type *)_Malloc((nb)*sizeof(type))
void *_Malloc(size_t size)
{
void *p;
// on alloue
if((p = malloc(size)) == NULL)
  {
  // s'il y a une erreur !
  printf("\nImpossible d'allouer %d octets !\n",size);
  exit(1);
  }
return p;
}
// -------------------------------------------------------
double InputDouble(void)
{
char buf[256];
return atof(gets(buf));
}
// -------------------------------------------------------
int InputInt(void)
{
char buf[256];
return atoi(gets(buf));
}
// -------------------------------------------------------
P_SERIE NouvelleSerie(int nbGroupe)
{
P_SERIE pSerie;
// on alloue la place neccesaire !
pSerie                 = Malloc(SERIE,1);
// on initialise quelque champs primordiaux !
pSerie->nbGroupe             = nbGroupe;
pSerie->pGroupe              = Malloc(GROUPE,nbGroupe);
pSerie->ppGroupeTri          = Malloc(P_GROUPE,nbGroupe);
pSerie->pEffectifsCumules    = Malloc(double,nbGroupe);
// on retourne la serie
return pSerie;
}
// -------------------------------------------------------
void SupprimerSerie(P_SERIE p)
{
// on supprime les groupes:
free(p->pGroupe);
// on supprime le rangement des groupes
free(p->ppGroupeTri);
// on supprime les effectifs cumules
free(p->pEffectifsCumules);
// on supprime le serie
free(p);
}
// -------------------------------------------------------
P_SERIE InputSerie(char *NomDeLaSerie)
{
P_SERIE   p;
int       nbGroupe;
P_GROUPE  pCur;
int       i;

printf("Serie : %s\n",NomDeLaSerie);
// on demande combien il y a de groupes
do
  {
  printf("Veuillez entrer les nombres de groupes :\n");
  nbGroupe = InputInt();
  }while(nbGroupe <= 0);
// on creer la nouvelle serie :
p = NouvelleSerie(nbGroupe);
// on rentre toutes les valeurs et tous les effectifs
pCur = p->pGroupe;
i    = 1;

while(i <= nbGroupe)
  {
  // la valeur
  printf("Valeur #%d :\n",i);
  pCur->valeur = InputDouble();

  // l'effectif ( > 0);
  do
    {
    printf("Effectif #%d :\n",i);
    pCur->effectif = InputDouble();
    }while(pCur->effectif <= 0);

  // groupe suivant
  i    ++;
  pCur ++;
  }

// on retourne la serie:
return p;
}
// -------------------------------------------------------
void CalculTotalEffectif(P_SERIE p)
{
int       i;
double    somme;
P_GROUPE  pCur;

somme = 0;
i     = p->nbGroupe;
pCur  = p->pGroupe;

while(i--)
  {
  somme += pCur->effectif;
  pCur  ++;
  }
p->totalEffectif = somme;
}
// -------------------------------------------------------
void CalculMoyenne(P_SERIE p)
{
int      i;
double   somme;
P_GROUPE pCur;

somme = 0;
i     = p->nbGroupe;
pCur  = p->pGroupe;

while(i--)
  {
  somme += (pCur->effectif) * (pCur->valeur);
  pCur  ++;
  }

p->moy = somme / (p->totalEffectif);
}
// -------------------------------------------------------
void CalculMin(P_SERIE p)
{
int      nbGroupe   = p->nbGroupe;
P_GROUPE pCur       = p->pGroupe;
double   curMin     = pCur->valeur;

while(--nbGroupe)
  if((++pCur)->valeur < curMin)
    curMin = pCur->valeur;
p->min = curMin;
}
// -------------------------------------------------------
void CalculMax(P_SERIE p)
{
int      nbGroupe   = p->nbGroupe;
P_GROUPE pCur       = p->pGroupe;
double   curMax     = pCur->valeur;

while(--nbGroupe)
  if((++pCur)->valeur > curMax)
    curMax = pCur->valeur;
p->max = curMax;
}
// -------------------------------------------------------
void CalculTri(P_SERIE p)
{
int         nbNombreTries    = 0;
double      max              = p->max;
double      prevMax          = p->max;
int         nbGroupe         = p->nbGroupe;
P_GROUPE    *ppTri           = &((p->ppGroupeTri)[nbGroupe - 1]);

while(nbNombreTries < nbGroupe)
  {
  int      i;
  P_GROUPE pCur     = p->pGroupe;
  double   nextMax  = p->min;

  for(i=0;i<nbGroupe;i++,pCur++)
    {
    if(pCur->valeur == max)
      {
      *(ppTri--) = pCur;
      nbNombreTries ++;
      }
    else if(pCur->valeur > nextMax && pCur->valeur < prevMax)
      {
      nextMax = pCur->valeur;
      }
    }
  prevMax = max;
  max = nextMax;
  }
}
// -------------------------------------------------------
// 
// 
//        ------                        2
//         \               (          )  
//          >     n    *  (     x      )
//         /       i       (     i    )
//        ------                                            2
//                                                    ( _ )
//  V = -------------------------------------     -  (  x  )
//                                                    (   )
//        ------
//         \ 
//          >     n
//         /       i
//        ------
// 
void CalculVariance(P_SERIE p)
{
double    somme;
int       i;
P_GROUPE  pCur;

somme = 0;
i     = p->nbGroupe;
pCur  = p->pGroupe;

while(i--)
  {
  somme += (pCur->effectif * pCur->valeur * pCur->valeur);
  pCur ++;
  }

p->variance = ((somme)/p->totalEffectif) - (p->moy * p->moy);
}
// -------------------------------------------------------
// s = | Rac(V) |
void CalculEcartType(P_SERIE p)
{
p->ecartType = sqrt(fabs(p->variance));
}
// -------------------------------------------------------
void CalculEffectifCumules(P_SERIE p)
{
double    somme;
int       i;
P_GROUPE  *ppCur;
double    *pEff;

somme = 0;
i     = p->nbGroupe;
ppCur = p->ppGroupeTri;
pEff  = p->pEffectifsCumules;

while(i--)
  {
  somme    += (*ppCur)->effectif;
  *pEff    = somme;
  ppCur    ++;
  pEff     ++;
  }
}
// -------------------------------------------------------
double ChercherNombreAPartirDesEffectifsCumules(P_SERIE p,double n)
{
int       i;
double    *pEff;

i     = p->nbGroupe;
pEff  = p->pEffectifsCumules;

while(i--)
  {
  if(n <= *pEff)
    {
    int a;
    a = (pEff - (p->pEffectifsCumules));
    return ((p->ppGroupeTri)[a])->valeur;
    }
  pEff     ++;
  }
return 0;
}
// -------------------------------------------------------
void CalculQuartile1(P_SERIE p)
{
p->Q1 = ChercherNombreAPartirDesEffectifsCumules(p,(p->totalEffectif)/4);
}
// -------------------------------------------------------
void CalculQuartile3(P_SERIE p)
{
p->Q3 = ChercherNombreAPartirDesEffectifsCumules(p,3*(p->totalEffectif)/4);
}
// -------------------------------------------------------
void CalculMediane(P_SERIE p)
{
p->med = ChercherNombreAPartirDesEffectifsCumules(p,(p->totalEffectif)/2);
}
// -------------------------------------------------------
void CalculDecile1(P_SERIE p)
{
p->D1 = ChercherNombreAPartirDesEffectifsCumules(p,(p->totalEffectif)/10);
}
// -------------------------------------------------------
void CalculDecile9(P_SERIE p)
{
p->D9 = ChercherNombreAPartirDesEffectifsCumules(p,9*(p->totalEffectif)/10);
}

// -------------------------------------------------------
void CalculSerie(P_SERIE p)
{
// l'ordre est tres important
CalculTotalEffectif(p);
CalculMoyenne(p);
CalculMax(p);
CalculMin(p);
CalculTri(p);
CalculVariance(p);
CalculEcartType(p);
CalculEffectifCumules(p);
CalculDecile1(p);
CalculQuartile1(p);
CalculMediane(p);
CalculQuartile3(p);
CalculDecile9(p);
}
// -------------------------------------------------------
int main(int argc,char **argv)
{
P_SERIE p;
int i;
P_GROUPE *pp;
double *pEff;

p = InputSerie("essai !");
printf("\nCalcul ...\n\n");
CalculSerie(p);

printf("Le maximun est de ............ %lf\n",p->max);
printf("Le minimum est de ............ %lf\n",p->min);
printf("Le nombre d'effectif est de .. %lf\n",p->totalEffectif);
printf("La moyenne est de ............ %lf\n",p->moy);
printf("La variance est de ........... %lf\n",p->variance);
printf("L'ecart type est de .......... %lf\n",p->ecartType);
printf("D1 ........................... %lf\n",p->D1);
printf("Q1 ........................... %lf\n",p->Q1);
printf("La mediane est de ............ %lf\n",p->med);
printf("Q3 ........................... %lf\n",p->Q3);
printf("D9 ........................... %lf\n",p->D9);

printf("\n");

i    = p->nbGroupe;
pp   = p->ppGroupeTri;
pEff = p->pEffectifsCumules;
while(i--)
  {
  printf("{ %10.05lf , %10.05lf , %10.05lf }\n",
    (*pp)->valeur,
    (*pp)->effectif,
    *pEff
    );

  pp   ++;
  pEff ++;
  }

SupprimerSerie(p);

getch();
return 0;
}