j'ai ecrit une fonction
qui fait appele a d'autre fonction.
 
quand je teste les fonctions auquelles elles
fait appelle, toutes ces fonctions marche bien.
 
par contre quand je fais un appel a la fonction qui  
englobe tout ca ne marche pas.
 
ca me met tout à 0 au lieu de calculer un resultat.
 
quelq'un saurait pourquoi?

Je crois qu'il y a un problème à la ligne 5 de la fonction qui englobe les autres.

non serieux
je n'arrive vraiment pas a comprendre ce qui se passe

T'as pas envie de passer une nuit avec moi ?

je parle serieux
j'ai un probleme de programmation que
je n'arrive pas a resoudre
alors ne dit pas de betise

Zut, j'ai laissé tomber ma boule de cristal. Désolé, je ne peux plus te répondre.
 
(Sérieux, poste ton code, on est pas devins...)

j'appelle une fonction construire_groupe qui
utilise une fonction calcul_groupe.
la fonction calcul_groupe utilise la fonction distance
et c'est la que j'ai une erreur
dist[i] est toujours egal a 0, et quand je teste juste la fonction
distance elle me met le bon chiffre.
 
je cherche depuis un moment mais je ne voit pas d'ou viens cette
erreur.
 
le fichier C est regression.c
le fichier de données est donnees.txt
et la commande est ./a.out donnees.txt 2 1
 
/****************************************************************************************************/
/*                                                                                                  */
/*                                                                                                  */                                                   */
/*                         Classification a l'aide de la regression lineraire                       */
/*                                                                                                  */
/*                                                                                                  */
/****************************************************************************************************/                                                  
 
 
/****************************************************************************************************/
/*inclusion des fichiers necessaires au programme                                                   */
/****************************************************************************************************/
#include <stdio.h>
#include  <string.h>
#include <math.h>
#include <stdlib.h>  
 
