Discussion :

[magol1]

Bonjour à tous,
J'ai créé une fonction qui doit transformer un vecteur en une matrice mais je rencontre un problème à l'éxécution: il n'y a que des zeros qui s'affiche. Ci-dessous mon code et le résultat de l'éxécution.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
 
#include <stdio.h>
#include <stdlib.h>
float** Allocate_Mat_Memory(int N, int M);
void Free_Mat_Memory(float **A, int N );
void Affiche_Mat( float **A, int N, int M );
void genere_mat( float **A, int N, int M );
float** function_reshape(float **v_in, int dim1, int dim2);
int main()
{
float **Ma;
 float **Vect;
 int dim1=3, dim2=3;
 int lig;
 lig=dim1*dim2;
 int col=1;
 Vect= Allocate_Mat_Memory( lig, col );
 printf("Le nombre de lignes de Vect lig=%d\n",lig);
 printf("Le nombre de colonnes de Vect est col= %d\n",col);
 genere_mat( Vect, lig, col );
 Affiche_Mat(Vect, lig,col );
 Ma=function_reshape(Vect, dim1,dim2);
  return 0;
   }
float** Allocate_Mat_Memory(int N, int M)//Cette fonction permet d'allouer de la memoire pour une matrice quelconque 
{
int i;
float **A = NULL;
// On fait l'allocation de memoire pour un vecteur de N cases, C'est un vecteur de pointeurs 
A = (float**) malloc( sizeof(float*) * N );
// Si l'allocation à réussi, On fait une allocation de M cases pour chaque ligne 
if( A != NULL )
for( i=0; i<N; i++ )
A[i] = (float*) malloc( sizeof(float) * M );
return A;
}
 
void Free_Mat_Memory( float **A, int N )//cette fonction fait la désallocation d'une matrice (liberer la memoire)
{
int i;
// libérer chaque ligne
for( i=0; i<N; i++ )
free( A[i] );
free( A );
} 
 
void Affiche_Mat( float **A, int N, int M )// Affichage des éléments de la matrice 
{
int i, j;
for(i=0; i<N; i++)
 {
   for(j=0; j<M; j++)
     printf("%f\t", A[i][j]);
     printf("\n");
 }
}
void genere_mat( float **A, int N, int M )//genere les éléments de la matrice de façon aléatoire 
{
int c,i, j;
c=255;
for( i=0; i<N; i++ )
  for( j=0; j<M; j++ )
    {
      A[i][j]=rand()%c;
    }
}
 
float** function_reshape(float **v_in, int dim1, int dim2)
{
int i,j,c,d;
d=1;
c=255;
int dim = dim1*dim2;
float **m_out;// matrice d'arrivée
puts ( " Vecteur ==> Matrice \n" ) ;
// allocation des cases du vecteur et remplissage avec des valeurs reconnaissables.
v_in =Allocate_Mat_Memory(dim,d);
   //if ( NULL == v_in )
   //return 0;  // EXIT_SUCCESS  et  EXIT_FAILURE  définies dans  stdlib.h .
 
  //  for ( i = 0 ; i < dim ; ++i )
 
        for ( i = 0 ; i < dim ; ++i )
	  for( j=0; j<d ; j++ )
        printf( " v_in[%d] = %f \n" , i, v_in[i][j] ) ;
   puts (" ") ;
 
  m_out = Allocate_Mat_Memory(dim1, dim2);
 
   *m_out = v_in ;  // on donne la bonne valeur, l'adresse de V_in au premier pointeur de la lign de la matrice.
 
  for ( i = 1 ; i < dim1 ; ++i )
   // for ( j = 0 ; j < dim2 ; ++j )
       // m_out[i]= m_out[i-1] + dim2 ;
 
   for ( i = 0 ; i < dim1 ; ++i)
   {
      for ( j = 0 ; j < dim2 ; ++j )
      {
	printf( "%f \t" ,m_out[i][j] ) ;
      }
      printf("\n");
   }
 
   //Free_Mat_Memory(m_out, dim1 );
 
  // return 1 ;
 
return m_out;
}

stagiaire@amaltee /mnt/manille/sdb2/stages/stagiaire $ gcc essaiori.c -o essaiori.out
essaiori.c: In function 'function_reshape':
essaiori.c:412:11: warning: assignment from incompatible pointer type
stagiaire@amaltee /mnt/manille/sdb2/stages/stagiaire $ ./essaiori.outLe nombre de lignes de Vect lig=9
Le nombre de colonnes de Vect est col= 1
163.000000
151.000000
162.000000
85.000000
83.000000
190.000000
241.000000
252.000000
249.000000
Vecteur ==> Matrice

v_in[0] = 0.000000
v_in[1] = 0.000000
v_in[2] = 0.000000
v_in[3] = 0.000000
v_in[4] = 0.000000
v_in[5] = 0.000000
v_in[6] = 0.000000
v_in[7] = 0.000000
v_in[8] = 0.000000

0.000000 0.000000 0.000000
0.000000 0.000000 0.000000
0.000000 0.000000 0.000000

Cordialement,

[Bktero]

Pour commencer, règle déjà le warning.

Ta fonction reshape connait les dimensions de sortie, mais pas les dimensions d'entrée, en paramètres. Tu redimensionnes toujours un vecteur colonne ?

Tu n'affiches pas ce qu'il faut au début de cette fonction. Rajoute :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
    puts("Debut de la fonction function_reshape");
    Affiche_Mat(v_in, dim, 1);

avant :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

    puts ( " Vecteur ==> Matrice \n" ) ;

pour t'en convaincre.

En effet, tu écrases la matrice d'entrée :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

v_in =Allocate_Mat_Memory(dim,d);

Rajoute les mêmes lignes que ci-avant pour t'en convaincre :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
    v_in =Allocate_Mat_Memory(dim,d);
    puts("Apres ecrasement...");
    Affiche_Mat(v_in, dim, 1);

Je ne sais pas si les parcours suivants sont corrects mais ce n'est pas la peine de regarder...

PS : en fait, j'ai jeté un oeil. Tu pourras tout recommencer je pense...

[magol1]

D'accord! Mais comment résoudre ce problème? Je réfléchi mais je trouve pas.

[Bktero]

As-tu corriger le code en intégrant les remarques que je t'ai donné, au moins ?

Je réfléchi mais je trouve pas.

Réfléchi plus fort. Pourrais-tu nous expliciter ta méthode (étape 1, étape 2, ....) de manière précise ?

[Bousk]

Mais.. un vecteur c'est une (sorte de?) matrice particulière !
Je ne comprends pas alors ce que tu souhaites réellement faire.

Même tes définitions sont identiques
float **Ma;
float **Vect;

D'ailleurs, il est plus simple de manipuler un float* et d'accéder aux éléments en 2 dimensions par Vect[x+y*width];

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
int width = 10; int height = 20;
float* Vec = malloc(width*height*sizeof(float));
float getValue(int x, int y) { return Vec[x+y*width]); }

Si c'est juste pour l'affichage en plus !