Plan du Chapitre 3

Chapitre 3 : Variables Indicées – Le type Tableau...............................................................................2

3.1. Introduction...............................................................................................................................2
3.2. Les tableaux unidimensionnels (Vecteurs)...............................................................................2
3.2.1. Accès à un élément du tableau..........................................................................................2
3.2.2. Représentation en mémoire...............................................................................................3
3.2.3. Déclaration d'un tableau unidimensionnel........................................................................4
3.2.4. Initialisation d'un tableau unidimensionnel.......................................................................5
3.2.5. Manipulation de Tableaux unidimensionnels (Vecteurs)..................................................6
a) Somme de deux Vecteurs V1 et V2....................................................................................6
b) Produit scalaire de deux vecteurs V1 et V2.......................................................................7
c) Recherche d'un élément dans un tableau............................................................................7
d) Recherche du maximum dans un tableau unidimensionnel...............................................8
e) L'algorithme de Tri.............................................................................................................9
3.3. Les tableaux bidimensionnels (Matrices).................................................................................9
3.3.1. Présentation de tableaux bidimensionnels........................................................................9
3.3.2. Déclaration de tableaux bidimensionnels........................................................................10
3.3.2. Lecture et affichage d'une matrice..................................................................................11
3.3.3. Manipulation de matrice..................................................................................................11
a) Lire et écrire un tableau bidimensionnels.........................................................................11
b) Produit d'une matrice par un vecteur................................................................................12
c) Compter le nombre d'éléments négatifs, positifs et nuls dans une matrice......................13
d) Produit de deux matrices..................................................................................................14
 LMD / S.T.                                                                Chapitre 3
      : Variables Indicées – Le type Tableau 

Chapitre 3 : Variables Indicées – Le type Tableau

3.1. Introduction
Jusque là, on a vu que des variables de type simple (entier, réel, caractère, chaîne et booléen) où 
chaque variable est associée à un seul espace mémoire, ne pouvant loger (ou bien contenir) qu'une 
seule valeur à instant de données. Afin de représenter des données complexes comme des tableaux 
de données (Tableaux statiques, vecteurs, matrices, listes, etc.) on utilise un autre type de variables : 
variables indicées ou tableaux.
Exemple
Représentation d'un vecteur : soit VECT = [c1 c2 c3 c4 c5]
Ce vecteur sera représenté par le tableau (variable) VECT comme suit :
1 2 3 4 5
c1 c2 c3 c4 c5

Avec VECT[1] = c1 ;   VECT[2] = c2 ;  VECT[3] = c3 ;      VECT[4] = c4 ;   VECT[5] = c5 .
Les positions {1, 2, 3, 4, 5} représentent les indices ou indexes du tableau. Ils donnent la position 
d'un   élément   du   tableau.  VECT[1],   VECT[2],   VECT[3],   VECT[4],   VECT[5]  représentent   les 
composantes du vecteur VECT, (les éléments du tableau).
VECT[1] est la première composante du tableau VECT
VECT[2] est la deuxième composante du tableau VECT
VECT[3] est la troisième composante du tableau VECT
Etc.

3.2. Les tableaux unidimensionnels (Vecteurs)

Les tableaux à une seule dimension correspondent au tableaux avec une seule plage d'indices. 
C'est­à­dire, pour accéder à une composante on a besoin d'un seul indice (valeur entière). Autrement 
dit : les cases sont repérées avec un seule indice qui représente une valeur entière (valeur immédiate, 
constante ou variable entière, ou expression donnant un résultat entier).

3.2.1. Accès à un élément du tableau

En programmation un élément de tableau est désigné par le nom du tableau suivi de l'indice (la 
position) de l'élément dans le tableau. Soit :

2
 LMD / S.T.                                                                Chapitre 3
      : Variables Indicées – Le type Tableau 

