Discussion :

[Daxmawale]

Salut, voilà j'ai deux warning mais je sais pas les résoudre j'ai passé du temps à essayer j'y arrive pas... merci d'avance ( je souligne les lignes en Warning).

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
#include <stdio.h>
#include <stdlib.h>
#define Max 100


void affichage(int NbLigne, int NbColonne, double *pMatrice)
{
    int i,j;

    for(i=0;i<NbLigne;i++)
    {
        printf("|");
            for(j=0;j<NbColonne;j++)
            {
                printf("%2.lf |",*(pMatrice+i+Max*j));
             }
        printf("\n");
      }


}



void remplir_matrice( int *pNbLigne, int *pNbColonne, double *pMatrice)
{
    int i,j;

   printf("Veuillez entrer la matrice caree de taille %dx%d \n", *pNbLigne, *pNbColonne);

    for(i=0;i<*pNbLigne;i++)
    {
        for(j=0;j<*pNbColonne;j++)
       {
           printf("M[%d][%d]\n",i,j);
           scanf("%2lf", pMatrice+i*Max+j);
        }

      }
}



int main()
{
   int Nbligne, NbColonne;
   double Matrice[Max][Max];
   int *pNbligne, *pNbColonne, *pMatrice;

   pNbligne=&Nbligne;
   pNbColonne=&NbColonne;
   pMatrice=(int*)Matrice;


   FILE* fichier=NULL;
   fichier=fopen("Matrice.txt","w");

       if( fichier!=NULL)
       {
           do{
                   printf("Entrez une matrice caree svp \n\n");
                   printf("Entrez le nombre de lignes \n");
                   scanf("%d",pNbligne);

                   printf("Entrez le nombre de colonne\n")
                   scanf("%d",pNbColonne);
                }while(*pNbligne!=*pNbColonne);

      pMatrice = malloc(Nbligne*sizeof(double));

              if(pMatrice)
              {
                remplir_matrice(  pNbligne,  pNbColonne,  pMatrice);
                affichage( Nbligne, NbColonne,  pMatrice);//warning passing argument 3 or affichage from incompatible type
                 free(pMatrice);
               }

        fclose(fichier);
        }

    return 0;
}

[mith06]

Bonjour,

Le compilateur n'est pas content à cause du paramètre 3 (pMatrice) passé à la méthode affichage : void affichage(int NbLigne, int NbColonne, double *pMatrice)

pMatrice est déclarer comme étant un int * , alors que affichage requière un double *.

Le warning est justifié, car si sizeof(int) != sizeof(double), c'est certain que ça ne va pas marcher.

[Sve@r]

Salut, voilà j'ai deux warning mais je sais pas les résoudre j'ai passé du temps à essayer j'y arrive pas... merci d'avance ( je souligne les lignes en Warning).

Code c :

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
#include <stdio.h>
#include <stdlib.h>
#define Max 100


void affichage(int NbLigne, int NbColonne, double*pMatrice )
{
    int i,j;

    for(i=0;i<NbLigne;i++)
    {
        printf("|");
            for(j=0;j<NbColonne;j++)
            {
                printf("%2.lf |",*(pMatrice+i+Max*j));
             }
        printf("\n");
      }


}



void remplir_matrice( int *pNbLigne, int *pNbColonne, double *pMatrice)
{
    int i,j;

   printf("Veuillez entrer la matrice caree de taille %dx%d \n", *pNbLigne, *pNbColonne);

    for(i=0;i<*pNbLigne;i++)
    {
        for(j=0;j<*pNbColonne;j++)
       {
           printf("M[%d][%d]\n",i,j);
           scanf("%2lf", pMatrice+i*Max+j);
        }

      }
}



int main()
{
   int Nbligne, NbColonne;
   double Matrice[Max][Max];
   int *pNbligne, *pNbColonne, *pMatrice;

   pNbligne=&Nbligne;
   pNbColonne=&NbColonne;
   pMatrice=(int*)Matrice;


   FILE* fichier=NULL;
   fichier=fopen("Matrice.txt","w");

       if( fichier!=NULL)
       {
           do{
                   printf("Entrez une matrice caree svp \n\n");
                   printf("Entrez le nombre de lignes \n");
                   scanf("%d",pNbligne);

                   printf("Entrez le nombre de colonne\n")
                   scanf("%d",pNbColonne);
                }while(*pNbligne!=*pNbColonne);

      pMatrice = malloc(Nbligne*sizeof(double));

              if(pMatrice)
              {
remplir_matrice(  pNbligne,  pNbColonne,  pMatrice);
                affichage( Nbligne, NbColonne,  pMatrice);//warning passing argument 3 or affichage from incompatible type
                 free(pMatrice);
               }

        fclose(fichier);
        }

    return 0;
}

Salut
T'as passé combien de temps exactement ??? Erreurs en rouge dans ton code.
Sinon concrètement elles servent à quoi les variables pNbligne, pNbColonne et pMatrice (que tu vas en plus ensuite allouer) ???

