matrice.aidez moi sur ça

**assane** · 04/03/2006, 03h20

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
 
typedef struct ele
{
   int l; /*indice de la ligne*/
   int c; /*indice de la colonne*/
   float e; /*l'element d'indice(l,c)*/
   struct ele *suiv; /*null ou adresse de la prochaine stucture
}ELE;
 
typedef el 
{
   int lig; /*nbre de ligne de la matrice reelle*/
   int col; /*nbre de ligne de la matrice reelle*/
   ELE *M ;/*adrss de la premiére variable de type ELE qui contient les informations sur l'élément non nul de la matrice réelle*/
}MATRIX;

1 .si A est une matrice (n,m) qui ne contient que peu d'elements non nuls cette structure MATRIX est une alternative pour la gestion des matrice compacts.
Le principe consite à ne conserver que les elmts non nuls de A.(parcours ligne par ligne)
Une matrice creuse est ici défini par une variable de type MATRIX avec lig et col le nombre deligne et de colonnes de la matrice réelle A(lig=n,col=m).
le role des variables de type ELE est de contenir dans e la valeur de l'élémentde la matrice réelle A(i,j) si A(i,j) non nul et dans ce cas l va contenir
la valeur de i,c celle de j et enfin suiv est un pointei qui indique l'adresse du prochain élément non nul de la matrice relle A s'il existe ou NULL.
2.Travail demandé
Ecrire les fonctions suivantes:
passage1:pour passer d'une matrice réelle à sa forme compact.
passage2:pour passer de la forme compact à la forme réelle.
Calculs matricielles par pointeur.Dans beaucoup de calculs une matrice est un grand tableau quasiment vide .Au lieu de memoriser la totalité du tableau,il convient alors
de ne remplir que les cases non nulles.On peut alors les mémoriser sous la forme d'un triplet:<coordonnées,valeur>.Mettre en place une telle structure
puis les opérations élémentaires entre deux matrices.

**Trap D** · 04/03/2006, 08h22

Salut

On ne fera pas ton exo à ta place !

Montre ce que tu as déjà écrit, indique les points qui te posent problème et là on t'aidera.
Ecris déjà les algos en pseudo langage (voir éventuellement du côté du forum algorithmique), puis traduis en C.

**assane** · 09/03/2006, 16h26

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
#include <stdio.h>
#include <conio.h>
 
 
 typedef  struct  ele {
		   int l;	 /*indice de la ligne*/
		   int c;	 /*indice de la colonne*/
		   float e; 	/*l'élément d'indice (l, c)*/
		   struct ele *suiv; 	/*null ou adresse de la prochaine structure*/
				   } ELE;
 
 typedef struct el {
		int lig;  /*nbre de ligne de la matrice reelle*/
		int col;  /*nbre de ligne de la matrice reelle*/
		ELE *M ;  /*adrss de la première variable de type ELE qui contient les informations sur          /*l'élément non nul de la matrice réelle*/
		} Matrix;
 
 
 
