Les series statistiques !

Commenter

Contenu du snippet

Voici la premiere version d'un getionnaire de serie statistiques en mode texte.
(la second dans quelque semaines en mode graphique ...)

Il y a tres peut de commentaire !
Je l'ai fais aujourd'hui en 2 heures ! donc s'il y a des bugs faites moi signe !!!

Source / Exemple : 


#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;
}

A voir également

S'inscrire maintenant

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.

Du même auteur (cs_JCDjcd)