Dîtes l’éditeur texte prend pas les espaces ? ( dsl je sais que c'est moche sans les espaces )

[Daxmawale]

Merci pour la réponse mith06 et Sve@r.

Le programme fonctionne très bien j'ai juste oublié de mettre l'espace entre double *p matrice ( car j'ai renommé mon pointeur) j'en suis désolé... mais dis pas que j'ai pas cherché. ( j'étais plus concentré sur mes procédures que sur mes déclarations une erreur que je referai pas )

J'ai mis des pointeurs car le prof a insisté mais sinon sans j'y arrive très bien, je suis conscient qu'ils servent à pas grand choses dans ce programme...

En tous cas merci à vous !

Cordialement Dax

[Sve@r]

...j'ai juste oublié de mettre l'espace entre double *p matrice ( car j'ai renommé mon pointeur) j'en suis désolé... mais dis pas que j'ai pas cherché. ( j'étais plus concentré sur mes procédures que sur mes déclarations une erreur que je referai pas )

Hum, un double [][] (2D) n'est pas équivalent d'un double* (1D). Bon dans l'absolu on peut toujours convertir et dire que tab[x][y]=*(tab + x * nb_col + y) mais je ne vois rien de tout ça dans ton code...

Le programme fonctionne très bien

On verra ça à l'exécution...

J'ai mis des pointeurs car le prof a insisté mais sinon sans j'y arrive très bien, je suis conscient qu'ils servent à pas grand choses dans ce programme...

A mon avis, t'as pas dû bien comprendre les instructions du prof. Il a dû dire un truc ressemblant à "il faudra utiliser les pointeurs" dans le sens "il y aura des moments où ceux-ci seront obligatoires" mais ça ne veut pas dire qu'il faut en mettre de partout. Par ailleurs j'ai pas parlé des pointeurs mais des variables. Parce que si tu remplaces, dans ton main, pNbligne par &NbLignes tu as toujours des pointeurs mais tu as des variables inutiles en moins...

[Daxmawale]

J'ai juste demandé de l'aide pour les deux warnings pas besoins de m'enfoncer
Sinon je refais le programme, plus jolie ! avec du codage moins deg et sans erreurs.
Si tu veux je t'envoie en mp mon nouveau prog, juste pour te montrer que ton aide m'a bien servi

merci bien.

[LittleWhite]

Bonjour,

Pourquoi ne pas envoyer le nouveau code ici, que cela inspire tous les futurs lecteurs ?

[Daxmawale]

je le met, mais me lapidez pas... Le programme n'est pas fini je rajouterai addition de matrice, multiplication, symétrie etc.

Code c :

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
 
#include <stdio.h>
#include <stdlib.h>
#define Max 100
 
 
void affichage(int *pNbLigne, int *pNbColonne, double **matrice)
{
    int i,j;
 
    for(i=0;i<*pNbLigne;i++)
    {
        printf("|");
        for(j=0;j<*pNbColonne;j++)
        printf("%2.lf |",matrice[i][j]);
 
        printf("\n");
     }
 
}
 
void init_matrice(int *pNbligne, int *pNbColonne)
{
 
    printf("Entrez le nombre de lignes \n");
    scanf("%d",pNbligne);
    printf("Entrez le nombre de colonne\n");
    scanf("%d",pNbColonne);
 
}
 
 
void remplir_matrice( int *pNbLigne, int *pNbColonne, double ** matrice)
{
    int i,j;
 
    for(i=0;i<*pNbLigne;i++)
    for(j=0;j<*pNbColonne;j++)
    {
        printf("M[%d][%d]\n",i,j);
        scanf("%2lf",&matrice[i][j]);
    }
 
}
 
 
 
int main()
{
   int Nbligne, NbColonne,*pNbligne=&Nbligne, *pNbColonne=&NbColonne, i;
   double** Matrice;
 
   FILE* fichier=NULL;
   fichier=fopen("Matrice.txt","w");
 
   if( fichier!=NULL)
   {
        init_matrice(pNbligne, pNbColonne);
 
        Matrice = (double **)malloc((*pNbligne)*sizeof(double *));
        for(i=0;i<*pNbligne;i++)
        {
            Matrice[i] = (double**) malloc((*pNbligne)*sizeof(double *));
        }
 
 
        if(Matrice==NULL)
        {
            exit(0);
        }
 
        remplir_matrice(pNbligne,pNbColonne,Matrice);
        affichage(pNbligne,pNbColonne,Matrice);
 
        free(Matrice);
        fclose(fichier);
 
    }
 
    return 0;
}

[LittleWhite]

En principe, les #define sont définis tout en majuscules :

Code :

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

#define MAX 100

Dans la fonction "affichage" (et pour d'autres fonctions), sachant que pNbLigne et pNbColonne ne sont pas modifiées et qu'il n'y a pas besoin de les modifier, je ne les passerai pas par pointeur, mais directement.
Il faut éviter les pointeurs en C (et C++), cela évite des erreurs.
J'apprécie le fait que les pointeurs ont des noms de variables commençant par 'p'

Autant que possible, donnez une valeur à la déclaration des variables, cela évite des problèmes :

Code :

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

1
2
int Nbligne, NbColonne,*pNbligne=&Nbligne, *pNbColonne=&NbColonne, i;
   double** Matrice;

(Les pointeurs ont les définis souvent à NULL, les entiers à 0).
Il n'y a théoriquement pas besoin d'avoir des variables pointeurs pour Nbligne et NbColonne.
Essayez d'être consistant dans le nommage de vos variable "Nbligne" et "NbColonne"

Si c'est vraiment une matrice à deux dimensions, j'ose croire que vous avez un problème lors de la libération de mémoire. En effet, vous faites plusieurs malloc et un seul free, alors qu'il devrait avoir autant de free() que de malloc().

Moi, j'indiquerai un message d'erreur, dans le cas où le fichier ne s'ouvre pas.

[Invité]

Bonjour,

• Ton cast à cette ligne :
  

  Code :

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

  Matrice[i] = (double**) malloc((*pNbligne)*sizeof(double *));

  n'est pas correct, tu as dû obtenir un avertissement :
  

  Code :

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

  1
  2
  main.c:63:24: warning: assignment from incompatible pointer type [enabled by default]
               Matrice[i] = (double**) malloc((*pNbligne)*sizeof(double *));

  Matrice étant de type double** les Matrice [i] sont de type double *.
  Et dans l'absolu, en C tu n'as pas à faire ce cast au retour de malloc() (Cf. FAQ). Ne compilerais-tu pas en C++ par hasard ?
  

• Code :

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

  1
  2
  3
  4
          if(Matrice==NULL)
          {
              exit(0);
          }

  Une retour 0 désigne par convention un programme qui a bien fonctionné, là ce n'est pas le cas. Et étant dans le main, tu peux te contenter d'utiliser return. Il en va de même si le fichier ne peut pas être ouvert.
  
• Tes variables pNbligne et pNbColonne ne servent pas à grand chose ici, tu peux te contenter de prendre les adresses de NbLigne et NbColonne comme ceci :
  

  Code :

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

  init_matrice(&Nbligne, &NbColonne);

  et utiliser directement
  

  Code :

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

  for(i=0;i<Nbligne;i++)

• Dans ta fonction init_matrice(), il est normal que tu les passes en pointeur car tu veux fixer leur valeur, mais ce n'est pas la ces dans tes autres fonctions remplir_matrice() et affichage(). Autant utiliser des int
  

  Code :

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

  1
  2
  void affichage(int NbLigne, int NbColonne, double **matrice)
  void remplir_matrice( int NbLigne, int NbColonne, double ** matrice)

• free(Matrice); ne suffit pas : il faut aussi libérer tous les Matrice [i] avant.

[LittleWhite]

[*]

Code :

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

1
2
3
4
if(Matrice==NULL)
{
    exit(0);
}

Une retour 0 désigne par convention un programme qui a bien fonctionné, là ce n'est pas le cas. Et étant dans le main, tu peux te contenter d'utiliser return. Il en va de même si le fichier ne peut pas être ouvert.

Je rajouterai même, notamment pour l'utilisation de la fonction exit(), il existe deux définitions :

• EXIT_FAILURE ;
• EXIT_SUCCESS.

permettant d'écrire un code clair et d'avoir toujours le code d'erreur adéquat à la situation. (Voir : http://man.developpez.com/man3/exit/#L6 )

[Daxmawale]

Merci pour vos réponses, elles m'ont servis énormément ! Donc voilà le code avec les erreurs corrigées ( j'ai pris en compte vos conseils pour *pNbcolonne et *pNbligne mais je voie pas comment les utiliser en simple variable quand j'utilise la procédure,
void addition(int *pNbligne, int *pNbcolonne, double ** Matrice);
Je sais je vous avez caché cette fonction mais elle était en construction)

Code c :

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
 
#include <stdio.h>
#include <stdlib.h>
#define MAX 100
 
 
void affichage(int *pNbligne, int *pNbcolonne, double **matrice)
{
    int i,j;
 
    for(i=0;i<*pNbligne;i++)
    {
        printf("|");
        for(j=0;j<*pNbcolonne;j++)
        printf("%2.lf |",matrice[i][j]);
 
        printf("\n");
     }
 
}
 
void init_matrice(int *pNbligne, int *pNbcolonne)
{
 
    printf("Entrez le nombre de lignes \n");
    scanf("%d",pNbligne);
    printf("Entrez le nombre de colonne\n");
    scanf("%d",pNbcolonne);
 
}
 
 
void remplir_matrice( int *pNbligne, int *pNbcolonne, double ** matrice)
{
    int i,j;
 
    for(i=0;i<*pNbligne;i++)
    for(j=0;j<*pNbcolonne;j++)
    {
        printf("M[%d][%d]\n",i,j);
        scanf("%2lf",&matrice[i][j]);
    }
 
}
 
 
void addition(int *pNbligne, int *pNbcolonne, double ** Matrice)
{
    int Nbligne2=*pNbligne,Nbcolonne2=*pNbcolonne,i,j; //la matrice_resulta sera obligatoiremant de la même taille que  Matrice.
    int *pNbligne2=&Nbligne2, *pNbcolonne2=&Nbcolonne2;
    double** matrice_resultat;
 
    matrice_resultat = (double **)malloc((*pNbligne2)*sizeof(double *));
    if(matrice_resultat==NULL)
    {
        printf("Pas assee de memoire\n");
        exit(EXIT_FAILURE);
 
    }
 
    for(i=0;i<*pNbligne2;i++)
    {
       matrice_resultat[i] = (double*) calloc((*pNbligne2),sizeof(double));
          if(matrice_resultat[i]==NULL)
          {
              printf("pas assez de memoire");
              exit(EXIT_FAILURE);
          }
    }
 
    remplir_matrice( pNbligne2, pNbcolonne2, matrice_resultat);
 
    for (i=0; i<*pNbligne2; i++)
    for (j=0; j<*pNbcolonne2; j++)
    {
        matrice_resultat[i][j] += Matrice[i][j];
    }
 
    affichage( pNbligne2, pNbcolonne2, matrice_resultat);
 
 
    free(matrice_resultat);
    for(i=0;i<*pNbligne;i++)
    {
        free(matrice_resultat[i]);
    }
 
 
}
 
void multiplication(int *pNbligne, int *pNbcolonne, double ** Matrice)
{
    int Nbligne2=*pNbligne,Nbcolonne2=*pNbcolonne,i,j,k; //la matrice_resulta doit obligatoiremant avoir ligne(matrice_tmp)=colonne(matrice resultat) idem pour colonne.
    int *pNbligne2=&Nbligne2, *pNbcolonne2=&Nbcolonne2;
    double** matrice_resultat;
    double** matrice_tmp; //matrice tampon
 
    matrice_resultat = (double **)malloc((*pNbligne2)*sizeof(double *));
    matrice_tmp = (double **)malloc((*pNbligne2)*sizeof(double *));
    if(matrice_resultat==NULL || matrice_tmp==NULL)
    {
        printf("Pas assee de memoire\n");
        exit(EXIT_FAILURE);
 
    }
 
    for(i=0;i<*pNbligne2;i++)
    {
       matrice_resultat[i] = (double*) calloc((*pNbligne2),sizeof(double));
       matrice_tmp[i] = (double*) calloc((*pNbligne2),sizeof(double));
          if(matrice_resultat[i]==NULL || matrice_tmp[i]==NULL)
          {
              printf("pas assez de memoire");
              exit(EXIT_FAILURE);
          }
    }
 
    remplir_matrice( pNbligne2, pNbcolonne2, matrice_tmp);
 
    for (i=0; i<*pNbligne; i++)
    for (j=0; j<*pNbcolonne2; j++)
    {
        matrice_resultat[i][j]=0;
 
        for(k=0;k<*pNbcolonne;k++)
        {
            matrice_resultat[i][j] += Matrice[i][k]*matrice_tmp[k][j];
        }
 
    }
 
    affichage( pNbligne2, pNbcolonne2, matrice_resultat);
 
 
    free(matrice_resultat);
    free(matrice_tmp);
    for(i=0;i<*pNbligne;i++)
    {
        free(matrice_resultat[i]);
        free(matrice_tmp[i]);
    }
 
 
}
 
 
 
int main()
{
   int Nbligne=0, Nbcolonne=0, i;
   int *pNbligne=&Nbligne, *pNbcolonne=&Nbcolonne;
   double** Matrice;
 
   FILE* fichier=NULL;
   fichier=fopen("Matrice.txt","w");
 
   if( fichier!=NULL)
   {
        init_matrice(pNbligne, pNbcolonne);
 
        Matrice = (double**)malloc((*pNbligne)*sizeof(double *));
        for(i=0;i<*pNbligne;i++)
        {
            Matrice[i] = (double*) calloc((*pNbligne),sizeof(double));
               if(Matrice[i]==NULL)
               {
                   printf("pas assez de memoire");
                   exit(EXIT_FAILURE);
               }
        }
 
 
        if(Matrice==NULL)
        {
            printf("pas assez de memoire");
            exit(EXIT_FAILURE);
        }
 
 
        remplir_matrice(pNbligne,pNbcolonne,Matrice);
        affichage(pNbligne,pNbcolonne,Matrice);
        printf("\n ");
        printf("entrez la deuxieme matrice pour l'adition svp\n");
        addition(pNbligne,pNbcolonne,Matrice);
        printf("\n ");
        printf("entrez la deuxieme matrice pour la multiplication svp\n");
        multiplication(pNbligne,pNbcolonne,Matrice);
        free(Matrice);
        for(i=0;i<*pNbligne;i++)
        {
            free(Matrice[i]);
        }
 
        fclose(fichier);
 
    }
 
    return 0;
}

[Invité]

free(Matrice); ne suffit pas : il faut aussi libérer tous les Matrice [i] avant.

Je te laisse appliquer les autres changements suggérés dans mon message

[Sve@r]

Merci pour vos réponses, elles m'ont servis énormément ! Donc voilà le code avec les erreurs corrigées ( j'ai pris en compte vos conseils pour *pNbcolonne et *pNbligne mais je voie pas comment les utiliser en simple variable quand j'utilise la procédure,
void addition(int *pNbligne, int *pNbcolonne, double ** Matrice);

Cette fonction n'a pas besoin de recevoir de pointeur vu que l'élément à traiter est un élément simple (un "int") et que cet élément n'est pas modifié dans la fonction

Exemple d'un pointeur inutile

Code c :

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

1
2
3
4
5
6
7
8
9
10
void affiche(int *pt)
{
    printf("Ma valeur est %d\n", *pt);
}
 
int main()
{
    int i=10;
    affiche(&i);
}

Exemple en remplaçant le pointeur par une variable simple

Code c :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
void affiche(int v)
{
    printf("Ma valeur est %d\n", v);
}
 
int main()
{
    int i=10;
    affiche(i);
 
    // Et on peut même passer une valeur, voire une opération, en direct (ce qu'on ne pouvait pas faire dans l'exemple précédent)
    affiche(125 + 236)
}

Les pointeurs, c'est bien mais c'est comme pour tout, faut pas en abuser...

[Daxmawale]

Merci pour les exemples et pour votre aide!

[Daxmawale]

re moi , donc voilà j'ai fini mon projet résolu les bugs, appliqué vos conseils ( oui oui tout vos conseils)... mais il y a un problème que j'arrive pas à résoudre...

Code c :

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
 
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
 
 
void affichage(int Nbligne,int Nbcolonne,double** matrice,FILE* fichier)
{
    int i,j;
 
        for(i=0;i<Nbligne;i++)
        {
            printf("|");
                for(j=0;j<Nbcolonne;j++)
                {
                    printf("%.8lf |",matrice[i][j]);//.8lf car les égalitées de deux nombres doubles seras vérifié si la valeur absolue de la différence est inférieur à 10^-8.
                }
 
            printf("\n");
        }
 
        for(i=0;i<Nbligne;i++)
        {
            fprintf(fichier,"|");
                for(j=0;j<Nbcolonne;j++)
                    fprintf(fichier,"%.8lf |",matrice[i][j]);//.8lf car les égalitées de deux nombres doubles seras vérifié si la valeur absolue de la différence est inférieur à 10^-8.
 
            fprintf(fichier,"\n");
        }
 
}
 
 
 
void remplir_matrice(int Nbligne,int Nbcolonne,double** matrice)
{
    int i,j;
 
        for(i=0;i<Nbligne;i++)
            for(j=0;j<Nbcolonne;j++)
            {
                printf("M[%d][%d]\n",i,j);
                scanf("%lf",&matrice[i][j]);// on entre un double car matrice de type double
            }
 
}
 
 
 
void addition(int Nbligne,int Nbcolonne,double** Matrice,double** matrice_resultat)// additions de matrrices
{
    int i,j;
 
        for (i=0; i<Nbligne; i++)//la matrice_resultat sera obligatoiremant de la même taille que  Matrice car elles doivente être de même taille.
 
            for(j=0; j<Nbcolonne; j++)
            {
                matrice_resultat[i][j] += Matrice[i][j];//M+M.
            }
 
}
 
 
int main()
{
    int Nbligne,Nbcolonne,i,j,k;
    double** matrice;
    double** matrice_resultat;
    double** matrice_tmp;
    double** matriceID;
    double scalaire;
 
    FILE* fichier=NULL;
    fichier=fopen("Matrice.txt","a+");
 
        if( fichier!=NULL)
        {
//----------------------------------------------------exercice 2---------------------------------------------------------------------------------
            fprintf(fichier,"-----EXERCICE 2-----\n");//la matrice_resultat sera obligatoiremant de la même taille que  Matrice car elles doivente être de même taille.
            printf("\n");
            printf("-----EXERCICE 2-----\n");
            //initialisation de la taille.
            printf("Entrez le nombre de lignes \n");
            scanf("%d",&Nbligne);
            printf("Entrez le nombre de colonne\n");
            scanf("%d",&Nbcolonne);
            printf("\n");
            //allocations mémoires des Double**
            matrice = (double**)malloc(Nbligne*sizeof(double *));
            matrice_resultat = (double**)malloc(Nbligne*sizeof(double *));
                if(matrice==NULL || matrice_resultat==NULL)
                {
                    printf("pas assez de memoire");
                    exit(EXIT_FAILURE);
                }
                for(i=0;i<Nbligne;i++)
                {
                    matrice[i] = (double*) calloc((Nbligne),sizeof(double));
                    matrice_resultat[i] =  (double*) calloc((Nbligne),sizeof(double));
                        if(matrice[i]==NULL)
                        {
                            printf("pas assez de memoire");
                            exit(EXIT_FAILURE);
                        }
                }
            printf("\n ");
            printf("Entrez la premiere matrice pour l'adition svp\n");
            remplir_matrice(Nbligne,Nbcolonne,matrice);
            printf("\n ");
            printf("Entrez la deuxieme matrice pour l'adition svp\n");
            printf("\n");
            remplir_matrice( Nbligne, Nbcolonne, matrice_resultat);//initialise la matrice resultat.
            fprintf(fichier,"Voici l'adition des deux matrices saisient \n");
            addition(Nbligne,Nbcolonne,matrice,matrice_resultat);
            printf("\n");
            printf("Voici l'adition des deux matrices saisient\n");
            affichage( Nbligne, Nbcolonne, matrice_resultat, fichier);//on affaiche le résultat de l'addition.
                //libération de la mémoire.
                for(i=0;i<Nbligne;i++)
                {
                    free(matrice[i]);
                    free(matrice_resultat[i]);
                }
            free(matrice);
            free(matrice_resultat);
 
//------------------------------------------------------------------------------------------------------------------------------------------------
 
                }
 
    fclose(fichier);
 
 
return 0;
}

C'est la fonction addition, quand j'entre une matrice impaire ( lorsque le nombre de colonnes et supérieur aux nombres de lignes )

exemple avec une matrice de 2 lignes et 3 colonnes
la première matrice.
|1|2|3|
|6|5|4|
deuxième matrice
|20|21|22|
|23|24|25|

le prog m'affiche la somme mais ensuite il s’arrête une fois sur deux... ça doit être due à la mémoire mais je vois pas...

merci d'avance ! (une fois le probléme résolue je vous poste mon jolie projet pour vous montrer que votre aide m'a vraiment servi )