<Nom du Tableau>[<Indice de l'élément>]

Exemple :
Soit deux Tableaux V1 et V2 où V1 contient 4 composantes et V2 contient 6 composantes :
V1 :
 1                        2                          3                          4

12.50 25.75 56.00 60.25

V2 :
               1                       2                     3                       4                      5                        6

24.00 38.25 28.00 70.25 63.00 96.25

On a :
V1[1] = 12.55 ;  V1[2] = 25.75 ;  V1[3] = 56.00 ;  V1[4] = 60.25
V2[1] = 24.00; V2[2] = 38.25; V2[3] = 28.00; V2[4] = 70.25; V2[5] = 63.00 ;  V2[6] = 96.25 ; 

3.2.2. Représentation en mémoire

Dans la mémoire centrale de l'ordinateur (RAM), un tableau est représenté sous forme d'une 
succession de cellules mémoires (cases mémoires) contiguës (l'une à la suite de l'autre). L'adresse 
d'un élément de tableau est obtenue par le système en utilisant l'adresse d'implantation du tableau en 
mémoire auquel est ajouté la valeur de la position de l'élément par rapport au début du tableau 
(l'offset de l'élément). Pour les deux tableaux V1 et V2, on aura cette représentation en mémoire :

Adresses Mémoire
0000
0001
0002
…....
…....
…....
V1 0006 12.50
0007 25.75
0008 56.00
0009 60.25

3
 LMD / S.T.                                                                Chapitre 3
      : Variables Indicées – Le type Tableau 

….... ….
….... ….
V2 0014 24.00
0015 38.25
0016 28.00
0017 70.25
0018 63.00
0018 96.25
…....
…....

3.2.3. Déclaration d'un tableau unidimensionnel

La syntaxe à suivre pour déclarer un tableau est la suivante :
    Syntaxe Algorithmique   Syntaxe en PASCAL
constante const
MAX = <valeur_entière> MAX = <valeur_entière>;
variable var
<id_tab>:Tableau[1..MAX] de <type>; <id_tab>:Array [1..MAX] of <type>;

Remarques : 
✗ C'est pas obligatoire d'utiliser une constante pour la taille maximale de tableau ; cependant, 
c'est une bonne pratique dans la programmation
✗ La plage d'indice  1 .. MAX  représente l'indice du premier élément  1  et l'indice du dernier 
élément MAX.
✗ C'est pas obligatoire d'utiliser toutes les composantes du tableaux, pour cela on déclare une 
variable entière n qui représente la taille du tableau à utiliser. La valeur de cette variable sera 
introduite au cours de l'exécution (par lecture)
Exemple : 
constante const
MAX = 50 MAX = 50;
variable var
V:Tableau[1..MAX] de réel; V:Array [1..MAX] of real;

V est un tableau de 50 composantes réelles (c'est comme si on a déclaré 50 variables réelles)

4
 LMD / S.T.                                                                Chapitre 3
      : Variables Indicées – Le type Tableau 

3.2.4. Initialisation d'un tableau unidimensionnel

Un tableau peut être initialisé en utilisant deux méthodes :
– En utilisant des affectations ;
– En utilisant la lecture à partir d'un fichier de données ou à partir de clavier.
a) Par affectations : On utilise pour cela l'opération d'affectation.
Exemple :
V[1] := 24.00; V[2] := 38.25; V[3] := 28.00; V[4] := 70.25; V[5] := 63.00 ;  V[6] := 96.25;
b) Par lecture :  On utilise pour cela l'opération de lecture READ : C'est la méthode la plus 
commode.
Exemple1 :  Exemple d'algorithme / programme Pascal permettant de lire et d'écrire (afficher) le 
tableau précédent :
algorithme LireEcrireTableau
variables program LireEcrireTableau;
v:tableau[1..6] de réel uses wincrt;
i:entier var
Début V:Array[1..6] of real;
écrire('Introduire V :') i:integer;
pour i:=1 à 6 faire Begin
lire(v[i]) writeln('Introduire V : ');
finPour for i:=1 to 6 do
écrire('Affichage V :') Read (V[I]);
pour i:=1 à 6 faire writeln ('Affichage V : ') ;
écrire(v[i]) for i:=1 to 6 do
finPour Write (V[I]);
Fin End.
À l'exécution : (RUN ou exécuter)
Introduire les composantes du Tableau V :
12.50 12.75 56 60.25 36.75 65
Affichage des composantes du Tableau V :
12.50 12.75 56 60.25 36.75 65

