Manipulation de matrices.

**anibal** · 04/11/2005, 16h34

Bonjour
Au fait le code et toutes les corrections sont trés bien.
j'ai repris le code et je me suis amusé à le déboguer, j'ai trouvé une petite erreur qui plante tout et c'est à ce niveau :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
void affic_matrix(matrix *m) { 
   int i,j; 
   printf("Matrice de taille : %i * %i\n",m->nb_lignes,m->nb_colonnes); 
   for (i=0; i<m->nb_lignes; i++) { 
      for (j=0; i<m->nb_colonnes; j++){ 
         printf("%i%s",m->element[i][j]," "); 
      } 
      printf("\n"); 
   } 
}

au lieu de mettre j ds la boucle de i vous avez mis i, tout simplement !
Essayez de corriger ça !
je crois que ça marchera

ANIBAL

**TeKa** · 04/11/2005, 16h52

Envoyé par anibal

Bonjour
Au fait le code et toutes les corrections sont trés bien.
j'ai repris le code et je me suis amusé à le déboguer, j'ai trouvé une petite erreur qui plante tout et c'est à ce niveau :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
void affic_matrix(matrix *m) { 
   int i,j; 
   printf("Matrice de taille : %i * %i\n",m->nb_lignes,m->nb_colonnes); 
   for (i=0; i<m->nb_lignes; i++) { 
      for (j=0; i<m->nb_colonnes; j++){ 
         printf("%i%s",m->element[i][j]," "); 
      } 
      printf("\n"); 
   } 
}

au lieu de mettre j ds la boucle de i vous avez mis i, tout simplement !
Essayez de corriger ça !
je crois que ça marchera

ANIBAL

Emmanuel avait deja corrige ca. Regarde dans le post ou j'ai mis le programme pour la derniere fois.

**Emmanuel Delahaye** · 04/11/2005, 16h57

Envoyé par anibal

au lieu de mettre j ds la boucle de i vous avez mis i, tout simplement !
Essayez de corriger ça !

Envoyé par Emmanuel Delahaye

Code :

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

1
2
3
 
      /* -ed- j et non i... */
      for (j = 0; j < m->nb_colonnes; j++)

**TeKa** · 05/11/2005, 12h19

Voial ou j'en suis:

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
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
 
#include <stdio.h>
#include <stdlib.h>
 
typedef struct
{
   int **element;
   int nb_lignes;
   int nb_colonnes;
} matrix;
 
static matrix *allouer_matrice (int nbli, int nbcol) {
   matrix *m = malloc (sizeof *m);
   if (m != NULL) {
      m->nb_lignes = nbli;
      m->nb_colonnes = nbcol;
      m->element = malloc (nbli * sizeof *m->element);
      if (m->element) {
         int i;
         for (i = 0; i < nbcol; i++) {
            int j;
            m->element[i] = malloc (nbcol * sizeof *m->element[i]);
            for (j = 0; j < m->nb_colonnes; j++) {
               if (m->element[i] != NULL) {
                  m->element[i][j] = 0;
               }
            }
         }
 
      }
   }
   return m;
}
 
static matrix *read_matrix (FILE *fp) {
   matrix *m = NULL;
   if (fp != NULL) {
      int nb_lignes;
      int nb_colonnes;
      if (fscanf (fp, "%i%i", &nb_lignes, &nb_colonnes) == 2) {
         {
            m = allouer_matrice (nb_lignes, nb_colonnes);
            if (m != NULL) {
               int i;
               for (i = 0; i < m->nb_lignes; i++) {
                  int j;
                  for (j = 0; j < m->nb_colonnes; j++) {
                     int n = fscanf (fp, "%i", &m->element[i][j]);
                     if (n != 1) {
                        printf ("erreur de lecture\n");
                        break;
                     }
                  }
               }
            }
         }
      }
   }
   return m;
}
 
static void affic_matrix (matrix * m) {
   int i, j;
   printf ("Matrice de taille : %i * %i\n", m->nb_lignes, m->nb_colonnes);
   for (i = 0; i < m->nb_lignes; i++) {
      for (j = 0; j < m->nb_colonnes; j++) {
         printf ("%i%s", m->element[i][j], " ");
      }
      printf ("\n");
   }
}
 
static void write_matrix(FILE *fp,matrix *m) {
	int i, j;
	if (fp!=NULL){
		fprintf(fp,"%i%s%i\n",m->nb_lignes," ",m->nb_colonnes);
		for (i=0; i<m->nb_lignes; i++) {
			for (j=0; j<m->nb_colonnes; j++) {
				fprintf(fp,"%i%s",m->element[i][j]," ");
			}
			fprintf(fp,"\n");
		}
	}
}
 