PS: avec les matrices carrées ou lorsque le nombre de ligne et supérieur aux nombres de colonnes ça marche très bien...

[Invité]

Code :

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

1
2
                    matrice[i] = (double*) calloc((Nbligne),sizeof(double));
                    matrice_resultat[i] =  (double*) calloc((Nbligne),sizeof(double));

Ne serait-ce pas plutôt Nbcolonne ?

[Daxmawale]

Oooh je t'aime ! si t'étais en face de moi je te ferrai un gros câlin !
Merci merci merci!

je poste mon projet après, je remodifie et je le rend plus jolie.

[Daxmawale]

Et voilà mon projet comme promis fini, merci à vous, vous m'avez donnés de bonne base pour la programmation. Je vous en suis entièrement reconnaissant !

Code c :

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
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
 
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
 
 
void affichage(int Nbligne,int Nbcolonne,double** matrice,FILE* fichier)
{
    int i,j;
 
        for(i=0;i<Nbligne;i++)
        {
            printf("|");
                for(j=0;j<Nbcolonne;j++)
                {
                    printf("%.8lf |",matrice[i][j]);//.8lf car les égalitées de deux nombres doubles seras vérifié si la valeur absolue de la différence est inférieur à 10^-8.
                }
 
            printf("\n");
        }
 
        for(i=0;i<Nbligne;i++)
        {
            fprintf(fichier,"|");
                for(j=0;j<Nbcolonne;j++)
                    fprintf(fichier,"%.8lf |",matrice[i][j]);//.8lf car les égalitées de deux nombres doubles seras vérifié si la valeur absolue de la différence est inférieur à 10^-8.
 
            fprintf(fichier,"\n");
        }
 
}
 
 
 