/*void Creation(int N,int M,float A[50][50])
{
  int I, J;       /* indices courants */
 
	 /* Saisie des donnees /
 
 for (I=0; I<N; I++)
	for (J=0; J<M; J++)
		{
		 printf("Element[%d][%d] : ",I,J);
		 scanf("%f",A[I][J]);
		}
 
 }*/
 /*void affichage(float** A,int N,int M) /* Affichage de la matrice /
   {
   int I,J;
   for (I=0; I<N; I++)
    {
     for ( J=0; J<M; J++)
	  printf("%3f", A[I][J]);
     printf("\n");
    }
  }
  ELE *nouv_maillon(int l,int c,float e)
   {
    ELE *nouv =(ELE*)malloc(sizeof (ELE));
     nouv->l=l;
     nouv->c=c;
     nouv -> e=e;
	 return nouv;
	}
void  Ajout (ELE **list , ELE *nouv)
   {
   ELE *tamp;
	if (*list==NULL)
	   *list =nouv;
	else
	  tamp=*list;
	  while (tamp->suiv)
		 tamp=tamp->suiv;
		 tamp->suiv=nouv;
		 //list=tamp;
	  //return list ;
	 }
  Matrix passage1 (float**t,int N,int M)
   {
	ELE *fc,*list,*mail,*pc;
	Matrix mx;
	int i,j;
	for(i=0;i<N;i++)
	  {
	   for(j=0;j<M;j++)
		 {
		  if (t[i][j]!=0)
		   mail=nouv_maillon(i,j,t[i][j]);
		   Ajout(&fc,mail);
		  }
		printf ("voici la forme compacte");
		pc=fc;
		while (pc)
		  {
		   printf("%3f",pc ->e);
		   pc=pc->suiv;
		   }
		}
	  mx.lig=N;
	  mx.col=M;
	  mx.M  =fc;
   return mx;
   }
void passage2(Matrix mx)
   {
	int N=mx.lig ,M=mx.col,i,j;
	float** t;
	ELE *p=mx.M;
	for(i=0;i<N;i++)
	   for(j=0;j<M;j++)
		 t[i][j]=0;
	 while(p)
	  {
	   t[p->l][p->c]=p->e ;
	   p=p->suiv ;
	   }
	/*for(i=0;i<N;i++)
	  {
	   for(j=0;j<M;j++)
		 {
		  if p->l ==i && p->c ==j )
			 t[i][j]=p->e;
		  else t[i][j]=0
		  (*Matrix.M)=(*Matrix.M)->suiv;
	  }
   printf("voici la forme compacte")
   while (*Matrix.M)
		  {
		   printf("%3f",(*Matrix.M) ->e);
		   (*Matrix.M)=(*Matrix.M)->suiv;
		   }
 
   printf("voici la matrice réelle de la forme compacte");/
   affichage(t,mx.lig,mx.col);
}  */
 main ()
   {
	float A[50][50];  /* matrice initiale */
	int N, M;       /* dimensions des matrices */
	int I, J;       /* indices courants */
	Matrix comp;
 
   printf("----------------------Saisie de La Taille de La matrice--------------\n");
 
	printf("Nombre de lignes   (max.50) : ");
	scanf("%d", &N );
	printf("Nombre de colonnes (max.50) : ");
	scanf("%d", &M );
	 for (I=0; I<N; I++)
	      {
		 for (J=0; J<M; J++)
		   {
		    printf("Elément[%d][%d]: ",I,J);
		    scanf("%3.1f",A[I][J]);
		    printf("\n");
		    }
 
	      }
	 /*for (I=0; I<N; I++)
	      {
		for ( J=0; J<M; J++)
		printf("%3.1f", A[I][J]);
		printf("\n");
				}  */
	getch();
 
  // Creation(N,M);
   //affichage(A,N,M);
 //passage1(A,N,M);
 //passage2(comp);
 getch();
 return 0;
 }

j'en s8 là mé ça sort dés l'entrée de la taille.

**Emmanuel Delahaye** · 09/03/2006, 17h02

Envoyé par assane

j'en s8 là mé ça sort dés l'entrée de la taille.

Tu peux le redire en gaulois ?

Ton code ne compile pas.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
Compiling: main.c
main.c:15:104: warning: "/*" within comment
main.c:22:19: warning: "/*" within comment
main.c:34:42: warning: "/*" within comment
main.c:104:4: warning: "/*" within comment
main.c:124: warning: return type defaults to `int'
main.c: In function `main_':
main.c:141: warning: unknown conversion type character `.' in format
main.c:141: warning: too many arguments for format
main.c:128: warning: unused variable `comp'
Linking console executable: D:\dev\ed02\cb\ed02.exe
Process terminated with status 0 (0 minutes, 1 seconds)
0 errors, 8 warnings

Pour ne pas compiler des portions de code, on utilise

Code :

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

1
2
3
4
 
#if 0
<code a isoler>
#endif

Envoyé par assane

Code :

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

1
2
3
4
 
   float A[50][50];  /* matrice initiale */
 
          scanf("%3.1f",A[I][J]);

scanf() avec "%f" attend l'adresse d'un float....

**assane** · 10/03/2006, 04h11

au fait je ne suis pas trop à l'aise avec le gaulois.Je vais commencer des cours en juin.Voici une version compilée de mon programme.Là j'ai un probléme avec le passage1

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
 
              #include <stdio.h>
#include <conio.h>
#include <stdlib.h>
 
 typedef  struct  ele {
		   int l;	 /*indice de la ligne*/
		   int c;	 /*indice de la colonne*/
		   float e; 	/*l'élément d'indice (l, c)*/
		   struct ele *suiv; 	/*null ou adresse de la prochaine structure*/
				   } ELE;
 
 typedef struct el {
		int lig;  /*nbre de ligne de la matrice reelle*/
		int col;  /*nbre de ligne de la matrice reelle*/
		ELE *M ;  /*adrss de la première variable de type ELE qui contient les informations sur          /*l'élément non nul de la matrice réelle*/
		} Matrix;
 
 
 
 
 void affichage(int N,int M,float A[50][50]) /* Affichage de la matrice */
   {
   int I,J;
   for (I=0; I<N; I++)
	{
	 for ( J=0; J<M; J++)
		  printf("%3.2f", A[I][J]);
	 printf("\n");
	}
	 getch();
	 }
  ELE *nouv_maillon(int l,int c,float e)
   {
    ELE *nouv =(ELE*)malloc(sizeof (ELE));
	 nouv->l=l;
     nouv->c=c;
	 nouv -> e=e;
	 return nouv;
	}