static void remplir_matrice(matrix *m){
	int i,j;
	printf("Remplissage de matrice %dx%d\n",m->nb_lignes,m->nb_colonnes);
	for(i=0;i<m->nb_lignes;i++){
		for(j=0;j<m->nb_colonnes;j++){
			printf("element (%d,%d)? ",i,j);
			scanf("%i",&(m->element[i][j]));
		}
	}
}
 
matrix *add_matrix(matrix *m1, matrix *m2){
	int i,j;
	matrix *madd = NULL;
	if(m1->nb_lignes == m2->nb_lignes && m1->nb_colonnes == m2->nb_colonnes){
		madd=allouer_matrice(m1->nb_lignes,m1->nb_colonnes);
		for(i=0;i<m1->nb_lignes;i++){
			for(j=0;j<m1->nb_colonnes;j++){
				madd->element[i][j]=m1->element[i][j]+m2->element[i][j];
			}
		}
		return madd;
	}
	else {
		printf("Attention! Les matrices ne sont pas de la meme taille.\n");
	}
	return NULL;
}
 
matrix *multiply_matrix(matrix *m1, matrix *m2){
	int i,j,k;
	matrix *mmul;
	if(m1->nb_colonnes == m2->nb_lignes){
		mmul=allouer_matrice(m1->nb_lignes,m2->nb_colonnes);
		for(i=0;i<mmul->nb_lignes;i++){
			for(j=0;j<mmul->nb_colonnes;j++){
				for(k=0;k<m1->nb_colonnes;k++){
					mmul->element[i][j]+= m1->element[i][k]*m2->element[k][j];
				}
			}
		}
		return mmul;
	}
	else{
		printf("Attention! Les matrices ne peuvent pas etre multipliees. Rectifiez les dimensions.\n");
	}
	return NULL;
}
 
int main(void) {
	int choix;
	int n;
	printf("Que voulez-vous faire?\n");
	printf("1 - Ecrire une matrice dans un fichier.\n");
	printf("2 - Lire une matrice depuis un fichier.\n");
	printf("Choix : ");
	n = scanf("%i",choix);
	if (n == 1) {
		if (choix==1) {
			FILE *fp = fopen ("matrix.txt", "w");
			if (fp != NULL) {
				matrix *m1 = remplir_matrice(m1);
				write_matrix(fp, m1);
			}
		fclose (fp);
		}
		else if (choix == 2) {
			FILE *fp = fopen ("matrix.txt", "r");
			if (fp != NULL) {
				matrix *m1 = read_matrix (fp);
				if (m1 != NULL) {
					affic_matrix (m1);
				}
			}
			fclose (fp);
		}
		else {
			printf("Choisir 1 ou 2.\n");
		}
	}
	return 0;
}

Logiquement, mon programme a toutes les fonctions necessaires, et le main devrait contenir un 3 eme choix lancant une "demo" qui fait quelques operatiosn sur 2 matrices lues depuis 2 fichiers differents, puis afficher la nouvelle matrice et l'ecrire dans un nouveau fichier. Mais si ce que j'ai deja fait est bon, ca ne devrait pas poser de problemes.
Je commence a voir mes erreurs, et maintenant je ne compile plus qu'avec Wall. Mais la j'ai beau faire, il me reste un warning et une erreur. Et l'erreur je vois pas du tout ce qui la cause. :/
Merci pour les eclaircissements.

**Trap D** · 05/11/2005, 12h36

Le code ne compile pas :

Code :

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

matrix *m1 = remplir_matrice(m1);

car

Code :

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

