2. Matrices

Objectifs

Implémenter une classe Matrice pour manipuler des matrices carrées
Implémenter des opérations entre les classe Matrice et Vecteur

Fichiers

Tout comme les vecteurs, il est largement préférable de créer un fichier header et un fichier source pour les matrices.

Stockage

La classe Matrice représente des matrices carrées (uniquement) et les stocke sous forme dense. Cette classe permettra d’effectuer des opérations matricielles (multiplication, …). Elle contient comme données privées (au moins, libre à vous d’en ajouter):

int N_ : Le nombre de colonnes (= de lignes)
std::vector<double> coef_ : Les coefficients, stockés dans un tableau à une dimension de la bibliothèque standard

Les coefficients sont stockés de la façon suivante. Le coefficient positionné en $(i,j)$ dans la matrice sera à la position j+i*N_ dans le vecteur de coefficients, où N_ est le nombre de colonnes ou de lignes.

Comme pour la classe Vecteur, la classe Matrice comporte des constructeurs et son fichier header ressemble ainsi à ceci

// Fichier include/matrice.hpp
#pragma once
#include<vector>   // pour les std::vector
#include<iostream> // pour std::ostream

class Matrice{
private:
  int N_;
  std::vector<double> coef_;
public:
  Matrice (); // constructeur vide
  Matrice (int N); // constructeur créant une matrice nulle de taille N
  Matrice (const Matrice & M); // constructeur par recopie
  ~Matrice() = default;
};

std::ostream & operator<<(std::ostream & os, const Matrice &A);

Quelques méthodes

Méthode (constante) qui renvoie la taille de la matrice
Les 2 accesseurs (l’un pour modifier, l’autre pour obtenir la valeur) :

double & operator() (int i, int j);     // Accès à la référence
double operator() (int i, int j) const; // Accès à la valeur (recopie)

Une Fonction qui affiche la matrice dans le terminal en utilisant les flux (en utilisant l’opérateur (i,j) et non directement coef_ !)

std::ostream & operator<<(std::ostream & os, const Matrice &A);

À partir de maintenant, vous ne devriez plus jamais accéder aux coefficients via coef_ mais uniquement via l’opérateur () !

En effet, si nous décidons de modifier la façon dont sont stockés les coefficients, nous aurons à répercuter cette modification uniquement dans les operator().

Opérations élémentaires

En mathématique, une matrice n’est pas qu’un tableau de coefficients et des opérations comme la multiplication ou l’addition sont possibles : ne nous privons pas de les implémenter ! Comme pour la classe Vecteur, nous vous invitons à définir ses fonctions en dehors de la classe Matrice et sans utiliser de friend :

L’addition et la soustraction entre deux matrices en surchargeant les opérateur + et -
La multiplication par une autre Matrice
La multiplication par un scalaire

En vous inspirant de ce qui a été réalisé pour la classe Vecteur, améliorez la classe Matrice avec les opérations arithmétiques précédentes (et d’autres si vous le souhaitez).

Produit Matrice-Vecteur

Implémentez le produit matrice vecteur sous forme d’un operator* :

Vecteur operator*(const Matrice& A, const Vecteur& x);

N’oubliez pas, alors, d’inclure le fichier header des vecteurs.

Quelques astuces générales :

Utilisez des références en argument pour éviter les recopies inutiles d’objets qui peuvent être lourdes en mémoire, ce qui est le cas pour les matrices.
Dans le cas des références passées en argument, déclarez les constantes (const truc &) si l’argument n’a pas vocation à être modifié par la fonction.
De même, déclarez les méthodes de vos classes comme constantes si l’objet appelant n’est pas modifié.

Résumé en diagrame

classDiagram class Matrice{ -int N_ -std::vector double coef_ +Matrice() +Matrice(int N) +Matrice(const Matrice & ) +~Matrice() +int size() const +double operator()(int i, int j) const + & double operator()(int i, int j) }

Last updated on 9 Sep 2018