Exemple 2 : Lecture et écriture d'un tableau de N éléments.
algorithme LireEcrireTableau
variables program LireEcrireTableau;
V:Tableau[1..100] de réel uses wincrt;
N, i:entier var
V:Array[1..100] of real;
Début N, i:integer;
écrire('Introduire nbre d'éléments N : ') Begin
lire (N) write('Introduire nbre d'éléments N:');
écrire('Introduire V : ') read (N);
pour i:=1 à N faire
lire (V[I]) writeln('Introduire V : ');
finPour for i:=1 to N do
écrire ('Affichage de V : ') ; Read (V[I]);
pour i:=1 à N faire writeln ('Affichage du V : ') ;
écrire (V[I]) for i:=1 to N do
finPour Write (V[I]);
Fin End.

5
 LMD / S.T.                                                                Chapitre 3
      : Variables Indicées – Le type Tableau 

À l'exécution : (RUN ou exécuter)
Introduire le nombre d'éléments N :
6
Introduire les composantes du Tableau V :
12.50 12.75 56 60.25 36.75 65
Affichage des composantes du Tableau V :
12.50 12.75 56 60.25 36.75 65

3.2.5. Manipulation de Tableaux unidimensionnels (Vecteurs)

Les tableaux ont une grande importance en informatique, la quasi­totalité des problèmes utilisent 
des structures de données sous forme de tableaux. On peut en citer le domaine du calcul matriciel, 
les   statistiques,   les   traitement   de   gestion,  etc.  La   gestion   et   l'analyse   de   données   nécessitent 
l'organisation des données dans des tableaux pour rendre possible leur traitement informatique.
Exemples :  Nous  allons  voir  quelques  exemples  d'algorithmes  pour les  tableaux  à une  seule 
dimension (Vecteurs).

a) Somme de deux Vecteurs V1 et V2

Algorithme Somme Program Somme;
Variables Uses Wincrt;
V1,V2,V:Tableau[1..100] de réel; Var
N, i:entier; V1, V2, V : Array[1..100] of real;
Début N, i : integer;
Lire (N) Begin
pour i=1 à N faire Read (N);
Lire (V1[i]) for i=1 to N do
FinPour readln (V1[i]);

pour i=1 à N faire for i=1 to N do

Lire (V2[i]) read (V2[i]);
FinPour

pour i=1 à N faire for i=1 to N do

V[i] ← V1[i] + V2[i] V[i]:=V1[i]+V2[i] ;
FinPour for i=1 to N do
Write(V[i]) ;
pour i=1 à N faire End.
Écrire (V[i])
FinPour
Fin

6
 LMD / S.T.                                                                Chapitre 3
      : Variables Indicées – Le type Tableau 

b) Produit scalaire de deux vecteurs V1 et V2

Algorithme ProduitScalaire Program ProduitScalaire;
Uses Wincrt;
Variables Var
V1, V2 : Tableau [1..100] de réel V1, V2 : Array[1..100] of real;
N, i:entier N, i : integer;
PS : réel PS : real;
Début Begin
Lire (N) Read (N);
pour i=1 à N faire for i=1 to N do
Lire (V1[i]) readln (V1[i]);
FinPour
pour i=1 à N faire for i=1 to N do
Lire (V2[i]) readln (V2[i]);
FinPour
PS ← 0 PS:=0;
pour i=1 à N faire for i=1 to N do
PS ← PS + V1[i] * V2[i] PS:= PS + V1[i]*V2[i] ;
FinPour

Écrire (PS)
Fin Write('Le produit scalaire = ', PS);
End.

c) Recherche d'un élément dans un tableau

Chercher un élément val dans un tableau à une dimension (vecteur). S'il existe on récupère son 
rang.
Algorithme Recherche Program Recherche;
Variables Uses Wincrt;
V:Tableau[1..100] de reel; Var
Val : reel; V : Array[1..100] of real;
N, I, R:entier; Val : real;
Trouve : boolean; N, I, R : integer;
Début Trouve : boolean ;
Lire (N) Begin
pour i=1 à N faire Read (N);
Lire (V1[i]) for i=1 to N do
FinPour readln (V[i]);
Lire (Val) read(val);

i ← 1 ; i:=1 ;
Trouve ← Faux while (i<=N) and (Trouve=false) do
TantQue (i<=N) et (Trouve=Faux) faire begin
Si V[i] = Val Alors if V[i] = Val then
Trouve ← Vrai begin
R ← i Trouve := true;
FinSi R:=i;
i ← i + 1 end ;
FinTantQue i:=i+1;
end;
Si Trouve = Vrai Alors
Écrire('La valeur ',Val,' exist.'); if Trouve = true then
Écrire('Son Rang est : ', R); begin
Sinon write('La valeur ', val, ' existe dans V');
Écrire(Val,' n''existe pas dans V.'); write('Son rang est : ', R);
FinSi end
Fin else
write(Val,' n''existe pas dans V.');
End.