void remplir_matrice(int Nbligne,int Nbcolonne,double** matrice)
{
    int i,j;
 
        for(i=0;i<Nbligne;i++)
            for(j=0;j<Nbcolonne;j++)
            {
                printf("M[%d][%d]\n",i,j);
                scanf("%lf",&matrice[i][j]);// on entre un double car matrice de type double
            }
 
}
 
 
 
void addition(int Nbligne,int Nbcolonne,double** Matrice,double** matrice_resultat)// additions de matrrices
{
    int i,j;
 
        for (i=0; i<Nbligne; i++)//la matrice_resultat sera obligatoiremant de la même taille sinon l'addition marche pas.
 
            for(j=0; j<Nbcolonne; j++)
            {
                matrice_resultat[i][j] += Matrice[i][j];//M+M.
            }
 
}
 
 
 
void multiplication(int Nbligne,int Nbcolonne,double** Matrice,double** matrice_tmp,double** matrice_resultat)
{
    int i,j,k; //la matrice_resulta doit obligatoiremant avoir ligne(matrice_tmp)=colonne(matrice resultat) idem pour colonne sinon la multiplication ne marche pas.
 
 
        for (i=0; i<Nbligne; i++)
            for (j=0; j<Nbcolonne; j++)
            {
                matrice_resultat[i][j]=0;//initilisation à 0 de la matrice_resultat pour éviter un calcul faux.
                    for(k=0;k<Nbcolonne;k++)
                    {
                        matrice_resultat[i][j] += Matrice[i][k]*matrice_tmp[k][j];//Matrice3=M1*M2.
                    }
 
            }
}
 
 
 
