Multiplication de matrices

salut

je dois faire le produit de deux matrices dynamiquement, quand je veux l'exécuter cela ne marche pas .aidez-moi s'il vous plait

merci d'avance

Code:

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
 
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
int main( int argc, char *argv[] ){
int N;
float *A, *B, *C;
N = atoi(argv[1]);
 
   int i, j;
 
    A = malloc(N*sizeof(*A));
for(i = 0; i < N; ++i)
    A[i] = malloc(N * sizeof(**A));
 
    B = malloc(N*sizeof(*B));
for(i = 0; i < N; ++i)
    B[i] = malloc(N * sizeof(**B));
    C= malloc(N*sizeof(*C));
for(i = 0; i < N; ++i)
    C[i] = malloc(N * sizeof(**C));
 
    for(i = 0; i < N; i++) {
        for(j = 0; j < N; j++) {
            A[i*N+j] = rand() / 100000;
            B[i*N+j] = rand() / 100000);}}
 
void MM(float *A, float *B, float *C,int nl, int nc, int nk) {
  int i,j,k;
  double somme;
  for(i=0;i<nl;i++) {
    for(j=0;j<nc;j++) {
      somme = 0;
      for(k=0;k<nk;k++) {
        somme += A[i*nk+k]*B[k*nl+j]; }
      C[i*nc+j] = somme;
    }
  }
}}

L'écriture A[i*N+j] correspond à un tableau à 1 dimension de N² float (autrement dit comme si les lignes se suivaient et s'empilaient dans un tableau 1D) interprété comme un tableau à 2 dimensions de NxN float par l'indexation (i,j).

Or les matrices sont construites comme un tableau de pointeurs vers des tableaux de float (chaque tableau représente, par exemple, une ligne de la matrice)
L'accès se fait par A[i][j] : A[i] sélectionne un pointeur donc l'adresse de début de l'un des tableaux de N float (disons d'une ligne de la matrice) et A[i][j] le j^ieme élément de ce tableau (disons la j^ieme colonne de la i^ieme ligne).

Cet accès est identique à celui utilisé pour un tableau 2D déclaré comme float A[N][N], mais le type de A est ici float **

merci beaucoup,mais mais ça marche toujours pas.Aidez moi s'il vous plait

Salut,

Si jamais tu n'as pas commencer par établir ni vérifier l'algorithme de multiplication d'une matrice, tu devrais peut être commencer par ça.
Ensuite, tu peux établir les fonctions qui te seront nécessaires afin d'avoir un main un peu plus compréhensible.
Quand tu as des erreurs dans ton code, essayes peut être de mieux l'indenter pour être sur de bien voir ce que tu fais.
Visiblement tu travailles avec des matrices carrées de même ordre donc pas besoin de vérifier si elles sont multipliables mais ça n'empêche rien.
Même si cela peut te paraître une perte de temps pour des codes simples, ton cas prouve une fois de plus que ce travaille en amont n'aurait pas été superflu et n'est pas une perte de temps.
Ça évite les mauvaises surprises.

Je te propose le code suivant, ça te permettra peut être de t'en sortir et de comprendre ce qui ne va pas dans ton code.
Déroules le main et regarde ce que font les fonctions. Si t'as des questions, n'hésites pas.

Code:

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
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <strings.h>
#include <limits.h>
 
float *allocate_1D_f( unsigned long long int n )
{
    unsigned long long int i;
    float *p = NULL;
    if ((p = (float *)malloc(n*sizeof(float))))
        for ( i=0 ; i<n ; i++ )
            p[i]=0;
 
    else printf("allocate_1D_f -> %s\n", strerror(errno));
    return p;
}
 
void matrix_destroy( float **p, unsigned long long int x )
{
    if (p)
    {
        unsigned long long int i;
        for ( i=0 ; i<x ; i++ )
            free(p[i]), p[i]=NULL;
 
        free(p), p=NULL;
    }
}
 
float **matrix_create( unsigned long long int x, unsigned long long int y )
{
    float **t = NULL;
    if ( (t = (float**)malloc( x*sizeof(float*))) )
    {
        unsigned long long int i;
        for ( i=0 ; i<x ; i++ )
        {
            if ( !( t[i] = allocate_1D_f(y) ) )
            {
                printf("matrix_create -> %s\n", strerror(errno));
                matrix_destroy(t,i-1);
                i=x;
            }
        }
    }
    else printf("matrix_create -> %s\n", strerror(errno));
    return t;
}
 
void matrix_display( float **p, unsigned long long int x, unsigned long long int y, const char *name)
{
   if(p)
   {
       printf("-----------------%s-----------------\n", name);
       unsigned long long int i,j;
       for (i=0 ; i<x ; i++)
           for (j=0 ; j<y ; j++)
               printf("p[%I64u][%I64u]=%f\n", i, j, p[i][j]);
   }
   else printf("matrix_display -> %s\n", strerror(errno));
}
 
void matrix_fill_random(float ** matrix, unsigned long long int x, unsigned long long int y)
{
    if(matrix)
    {
        unsigned long long int i,j;
        for ( i=0 ; i<x ; i++ )
            for ( j=0 ; j<y ; j++ )
                matrix[i][j]=0.001*(rand()%INT_MAX);
    }
    else printf("matrix_fill_random -> %s\n", strerror(errno));
}
 
unsigned short matrix_are_multipliable( unsigned long long int m0_y, unsigned long long int m1_x )
{
    if ( m0_y == m1_x )
        return 1;
 
    return 0;
}
 
float **matrix_multiply(float **m0, float **m1, unsigned long long int m0_x, unsigned long long int m0_y, unsigned long long int m1_x, unsigned long long int m1_y)
{
    float **m = NULL;
    if ( m0&&m1 )
    {
        if ( matrix_are_multipliable(m0_y, m1_x)==1 )
        {
            if ( (m=matrix_create(m0_x,m1_y)) )
            {
                unsigned long long int i,j,repeat=0;
                for( i=0 ; i<m0_x ; i++ )
                {
                   for ( j=0 ; j<m1_y ; j++ )
                   {
                       while( repeat != m0_y )
                       {
                           m[i][j] += m0[i][repeat]*m1[repeat][j];
                           repeat++;
                       }
                       repeat=0;
                   }
                }
            }
            else printf("matrix_multiply -> %s\n", strerror(errno));
        }
        else printf("matrix_multiply -> matrix can't be multiplied\n");
    }
    else printf("matrix_multiply -> %s\n", strerror(errno));
    return m;
}
 
int main()
{
    float **m1 = matrix_create(5,5);
    float **m2 = matrix_create(5,9);
 
    matrix_fill_random(m1,5,5);
    matrix_fill_random(m2,5,9);
 
    matrix_display(m1,5,5,"m1");
    matrix_display(m2,5,9,"m2");
 
    float **m0 = matrix_multiply(m1,m2,5,5,5,9);
    matrix_display(m0,5,9,"m0");
 
    matrix_destroy(m2,5);
    matrix_destroy(m0,5);
    matrix_destroy(m1,5);
 
    return 0;
}

Cordialement.

merci beaucoup Alex,c'est très gentil de votre part