7
 LMD / S.T.                                                                Chapitre 3
      : Variables Indicées – Le type Tableau 

d) Recherche du maximum dans un tableau unidimensionnel

Soient deux tableaux NOMS et NOTES contenant respectivement des noms d'étudiants et leurs 
notes respectives, on veut sélectionner la meilleurs note de l'étudiant correspondant.

Algorithme Maximum Program Recherche;

Variables Uses Wincrt;
Noms : Tableau[1..100] de chaîne Var
Notes : Tableau[1..100] de réel Noms : Array[1..100] of String;
Notes : Array[1..100] of real;
N, i, imax : entier n, i, imax : integer;
max : réel max : real;
Début Begin
Lire (N) Read (n);
pour i=1 à N faire for i=1 to N do
Lire (Noms[i]) begin
Lire (Notes[i]) readln (Noms[i]);
FinPour readln (Notes[i]);
end;
max ← Notes[1] imax ← 1;
max:=Notes[1] ; imax:=1;
←
pour i 2 à N faire for i:=2 to n do
si Notes[i] > max then begin
max ← Notes[i] if Notes[i] > max then
imax ← i begin
finsi max := Notes[i];
imax := i;
FinPour
end;
end;
Écrire('L''étudiant : ', Noms[imax]);
Écrire(' a obtenu la meilleur note :'); write('L''étudiant : ', Noms[imax]);
Écrire (max); write('a obtenu la meilleur note : ');
Fin write(max)
End.

8
 LMD / S.T.                                                                Chapitre 3
      : Variables Indicées – Le type Tableau 

e) L'algorithme de Tri
– Méthode de Tri Simple (Tri croissant)
Algorithme TriSimple Program TriSimple;
Variables uses wincrt;
T:Tableau[1..100] de reel var
I, J, N:entier T : Array[1..100] of real;
Z : real I, J, N : integer;
Début Z:real;
Lire (N) Begin
pour i=1 à N faire Readln(N);
Lire (T[i]) for i:=1 to n do
FinPour Read(T[i]);

pour i=1 à N-1 faire for i:=1 to (N-1) do

pour j=(i+1) à N faire for j:=(i+1) to N do
Si T[I] > T[J] Alors if T[I] > T[J] then
begin
Z ← T[I]
Z:=T[I];
T[I] ← T[J] T[I]:=T[J];
T[J]:=Z;
T[J] ← Z end;
FinSi
FinPour for i:=1 to N do
FinPour Write(T[I], ' ');
End.
pour i=1 à N faire
Ecrire (T[I])
FinPour
Fin

Réaliser le déroulement (Trace d'exécution) Pour N = 4) : Le tableau avec et après l'opération de

tri.)

3.3. Les tableaux bidimensionnels (Matrices)

3.3.1. Présentation de tableaux bidimensionnels

Un   tableau   est   dit   bidimensionnels   (ou   à   deux   dimensions),   si   chacun   des   ses   éléments 
(composant) est repéré par un couple d'indices (i, j) où i est le numéro de la ligne et j est le numéro 
de la colonne où l'élément est situé. Ce type de tableau est appelé Matrice.
Soit la matrice A suivant :
A = 14.32 14.50 14.25 25.84
15.26 15.65 12.23 15.36
12.25 16.23 10.20 15.63

9
 LMD / S.T.                                                                Chapitre 3
      : Variables Indicées – Le type Tableau 

peut être représentée par une tableau bidimensionnels (avec deux dimensions) de trois ligne et 
quatre colonnes :

A= 1 2 3 4
1 14.32 14.50 14.25 25.84
2 15.26 15.65 12.23 15.36
3 12.25 16.23 10.20 15.63

3.3.2. Déclaration de tableaux bidimensionnels

Pour déclarer la matrice A définie précédemment, on a deux façons :
 1ère Façon     
: 
ALGORITHME PASCAL
Variables Var
A:Tableau[1..3,1..4] de Réel A:Array[1..3,1..4] of real;

 2ème Façon     