void multiplication_scalaire(int Nbligne,int Nbcolonne,double scalaire,double** Matrice,double** matrice_resultat)//Multiplication d'une matrice avec un scalaire.
{
 
    int Nbligne2=Nbligne,Nbcolonne2=Nbcolonne,i,j; //la matrice_resulta sera obligatoiremant de la même taille que  Matrice.
 
        for (i=0; i<Nbligne2; i++)
            for (j=0; j<Nbcolonne2; j++)
            {
                matrice_resultat[i][j] = scalaire*Matrice[i][j]; // M2=x*M1
            }
 
}
 
 
 
void transposee(int Nbligne,int Nbcolonne,double** matrice,double** matrice_resultat)//Transposée de matrice.
{
    int i,j;
 
        for (i=0; i<Nbligne; i++)
            for (j=0; j<Nbcolonne; j++)
                matrice_resultat[j][i]=matrice[i][j];//M(n,m)=>M^t(m,n).
}
 
 
 
int symetrie_Matrice(int Nbligne,double** matrice )//vérifie si une matrice est symétrique.
{
    int j;
    int i=0;
 
        while(i<Nbligne)// plus rapide ( car moins de comparaison à faire) si on utilise ce modéle à la place d'une deuxiéme boucle for.
        {
            for(j=i;j<Nbligne;j++)
            {
                if(abs( matrice[i][j]-matrice[j][i])<pow(10,-8))
                {
                  matrice[i][j] = matrice[j][i];
                }
 
                if ( matrice[i][j] != matrice[j][i])// Une matrice symétrique est une matrice carrée qui est égale à sa propre transposée, si M=M^t.
                    return 0;//retourne 0 si elle n'est pas symétrique
            }
            i++;
        }
 
return 1; //retourne 1 si elle est symétrique
}
 
int antisymetrique_Matrice(int Nbligne,double** matrice )//vérifie si une matrice est antisymétrique
{
    int j;
    int i=0;
 
        while(i<Nbligne)
        {
            for(j=i;j<Nbligne;j++)
            {
                if(abs(matrice[i][j]-matrice[j][i])<pow(10,-8))
                {
                  matrice[i][j] = matrice[j][i];
                }
 
                if ( (-matrice[i][j]) != matrice[j][i] || matrice[i][j] != (-matrice[j][i]) )//si M^t!=-A.
                    return 0;//alors la matrice n'est pas antisymétrique.
            }
                i++;
        }
    return 1;// matrice antisymétrique
}
 
 
 
int matrice_orthogonale(int Nbligne,int Nbcolonne,double** matrice,double** matrice_resultat,double** matriceID,double** matrice_tmp,FILE* fichier) //vérifie si une matrice est transposable.
{
    int i,j;
 
        for(i=0;i<Nbligne;i++)
        {
             matriceID[i][i]=1;//On initialise une matrice identitée.
        }
 
    transposee(Nbligne,Nbcolonne,matrice,matrice_tmp);
    multiplication(Nbligne,Nbcolonne,matrice,matrice_tmp,matrice_resultat);//on vérifie si elle est orthogonale graçe à M^t * M = Id.
 
        for(i=0;i<Nbligne;i++)
            for(j=0;j<Nbcolonne;j++)
                if(matrice_resultat[i][j]!=matriceID[i][j])//si M^t * M = Id.
                {
                    return 0;//la matrice n'est pas orthogonale.
                }
 
return 1;//la matrice est orthogonale.
}
 
 
 