/****************************************************************************************************/
/*declarations des differentes fonctions                                                            */
/****************************************************************************************************/
void initialise_int(int i, int tab[]);
void initialise_float(int i, float tab[]);
float total (float tab[],int n);
float moyenne(float total,int n);
void remplir_aleatoire_groupe(int tab[],int nb_ind,int nb_grp);
int calcul_nb_individu_groupe(int groupe[],int k,int n);
float  calcul_somme1(float x[],float y[],int groupe[],int n,int num_grp);
float calcul_somme2(float x[],int groupe[],int n,float moyenne,int num_grp);
float calcul_a(float somme1,float somme2,float x_barre,float y_barre,int n);
float calcul_b(float x_barre,float y_barre,float a);
void regression_groupe(float x[],float y[],int groupe[],int nb_grp,int num_grp,int nb_ind,float a[],float b[]);
void calcul_y_chapeau(float x[],float a[], float b[],int groupe[],float y_chapeau[],int n);
void calcul_tout_y_chapeau(float x[],float a[], float b[],int groupe[],float y_chapeau[],int nb_ind);
void regression(float x[],float y[],int groupe[],int nb_grp,int nb_ind,float a[],float b[],float y_chapeau[]);
void sortie_html(float x[],float y[],int groupe[],float a[],float b[],float y_chapeau[],int nb_groupe,int nb_individu);
float distance(int num_ind,int num_grp,float a[],float b[],float x[],float y[]);
int index_min(float tab[],int n);
int calcul_groupe(int num_ind,int nb_grp,float a[],float b[],float x[],float y[]);
void construire_groupe(int nb_ind,int nb_grp,float a[],float b[],float x[],float y[],int groupe[]);
 
 
/****************************************************************************************************/
/*fonction principale                                                                               */
/****************************************************************************************************/
main (int argc, char* argv[]) {
   
  //declarations variables
  char fichier[256];
  FILE *stream;
  int i= 0;
  int j = 0;
  int k=0;
  int l =0;  
  float valeur1 = 0;
  float valeur2 = 0;
  float *x;
  float *y;
  int *groupe;
  float *a;
  float *b;
  float *y_chapeau;  
  int nb_individu = 0;
  int nb_groupe = 0;
  int nb_iteration =0;
   
  //test sur le nombre d'arguments  
  if (argc !=4) {
    printf("Vous devez entrer trois paramètres : le nom du fichier, le nombre de classes et le nombre d'itérations de l'algorithme\n" );
    exit(-1);  
  }
   
 
  //affectation du nombre de groupe
  nb_groupe = atoi(argv[2]);
   
  //affectation du nombre d'iteration
  nb_iteration = atoi(argv[3]);
 
  //comptage du nombre d'individu  
  sprintf(fichier,"%s",argv[1]);
  stream = fopen(fichier,"r" );
 if (stream == NULL) {
    printf("Le fichier %s est inexistant\n",fichier);
    exit(-1);
  }
 else {  
while (!feof(stream)) {
    fscanf(stream,"%f",&valeur1);
    i++;
  }
  fclose(stream);
 }  
  nb_individu = i/2;  
   
  //test sur le nombre de groupe
  if ((nb_groupe<1)||(nb_groupe>nb_individu-1)) {
  printf("Le nombre de groupe est incorrect\n" );
    exit(-1);  
  }
 
  //test sur le nombre d'iteration
  if (nb_iteration<1) {
    printf("Le nombre d'iterations est incorrect\n" );
    exit(-1);
  }
 
   
  // allocation dynamique
  x= (float *)malloc(sizeof(float)*nb_individu);
  y= (float *)malloc(sizeof(float)*nb_individu);
  groupe= (int *)malloc(sizeof(int)*nb_individu);
  a= (float *)malloc(sizeof(float)*nb_groupe);
  b= (float *)malloc(sizeof(float)*nb_groupe);
  y_chapeau=(float *)malloc(sizeof(float)*nb_individu);
   
   
 
  //initialisation des tableau
  initialise_float(nb_individu,x);
  initialise_float(nb_individu,y);
  initialise_int(nb_individu,groupe);
  initialise_float(nb_groupe,a);
  initialise_float(nb_groupe,b);
  initialise_float(nb_individu,y_chapeau);
 
  //remplissage des X et Y
  stream = fopen(fichier,"r" );
  while (!feof(stream)) {
    fscanf(stream,"%f",&valeur1);
    x[j]=valeur1;
    fscanf(stream,"%f",&valeur2);
    y[j]= valeur2;
    j++;
  }
  fclose(stream);  
 
    //tirage aleatoirement des groupes
  remplir_aleatoire_groupe(groupe,nb_individu,nb_groupe);
   
  //calcule des differents coeff pour chaque groupe et individu
  regression(x,y,groupe,nb_groupe,nb_individu,a,b,y_chapeau);  
   
  // construire_groupe(nb_individu,nb_groupe,a,b,x,y,groupe);
   
  //affichage du resulat de l'analyse
  sortie_html(x,y,groupe,a,b,y_chapeau,nb_groupe,nb_individu) ;  
}
 
 
 
 
 
/****************************************************************************************************/
/*initialise a 0 un tableau d'entier                                                                */
/****************************************************************************************************/  
void initialise_int(int i, int tab[]) {
  int j;
  for (j=0;j<i;j++) {
    tab[j] =0;
  }
}
 
/****************************************************************************************************/
/*initialise a 0 un tableau de decimaux                                                             */
/****************************************************************************************************/  
void initialise_float(int i, float tab[]) {
  int j;
  for (j=0;j<i;j++) {
    tab[j] =0;
  }
}
 
 
 
