Multiplication de deux matrices triangulaires supérieures compressées

Question

Je suis terrible en algèbre linéaire et j'ai du mal à construire mes boucles pour multiplier deux matrices compressées sans les étendre et y compris les zéros.

Par exemple,

0 1 2 3 * 10 11 12 13 
0 4 5 6 0 14 15 16 
0 0 7 8 0 0 17 18 
0 0 0 9 0 0 0 19 

est en fait juste

a = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9} 
b = {10, 11, 12, 13, 14, 15, 16, 17, 18, 19} 

j'avais d'abord

for(i = 0; i < r1; ++i) 
    for(j = 0; j < c2; ++j) 
     for(k = 0; k < c1; ++k) 
     { 
      *(mult(i * cols) + j) += *(a(i * cols) + k) * (b + (k * cols) + j; 
     } 

mais cela va évidemment hors des limites car il est construit comme si elles sont en 2D tableaux et passe à 16 lorsque la taille de chaque tableau est seulement 10 éléments. J'ai observé que les diagonales ne sont que les produits des seuls éléments sur les diagonales, par exemple c [4] = a [4] * b [4]

Je comprends aussi que pour la première rangée vous multipliez le même nombre de termes qu'il y a de colonnes, la deuxième rangée multiplie autant de termes - 1 et ainsi de suite.

Mais au-delà de cela, je suis assez perdu sur la façon de construire le code réel. Toute aide est grandement appréciée.

Answer 1

Cette programmation est assez simple. Pour multiplier deux matrices ensemble, le nombre de colonnes de la première matrice doit être le même que le nombre de lignes de la seconde. Par exemple, si A est une matrice M X N et B est une matrice N X P, la multiplication fonctionne. Par exemple, si A est une matrice M X N et que B est une matrice N X P, la multiplication fonctionne. Le résultat de la multiplication est une matrice M X P. Dans votre exemple, les matrices sont carrées et de la même taille, donc la multiplication fonctionne.

Dans tous les cas, vous allez finir avec une troisième matrice, appelez C, de la taille 4 X 4.

En supposant que les matrices seront toujours triangulaire supérieure, vous pouvez réduire le nombre de Calculs requis en initialisant la matrice C à tous les 0 éléments, puis en travaillant UNIQUEMENT sur les parties triangulaires supérieures. Quelque chose comme ce qui suit (en supposant A, B, et les matrices C sont déjà définies et initialisées):

double dummy; 
int i, j, k; 
int mRows, nCols, pCols; // Number of rows of A, and columns of B and C 

for (k = 0; k < mRows; ++k) { // Do each row of A with each column of B 
    for (i = 0; i < pCols; ++i) { 
     dummy = 0.0; 
     for (j = 0; j <= i; ++j) dummy += A_Matrix[k][j]*B_Matrix[j][i]; 
     C_Matrix[k][i] = dummy; 
    } // End for i 
} // End for k 

Si vous vouliez réduire le nombre de calculs plus, et si vous connaissez la première colonne de la matrice A est toujours 0, vous pouvez démarrer les boucles sur l'élément 1 au lieu du 0-ème élément. c'est-à-dire,

for (k = 0; k < mRows; ++k) { // Do each row of A with each column of B 
    for (i = 1; i < pCols; ++i) { 
     dummy = 0.0; 
     for (j = 1; j < nCols; ++j) dummy += A_Matrix[k][j]*B_Matrix[j][i]; 
     C_Matrix[k][i] = dummy; 
    } // End for i 
} // End for k 

Je pense que la manière la plus simple de résoudre ce problème est d'utiliser une notation matricielle régulière. Essayer de l'agrandir, comme vous l'avez fait, le complique et je pense que vous vous tirez dans le pied.