int main()
{
    int Nbligne,Nbcolonne,i,j;
    double** matrice;
    double** matrice_resultat;
    double** matrice_tmp;
    double** matriceID;
    double scalaire;
 
    FILE* fichier=NULL;
    fichier=fopen("Matrice.txt","a+");
 
        if( fichier!=NULL)//si le fichier est créé
        {
 
 
//----------------------------------------------------exercice 1---------------------------------------------------------------------------------
            fprintf(fichier,"-----EXERCICE 1-----\n");
            printf("-----EXERCICE 1-----\n");
            //initialisation de la taille.
            printf("Entrez le nombre de lignes \n");
            scanf("%d",&Nbligne);
            printf("Entrez le nombre de colonne\n");
            scanf("%d",&Nbcolonne);
            printf("\n");
            //allocations mémoires des Double**.
            matrice = (double**)malloc((Nbligne)*sizeof(double *));
                if(matrice==NULL)
                {
                    printf("pas assez de memoire");
                    exit(EXIT_FAILURE);
                }
                for(i=0;i<Nbligne;i++)
                {
                    matrice[i] = (double*) calloc((Nbcolonne),sizeof(double));
                        if(matrice[i]==NULL)
                        {
                            printf("pas assez de memoire");
                            exit(EXIT_FAILURE);
                        }
                }
            remplir_matrice(Nbligne,Nbcolonne,matrice);
            printf("\n");
            printf("voici votre matrice\n");
            affichage(Nbligne,Nbcolonne,matrice,fichier);
                //libération de la mémoire.
                for(i=0;i<Nbligne;i++)
                {
                    free(matrice[i]);
                }
            free(matrice);
 
 //----------------------------------------------------------------------------------------------------------------------------------------------
 
            fprintf(fichier,"\n");
 
//----------------------------------------------------exercice 2---------------------------------------------------------------------------------
            fprintf(fichier,"-----EXERCICE 2-----\n");//la matrice_resultat sera obligatoiremant de la même taille que  Matrice car elles doivente être de même taille.
            printf("\n");
            printf("-----EXERCICE 2-----\n");
            //initialisation de la taille.
            printf("Entrez le nombre de lignes \n");
            scanf("%d",&Nbligne);
            printf("Entrez le nombre de colonne\n");
            scanf("%d",&Nbcolonne);
            printf("\n");
            //allocations mémoires des Double**
            matrice = (double**)malloc(Nbligne*sizeof(double *));
            matrice_resultat = (double**)malloc(Nbligne*sizeof(double *));
                if(matrice==NULL || matrice_resultat==NULL)
                {
                    printf("pas assez de memoire");
                    exit(EXIT_FAILURE);
                }
                for(i=0;i<Nbligne;i++)
                {
                    matrice[i] = (double*) calloc((Nbcolonne),sizeof(double));
                    matrice_resultat[i] =  (double*) calloc((Nbcolonne),sizeof(double));
                        if(matrice[i]==NULL)
                        {
                            printf("pas assez de memoire");
                            exit(EXIT_FAILURE);
                        }
                }
            printf("\n ");
            printf("Entrez la premiere matrice pour l'adition svp\n");
            remplir_matrice(Nbligne,Nbcolonne,matrice);
            printf("\n ");
            printf("Entrez la deuxieme matrice pour l'adition svp\n");
            printf("\n");
            remplir_matrice( Nbligne, Nbcolonne, matrice_resultat);//initialise la matrice resultat.
            fprintf(fichier,"Voici l'adition des deux matrices saisient \n");
            addition(Nbligne,Nbcolonne,matrice,matrice_resultat);
            printf("\n");
            printf("Voici l'adition des deux matrices saisient\n");
            affichage( Nbligne, Nbcolonne, matrice_resultat, fichier);//on affaiche le résultat de l'addition.
                //libération de la mémoire.
                for(i=0;i<Nbligne;i++)
                {
                    free(matrice[i]);
                    free(matrice_resultat[i]);
                }
            free(matrice);
            free(matrice_resultat);
 
//------------------------------------------------------------------------------------------------------------------------------------------------
 
            fprintf(fichier,"\n");
 
//----------------------------------------------------exercice 3----------------------------------------------------------------------------------
            printf("\n ");
            fprintf(fichier,"-----EXERCICE 3-----\n");
            printf("-----EXERCICE 3-----\n");
            printf("Entrez un nombre pour la multiplication par un scalaire svp\n");
            scanf("%lf",&scalaire);
            printf("\n ");
            //initialisation de la taille.
            printf("Entrez le nombre de lignes \n");
            scanf("%d",&Nbligne);
            printf("Entrez le nombre de colonne\n");
            scanf("%d",&Nbcolonne);
            printf("\n");
            printf("\n ");
            printf("Entrez une matrice pour la multiplier avec le scalaire svp\n");
            printf("\n ");
            //allocations mémoires des Double**.
            matrice = (double**)malloc((Nbligne)*sizeof(double *));
            matrice_resultat = (double**)malloc((Nbligne)*sizeof(double *));
                if(matrice==NULL)
                {
                    printf("pas assez de memoire");
                    exit(EXIT_FAILURE);
                }
                for(i=0;i<Nbligne;i++)
                {
                    matrice[i] = (double*) calloc((Nbcolonne),sizeof(double));
                    matrice_resultat[i] = (double*) calloc((Nbcolonne),sizeof(double));
                        if(matrice[i]==NULL)
                        {
                            printf("pas assez de memoire");
                            exit(EXIT_FAILURE);
                        }
                }
            remplir_matrice(Nbligne,Nbcolonne,matrice);
            printf("\n");
            multiplication_scalaire(Nbligne,Nbcolonne,scalaire,matrice,matrice_resultat);
            fprintf(fichier,"Voici le produit de la multiplication d'une matrice par un scalaire\n");
            printf("\n");
            printf("Voici le produit de la multiplication d'une matrice par un scalaire\n");
            affichage(Nbligne,Nbcolonne,matrice_resultat,fichier);// affichage du produit de la matrice par un scalaire.
                for(i=0;i<Nbligne;i++)
                {
                    free(matrice[i]);
                    free(matrice_resultat[i]);
                }
            free(matrice);
            free(matrice_resultat);
 
//------------------------------------------------------------------------------------------------------------------------------------------------
 
            fprintf(fichier,"\n");
 
//----------------------------------------------------exercice 4----------------------------------------------------------------------------------
            fprintf(fichier,"-----EXERCICE 4-----\n");
            printf("\n ");
            printf("-----EXERCICE 4-----\n");
            printf("\n ");
            printf("Multiplications de matrice\n");
            printf("Entrez le nombre de lignes\n");
            scanf("%d",&Nbligne);
            printf("Entrez le nombre de colonne\n");
            scanf("%d",&Nbcolonne);
            printf("\n ");
            //allocation de mémoire
            matrice_tmp= (double**)malloc((Nbcolonne)*sizeof(double *));// ligne=colonne, colonnes=ligne pour la deuxiéme matrice.
            matrice = (double**)malloc((Nbligne)*sizeof(double *));
            matrice_resultat = (double**)malloc((Nbligne)*sizeof(double *));
                if(matrice==NULL || matrice_resultat==NULL)
                {
                    printf("pas assez de memoire");
                    exit(EXIT_FAILURE);
                }
                for(i=0;i<Nbligne;i++)
                {
                    matrice_tmp[i] = (double*) calloc((Nbligne),sizeof(double));
                    matrice[i] = (double*) calloc((Nbcolonne),sizeof(double));
                    matrice_resultat[i] =  (double*) calloc((Nbcolonne),sizeof(double));
                        if(matrice[i]==NULL)
                        {
                            printf("pas assez de memoire");
                            exit(EXIT_FAILURE);
                        }
                }
            printf("Entrez la premiere matrice pour la multiplication  svp\n");
            printf("\n");
            remplir_matrice( Nbligne, Nbcolonne, matrice);//la matrice_resulta doit obligatoiremant avoir ligne(matrice_tmp)=colonne(matrice resultat) idem pour colonne sinon la multiplication n'est pas possible.
            printf("\n ");
            printf("Entrez la deuxieme matrice  pour la multiplication  svp\n");
            remplir_matrice( Nbcolonne, Nbligne, matrice_tmp);
            multiplication(Nbligne,Nbcolonne,matrice,matrice_tmp,matrice_resultat);
            fprintf(fichier,"voici le produit des deux matrices\n");
            printf("\n");
            printf("voici le produit des deux matrices \n");
            affichage( Nbligne, Nbcolonne, matrice_resultat,fichier);//affichage de la multiplication des matrices.
                for(i=0;i<Nbligne;i++)
                {
                    free(matrice_tmp[i]);
                    free(matrice[i]);
                    free(matrice_resultat[i]);
                }
            free(matrice_tmp);
            free(matrice);
            free(matrice_resultat);
//------------------------------------------------------------------------------------------------------------------------------------------------
 
            fprintf(fichier,"\n");
 
 //----------------------------------------------------exercice 5----------------------------------------------------------------------------------
            printf("\n ");
            fprintf(fichier,"-----EXERCICE 5-----\n");
            printf("-----EXERCICE 5-----\n");
            printf("\n ");
            printf("Entrez la transposee \n");
            printf("\n");
            //initialisation de la taille.
            printf("Entrez le nombre de lignes \n");
            scanf("%d",&Nbligne);
            printf("Entrez le nombre de colonne\n");
            scanf("%d",&Nbcolonne);
            printf("\n");
            //allocations mémoires des Double**
            matrice = (double**)malloc((Nbligne)*sizeof(double *));
            matrice_resultat = (double**)malloc((Nbligne)*sizeof(double *));
                if(matrice==NULL || matrice_resultat==NULL)
                {
                    printf("pas assez de memoire");
                    exit(EXIT_FAILURE);
                }
                for(i=0;i<Nbligne;i++)
                {
                    matrice[i] = (double*) calloc((Nbcolonne),sizeof(double));
                    matrice_resultat[i] =  (double*) calloc((Nbcolonne),sizeof(double));
                        if(matrice[i]==NULL)
                        {
                            printf("pas assez de memoire");
                            exit(EXIT_FAILURE);
                        }
                }
            remplir_matrice(Nbligne,Nbcolonne,matrice);
            transposee(Nbligne,Nbcolonne,matrice,matrice_resultat); //les lignes et les colonnes sont maitenant inversaient
            fprintf(fichier,"Voici la transposee\n");
            printf("\n");
            printf("voici la transposee\n");
            affichage(Nbcolonne,Nbligne,matrice_resultat,fichier);// affichage de la transposée.
                for(i=0;i<Nbligne;i++)
                {
                    free(matrice[i]);
                    free(matrice_resultat[i]);
                }
            free(matrice);
            free(matrice_resultat);
 
//------------------------------------------------------------------------------------------------------------------------------------------------
 
            fprintf(fichier,"\n");
 
//----------------------------------------------------exercice 6----------------------------------------------------------------------------------
             printf("\n ");
            fprintf(fichier,"-----EXERCICE 6-----\n");
            printf("-----EXERCICE 6-----\n");
            printf("\n ");
                for(i=0;i<3;i++)//i<3 car 3 symétries vérifier.
                {
                    printf("\n");
                    printf("Entrez la Matrice %d pour savoir si elle est symetrique\n",i+1);
                    printf("\n");
                    printf("Entrez le nombre de lignes \n");
                    scanf("%d",&Nbligne);
                    printf("Entrez le nombre de colonne\n");
                    scanf("%d",&Nbcolonne);
                    printf("\n");
                    //allocations mémoires des Double**.
                    matrice = (double**)malloc((Nbligne)*sizeof(double *));
                        if(matrice==NULL)
                        {
                            printf("pas assez de memoire");
                            exit(EXIT_FAILURE);
                        }
                        for(j=0;j<Nbligne;j++)
                        {
                            matrice[j] = (double*) calloc((Nbcolonne),sizeof(double));
                                if(matrice[j]==NULL)
                                {
                                    printf("pas assez de memoire");
                                    exit(EXIT_FAILURE);
                                }
                        }
                            remplir_matrice(Nbligne,Nbcolonne,matrice);
                            affichage(Nbligne,Nbcolonne,matrice,fichier);
                            printf("\n");
 
                        if( Nbligne==Nbcolonne)
                        {
                            if(!symetrie_Matrice(Nbligne,matrice))
                            {
                                fprintf(fichier,"\n");
                                fprintf(fichier,"Matrice numero %d non symetrique\n",i+1);
                                fprintf(fichier,"\n");
                                printf("Matrice numero %d non symetrique\n",i+1);
                            }
                                    else
                                    {
                                        fprintf(fichier,"\n");
                                        fprintf(fichier,"Matrice %d symetrique\n",i+1);
                                        fprintf(fichier,"\n");
                                        printf("\n");
                                        printf("Matrice %d symetrique\n",i+1);
                                    }
 
                        }
                            else
                            {
                                 fprintf(fichier,"\n");
                                 fprintf(fichier,"Impossible la matrice %d n'est pas caree\n",i+1);
                                 fprintf(fichier,"\n");
                                 printf("Impossible la matrice %d n'est pas caree\n",i+1);
                            }
                }
 
                        //libération de la mémoire.
                        for(j=0;j<Nbligne;j++)
                        {
                            free(matrice[j]);
                        }
                    free(matrice);
 
 
//------------------------------------------------------------------------------------------------------------------------------------------------
 
            fprintf(fichier,"\n");
 
//----------------------------------------------------exercice 7----------------------------------------------------------------------------------
               fprintf(fichier,"-----EXERCICE 7-----\n");
               printf("-----EXERCICE 7-----\n");
                    for(i=0;i<3;i++)//i<3 3 antisymétries à vérifier.
                    {
 
                        printf("\n");
                        printf("Entrez la Matrice %d pour savoir si elle est antisymetrique\n",i+1);
                        printf("\n");
                        printf("Entrez le nombre de lignes \n");
                        scanf("%d",&Nbligne);
                        printf("Entrez le nombre de colonne\n");
                        scanf("%d",&Nbcolonne);
                        printf("\n");
                        //allocations mémoires des Double**.
                        matrice = (double**)malloc((Nbligne)*sizeof(double *));
                            if(matrice==NULL)
                            {
                                printf("pas assez de memoire");
                                exit(EXIT_FAILURE);
                            }
                            for(j=0;j<Nbligne;j++)
                            {
                                matrice[j] = (double*) calloc((Nbcolonne),sizeof(double));
                                    if(matrice[j]==NULL)
                                    {
                                        printf("pas assez de memoire");
                                        exit(EXIT_FAILURE);
                                    }
                            }
                        remplir_matrice(Nbligne,Nbcolonne,matrice);
                        affichage(Nbligne,Nbcolonne,matrice,fichier);
                        printf("\n");
 
                            if( Nbligne==Nbcolonne)
                            {
                                if(!antisymetrique_Matrice( Nbligne, matrice))
                                {
                                    fprintf(fichier,"\n");
                                    fprintf(fichier, "Matrice %d non antisymetrique\n",i+1);
                                    fprintf(fichier,"\n");
                                    printf("\n");
                                    printf("Matrice %d non antisymetrique\n",i+1);
                                }
                                        else
                                        {
                                            fprintf(fichier,"\n");
                                            fprintf(fichier, "Matrice %d antisymetrique\n",i+1);
                                            fprintf(fichier,"\n");
                                            printf("\n");
                                            printf("Matrice %d antisymetrique\n",i+1);
                                        }
                            }
                                else
                                {
                                    fprintf(fichier,"Impossible la matrice %d n'est pas caree\n",i+1);
                                    fprintf(fichier,"\n");
                                    printf("Impossible la matrice %d n'est pas caree\n",i+1);
                                }
                                for(j=0;j<Nbligne;j++)
                                {
                                free(matrice[j]);
                                }
                            free(matrice);
                        }
//------------------------------------------------------------------------------------------------------------------------------------------------
 
        fprintf(fichier,"\n");
 
 //----------------------------------------------------exercice 8----------------------------------------------------------------------------------
            fprintf(fichier,"-----EXERCICE 8-----\n");
            printf("-----EXERCICE 7-----\n");
                for(i=0;i<2;i++)//i<2 car deux orthogonales à vérifier.
                {
                    printf("\n");
                    printf("Entrez la Matrice pour savoir si elle est orthogonale %d\n",i+1);
                    printf("\n");
                    printf("Entrez le nombre de lignes \n");
                    scanf("%d",&Nbligne);
                    printf("Entrez le nombre de colonne\n");
                    scanf("%d",&Nbcolonne);
                    matrice = (double**)malloc((Nbligne)*sizeof(double *));
                    matrice_resultat = (double**)malloc((Nbligne)*sizeof(double *));
                    matriceID = (double**)malloc((Nbligne)*sizeof(double *));
                    matrice_tmp = (double**)malloc((Nbligne)*sizeof(double *));
                        if(matrice==NULL)
                        {
                            printf("pas assez de memoire");
                            exit(EXIT_FAILURE);
                        }
                        for(j=0;j<Nbligne;j++)
                        {
                            matrice[j] = (double*) calloc((Nbcolonne),sizeof(double));
                            matrice_tmp[j] = (double*) calloc((Nbcolonne),sizeof(double));
                            matrice_resultat[j] = (double*) calloc((Nbcolonne),sizeof(double));
                            matriceID[j] = (double*) calloc((Nbcolonne),sizeof(double));
                                if(matrice[j]==NULL)
                                {
                                    printf("pas assez de memoire");
                                    exit(EXIT_FAILURE);
                                }
                        }
                    printf("\n");
                    remplir_matrice(Nbligne,Nbcolonne,matrice);
                    printf("\n");
                    affichage(Nbligne,Nbcolonne,matrice,fichier);
                    printf("\n");
 
                         if(Nbligne==Nbcolonne)
                        {
                            if(!matrice_orthogonale(Nbligne,Nbcolonne,matrice,matrice_resultat,matriceID,matrice_tmp,fichier))
                            {
                                fprintf(fichier,"\n");
                                fprintf(fichier,"Matrice  %d non orthogonale\n",i+1);
                                printf("\n");
                                printf("Matrice  %d non orthogonale\n",i+1);
                            }
                                    else
                                    {
                                          fprintf(fichier,"\n");
                                          fprintf(fichier, "Matrice %d orthogonale\n",i);
                                          printf("\n");
                                          printf("Matrice %d orthogonale\n",i);
                                    }
                        }
 
                            else
                            {
                                fprintf(fichier,"Impossible la matrice %d n'est pas caree\n",i);
                                printf("Impossible la matrice %d n'est pas caree\n",i);
                            }
 
 
                for(j=0;j<Nbligne;j++)
                {
                    free(matrice[j]);
                    free(matrice_resultat[j]);
                    free(matrice_tmp[j]);
                    free(matriceID[j]);
                }
 
            free(matrice);
            free(matrice_resultat);
            free(matrice_tmp);
            free(matriceID);
            fclose(fichier);
    }
                }
 
    fclose(fichier);
 
 
return 0;
}