: 
ALGORITHME PASCAL
Type Ligne = Tableau[1..4] de reel Type Ligne = Array[1..4] of real;
Variables Var
A:Tableau[1..3] de Ligne A:Array[1..3] of Ligne;

Exemples
Une   chaîne   de   28   magasins,   chacun   comportant   4   rayons.   On   veut   établir   l'état   des   ventes 
hebdomadaires. Ces données sont ensuite entrées dans un ordinateurs en utilisant un tableau à deux 
dimensions où le premier indices repère le magasin et le second le rayon. Si VENTES est le nom du 
tableau, décrire cette représentation des données.

VENTES 01 02 03 04
01 2872 805 3211 1560
02 2196 1225 2525 1477
03 3257 1017 3687 1951
…. …. …. …. ….
…. …. …. …. ….
…. …. …. …. ….
…. …. …. …. ….
28 2618 913 2333 982
Variables
VENTES : Tableau[1..28,1..4] de Entier

10
 LMD / S.T.                                                                Chapitre 3
      : Variables Indicées – Le type Tableau 

3.3.2. Lecture et affichage d'une matrice

L'algorithme (respectivement, le programme ) suivant permet de lire et d'écrire une matrice de n 
ligne et m colonnes :
Algorithme LectureAffichageMatrice Program LectureAffichageMatrice;
Variables uses wincrt;
mat:tableau [1..10, 1..10] de réel var
N,M, i,j:entier mat:array [1..10, 1..10] of real;
Début N,M, i,j : integer;
Lire (N, M); Begin
pour i=1 à N faire Read(N, M);
Pour j=1 à M faire For i:=1 To N Do
Lire (mat[i, j]) For j:=1 To M Do
FinPour Read(mat[i, j]);
FinPour
For i:=1 To N Do
pour i=1 à N faire begin
Pour j=1 à M faire For j:=1 To M Do
Écrire (mat[i, j]) begin
FinPour Write(mat[i,j],' ');
FinPour end;
Fin writeln;
end;
End.

On doit introduire le nombre de lignes n et le nombre de colonnes m.

3.3.3. Manipulation de matrice

a) Lire et écrire un tableau bidimensionnels

Algorithme LectureEcritureMatrice Program LectureEcritureMatrice;
Variables uses wincrt;
mat:tableau [1..10, 1..10] de reel var
N,M, i,j:entier mat:array [1..10, 1..10] of real;
Début N,M, i,j : integer;
Lire (N, M); Begin
pour i=1 à N faire Read(N, M);
Pour j=1 à M faire For i:=1 To N Do
Lire (mat[i, j]) For j:=1 To M Do
FinPour Read(mat[i, j]);
FinPour
For i:=1 To N Do
pour i=1 à N faire begin
Pour j=1 à M faire For j:=1 To M Do
Écrire (mat[i, j]) begin
FinPour Write(mat[i,j],' ');
FinPour end;
Fin writeln; {saut de ligne}
end;
End.

11
 LMD / S.T.                                                                Chapitre 3
      : Variables Indicées – Le type Tableau 

b) Produit d'une matrice par un vecteur

(le nombre de colonne de la matrice = le nombre de composantes du vecteur)
Algorithme ProduitMatVect Program ProduitMatVect;
Variables uses wincrt;
mat : tableau [1..10, 1..10] de reel var
vect : tableau [1..10] de reel mat:array [1..10, 1..10] of real;
p : tableau [1..10] de reel vect, p:array[1..10] of real;
N,M, i,j:entier N,M, i,j : integer;
Début Begin
Lire (N, M); Read(N, M);
pour i=1 à N faire For i:=1 To N Do
Pour j=1 à M faire For j:=1 To M Do
Lire (mat[i, j]) Read(mat[i, j]);
FinPour For i:=1 To M Do
FinPour Read(vect[i]);
pour i=1 à M faire For i:=1 To N Do
Lire(vect[i]) begin
finPour p[i]=0;
pour i=1 à N faire For j:=1 To M Do
p[i] = 0 p[i]:= p[i]+ mat[i,j]*vect[j];
Pour j=1 à M faire end;
P[i] ← p[i] + mat[i, j]*vect[j]
FinPour For i:=1 To N Do
FinPour write(p[i]);
pour i=1 à N faire End.
Écrire(p[i])
finPour
Fin