/****************************************************************************************************/
/*calcule le total des elements d'un tableau                                                        */
/****************************************************************************************************/
float total (float tab[],int n) {
  int i;
  int total = 0;
  for (i=0;i<n;i++) {
    total += tab[i];
  }
  return(total);
}
 
 
/****************************************************************************************************/
/*calcule la moyenne                                                                                */
/****************************************************************************************************/      
float moyenne(float total,int n) {
  float moyenne =0;
  moyenne = total/n;
  return(moyenne);
}
 
 
/****************************************************************************************************/
/*tire aleatoirement les groupes                                                                    */
/****************************************************************************************************/
void remplir_aleatoire_groupe(int groupe[],int nb_ind,int nb_grp) {
  int i;
  for (i=0;i<nb_ind;i++) {
    groupe[i] = rand()% (nb_grp);
  }
}
 
/****************************************************************************************************/
/*calcule le nombre d'individu dans un groupe                                                       */
/****************************************************************************************************/
int calcul_nb_individu_groupe(int groupe[],int k,int n) {
  int i=0;
  int nb_individu_groupe =0;
  for (i=0;i<n;i++) {
    if (groupe[i]==k) {
      nb_individu_groupe++;
    }
  }
  return (nb_individu_groupe);
}
 
 
/****************************************************************************************************/
/*calcule la somme des Xi*Yi                                                                        */
/****************************************************************************************************/
float  calcul_somme1(float x[],float y[],int groupe[],int n,int num_grp) {
  int i=0;
  float somme1 =0;
  for (i=0;i<n;i++) {
    if (groupe[i]==num_grp) {
      somme1 += x[i]*y[i];
    }  
  }
  return (somme1);
}
 
 
/****************************************************************************************************/
/*calcule les moindres carres                                                                       */
/****************************************************************************************************/
float calcul_somme2(float x[],int groupe[],int n,float moyenne,int num_grp) {
  int i;
  float somme2 = 0;
  for (i=0;i<n;i++) {
    if (groupe[i]==num_grp) {
      somme2 += (x[i]-moyenne)*(x[i]-moyenne);
    }
  }
  return (somme2);
}
 
 
/****************************************************************************************************/
/*calcule le coefficient a                                                                          */
/****************************************************************************************************/  
float calcul_a(float somme1,float somme2,float x_barre,float y_barre,int n) {
  float a =0;
  a = (somme1 - (n*x_barre*y_barre))/somme2;
  return (a);
}
 
/****************************************************************************************************/
/*calcule le coefficient b                                                                          */
/****************************************************************************************************/
float calcul_b(float x_barre,float y_barre,float a) {
  float b =0;
  b= y_barre-(a*x_barre);
  return (b);
}
 
/****************************************************************************************************/
/*calcule les coefficients a et b pour un groupe                                                    */
/****************************************************************************************************/        
void regression_groupe(float x[],float y[],int groupe[],int nb_grp,int num_grp,int nb_ind,float a[],float b[]) {
  float totalx =0;
  float totaly =0;
  float x_barre = 0;
  float y_barre = 0;
  float somme1 =0;
  float somme2 =0;
  int i = 0;
  int nb_individu_groupe=0;
   
  totalx = total(x,nb_ind);
  totaly = total(y,nb_ind);
  x_barre = moyenne(totalx,nb_ind);
  y_barre = moyenne(totaly,nb_ind);
  nb_individu_groupe=calcul_nb_individu_groupe(groupe,num_grp,nb_ind);  
  if (nb_individu_groupe >0) {
  somme1= calcul_somme1(x,y,groupe,nb_ind,num_grp);
  somme2= calcul_somme2(x,groupe,nb_ind,x_barre,num_grp);
  a[num_grp] = calcul_a(somme1,somme2,x_barre,y_barre,nb_individu_groupe);
  b[num_grp] = calcul_b(x_barre,y_barre,a[num_grp]);
}
  else {
    a[num_grp]=0;
    b[num_grp]=0;
  }
}
/****************************************************************************************************/
/*calcule les valeurs de a,b,y_chapeau et residu pour tous les groupes                              */
/****************************************************************************************************/
void regression(float x[],float y[],int groupe[],int nb_grp,int nb_ind,float a[],float b[],float y_chapeau[]) {
  int i=0;
  for (i=0;i<nb_grp;i++) {
    regression_groupe(x,y,groupe,nb_grp,i,nb_ind,a,b);
  }
  calcul_tout_y_chapeau(x,a,b,groupe,y_chapeau,nb_ind);
}
 
 
/****************************************************************************************************/
/*calcule y_chapeau pour un individu                                                                */
/****************************************************************************************************/
void calcul_y_chapeau(float x[],float a[], float b[],int groupe[],float y_chapeau[],int n) {
  int i =0;
  i = groupe[n];  
  y_chapeau[n] = (a[i]*x[n])+b[i];
}
 
