Sujet Précédent Sujet Suivant

Appel fonction affichage résultats

Résolu/Fermé
haikei00X Messages postés 67 Date d'inscription dimanche 20 juillet 2014 Statut Membre Dernière intervention 11 janvier 2016 - 15 sept. 2014 à 14:58
haikei00X Messages postés 67 Date d'inscription dimanche 20 juillet 2014 Statut Membre Dernière intervention 11 janvier 2016 - 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?
A voir également:

6 réponses

Réponse 1 / 6
fiddy Messages postés 11069 Date d'inscription samedi 5 mai 2007 Statut Contributeur Dernière intervention 23 avril 2022 1 841
15 sept. 2014 à 15:20
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,
0
Réponse 2 / 6
haikei00X Messages postés 67 Date d'inscription dimanche 20 juillet 2014 Statut Membre Dernière intervention 11 janvier 2016 3
Modifié par haikei00X le 15/09/2014 à 15:34
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.
0
Réponse 3 / 6
fiddy Messages postés 11069 Date d'inscription samedi 5 mai 2007 Statut Contributeur Dernière intervention 23 avril 2022 1 841
15 sept. 2014 à 15:49
#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,
0
Réponse 4 / 6
haikei00X Messages postés 67 Date d'inscription dimanche 20 juillet 2014 Statut Membre Dernière intervention 11 janvier 2016 3
Modifié par haikei00X le 15/09/2014 à 19:32
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;     
    
    
}
0
fiddy Messages postés 11069 Date d'inscription samedi 5 mai 2007 Statut Contributeur Dernière intervention 23 avril 2022 1 841
15 sept. 2014 à 22:54

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,
0
haikei00X Messages postés 67 Date d'inscription dimanche 20 juillet 2014 Statut Membre Dernière intervention 11 janvier 2016 3
17 oct. 2014 à 16:46
Merci infiniment à vous tous vous m'avez beaucoup aidé ^^
0

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

Posez votre question
Réponse 5 / 6
evilfalcon
17 sept. 2014 à 10:31
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
0
fiddy Messages postés 11069 Date d'inscription samedi 5 mai 2007 Statut Contributeur Dernière intervention 23 avril 2022 1 841
17 sept. 2014 à 14:09
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]);.
0
Réponse 6 / 6
fiddy Messages postés 11069 Date d'inscription samedi 5 mai 2007 Statut Contributeur Dernière intervention 23 avril 2022 1 841
17 sept. 2014 à 14:12
Ca me fait penser, tu as mis : nc=int(TC[j]);
Ce n'est pas correct ça. Mets plutôt : nc=(int)TC[j];
0

Discussions similaires

Code de renvoi d'appel : Ooredo, Mobilis...
midoou07 -
Camille -

13 réponses
adele
marine carnet-pantier -
irongege -

2 réponses
Prix d'un appel locale = gratuit ?
madmax09 -
Pseudo -

5 réponses
Récupérer un résultat selon la date d'aujourd'hui
l1607 -
l1607 -

3 réponses
Renvoie code ooredoo
Aicha -
bazfile -

1 réponse