static void remplir_matrice(matrix *m){

Il faut que remplir_matrice renvoie une adresse de matrix !

**Emmanuel Delahaye** · 05/11/2005, 12h39

Envoyé par TeKa

Je commence a voir mes erreurs, et maintenant je ne compile plus qu'avec Wall.

Insuffisant. Au minimum :

Code :

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

-Wall -Wextra -O2

Mais la j'ai beau faire, il me reste un warning et une erreur. Et l'erreur je vois pas du tout ce qui la cause. :/
Merci pour les eclaircissements.

Code :

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

1
2
3
4
5
 
Compiling: main.c
main.c: In function `main_':
main.c:141: warning: format argument is not a pointer (arg 2)
main.c:146: error: void value not ignored as it ought to be

Ligne 141

Code :

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

   n = scanf("%i",choix);

"%i" attend l'adresse d'un int et non un int.

Code :

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

   n = scanf("%i", &choix);

Ligne 146
La fonction remplir_matrice() ne retourne rien (void)

Code :

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

static void remplir_matrice(matrix *m){

il est donc incohérent d'écrire:

Code :

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

            matrix *m1 = remplir_matrice(m1);

**TeKa** · 05/11/2005, 12h43

Alors la... J'ai vraiment honte d'avoir fait des erreurs pareilles... :/
Merci encore une fois de tes lumieres.

**anibal** · 08/11/2005, 18h03

g repris qques fonctions, en fait les codes déja posté sont trés bien écrit mais je crois qu'il ya une manière plus simple d'allouer la matrice, notez que g supposé que je connaissais les lignes et les colonnes de ma matrice, ce qui serait plus onteressatn serait de pouvoir dégagé d'une manière automatique combien de lignes et de colonnes on a ?
Qqu'un aurait une idée ?

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
 
#include <stdio.h> 
#include <stdlib.h>
 
/***********************************************************/
/****************        READ MATRIX       *****************/
/***********************************************************/
 
int ** readmatrix(char *name,int lines, int columns){
 
  FILE *F ;
  int ** matrix;
  int i,j;
 
 
  F= fopen(name,"r");
  matrix=(int**)malloc(columns*sizeof(int*));
  for (i=0;i<columns;i++){
    matrix[i]=(int*)malloc(lines*sizeof(int));
  }
  /* Parse external matrix file per line than per column */
  for(j=0;j<lines;j++){
    for(i=0;i<columns;i++){
      fscanf(F,"%d",&matrix[i][j]);
    }
  }
  fclose(F);
  return matrix;
}
 
 
/***********************************************************/
/****************        PRINT MATRIX      *****************/
/***********************************************************/
 
 
void print_matrix(int **matrix,int lines,int columns) { 
 
  int i,j;
 
    for (j=0; j<lines; j++){
      for (i=0; i<columns; i++) { 
      printf("%d ",matrix[i][j]); 
    } 
    printf("\n"); 
    }
} 
 
 
/***********************************************************/
/****************        MAIN PROGRAM      *****************/
/***********************************************************/
 
 
 
 
int main(int argc,char **argv){
  int **m;
  m = readmatrix(argv[1],4,4);
  print_matrix(m,4,4);
  return 0;
}

**TeKa** · 16/11/2005, 15h53

Hello.
Je uppe ce thread pour y mettre fin.
Voici le code que j'ai rendu:

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
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
 
#include <stdio.h>
#include <stdlib.h>
 
typedef struct
{
   int **element;
   int nb_lignes;
   int nb_colonnes;
} matrix;
 
static matrix *allouer_matrice (int nbli, int nbcol) {
   matrix *m = malloc (sizeof *m);
   if (m != NULL) {
      m->nb_lignes = nbli;
      m->nb_colonnes = nbcol;
      m->element = malloc (nbli * sizeof *m->element);
      if (m->element) {
         int i;
         for (i = 0; i < nbcol; i++) {
            int j;
            m->element[i] = malloc (nbcol * sizeof *m->element[i]);
            for (j = 0; j < m->nb_colonnes; j++) {
               if (m->element[i] != NULL) {
                  m->element[i][j] = 0;
               }
            }
         }
 
      }
   }
   return m;
}
 
static void liberer_matrice(matrix *m){
	int i;
	for(i=0;i<m->nb_colonnes;i++){
		free(m->element[i]);
	}
	free(m->element);
}
 
static matrix *read_matrix (FILE *fp) {
   matrix *m = NULL;
   if (fp != NULL) {
      int nb_lignes;
      int nb_colonnes;
      if (fscanf (fp, "%i%i", &nb_lignes, &nb_colonnes) == 2) {
         {
            m = allouer_matrice (nb_lignes, nb_colonnes);
            if (m != NULL) {
               int i;
               for (i = 0; i < m->nb_lignes; i++) {
                  int j;
                  for (j = 0; j < m->nb_colonnes; j++) {
                     int n = fscanf (fp, "%i", &m->element[i][j]);
                     if (n != 1) {
                        printf ("erreur de lecture\n");
                        break;
                     }
                  }
               }
            }
         }
      }
   }
   return m;
}
 
static void affic_matrix (matrix * m) {
   int i, j;
   printf ("Matrice de taille : %i * %i\n", m->nb_lignes, m->nb_colonnes);
   for (i = 0; i < m->nb_lignes; i++) {
      for (j = 0; j < m->nb_colonnes; j++) {
         printf ("%i%s", m->element[i][j], " ");
      }
      printf ("\n");
   }
}
 
static void write_matrix(FILE *fp,matrix *m) {
	int i, j;
	if (fp!=NULL){
		fprintf(fp,"%i%s%i\n",m->nb_lignes," ",m->nb_colonnes);
		for (i=0; i<m->nb_lignes; i++) {
			for (j=0; j<m->nb_colonnes; j++) {
				fprintf(fp,"%i%s",m->element[i][j]," ");
			}
			fprintf(fp,"\n");
		}
	}
}
 
static void remplir_matrice(matrix *m){
	int i,j;
	printf("Remplissage de matrice %dx%d\n",m->nb_lignes,m->nb_colonnes);
	for(i=0;i<m->nb_lignes;i++){
		for(j=0;j<m->nb_colonnes;j++){
			printf("element (%d,%d)? ",i,j);
			scanf("%i",&(m->element[i][j]));
		}
	}
}
 
matrix *add_matrix(matrix *m1, matrix *m2){
	int i,j;
	matrix *madd = NULL;
	if(m1->nb_lignes == m2->nb_lignes && m1->nb_colonnes == m2->nb_colonnes){
		madd=allouer_matrice(m1->nb_lignes,m1->nb_colonnes);
		for(i=0;i<m1->nb_lignes;i++){
			for(j=0;j<m1->nb_colonnes;j++){
				madd->element[i][j]=m1->element[i][j]+m2->element[i][j];
			}
		}
		return madd;
	}
	else {
		printf("Attention! Les matrices ne sont pas de la meme taille.\n");
	}
	return NULL;
}
 
matrix *multiply_matrix(matrix *m1, matrix *m2){
	int i,j,k;
	matrix *mmul;
	if(m1->nb_colonnes == m2->nb_lignes){
		mmul=allouer_matrice(m1->nb_lignes,m2->nb_colonnes);
		for(i=0;i<mmul->nb_lignes;i++){
			for(j=0;j<mmul->nb_colonnes;j++){
				for(k=0;k<m1->nb_colonnes;k++){
					mmul->element[i][j]+= m1->element[i][k]*m2->element[k][j];
				}
			}
		}
		return mmul;
	}
	else{
		printf("Attention! Les matrices ne peuvent pas etre multipliees. Rectifiez les dimensions.\n");
	}
	return NULL;
}
 
int main(void) {
	int choix;
	int n;
	printf("Que voulez-vous faire?\n");
	printf("1 - Ecrire une matrice dans un fichier.\n");
	printf("2 - Lire une matrice depuis un fichier.\n");
	printf("3 - Lancer la Demo.\n");
	printf("Choix : ");
	n = scanf("%i",&choix);
	if (n == 1) {
		if (choix==1) {
			FILE *fp = fopen ("matrix.txt", "w");
			if (fp != NULL) {
				matrix *m1;
				int nbli, nbcol, p, q;
				printf("Nombre de lignes : ");
				p = scanf("%i", &nbli);
				printf("Nombre de colonnes : ");
				q = scanf("%i", &nbcol);
				if (p == 1 && q == 1){
					m1 = allouer_matrice(nbli, nbcol);
					remplir_matrice(m1);
					write_matrix(fp, m1);
				}
				liberer_matrice(m1);
			}
			fclose (fp);
		}
		else if (choix == 2) {
			FILE *fp = fopen ("matrix.txt", "r");
			if (fp != NULL) {
				matrix *m1 = read_matrix (fp);
				if (m1 != NULL) {
					affic_matrix (m1);
				}
				liberer_matrice(m1);
			}
			fclose (fp);
		}
		else if (choix==3) {
			FILE *fp1 = fopen("matrix1.txt","r");
			FILE *fp2 = fopen("matrix2.txt","r");
			FILE *fp3 = fopen("matrix3.txt","w");
			if (fp1 != NULL && fp2 != NULL && fp3 != NULL) {
				matrix *m1 = read_matrix (fp1);
				matrix *m2 = read_matrix (fp2);
				if (m1 != NULL && m2 != NULL) {
					affic_matrix (m1);
					affic_matrix (m2);
					printf("Additionnons la matrice M1 et la matrice M1xM2...\n");
					matrix *m3 = add_matrix(m1, multiply_matrix(m1, m2));
					affic_matrix(m3);
					printf("Stockons le resultat dans un fichier...\n");
					write_matrix(fp3, m3);
					liberer_matrice(m3);
				}
				liberer_matrice(m1);
				liberer_matrice(m2);
			}
			fclose(fp1);
			fclose(fp2);
			fclose(fp3);
		}
		else {
			printf("Choisir 1, 2 ou 3.\n");
		}
	}
	return 0;
}

Merci pour votre aide a tous. Je reviendrais certainement.

Manipulation de matrices.

C

Discussions similaires

Partager

Partager