/****************************************************************************************************/
/*calcule y_chapeau pour tous les individus                                                         */
/****************************************************************************************************/
void calcul_tout_y_chapeau(float x[],float a[], float b[],int groupe[],float y_chapeau[],int nb_ind) {
  int i =0;
  for (i=0;i<nb_ind;i++) {
    calcul_y_chapeau(x,a,b,groupe,y_chapeau,i);
  }
}
 
/****************************************************************************************************/
/*calcule la distance d'un individu a un groupe                                                     */
/****************************************************************************************************/
float distance(int num_ind,int num_grp,float a[],float b[],float x[],float y[]) {
  float y_chapeau =0;
  float dist =0;
  y_chapeau = a[num_grp]*x[num_ind]+b[num_grp];
  dist = (y[num_ind]-y_chapeau)*(y[num_ind]-y_chapeau);
   
}
 
/****************************************************************************************************/
/*retourne l'index du plus petit element d'un tableau                                               */
/****************************************************************************************************/
int index_min(float tab[],int n) {
  int index=0;  
  int i=0;
  for (i=1;i<n;i++) {
    if (tab[i]<tab[index]) {
      index=i;
    }
  }
  return (index);
}
 
/****************************************************************************************************/
/*calcul le nouveau groupe d'un individu en fonction des distances                                  */
/****************************************************************************************************/
int calcul_groupe(int num_ind,int nb_grp,float a[],float b[],float x[],float y[]) {
  float dist[3];
  int i=0;
  int res =0;
  for (i=0;i<nb_grp;i++) {
          dist[i] = distance(num_ind,i,a,b,x,y);
  }
     res = index_min(dist,nb_grp);
  return (res);
}
 
 
/****************************************************************************************************/
/*construit les nouveaux groupes en fonction des distances                                          */
/****************************************************************************************************/
void construire_groupe(int nb_ind,int nb_grp,float a[],float b[],float x[],float y[],int groupe[]) {
  int i=0;
  for (i=0;i<nb_ind;i++) {
    groupe[i] = calcul_groupe(i,nb_grp,a,b,x,y);
  }
}
 
 
 
 
 
 
 
