Appel fonction affichage résultats

Résolu

haikei00X Messages postés 67 Date d'inscription Statut Membre Dernière intervention -
haikei00X Messages postés 67 Date d'inscription Statut Membre Dernière intervention - 17 oct. 2014 à 16:46

Bonjour à tous.
J'ai un problème dans l'appel de mes fonctions.
En effet je fais l'appel de 10 fonctions dans mon main.Si j'appelle les 5 premières fonctions,pas de problèmes,une fois je dépasse 5,c'est à dire à l'appel de la 6ème fonction je perds le résultat de la première fonction (il ne s'affiche plus) et à l'appel de la 7ème fonction après la 6ème, je perds et le résultat de la première fonction et celui de la deuxième.
Est-ce que quelqu'un connaît la source de ce problème?

Afficher la suite

A voir également:

Appel fonction affichage résultats
Fonction si et - Guide
Nommez une application d'appel vidéo ou de visioconférence - Guide
Resultats foot - Télécharger - Vie quotidienne
Appel privé - Guide
Affichage double ecran - Guide

6 réponses

Réponse 1 / 6

fiddy Messages postés 11069 Date d'inscription Statut Contributeur Dernière intervention 1 846

Ben le problème vient du code...
Pour qu'on te corrige, il va falloir poster ton code.
N'oublie pas d'utiliser la balise "code c".
Exemple :
<"code c">
#include <...>
...
<"/code">
(à mettre sans les guillemets)
Note : c'est bien "code c" (et non "code").

Cdlt,

Réponse 2 / 6

haikei00X Messages postés 67 Date d'inscription Statut Membre Dernière intervention 3

Voilà le code:


#include<stdio.h>
#include<stdlib.h>
#include<conio.h>
#include<math.h>
#include<time.h>

#define maxD 64
#define pi 3.14
#define eps 0.01
#define k 15

typedef double matD[maxD][maxD];
typedef double tabD[maxD];

int i,j,x,y;
double s; 
tabD c;

//Saisir-mat
void saisir_mat(matD M,int &n)
{int i,j;
     printf("Donnez la dimension de la matrice M:");
   scanf("%d",&n);

   for(i=0;i<n;i++)
     for(j=0;j<n;j++)
    {  
       M[i][j]=rand()%10;               
      printf("M[%d][%d]=%f\n",i,j,M[i][j]);
                  
    }  
}
/*******************************************************/
void DCT_matrice(matD M, matD D,int n)
{
 double r,q;

 
    for(i=0;i<n;i++)
     if(i==0)     
      c[i]=1/sqrt(2);
     else
      c[i]=1; 
 
   
    
   for(i=0;i<n;i++)
     for(j=0;j<n;j++)
     { 
       s=0.0;              
      for(x=0;x<n;x++)
       for(y=0;y<n;y++)
        {
           r=cos(   (2*x+1)*i*pi/(2*n)   );
           q=cos(   (2*y+1)*j*pi/(2*n)   );          
           s= s+M[x][y]*r*q;   
        }   
        
         D[i][j]=(2.0/n)*c[i]*c[j]*s;
        
      } 
     for(i=0;i<n;i++)
       for(j=0;j<n;j++)
         printf("D[%d][%d]=%lf\n",i,j,D[i][j]);
                       
}

/*************************************************************/

void DCT_matrice_Q(matD DQ,matD D,int n)
{matD Q; 
 
 
   for(i=0;i<n;i++)
    for(j=0;j<n;j++) 
      {Q[i][j]=1+k*(1+i+j);
       DQ[i][j]=D[i][j]/Q[i][j];
      }
   for(i=0;i<n;i++)
    for(j=0;j<n;j++)
     printf("DQ[%d][%d]=%lf\n",i,j,DQ[i][j]); 
     
}
/***********************************************/     
void zigzag(matD DQ,tabD TQ,int n) 
{ int m=0,croiss=0;
  int i=0,j=0;
 
 {
 while (i <= n-1 && j <= n-1)
{
      
        TQ[m]=DQ[i][j];
        m++;
    if (i == 0 || i == n-1) 
 {
        if (j == n-1) 
  {
            j = j - 1;
            i = i + 1;
  }
        j = j + 1;
        
        TQ[m]=DQ[i][j];
        m++;
 }
    else
 {
        if (j == 0 || j == n-1) 
  {
            if (i == n-1) 
   {
                i = i - 1;
                j = j + 1;
   }
            i = i + 1;
             
        TQ[m]=DQ[i][j];
        m++;
  }
 }
        
  if (i == 0 || j == n-1) { croiss = 0;}
  if (j == 0 || i == n-1)  { croiss = 1;}
    
    if (croiss==1) 
 {
        i = i - 1;
        j = j + 1;
 }
 else
 {
        i = i + 1;
        j = j - 1;
 }

 }    
} 
for(i=0;i<n*n;i++)
printf("TQ[%d]=%lf\n",i,TQ[i]);    
}  
/********************************************/
void RLE_compresse(tabD T, int n, tabD TC, int nc)
{  int j=0;
   int m=0;

    for(i=0;i<n;i++)
    { nc=0;
      
     while(T[i+m]==T[i+m+1])
      { nc++;
        m++;
      }
   
     TC[j]=nc+1;
     TC[j+1]=T[i+m];
     j=j+2;
     
    }
    m=0;
    for(i=0;i<n;i++)
    {if(T[i]!=T[i+1])
     m++;
    } 
    m=2*m;
    for(i=0;i<m;i++)
     printf("TC[%d]=%lf\n",i,TC[i]); 
}
/********************************************/
//RLE_decompresse
void RLE_decompresse(tabD TC, int nc, tabD TI, int n)
{int m=0,j=0;
 while(j<2*n*n)
 {
   nc=int(TC[j]);
 for(i=m;i<nc+m;i++)
   TI[i]=TC[j+1];
   j=j+2;
   m=m+nc;
}    
   
    
   for(i=0;i<n*n;i++) 
     printf("TI[%d]=%lf\n",i,TI[i]); 
     
 
     
}
/*******************************************/
void zigzag_inv(tabD TI,matD DQI,int n)
{ int m=0,croiss=0;
 int i=0,j=0;
 
 
 {
 while (i <= n-1 && j <= n-1)
{
      
       DQI[i][j]= TI[m];
        m++;
    if (i == 0 || i == n-1) 
 {
        if (j == n-1) 
  {
            j = j - 1;
            i = i + 1;
  }
        j = j + 1;
        
        DQI[i][j]= TI[m];
        m++;
 }
    else
 {
        if (j == 0 || j == n-1) 
  {
            if (i == n-1) 
   {
                i = i - 1;
                j = j + 1;
   }
            i = i + 1;
             
        DQI[i][j]= TI[m];
        m++;
  }
 }
        
  if (i == 0 || j == n-1) { croiss = 0;}
  if (j == 0 || i == n-1)  { croiss = 1;}
    
    if (croiss==1) 
 {
        i = i - 1;
        j = j + 1;
 }
 else
 {
        i = i + 1;
        j = j - 1;
 }

 }    
} 
for(i=0;i<n;i++)
 for(j=0;j<n;j++)
printf("DQI[%d][%d]=%lf\n",i,j,DQI[i][j]);   
}  
/******************************************************/
void DCT_matrice_Q_inv(matD DQI,matD DI,int n)
{matD Q; 
 
 
   for(i=0;i<n;i++)
    for(j=0;j<n;j++) 
      {Q[i][j]=1+k*(1+i+j);
       DI[i][j]=DQI[i][j]*Q[i][j];
      }
   for(i=0;i<n;i++)
    for(j=0;j<n;j++)
     printf("DI[%d][%d]=%lf\n",i,j,DI[i][j]); 
     
     }
/*********************************************************/

void IDCT_matrice(matD DI, matD MI, int n)
{ double m,p;

   for(i=0;i<n;i++)  
     if(i==0)
        c[i]=1/sqrt(2); 
     else
        c[i]=1;
     
     
for(x=0;x<n;x++)
   for(y=0;y<n;y++)          
    {
        s=0.0;                     
     for(i=0;i<n;i++)
      for(j=0;j<n;j++) 
       {
            m=cos(   (((2*x)+1)*i*pi)/(2*n)   );
            p=cos(   (((2*y)+1)*j*pi)/(2*n)   ); 
            s=s+c[i]*c[j]*DI[i][j]*m*p ;              
      
         
       }                        
       MI[x][y]=s*(2.0/n) ; 
                             
    } 
    for(x=0;x<n;x++)
      for(y=0;y<n;y++)
      printf("MI[%d][%d]=%lf\n",x,y,MI[x][y]);       
} 
/***************************************************/
int matrice_egale(matD M, matD MI,int n)
{
   for(i=0;i<n;i++)
    for(j=0;j<n;j++) 
     if(fabs(M[i][j]-MI[i][j])<=eps)
      return 1;
     else
      return 0;     
    
    
}    
 
//Fonction principale
main()
{matD M,MI,DQ,D,DI,DQI;
 tabD TQ,TC,T,TI;
 int n,nc,comp;

  saisir_mat(M,n);
  DCT_matrice(M,D,n);
  DCT_matrice_Q(DQ,D,n);
  zigzag(DQ,TQ,n);
  RLE_compresse(TQ,n*n,TC,nc);
  RLE_decompresse(TC,nc,TI,n);
  zigzag_inv(TI,DQI,n);
  DCT_matrice_Q_inv(DQI,DI,n);
  IDCT_matrice(DI,MI,n);
  comp=matrice_egale(M,MI,n);
  printf("\n%d",comp);
  
  
     getch();
      
      }

En effet le code prend une matrice calcule sa DCT (Transformée en Cosinus Discrète) puis calcule sa DCT Quantifiée ,après parcourt la matrice résultante en zigzag ,puis comprime la séquence trouvée.La compression consiste à éliminer les répétitions par exemple si on a T[0]=1 T[1]=1 T[2]=2 et T[3]=2 , la compression donne: 2 1 2 2 c'est à dire 2 fois 1 et 2 fois 2.Après la compression on remonte à la matrice initiale (approximativement) en effectuant les opérations inverses, à savoir la décompression , l'inverse du zigzag ,l'inverse de la DCT Quantifiée puis l'inverse de la DCT puis on compare la matrice finale avec l'initiale.La fonction qui fait cela retourne 1 si les deux matrices sont approximativement égaux et 0 si non.

Réponse 3 / 6

fiddy Messages postés 11069 Date d'inscription Statut Contributeur Dernière intervention 1 846

#include<conio.h>
Non standard.

#define maxD 64
#define pi 3.14
#define eps 0.01
#define k 15

typedef double matD[maxD][maxD];
typedef double tabD[maxD];

int i,j,x,y;
double s;
tabD c;
Par convention, on utilise des majuscules pour les #define.
Sauf pour MAXD et EPS, je te conseille d'utiliser pour les autres des constantes. Note EPS est déjà définie dans math.h...
Il vaut mieux éviter les variables globales. Utilise plutôt des variables locales. Si elles doivent être connues d'une fonction, il suffit de les envoyer en paramètre de la fonction.

main()
Le bon prototype est : int main(void).
Et il ne faut pas oublier "return 0;" pour indiquer que le main() s'est déroulé sans problème.

printf("\n%d",comp);
N'oublie pas de mettre un '\n' en fin d'instruction avant la fin du programme.

getch();
Non standard. Utilise plutôt getchar(); ou éventuellement system("PAUSE");

Fonction : int matrice_egale(matD M, matD MI,int n)
if(fabs(M[i][j]-MI[i][j])<=eps)
return 1;
else
return 0;

Algorithme faux. Si tu fais ça, tu ne compares que la première valeur. Le return 0; intervient en fin de fonction après les boucles for. On s'assure ainsi que toutes les valeurs sont inférieures à epsilon.

printf("MI[%d][%d]=%lf\n",x,y,MI[x][y]);
Dans tous tes printf(), c'est %f (et non %lf) pour afficher un double.

As-tu essayé de mettre en commentaire certaines fonctions afin de localiser plus précisément d'où vient le problème ?

N'hésite pas à reposter ton code avec les corrections.

Cdlt,

Réponse 4 / 6

haikei00X Messages postés 67 Date d'inscription Statut Membre Dernière intervention 3

bonsoir fiddy.
A propos de la fonction int matrice_egale(matD M, matD MI,int n) ,vous avez raison ,j'ai fait des tests et j'ai trouvé que effectivement elle envoie le résultat on se basant sur la comparaison du premier élément seulement. J'ai essayé mais je n'ai pas su comment y remédier .
j'ai essayé le return 0 à la fin après les boucles for mais toujours le même problème.

Est-ce que vous avez une idée?

voilà mon code ,mais il ne marche pas , je ne sais pas où est le problème?

int matrice_egale(matD M, matD N,int n)
{  int i,j;
   for(i=0;i<n;i++)
     for(j=0;j<n;j++)
     
       if(fabs(M[i][j]-N[i][j])>eps)
        {
                                 
        return 0;
         exit(1);
        }
                
      
      return 1;     
    
    
}

fiddy Messages postés 11069 Date d'inscription Statut Contributeur Dernière intervention 1 846

return 0;
exit(1);
Ton exit(1); sert à rien. Dès que le return 0; sera rencontré, la fonction sera terminée et renverra 0.
De plus, attention à exit(1), cela sert à quitter le programme (pas uniquement la fonction). On l'utilise souvent lorsqu'il y a une erreur, ce qui n'est pas le cas ici.

Dans ton cas, il faut faire le return 1; après les for() mais en dehors.
D'ailleurs, je te conseille de mettre des accolades autour des for pour bien délimiter. Cela évitera bien des erreurs au cas où tu aurais besoin de rajouter des instructions.
Cela donne :

int matrice_egale(matD M, matD N,int n) {
   int i,j;
   for(i=0;i<n;i++) {
      for(j=0;j<n;j++) {
         if(fabs(M[i][j]-N[i][j])>eps) {           
            return 0;
         }
      }
   }   
   return 1;
}

Cdlt,

haikei00X Messages postés 67 Date d'inscription Statut Membre Dernière intervention 3

Merci infiniment à vous tous vous m'avez beaucoup aidé ^^

Vous n’avez pas trouvé la réponse que vous recherchez ?

Posez votre question

Réponse 5 / 6

evilfalcon

Salut,
Dans ton programme, tu utilises que des void, et tu n'utilises aucun pointeur.
Je pense que tu perds une de tes valeurs entre tes fonctions.

Par exemple nc que tu utilises dans RLE_compresse (tien c'est la 5e fonction), tu modifes cette valeur dans ce programme sans la renvoyer dans le main, donc pour le programme, c'est toujours la valeur initiale.

Tu devrais essayer ça.

int RLE_compresse(tabD T, int n, tabD TC, int nc)
{  int j=0;
   int m=0;

    for(i=0;i<n;i++)
    { nc=0;
      
     while(T[i+m]==T[i+m+1])
      { nc++;
        m++;
      }
   
     TC[j]=nc+1;
     TC[j+1]=T[i+m];
     j=j+2;
     
    }
    m=0;
    for(i=0;i<n;i++)
    {if(T[i]!=T[i+1])
     m++;
    } 
    m=2*m;
    for(i=0;i<m;i++)
     printf("TC[%d]=%lf\n",i,TC[i]); 
  return nc;
}

dans le main:

nc = RLE_compresse(TQ,n*n,TC,nc);

Pour l'info, tu remarques pas ce problème avant car tu envois des pointeurs sans le savoir.

cordialement

fiddy Messages postés 11069 Date d'inscription Statut Contributeur Dernière intervention 1 846

tu n'utilises aucun pointeur.
Si, lorsqu'il appelle les fonctions en utilisant les types matD ou tabD.

Pour nc, cela n'est pas un problème puisqu'il s'en sert comme variable locale...
En effet, dans la fonction RLE_decompress(), il recalcule nc via nc=int(TC[j]);.

Réponse 6 / 6

fiddy Messages postés 11069 Date d'inscription Statut Contributeur Dernière intervention 1 846

Ca me fait penser, tu as mis : nc=int(TC[j]);
Ce n'est pas correct ça. Mets plutôt : nc=(int)TC[j];

Discussions similaires

Prix d'un appel locale = gratuit ?

Code de renvoi d'appel : Ooredo, Mobilis...

Prix d'un appel local

Votre réponse

Discussions similaires