Section courante

A propos

Section administrative du site

 Langage  Elément  Aide 
ABAP/4
Ada
Assembleur
Assembly & bytecode
ASP (Active Server Pages)
Basic
C
C++
C# (C Sharp)
Cobol
ColdFusion
Fortran
HTML
Java
JavaScript
LISP
Logo
LotusScript
Oberon
Pascal
Perl
PHP
PL/1
Prolog
Python
Rebol
REXX
Ruby
SAS
NoSQL
SQL
Swift
X++ (Axapta)
GNAT
SMALLAda
VHDL
Assembleur 370
Assembleur 1802
Assembleur 4004
Assembleur 6502
Assembleur 6800
Assembleur 68000
Assembleur 8080 et 8085
Assembleur 8089
Assembleur 80x86
Assembleur AGC4
Assembleur ARM
Assembleur DPS 8000
Assembleur i860
Assembleur Itanium
Assembleur MIPS
Assembleur PDP-11
Assembleur PowerPC
Assembleur RISC-V
Assembleur SPARC
Assembleur SuperH
Assembleur UNIVAC I
Assembleur VAX
Assembleur Z80
Assembleur Z8000
Assembleur z/Architecture
ASSEMBLER/MONITOR 64
Micol Assembler
GFA Assembler
A86
MASM (Macro Assembler)
TASM (Turbo Assembler)
CIL
Jasmin
LLVM
MSIL
Parrot
P-Code (PCode)
SWEET16
G-Pascal
ASP 1.0
ASP 2.0
ASP 3.0
ASP.NET
ASP.NET Core
ABasiC (Amiga)
Adam SmartBASIC
Altair BASIC
AmigaBASIC (Amiga)
AMOS Basic (Amiga)
Atari Basic (Atari 400, 600 XL, 800, 800XL)
Basic Apple II (Integer BASIC/APPLESOFT)
Basic Commodore 64 (CBM-BASIC)
Basic Commodore 128 (BASIC 7.0)
Basic Commodore VIC-20 (CBM-BASIC 2.0)
Basic Coco 1 (Color Basic)
Basic Coco 2 (Extended Color Basic)
Basic Coco 3 (Extended Color Basic 2.0)
BASICA (PC DOS)
Basic Pro
BBC BASIC
Blitz BASIC (Amiga)
DarkBASIC
Dartmouth BASIC
GFA-Basic (Atari ST/Amiga)
GWBASIC (MS-DOS)
Liberty BASIC
Locomotive BASIC (Amstrad CPC)
MSX-Basic
Omikron Basic (Atari ST)
Oric Extended Basic
Power Basic
Quick Basic/QBasic (MS-DOS)
Sinclair BASIC (ZX80, ZX81, ZX Spectrum)
ST BASIC (Atari ST)
Turbo Basic
Vintage BASIC
VBScript
Visual Basic (VB)
Visual Basic .NET (VB .NET)
Visual Basic pour DOS
Yabasic
BeckerBASIC
SIMONS' BASIC
Basic09 d'OS-9
Disk Extended Color Basic
Basic09 d'OS-9
Disk Extended Color Basic
Access
Excel
Visual Basic pour Windows
Visual Basic .NET pour Windows
C Shell Unix (csh)
C pour Amiga
C pour Atari ST
C pour DOS
C pour Falcon030
C pour GEMDOS (Atari ST)
C pour Linux
C pour PowerTV OS
C pour OS/2
C pour Unix
C pour Windows
Aztec C
CoCo-C
GNU C
HiSoft C
IBM C/2
Introl-C
Lattice C
Microsoft C
MinGW C
MSX-C
Open Watcom C
OS-9 C Compiler
Pure C
Quick C
Turbo C
HiSoft C for Atari ST
HiSoft C for CP/M (Amstrad CPC)
C++ pour OS/2
C++ pour Windows
Borland C++
C++Builder
IBM VisualAge C++
Intel C++
MinGW C++
Open Watcom C++
Symantec C++
Turbo C++
Visual C++
Visual C++ .NET
Watcom C++
Zortech C++
C# (C Sharp) pour Windows
Apple III Cobol
Microsoft Cobol
BlueDragon
Lucee
OpenBD
Railo
Smith Project
Microsoft Fortran
WATFOR-77
CSS
FBML
Open Graph
SVG
XML
XSL/XSLT
LESS
SASS
GCJ (GNU)
JSP
Jython
Visual J++
Node.js
TypeScript
AutoLISP
ACSLogo
LotusScript pour Windows
Amiga Oberon
Oberon .NET
Apple Pascal
Delphi/Kylix/Lazarus
Free Pascal
GNU Pascal
HighSpeed Pascal
IBM Personal Computer Pascal
Lisa Pascal
Maxon Pascal
MPW Pascal
OS-9 Pascal
OSS Personal Pascal
Pascal-86
Pascal du Cray Research
Pascal/VS
Pascal-XT
PURE Pascal
QuickPascal
RemObjets Chrome
Sun Pascal
THINK Pascal
Tiny Pascal (TRS-80)
Turbo Pascal
UCSD Pascal
VAX Pascal
Virtual Pascal
Turbo Pascal for CP/M-80
Turbo Pascal for DOS
Turbo Pascal for Macintosh
Turbo Pascal for Windows
CodeIgniter (Cadre d'application)
Drupal (Projet)
Joomla! (Projet)
Phalanger (PHP .NET)
phpBB (Projet)
Smarty (balise)
Twig (balise)
Symfony (Cadre d'application)
WordPress (Projet)
Zend (Cadre d'application)
PL360
PL/M-80
PL/M-86
Turbo Prolog
CPython
IronPython
Jython
PyPy
AREXX
Regina REXX
JMP
Btrieve
Cassandra
Clipper
CouchDB
dBASE
Hbase
Hypertable
MongoDB
Redis
Access
BigQuery
DB2
H2
Interbase
MySQL
Oracle
PostgreSQL
SAP HANA
SQL Server
Sybase
U-SQL
Introduction
Algèbre de Boole
Les opérateurs
Les nombres
Les matrices
Règles de l'algèbre de Boole
Table de vérité
Addition binaire
Multiplication naïve (multiplication par boucle d'addition)
Multiplication russe (Multiplication par décalage de bits)
Nombres complexes
Préface
Notes légal
Dictionnaire
Recherche

Introduction

Les matrices sont un tableau rectangulaires contenant des éléments généralement sous forme de nombres à laquelle on pourra appliquera appliqué une opération d'un opérateur comme une addition, soustraction, multiplication et division. On utilise les matrices dans les ordinateurs afin d'effectuer des calculs en séries où de façon «industrielles» dans les ordinateurs afin par exemple fournir des réponses dans des feuilles de calculs, dans des bases de données, dans l'affichage de graphiques et dans les jeux vidéos. En général, lorsqu'on effectue une opération sur 2 matrices, on nomme la première matrice A et la deuxième matrice B. Chacune des matrices auront des dimensions, soit de tailles égales ou de tailles différentes. Les 2 dimensions normalement prisent en compte sont l'horizontale et la verticale. On aura donc un schéma théorique comme ceci :

[a11 a12 ... a1n
a21 a22 ... a2n
... ... aij ...
am1 am2 ... amn
]

Dans de rares cas, si on souhaite utiliser une matrice en 3 dimensions, les 3 dimensions seront nommés : horizontale, verticale et profondeur.

Somme de matrices (Additionner 2 matrices)

La somme de matrice est l'opération d'effectuer une addition de 2 matrices en d'en retourner le résultat. Sachant que la première matrice A = (aij) et que la deuxième matrice B = (bij) sont les 2 matrices à additionner (A + B), on obtiendra donc la formule suivante :

A + B = (aij) + (bij) = (aij + bij)

A partir de cette formule mathématique, on pourra donc construire l'algorithme suivant :

BOUCLE POUR J ← 1 JUSQU'A nombre de dimensions verticale
   BOUCLE POUR I ← 1 JUSQU'A nombre de dimensions horizontale
      Résultat[J,I] ← A[J,I] + B[J,I]
   FIN BOUCLE POUR I
FIN BOUCLE J

L'exemple suivant, écrit en Free Pascal, permet d'effectuer l'addition d'une matrice de 3x2 :

  1. Program AddMatrix3x2Samples;
  2.  
  3. Const
  4.  DimensionY=2;
  5.  DimensionX=3;
  6.  
  7. Type
  8.  Matrix=Array[1..DimensionY,1..DimensionX]of Integer;
  9.  
  10. Procedure AddMatrix(Const A,B:Matrix;Var Resultat:Matrix);
  11. Var
  12.  I,J:Word;
  13. Begin
  14.  For J:=1 to DimensionY do Begin
  15.    For I:=1 to DimensionX do Begin
  16.     Resultat[J,I] := A[J,I] + B[J,I];
  17.    End;
  18.  End;
  19. End;
  20.  
  21. Procedure ShowMatrix(Const C:Matrix);
  22. Var
  23.  I,J:Word;
  24. Begin
  25.  For J:=1 to DimensionY do Begin
  26.    For I:=1 to DimensionX do Begin
  27.     Write(C[J,I],' ');
  28.    End;
  29.    WriteLn;
  30.  End;
  31. End;
  32.  
  33. Var
  34.  A:Matrix = (
  35.   (3,4,-5),
  36.   (2,-7,3)
  37.  );
  38.  B:Matrix = (
  39.   (4,-2,3),
  40.   (5,3,-2)
  41.  );
  42.  C:Matrix;
  43.  
  44. BEGIN
  45.  AddMatrix(A,B,C);
  46.  ShowMatrix(C);
  47. END.

on obtiendra le résultat suivant :

7 2 -2
7 -4 1

Voici le même exemple en écrit en C, permet d'effectuer l'addition d'une matrice de 3x2 :

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3.  
  4. #define DimensionY 2
  5. #define DimensionX 3
  6.  
  7. typedef int Matrix[DimensionY][DimensionX];
  8.  
  9. void AddMatrix(Matrix A, Matrix B,Matrix *Resultat) {
  10.  int I,J;
  11.  for(J = 0; J < DimensionY; J++) {
  12.    for(I = 0; I <  DimensionX; I++) {
  13.     (*Resultat)[J][I] = A[J][I] + B[J][I];
  14.    }
  15.  }
  16. }
  17.  
  18. void ShowMatrix(Matrix C) {
  19.  int I,J;
  20.  for(J = 0; J < DimensionY; J++) {
  21.   for(I = 0; I < DimensionX; I++) {
  22.    printf("%i ",C[J][I]);
  23.   }
  24.   printf("\n");
  25.  }
  26. }
  27.  
  28. int main() {
  29.   Matrix A = {
  30.   {3,4,-5},
  31.   {2,-7,3}
  32.   };
  33.   Matrix B = {
  34.   {4,-2,3},
  35.   {5,3,-2}
  36.   };
  37.   Matrix C;
  38.   AddMatrix(A,B,&C);
  39.   ShowMatrix(C);
  40.   return 0;
  41. }

on obtiendra le résultat suivant :

7 2 -2
7 -4 1

Produit scalaire de matrices (Multiplication 1 matrice par un scalaire)

Le produit scalaire de matrices est l'opération d'effectuer une multiplication de 1 matrices par une valeur scalaire en d'en retourner le résultat. On aura donc A(aij) avec une matrice m x n et un k étant un nombre scalaire. On obtiendra donc la formule mathématique suivante :

kA = k(aij) = (kaij)

A partir de cette formule mathématique, on pourra donc construire l'algorithme suivant :

BOUCLE POUR J ← 1 JUSQU'A nombre de dimensions verticale
   BOUCLE POUR I ← 1 JUSQU'A nombre de dimensions horizontale
      Résultat[J,I] ← A[J,I] x k
   FIN BOUCLE POUR I
FIN BOUCLE J

L'exemple suivant, écrit en Free Pascal, permet d'effectuer la multiplication d'une matrice de 3x2 par le scalaire 5 :

  1. Program MulMatrix3x2By5Samples;
  2.  
  3. Const
  4.  DimensionY=2;
  5.  DimensionX=3;
  6.  
  7. Type
  8.  Matrix=Array[1..DimensionY,1..DimensionX]of Integer;
  9.  
  10. Procedure MulMatrixBy(Const A:Matrix;Scalaire:Integer;Var Resultat:Matrix);
  11. Var
  12.  I,J:Word;
  13. Begin
  14.  For J:=1 to DimensionY do Begin
  15.    For I:=1 to DimensionX do Begin
  16.     Resultat[J,I] := A[J,I] * Scalaire;
  17.    End;
  18.  End;
  19. End;
  20.  
  21. Procedure ShowMatrix(Const C:Matrix);
  22. Var
  23.  I,J:Word;
  24. Begin
  25.  For J:=1 to DimensionY do Begin
  26.    For I:=1 to DimensionX do Begin
  27.     Write(C[J,I],' ');
  28.    End;
  29.    WriteLn;
  30.  End;
  31. End;
  32.  
  33. Var
  34.  A:Matrix = (
  35.   (-2,3,1),
  36.   (4,-2,5)
  37.  );
  38.  C:Matrix;
  39.  
  40. BEGIN
  41.  MulMatrixBy(A,5,C);
  42.  ShowMatrix(C);
  43. END.

on obtiendra le résultat suivant :

-10 15 5
20 -10 25

Produit de matrices (Multiplication 2 matrices)

Le produit de matrices est l'opération d'effectuer une multiplication de 2 matrices en d'en retourner le résultat. On obtiendra donc la formule mathématique suivante :

cij = ai1b1j + ai2b2j + ai3b3j + ... + aipbpj =  p

k=1
aikbkj

A partir de cette formule mathématique, on pourra donc construire l'algorithme suivant :

BOUCLE POUR J ← 1 JUSQU'A nombre de dimensions verticale
   BOUCLE POUR I ← 1 JUSQU'A nombre de dimensions horizontale
      Résultat[J,I] ← 0
      BOUCLE POUR K ← 1 JUSQU'A nombre de dimensions
         Résultat[J,I] ← Résultat[J,I] + M[K,I] x N[J,K]
      FIN BOUCLE K
   FIN BOUCLE POUR I
FIN BOUCLE J

L'exemple suivant, écrit en Free Pascal, permet d'effectuer la multiplication de 2 matrices de 3x3 :

  1. Program MulMatrix3x3Samples;
  2.  
  3. Const
  4.  DimensionY=3;
  5.  DimensionX=3;
  6.  
  7. Type
  8.  Matrix=Array[1..DimensionY,1..DimensionX]of Integer;
  9.  
  10. Procedure MulMatrix(Const A,B:Matrix;Var Resultat:Matrix);
  11. Var
  12.  I,J,K:Word;
  13. Begin
  14.  For J:=1 to DimensionY do Begin
  15.    For I:=1 to DimensionX do Begin
  16.     Resultat[J,I] := 0;
  17.     For K:=1 to DimensionX do Begin
  18.      Resultat[J,I] := Resultat[J,I] + A[J,I] * B[J,I];
  19.     End;
  20.    End;
  21.  End;
  22. End;
  23.  
  24. Procedure ShowMatrix(Const C:Matrix);
  25. Var
  26.  I,J:Word;
  27. Begin
  28.  For J:=1 to DimensionY do Begin
  29.    For I:=1 to DimensionX do Begin
  30.     Write(C[J,I],' ');
  31.    End;
  32.    WriteLn;
  33.  End;
  34. End;
  35.  
  36. Var
  37.  A:Matrix = (
  38.   (3,4,-5),
  39.   (2,-7,3),
  40.   (6,1,8)
  41.  );
  42.  B:Matrix = (
  43.   (4,-2,3),
  44.   (5,3,-2),
  45.   (8,6,1)
  46.  );
  47.  C:Matrix;
  48.  
  49. BEGIN
  50.  MulMatrix(A,B,C);
  51.  ShowMatrix(C);
  52. END.

on obtiendra le résultat suivant :

36 -24 -45
30 -63 -18
144 18 24

Matrice identité

Les matrices d'identités sont des matrices carrées où la dimension horizontale est égale à la dimension verticale, soit une matrice ayant le même nombre de ligne qu'elle a de nombre de colonne. De plus, le nombre d'éléments de la diagonale sont égaux à 1 et les éléments en dehors de cette diagonale sont de valeurs nulles ou 0. Voici quelques exemples de matrices d'identités :

[1 0
0 1
]
[1 0 0
0 1 0
0 0 1
]
[1 0 0 0
0 1 0 0
0 0 1 0
0 0 0 1
]

Sachant que la diagonale détermine les valeurs, on aura donc l'algorithme suivant :

BOUCLE POUR J ← 1 JUSQU'A nombre de dimensions verticale
   BOUCLE POUR I ← 1 JUSQU'A nombre de dimensions horizontale
      SI I = J ALORS
         R[J,I] ← 1
      SINON
         R[J,I] ← 0
      FIN SI
   FIN BOUCLE POUR I
FIN BOUCLE J

Matrice inversé

Les matrices inversés sont des matrices carrées avec un ordre précis dans lequel il faut inversé la première matrice (soit la matrice A) avec la formule suivante, où I est une matrice d'identité d'ordre précis :

A • A-1 = A-1 • A = 1

Voir également

Langage de programmation - Turbo Pascal - Turbo Pascal et Assembleur - Opération Mathématique

PARTAGER CETTE PAGE SUR
Dernière mise à jour : Jeudi, le 25 avril 2019