/****************************************************************************************************/
/*affiche les resultats de l'analyse                                                                */
/****************************************************************************************************/
void sortie_html(float x[],float y[],int groupe[],float a[],float b[],float y_chapeau[],int nb_groupe,int nb_individu) {
  FILE *sortie;
  char nom_fichier[256];
  int i=0;
  int j=0;
   
  printf("\nEntrez le nom du fichier dans lequel vous desirez entrer vos resultats\n" );
  scanf("%s",nom_fichier);
  strcat(nom_fichier,".html" );
  sortie = fopen(nom_fichier,"w" );
   
  if (sortie == NULL) {
    printf("\nLe fichier n'a pu etre ouvert\n" );
    exit(-1);
  }
  fprintf(sortie,"<HTML><HEAD><TITLE>sortie</TITLE></HEAD><center>" );
  fprintf(sortie,"<BODY bgcolor ='#FFFFCC'><h1><FONT COLOR='#993399'><center><br><u>Resultats de l'analyse</u><br><br></font></h1>" );
  fprintf(sortie,"<br><table border bordercolorlight='#6600CC' bordercolordark=black>" );
  fprintf(sortie,"<TH COLSPAN=10 BGCOLOR='#993399'><H1>LES INDIVIDUS</H1></th>" );
  fprintf(sortie,"<tr><td bgcolor='#CCFFCC'>Variable X</td><td bgcolor='#CCFFCC'>Variable Y</td><td bgcolor='#CCFFCC'>Numero du groupe</td>" );
  fprintf(sortie,"<td bgcolor='#CCFFCC'>Y chapeau</td></tr>" );
   
  for (i=0;i<nb_individu;i++) {
    fprintf(sortie,"<tr><td bgcolor='#FFCCFF'>%.2f</td><td bgcolor='#FFCCFF'>%.2f</td><td bgcolor='#FFCCFF'>%d</td><td bgcolor='#FFCCFF'>%.2f</td></tr>",x[i],y[i],groupe[i],y_chapeau[i]);
  }  
  fprintf(sortie,"</table><br><br><table border bordercolorlight='#6600CC' bordercolordark=black>" );
  fprintf(sortie,"<TH COLSPAN=10 BGCOLOR='#993399'><H1>LES GROUPES</H1></th>" );
  fprintf(sortie,"<tr><td bgcolor='#CCFFCC'>Numero du groupe</td><td bgcolor='#CCFFCC'>Coefficient a</td><td bgcolor='#CCFFCC'>Coefficient b</td></tr>" );
   
  for(j=0;j<nb_groupe;j++) {
    fprintf(sortie,"<tr><td bgcolor='#FFCCFF'>%d</td><td bgcolor='#FFCCFF'>%.2f</td><td bgcolor='#FFCCFF'>%.2f</td></tr>",j,a[j],b[j]);
  }
   
  fprintf(sortie,"</table></center></BODY></HTML> " );
  fclose(sortie);
  printf("Vous trouverez les resultats de l'analyse dans le fichier %s\n",nom_fichier);
}
 

0 5
1 3
3 2
2 4
4 6
 
 
c'est le contenu du fichier de données

quelqu'un peu m'aider?

manquerait pas un

dans la fonction distance ?

maintenant tu peux dire quelle fonction ne marche pas

non

jsui vraiment trop conne!!!!!!!!!!!!!!!!!!!!!!

je ne peux pas tester car je n'ai pas linux en ce moment
 
peux etre que cetait ca!

les lignes de commentaires c'est fait uniquement pour péter les couilles des gens qui auraient l'idée perverse de visualiser ton source sur un terminal en 80*25?

que veux tu dire par la
parle francais
je comprend rien a l'informatique moi

et ben

 
c'est ce qui me semblait.  

Ca m'fait penser au topic de Taz...
"Bonjour, j'ai un problème, mon prog C ne fait pas c'que j'veux mais parlez-moi comme à un gosse de 12 ans passke je comprends rien à l'informatique "

en tout cas merci a tous!
 
mon programme marche maintenant
 
(les filles et l'informatique ca fait 2)

Mais on peut faire 1 quand tu veux.

 
And the winner is....

SquiZZ
 
je veux bien t'eposer!

> WhatDe : on dirait que tu as perdu

Et c'est le rara, et c'est le toto, et c'est le rateau

mais non y'a aucun rateau
moi j'aime tout le monde

cochonne

Je peux t'apprendre à programmer moi  

je voi pas pourquoi tu dis ca!
tu voi les truc bizarreent toi

c fini avec les questions stupide

Vive le tact et la finesse

Bande de porcs laissez la tranquille.
Espèces de gros nerds associals.

 
WhatDe  quand tu veux
 
pour les cours de programmation

C'est la fête du slip ce thread, non ?

Fais gaffe avec WhatDe, il a ses hormones qui bouillonnent, il est en pleine puberté tardive

MP envoyé avec mon msn.

ca veux dire quoi MP

message privé
ici: http://forum.hardware.fr/forum1.ph [...] &cat=prive

WhatDe
 
tu es la?