[Sve@r]

Et voilà mon projet comme promis fini, merci à vous, vous m'avez donnés de bonne base pour la programmation. Je vous en suis entièrement reconnaissant !

Code c :

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
 
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
 
 
void affichage(int Nbligne,int Nbcolonne,double** matrice,FILE* fichier)
{
    int i,j;
 
        for(i=0;i<Nbligne;i++)
        {
            printf("|");
                for(j=0;j<Nbcolonne;j++)
                {
                    printf("%.8lf |",matrice[i][j]);//.8lf car les égalitées de deux nombres doubles seras vérifié si la valeur absolue de la différence est inférieur à 10^-8.
                }
 
            printf("\n");
        }
 
        for(i=0;i<Nbligne;i++)
        {
            fprintf(fichier,"|");
                for(j=0;j<Nbcolonne;j++)
                    fprintf(fichier,"%.8lf |",matrice[i][j]);//.8lf car les égalitées de deux nombres doubles seras vérifié si la valeur absolue de la différence est inférieur à 10^-8.
 
            fprintf(fichier,"\n");
        }
 
}

As-tu remarqué que quasiment toutes tes fonctions devaient recevoir comme paramètre la matrice bien entendu mais aussi ses dimensions ???
Puisque les dimensions sont aussi liées à la matrice que le sont jj, mm et aa pour une date, pourquoi ne pas regrouper tout ça dans une structure ???

