Fonctions d`algèbre linéaire - The IC Home Page is in:ic.epfl.ch

Fonctions d'algèbre linéaire
Nous allons définir une matrice comme un tableau de tableaux de double:
vector< vector<double> > M;
• 
• 
• 
• 
• 
et écrire des fonctions qui permettent de manipuler des matrices, par exemple:
une fonction qui crée une matrice nulle;
une fonction qui crée une matrice Identité;
une fonction qui permet d'additionner deux matrices;
une fonction qui permet de multiplier deux matrices;
...
En-tête des fonctions
• 
Quel est l'en-tête de la fonction qui crée une matrice nulle, dont la taille sera passée
en paramètre ?
vector< vector<double> > mat0(int nl, int nc)
• 
Quel est l'en-tête de la fonction qui crée une matrice Identité, dont la taille sera
passée en paramètre ?
vector< vector<double> > mat_Id(int n)
(une matrice Identité est forcément carrée, on a besoin que du nombre de lignes ou du
nombre de colonnes)
• 
Quel est l'en-tête de la fonction qui prend deux matrices en paramètre, et retourne
leur somme ?
vector< vector<double> > add_mat(vector< vector<double> > & M1,
vector< vector<double> > & M2)
typedef
Pour éviter de répéter vector< vector<double> > quand on doit définir le
type d'une matrice, on peut utiliser le mot-clé typedef:
typedef type type_synonyme;
Dans notre cas:
typedef vector< vector<double> > Matrice;
on peut alors écrire les en-têtes précédents:
Matrice mat0(int nl, int nc)
Matrice mat_Id(int n)
Matrice add_mat(Matrice & M1, Matrice & M2)
Fonction mat0
La fonction mat0 sera codée de la façon suivante:
Matrice mat0(int nl, int nc)
{
Matrice R(nl);
for(int i(0); i < nl; ++i) {
R[i] = vector<double>(nc);
for(int j(0); j < nc; ++j) {
R[i][j] = 0.0;
}
}
return R;
}
A
Cette fonction pourra être utilisée de la façon suivante:
Matrice A = mat0(3, 2);
0
0
0
0
0
0
Fonction mat_Id
Ecrivez la fonction mat_Id d'en-tête
Matrice mat_Id(int n)
qui retourne la matrice Identité de taille n
Fonctions init...
Nous allons aussi définir des fonctions qui vont nous permettre d'initialiser des
matrices.
Matrice init2x2(double a, double b,
double c, double d)
{
Matrice R = mat0(2, 2);
R[0][0]
R[0][1]
R[1][0]
R[1][1]
=
=
=
=
a;
b;
c;
d;
return R;
}
Par exemple:
Matrice M1 = init2x2(1, 2,
3, 4);
&1 2#
!!
M1 est initialisée à $$
%3 4"
Fonction affiche_mat
La fonction affiche_mat permet d'afficher une matrice passée en paramètre:
void affiche_mat(Matrice & M)
{
for(int i(0); i < M.size(); ++i) {
for(int j(0); j < M[i].size(); ++j) {
cout << M[i][j] << " ";
}
cout << endl;
}
}
le nombre de lignes de la matrice M vaut M.size(),
et le nombre de colonnes vaut M[i].size(), qui
devrait être toujours la même valeur quelle que soit la
valeur de i
add_mat
Ecrivez la fonction d'en-tête:
Matrice add_mat(Matrice & M1, Matrice & M2)
qui retourne la somme de M1 et M2
Vecteur
De la même façon, on peut définir le type Vecteur:
typedef vector<double> Vecteur;
On peut maintenant écrire la fonction pour créer un vecteur nul:
Vecteur vect0(int n)
{
Vecteur r = Vecteur(n);
for(int i(0); i < n; ++i) {
r[i] = 0.0;
}
return r;
}
Fonction affiche_vect
void affiche_vect(Vecteur & V)
{
for(int i(0); i < V.size(); ++i) {
cout << V[i] << " ";
}
cout << endl;
}
trace
Écrivez la fonction qui retourne la trace d'une matrice passée en paramètre.
La trace d'une matrice (nécessairement carrée) est la somme des éléments sur la
diagonale.
produit_scalaire
Écrivez la fonction qui permet de calculer le produit scalaire de deux vecteurs.
Écrivez la fonction mult d'en-tête:
Vecteur mult(Matrice & A, Vecteur & V)
qui retourne le produit de A et V.
Écrivez la fonction mult d'en-tête:
Matrice mult(Matrice & A, Matrice & B)
qui retourne le produit de A et V.