12
 LMD / S.T.                                                                Chapitre 3
      : Variables Indicées – Le type Tableau 

c) Compter le nombre d'éléments négatifs, positifs et nuls dans une matrice

Algorithme compteurPNN Program compteurPNN;
Variables uses wincrt;
mat : tableau [1..10, 1..10] de reel var
N,M, i,j:entier mat:array [1..10, 1..10] of real;
nbP, nbN, nbNul : entier N,M, i,j : integer;
Début nbP, nbN, nbNul, integer;
Lire (N, M); Begin
pour i=1 à N faire Read(N, M);
Pour j=1 à M faire For i:=1 To N Do
Lire (mat[i, j]) For j:=1 To M Do
FinPour Read(mat[i, j]);
FinPour nbP:=0; nbN:=0;
nbP ←
0; nbN ←
0; nbNul 0; ← nbNul:=0;
pour i=1 à N faire For i:=1 To N Do
Pour j=1 à M faire For j:=1 To M Do
Si mat[i, j] > 0 Alors if mat[i,j]>0 then
nbP ←
nbP + 1; nbP:=nbP+1
Sinon else
Si mat[i,j] < 0 Alors if mat[i,j]<0 then
nbN:=nbN+1
nbN ← nbN + 1; else
Sinon nbNul:=nbNul+1;
nbNul ← nbNul + 1;
FinSi Write(nbP, nbN, nbNul);
FinSi End.
FinPour
FinPour

Écrire (nbP, nbN, nbNul);

Fin

nbP est le compteur des nombres positifs, nbN est le compteur des nombre négatifs et nbNul est
le compteur des nombre nuls.

13
 LMD / S.T.                                                                Chapitre 3
      : Variables Indicées – Le type Tableau 

d) Produit de deux matrices

Le nombre de colonne de la première matrice = le nombre de ligne de la deuxième matrice
Algorithme compteurPNN Program produitMatriceMatrice;
Variables uses wincrt;
m1,m2 : tableau [1..10, 1..10] de reel var
N,M, L, i,j, k:entier m1,m2:array [1..10, 1..10] of real;
Result:tableau [1..10, 1..10] de reel N,M, L, i,j, k : integer;
Début Result:array [1..10, 1..10] of real;
Lire (N, M, L); Begin
pour i=1 à N faire Write('Donnez les dim. de m1 : ');
Pour j=1 à M faire read (N, M);
Lire (m1[i, j]) write('Donnez le nbre de colonnes de m2 : ');
FinPour read(L);
FinPour
For i:=1 To N Do
pour i=1 à M faire For j:=1 To M Do
Pour j=1 à L faire Read(m1[i, j]);
Lire (m2[i, j])
FinPour For i:=1 To M Do
FinPour For j:=1 To L Do
Read(m2[i, j]);
pour i=1 à N faire
Pour j=1 à L faire For i:=1 To N Do
For j:=1 To L Do
Result[i, j] 0 ← begin
pour k=1 à M faire Result[i, j]:=0;
Result[i,j] ←
Result[i,j]+ For k:=1 To M Do
m1[i,k]*m2[k,j] Result[i,j] := Result[i,j]
finPour +m1[i,k]*m2[k,j];
FinPour end;
FinPour
For i:=1 To N Do
pour i=1 à N faire begin
Pour j=1 à L faire For j:=1 To L Do
Écrire (Result[i, j]) write(Result[i,j], ' ');
FinPour writeln; {Saut de ligne}
FinPour end;
Fin End.

Pour réaliser le produit des deux matrices m1 et m2, il faut que le nombre de colonne de m1 soit 
égale au nombre de ligne de m2. Le résultat est une matrice Result dont le nombre de ligne est le 
même qui celui de m1 et le nombre de colonne est le même qui celui de m2.
Result(N, L) = m1(N, M) * m2 (M, L)
✗ Result est une matrice de N lignes et L colonnes
✗ m1 est une matrice de N lignes et M colonnes
✗ m2 est une matrice de N lignes et L colonnes
✗ L'élément Result[i, j] est calculé comme suit :
Result[i, j] = m1[i, 1] * m2[1, j] +   m1[i, 2] * m2[2, j] + m1[i, 3] * m2[3, j] +  
M
Σ  m1[i, k] * m2[k, j]
…............. + m1[i, M] * m2[M, j] =  k=1

14