Code c :

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

1
2
3
4
5
typedef struct {
	unsigned short nbLig;
	unsigned short nbCol;
	double **val;
} t_matrice;

Ainsi, tu n'as plus besoin de passer tous ces paramètres aux fonctions. Te suffit juste de passer la structure (ou plus précisément un pointeur car c'est plus rapide) et hop, les fonctions ont instantanément accès à tous les éléments nécessaires. Accessoirement tu noteras le soucis de l'optimisation en n'oubliant pas que des dimensions étant forcément positives et ne dépassant très certainement pas la valeur de 65535, on peut les mettre unsigned short plutôt que int.

Par ailleurs, c'est dommage de faire une fonction qui fait deux fois la même chose à une nuance près car la première fois elle affiche dans stdout et la seconde elle affiche dans un fichier. Pourquoi ne pas en faire une plus générale qui ne fait le travail qu'une fois mais qui le fait là où tu lui dis de le faire...?

Code c :

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

1
2
3
4
5
6
7
8
9
10
11
12
void affichage(t_matrice *matrice, FILE* fichier)
{
	unsigned short i,j;
 
	for(i=0;i<matrice->nbLig;i++)
	{
		fputc('|', fichier);
		for(j=0;j<matrice->nbCol;j++)
			fprintf(fichier, "%.8lf |",matrice->val[i][j]);//.8lf car les égalitées de deux nombres doubles seras vérifié si la valeur absolue de la différence est inférieur à 10^-8.
		fputc('\n', fichier);
	}
}

Et ensuite tu n'as plus qu'à l'appeler deux fois, la première en lui passant le fichier et la seconde en lui passant stdout. Et là encore tu noteras le soucis de l'optimisation en préférant fputc() plus adapté que printf() lorsqu'il n'y a qu'un simple caractère à afficher...

Code c :

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
 
int symetrie_Matrice(int Nbligne,double** matrice )//vérifie si une matrice est symétrique.
{
    int j;
    int i=0;
 
        while(i<Nbligne)// plus rapide ( car moins de comparaison à faire) si on utilise ce modéle à la place d'une deuxiéme boucle for.
        {
            for(j=i;j<Nbligne;j++)
            {
                if(abs( matrice[i][j]-matrice[j][i])<pow(10,-8))
                {
                  matrice[i][j] = matrice[j][i];
                }
 
                if ( matrice[i][j] != matrice[j][i])// Une matrice symétrique est une matrice carrée qui est égale à sa propre transposée, si M=M^t.
                    return 0;//retourne 0 si elle n'est pas symétrique
            }
            i++;
        }
 
return 1; //retourne 1 si elle est symétrique
}
 
int antisymetrique_Matrice(int Nbligne,double** matrice )//vérifie si une matrice est antisymétrique
{
    int j;
    int i=0;
 
        while(i<Nbligne)
        {
            for(j=i;j<Nbligne;j++)
            {
                if(abs(matrice[i][j]-matrice[j][i])<pow(10,-8))
                {
                  matrice[i][j] = matrice[j][i];
                }
 
                if ( (-matrice[i][j]) != matrice[j][i] || matrice[i][j] != (-matrice[j][i]) )//si M^t!=-A.
                    return 0;//alors la matrice n'est pas antisymétrique.
            }
                i++;
        }
    return 1;// matrice antisymétrique
}

Ces deux fonctions ne font-elles pas exactement la même chose ??? A savoir que si antisymetrique_Matrice() == 1 renvoie vrai, alors symetrie_Matrice() != 1 renverra vrai aussi...