ELE  Ajout ( ELE *list,ELE *nouv)
   {
    ELE *tamp;
    //tamp=list;
	if (list==NULL)
	   list =nouv;
	else
	  tamp=list;
	  while (tamp->suiv)
		 tamp=tamp->suiv;
		 tamp->suiv=nouv;
		 //list=tamp;
	  return *tamp ;
	 }
  Matrix passage1 (int N,int M,float t[50][50])
   {
	ELE *list,*maillon,*pc;
	Matrix mx;
	int i,j;
    printf ("voici la forme compacte");
	for(i=0;i<N;i++)
	  {
	   for(j=0;j<M;j++)
		 {
		  if (t[i][j]!=0)
		   {
           maillon=nouv_maillon(i,j,t[i][j]);
		   Ajout(list,maillon);
		   }
         }
       }
		pc=list;
        printf ("voici la forme compacte");
		while (pc)
		  {
		   printf("%3.1f",pc ->e);
		   pc=pc->suiv;
		   }
		}
	  mx.lig=N;
	  mx.col=M;
	  mx.M  =list;
   return mx;
   }
void passage2(Matrix mx)
   {
	int N=mx.lig ,M=mx.col,i,j;
	float t[50][50];
	ELE *p=mx.M;
	for(i=0;i<N;i++)
	   for(j=0;j<M;j++)
		 t[i][j]=0;
	 while(p)
	  {
	   t[p->l][p->c]=p->e ;
	   p=p->suiv ;
	   }
 
   affichage(mx.lig,mx.col,t);
}
 main ()
   {
	float A[50][50];  /* matrice initiale */
	int N, M;       /* dimensions des matrices */
	int I, J;       /* indices courants */
	Matrix comp;
 
   printf("----------------------Saisie de La Taille de La matrice--------------");
 
	printf("Nombre de lignes   (max.50) : ");
	scanf("%d", &N );
	printf("Nombre de colonnes (max.50) : ");
	scanf("%d", &M );
	  	for (I=0; I<N; I++)
			 for (J=0; J<M; J++)
					{
						printf("Elément[%d][%d] : ",I,J);
						scanf("%f", &A[I][J]);
					}
   affichage(N,M,A);
   passage1(N,M,A);
 //passage2(comp);
 getch();
 return 0;
 }

**Emmanuel Delahaye** · 10/03/2006, 08h02

Envoyé par assane

Voici une version compilée de mon programme.

Peut mieux faire... (et je ne parle pas de la présentation. Pas très cohérent tout ça...)

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
 
Compiling: main.c
main.c:15:104: warning: "/*" within comment
main.c: In function `passage1':
main.c:64: warning: comparing floating point with == or != is unsafe
main.c:57: warning: unused variable `mx'
main.c: At top level:
[b]main.c:79: error: syntax error before '.' token[/b]
main.c:101: warning: return type defaults to `int'
main.c: In function `main_':
main.c:105: warning: unused variable `comp'
main.c: In function `Ajout':
main.c:41: warning: function returns an aggregate
main.c: In function `passage1':
main.c:55: warning: function returns an aggregate
main.c:67: warning: function call has aggregate value
main.c: In function `main_':
main.c:120: warning: function call has aggregate value

Là j'ai un probléme avec le passage1

Les lignes de texte doivent être terminées par '\n'
Dans le format des flottants "3.2f", 3 est la largeur totale minimale. C'est insuffisant. Préferer "8.2f", par exemple...
malloc() : cast inutile. malloc() peut echouer (retourne alors NULL).
Conséquence de ce qui précède, nouv_maillon() peut echouer.
La fonction Ajout() reçoit une copie de list qui n'est pas initialisée. Le comportement est indéfini. J'arrête l'analyse ici.

Tu vas trop vite. Commence par passer un peu de temps pour maîtriser l'implémentation des listes chainées. Il y a des tutoriels sur le sujet sur ce site.

**Process Linux** · 12/03/2006, 00h41

L'approche d'opptimisation est correcte, il faut savoir qu'il y a deux sens d'optimisation, soit tu optimises la vitesse et ton programme doit bouffer la mémoire ( C'est le cas d'une matrice ordinaire ) , soit tu optimises la RAM et tu perd la vitesse.

Pour faire simple , la représentation de la matrice dans ton cas , devien une liste d'élément qui porte les indices de ligne et colonne , et la valeur.

Donc pour passer d'une matrice normal à une matrice optimiser , il suffit de compter le nombre des valeurs non null , ensuite allouer un tableau de type Elem ( la structure que tu as définit ).
et tu vas remplire le tableau avec les valeurs non null .
sinon tu peux travailler avec une liste chainé de type elem .

Dans ce cas la fonction de lecture qui va remplacer l'accé à une martice M par M[i][j] , sera une fonction de recherche dans le tableau ou la liste chainée d'éléments de type elem, elle retourne une valeur si elle trouve un élément qui à comme indice I,J , sinon elle retourn null.