From cc8068b8fe96b09699fee8c66088d49173f0afa9 Mon Sep 17 00:00:00 2001 From: william Date: Tue, 23 Jan 2024 21:00:14 -0500 Subject: [PATCH] Things --- labo01/DenseStorage.h | 334 ++++++++++++------------- labo01/Matrix.h | 564 +++++++++++++++++++++--------------------- labo01/MatrixBase.h | 9 +- labo01/Vector.h | 158 ++++++------ 4 files changed, 524 insertions(+), 541 deletions(-) diff --git a/labo01/DenseStorage.h b/labo01/DenseStorage.h index e0a1bfd..4c2ec97 100644 --- a/labo01/DenseStorage.h +++ b/labo01/DenseStorage.h @@ -5,213 +5,197 @@ * * @brief Stockage dense pour des données à taille fixe ou dynamique. * - * Nom: - * Code permanent : - * Email : + * Nom: William Nolin + * Code permanent : NOLW76060101 + * Email : william.nolin.1@ens.etsmtl.ca * */ #include #include -namespace gti320 -{ - enum SizeType { Dynamic = -1 }; +namespace gti320 { + enum SizeType { + Dynamic = -1 + }; - /** - * Stockage à taille fixe. - * - * Le nombre de données à stocker est connu au moment de la compilation. - * Ce nombre est donné par le paramètre de patron : _Size - * - * Un tampon (tableau) de taille `_Size_` est alloué sur la pile d'exécution. - */ - template - class DenseStorage - { - private: + /** + * Stockage à taille fixe. + * + * Le nombre de données à stocker est connu au moment de la compilation. + * Ce nombre est donné par le paramètre de patron : _Size + * + * Un tampon (tableau) de taille `_Size_` est alloué sur la pile d'exécution. + */ + template + class DenseStorage { + private: - // TODO déclarer une variable m_data et allouer la mémoire pour y stocker _Size éléments - _Scalar* m_data; // <-- Ceci n'est pas bon, à modifier + _Scalar m_data[_Size]; - public: + public: - /** - * Constructeur par défaut - */ - DenseStorage() { } + /** + * Constructeur par défaut + */ + DenseStorage() {} - /** - * Constructeur de copie - */ - DenseStorage(const DenseStorage& other) - { - memcpy(m_data, other.m_data, sizeof(m_data)); - } + /** + * Constructeur de copie + */ + DenseStorage(const DenseStorage &other) { + memcpy(m_data, other.m_data, sizeof(m_data)); + } - /** - * Constructeur avec taille spécifiée - * - * (doit être la même que la taille spécifiée dans le patron) - */ - explicit DenseStorage(int _size) { } + /** + * Constructeur avec taille spécifiée + * + * (doit être la même que la taille spécifiée dans le patron) + */ + explicit DenseStorage(int _size) { + } - /** - * Constructor avec taille (_size) et données initiales (_data). - */ - explicit DenseStorage(const _Scalar* _data, int _size) - { - assert(_size >= 0 && _size == _Size); - memcpy(m_data, _data, sizeof(_Scalar) * _size); - } + /** + * Constructor avec taille (_size) et données initiales (_data). + */ + explicit DenseStorage(const _Scalar *_data, int _size) { + assert(_size >= 0 && _size == _Size); + memcpy(m_data, _data, sizeof(_Scalar) * _size); + } - /** - * Opérateur de copie - */ - DenseStorage& operator=(const DenseStorage& other) - { - if (this != &other) - { - assert(other.size() == _Size); - memcpy(m_data, other.m_data, sizeof(m_data)); - } - return *this; - } + /** + * Opérateur de copie + */ + DenseStorage &operator=(const DenseStorage &other) { + if (this != &other) { + assert(other.size() == _Size); + memcpy(m_data, other.m_data, sizeof(m_data)); + } + return *this; + } - static int size() { return _Size; } + static int size() { return _Size; } - /** - * Redimensionne le stockage pour qu'il contienne `size` élément. - */ - void resize(int size) - { - // Ne rien faire. Invalide pour les matrices à taille fixe. - } + /** + * Redimensionne le stockage pour qu'il contienne `size` élément. + */ + void resize(int size) { + // Ne rien faire. Invalide pour les matrices à taille fixe. + } - /** - * Mets tous les éléments à zéro. - */ - void setZero() - { - memset(m_data, 0, sizeof(_Scalar) * _Size); - } + /** + * Mets tous les éléments à zéro. + */ + void setZero() { + memset(m_data, 0, sizeof(_Scalar) * _Size); + } - /** - * Accès au tampon de données (en lecteur seulement) - */ - const _Scalar* data() const - { - return m_data; - } + /** + * Accès au tampon de données (en lecteur seulement) + */ + const _Scalar *data() const { + return &m_data[0]; + } - /** - * Accès au tampon de données (pour lecture et écriture) - */ - _Scalar* data() - { - return m_data; - } - }; + /** + * Accès au tampon de données (pour lecture et écriture) + */ + _Scalar *data() { + return &m_data[0]; + } + }; + /** + * Stockage à taille dynamique. + * + * Le nombre de données à stocker est déterminé à l'exécution. + * Un tampon de la taille demandée doit être alloué sur le tas via + * l'opérateur `new []` et la mémoire doit être libérée avec `delete[]` + */ + template + class DenseStorage<_Scalar, Dynamic> { + private: + _Scalar *m_data; + int m_size; - /** - * Stockage à taille dynamique. - * - * Le nombre de données à stocker est déterminé à l'exécution. - * Un tampon de la taille demandée doit être alloué sur le tas via - * l'opérateur `new []` et la mémoire doit être libérée avec `delete[]` - */ - template - class DenseStorage<_Scalar, Dynamic> - { - private: - _Scalar* m_data; - int m_size; + public: - public: + /** + * Constructeur par défaut + */ + DenseStorage() : m_data(nullptr), m_size(0) {} - /** - * Constructeur par défaut - */ - DenseStorage() : m_data(nullptr), m_size(0) {} + /** + * Constructeur avec taille spécifiée + */ + explicit DenseStorage(int _size) : m_data(nullptr), m_size(_size) { + m_data = new _Scalar[_size]; + setZero(); + } - /** - * Constructeur avec taille spécifiée - */ - explicit DenseStorage(int _size) : m_data(nullptr), m_size(_size) - { - // TODO allouer un tampon pour stocker _size éléments de type _Scalar. + /** + * Constructeur de copie + */ + DenseStorage(const DenseStorage &other) + : m_data(nullptr), m_size(other.m_size) { + m_data = new _Scalar[m_size]; + memcpy(m_data, other.m_data, m_size); + } - // TODO initialiser ce tampon à zéro. - } + /** + * Opérateur de copie + */ + DenseStorage &operator=(const DenseStorage &other) { + m_data = other.m_data; + m_size = other.m_size; + return *this; + } - /** - * Constructeur de copie - */ - DenseStorage(const DenseStorage& other) - : m_data(nullptr) - , m_size(other.m_size) - { - // TODO allouer un tampon pour stocker _size éléments de type _Scalar. + /** + * Destructeur + */ + ~DenseStorage() { + delete[] m_data; + } - // TODO copier other.m_data dans m_data. + /** + * Retourne la taille du tampon + */ + inline int size() const { return m_size; } - } + /** + * Redimensionne le tampon alloué pour le stockage. + * La mémoire qui n'est plus utilisée doit être libérée. + * + * Note :​ Toutes opérations de redimensionnement entraînent une réallocation de mémoire. + * Il n’est pas pertinent de copier les données car le résultat serait de toute façon incohérent. + */ + void resize(int _size) { + auto *data = new _Scalar[_size]; +// memcpy(data, m_data, m_size); // ??? - /** - * Opérateur de copie - */ - DenseStorage& operator=(const DenseStorage& other) - { - // TODO implémenter ! - return *this; - } + delete[] m_data; + m_data = data; + m_size = _size; + } - /** - * Destructeur - */ - ~DenseStorage() - { - // TODO libérer la mémoire allouée + /** + * Met tous les éléments à zéro. + */ + void setZero() { + memset(m_data, 0, m_size); + } - } + /** + * Accès au tampon de données (en lecteur seulement) + */ + const _Scalar *data() const { return m_data; } - /** - * Retourne la taille du tampon - */ - inline int size() const { return m_size; } - - /** - * Redimensionne le tampon alloué pour le stockage. - * La mémoire qui n'est plus utilisée doit être libérée. - * - * Note :​ Toutes opérations de redimensionnement entraînent une réallocation de mémoire. - * Il n’est pas pertinent de copier les données car le résultat serait de toute façon incohérent. - */ - void resize(int _size) - { - // TODO redimensionner la mémoire allouée - - } - - /** - * Met tous les éléments à zéro. - */ - void setZero() - { - // TODO implémenter ! - } - - /** - * Accès au tampon de données (en lecteur seulement) - */ - const _Scalar* data() const { return m_data; } - - /** - * Accès au tampon de données (pour lecture et écriture) - */ - _Scalar* data() { return m_data; } - }; + /** + * Accès au tampon de données (pour lecture et écriture) + */ + _Scalar *data() { return m_data; } + }; } diff --git a/labo01/Matrix.h b/labo01/Matrix.h index b6a9548..2a580f2 100644 --- a/labo01/Matrix.h +++ b/labo01/Matrix.h @@ -5,339 +5,335 @@ * * @brief Implémentation de matrices simples. * - * Nom: - * Code permanent : - * Email : + * Nom: William Nolin + * Code permanent : NOLW76060101 + * Email : william.nolin.1@ens.etsmtl.ca * */ #include "MatrixBase.h" -namespace gti320 -{ - enum StorageType - { - ColumnStorage = 0, - RowStorage = 1 - }; +namespace gti320 { + enum StorageType { + ColumnStorage = 0, + RowStorage = 1 + }; - // Déclaration avancée - template class SubMatrix; + // Déclaration avancée + template + class SubMatrix; - /** - * Classe Matrix spécialisé pour le cas générique. (defaut par colonne) - * - * (le cas d'un stockage par ligne fait l'objet d'une spécialisation de patron, voir plus bas) - */ - template - class Matrix : public MatrixBase<_Scalar, _RowsAtCompile, _ColsAtCompile> { - public: + /** + * Classe Matrix spécialisé pour le cas générique. (defaut par colonne) + * + * (le cas d'un stockage par ligne fait l'objet d'une spécialisation de patron, voir plus bas) + */ + template + class Matrix : public MatrixBase<_Scalar, _RowsAtCompile, _ColsAtCompile> { + public: - /** - * Constructeur par défaut - */ - Matrix() : MatrixBase<_Scalar, _RowsAtCompile, _ColsAtCompile>() { } + /** + * Constructeur par défaut + */ + Matrix() : MatrixBase<_Scalar, _RowsAtCompile, _ColsAtCompile>() {} - /** - * Constructeur de copie - */ - Matrix(const Matrix& other) : MatrixBase<_Scalar, _RowsAtCompile, _ColsAtCompile>(other) { } + /** + * Constructeur de copie + */ + Matrix(const Matrix &other) : MatrixBase<_Scalar, _RowsAtCompile, _ColsAtCompile>(other) {} - /** - * Constructeur avec spécification du nombre de ligne et de colonnes - */ - explicit Matrix(int _rows, int _cols) : MatrixBase<_Scalar, _RowsAtCompile, _ColsAtCompile>(_rows, _cols) { } + /** + * Constructeur avec spécification du nombre de ligne et de colonnes + */ + explicit Matrix(int _rows, int _cols) : MatrixBase<_Scalar, _RowsAtCompile, _ColsAtCompile>(_rows, _cols) {} - /** - * Destructeur - */ - ~Matrix() { } + /** + * Destructeur + */ + ~Matrix() {} - /** - * Opérateur de copie à partir d'une sous-matrice. - * - * Exemple : Matrix B = A.block(i,j,m,n); - */ - template - Matrix& operator= (const SubMatrix<_OtherScalar, OtherRows, _OtherCols, _OtherStorage>& submatrix) - { - // TODO copier les données de la sous-matrice. - // Note : si les dimensions ne correspondent pas, la matrice doit être redimensionnée. - // Vous pouvez présumer qu'il s'agit d'un stockage par colonnes. - return *this; - } + /** + * Opérateur de copie à partir d'une sous-matrice. + * + * Exemple : Matrix B = A.block(i,j,m,n); + */ + template + Matrix &operator=(const SubMatrix<_OtherScalar, _OtherRows, _OtherCols, _OtherStorage> &submatrix) { + if (_RowsAtCompile != _OtherRows || _ColsAtCompile != _OtherCols) { + this->resize(_OtherRows, _OtherCols); + } - /** - * Accesseur à une entrée de la matrice (lecture seule) - */ - _Scalar operator()(int i, int j) const - { - // TODO implementer - return (double)(i + j); - } + // TODO copier les données de la sous-matrice. + // Note : si les dimensions ne correspondent pas, la matrice doit être redimensionnée. + // Vous pouvez présumer qu'il s'agit d'un stockage par colonnes. + return *this; + } - /** - * Accesseur à une entrée de la matrice (lecture ou écriture) - */ - _Scalar& operator()(int i, int j) - { - // TODO implementer - // Indice : l'implémentation est identique à celle de la fonction précédente. - _Scalar x = (double)(i + j); - return x; - } + /** + * Accesseur à une entrée de la matrice (lecture seule) + */ + _Scalar operator()(int i, int j) const { + // TODO implementer + return (double) (i + j); + } - /** - * Crée une sous-matrice pour un block de taille (rows, cols) à partir de l'index (i,j). - */ - SubMatrix<_Scalar, _RowsAtCompile, _ColsAtCompile, _StorageType> block(int i, int j, int rows, int cols) const - { - return SubMatrix<_Scalar, _RowsAtCompile, _ColsAtCompile, _StorageType>(*this, i, j, rows, cols); - } + /** + * Accesseur à une entrée de la matrice (lecture ou écriture) + */ + _Scalar &operator()(int i, int j) { + // TODO implementer + // Indice : l'implémentation est identique à celle de la fonction précédente. + _Scalar x = (double) (i + j); + return x; + } - /** - * Calcule l'inverse de la matrice - */ - Matrix inverse() const - { - // Do nothing. - return *this; - } + /** + * Crée une sous-matrice pour un block de taille (rows, cols) à partir de l'index (i,j). + */ + SubMatrix<_Scalar, _RowsAtCompile, _ColsAtCompile, _StorageType> block(int i, int j, int rows, int cols) const { + return SubMatrix<_Scalar, _RowsAtCompile, _ColsAtCompile, _StorageType>(*this, i, j, rows, cols); + } - /** - * Retourne la transposée de la matrice - */ - template - Matrix<_OtherScalar, _OtherRows, _OtherCols, _OtherStorage> transpose() const - { - // TODO calcule et retourne la transposée de la matrice. + /** + * Calcule l'inverse de la matrice + */ + Matrix inverse() const { + // Do nothing. + return *this; + } - return Matrix<_OtherScalar, _OtherRows, _OtherCols, _OtherStorage>(); // pas bon, à changer - } + /** + * Retourne la transposée de la matrice + */ + template + Matrix<_OtherScalar, _OtherRows, _OtherCols, _OtherStorage> transpose() const { + // TODO calcule et retourne la transposée de la matrice. - /** - * Affecte l'identité à la matrice - */ - inline void setIdentity() - { - // TODO affecter la valeur 0.0 partour, sauf sur la diagonale principale où c'est 1.0.. - // Votre implémentation devrait aussi fonctionner pour des matrices qui ne sont pas carrées. - } + return Matrix<_OtherScalar, _OtherRows, _OtherCols, _OtherStorage>(); // pas bon, à changer + } - }; + /** + * Affecte l'identité à la matrice + */ + inline void setIdentity() { + // TODO affecter la valeur 0.0 partour, sauf sur la diagonale principale où c'est 1.0.. + // Votre implémentation devrait aussi fonctionner pour des matrices qui ne sont pas carrées. + } - /** - * Classe Matrix spécialisée pour un stockage par lignes - */ - template - class Matrix< _Scalar, _RowsAtCompile, _ColsAtCompile, RowStorage> : public MatrixBase<_Scalar, _RowsAtCompile, _ColsAtCompile> { + }; - public: - /** - * Constructeur par défaut - */ - Matrix() : MatrixBase<_Scalar, _RowsAtCompile, _ColsAtCompile>() { } + /** + * Classe Matrix spécialisée pour un stockage par lignes + */ + template + class Matrix<_Scalar, _RowsAtCompile, _ColsAtCompile, RowStorage> + : public MatrixBase<_Scalar, _RowsAtCompile, _ColsAtCompile> { - /** - * Constructeur de copie - */ - Matrix(const Matrix& other) : MatrixBase<_Scalar, _RowsAtCompile, _ColsAtCompile>(other) { } + public: + /** + * Constructeur par défaut + */ + Matrix() : MatrixBase<_Scalar, _RowsAtCompile, _ColsAtCompile>() {} - /** - * Constructeur avec spécification du nombre de ligne et de colonnes - */ - explicit Matrix(int rows, int cols) : MatrixBase<_Scalar, _RowsAtCompile, _ColsAtCompile>(rows, cols) { } + /** + * Constructeur de copie + */ + Matrix(const Matrix &other) : MatrixBase<_Scalar, _RowsAtCompile, _ColsAtCompile>(other) {} - /** - * Destructeur - */ - ~Matrix() { } + /** + * Constructeur avec spécification du nombre de ligne et de colonnes + */ + explicit Matrix(int rows, int cols) : MatrixBase<_Scalar, _RowsAtCompile, _ColsAtCompile>(rows, cols) {} - /** - * Opérateur de copie à partir d'une sous-matrice. - * - * Exemple : Matrix B = A.block(i,j,m,n); - */ - template - Matrix& operator= (const SubMatrix<_OtherScalar, OtherRows, _OtherCols, _OtherStorage>& submatrix) - { - // TODO copier les données de la sous-matrice. - // Note : si les dimensions ne correspondent pas, la matrice doit être redimensionnée. - // Vous pouvez présumer qu'il s'agit d'un stockage par lignes. - return *this; - } + /** + * Destructeur + */ + ~Matrix() {} - /** - * Accesseur à une entrée de la matrice (lecture seule) - */ - _Scalar operator()(int i, int j) const - { - // TODO implementer - return 0.0; - } + /** + * Opérateur de copie à partir d'une sous-matrice. + * + * Exemple : Matrix B = A.block(i,j,m,n); + */ + template + Matrix &operator=(const SubMatrix<_OtherScalar, OtherRows, _OtherCols, _OtherStorage> &submatrix) { - /** - * Accesseur à une entrée de la matrice (lecture ou écriture) - */ - _Scalar& operator()(int i, int j) - { - // TODO implementer - _Scalar x = 0.0; - return x; - } - /** - * Crée une sous-matrice pour un block de taille (rows, cols) à partir de l'index (i,j). - */ - SubMatrix<_Scalar, _RowsAtCompile, _ColsAtCompile, RowStorage> block(int i, int j, int rows, int cols) const { - return SubMatrix<_Scalar, _RowsAtCompile, _ColsAtCompile, RowStorage>(*this, i, j, rows, cols); - } + // TODO copier les données de la sous-matrice. + // Note : si les dimensions ne correspondent pas, la matrice doit être redimensionnée. + // Vous pouvez présumer qu'il s'agit d'un stockage par lignes. + return *this; + } - /** - * Calcule l'inverse de la matrice - */ - Matrix inverse() const - { - // Do nothing. - return *this; - } + /** + * Accesseur à une entrée de la matrice (lecture seule) + */ + _Scalar operator()(int i, int j) const { + // TODO implementer + return 0.0; + } - /** - * Retourne la transposée de la matrice - */ - Matrix<_Scalar, _ColsAtCompile, _RowsAtCompile, ColumnStorage> transpose() const - { - // TODO calcule et retourne la transposée de la matrice. - // Optimisez cette fonction en tenant compte du type de stockage utilisé. + /** + * Accesseur à une entrée de la matrice (lecture ou écriture) + */ + _Scalar &operator()(int i, int j) { + // TODO implementer + _Scalar x = 0.0; + return x; + } - return Matrix<_Scalar, _ColsAtCompile, _RowsAtCompile, ColumnStorage>(); - } + /** + * Crée une sous-matrice pour un block de taille (rows, cols) à partir de l'index (i,j). + */ + SubMatrix<_Scalar, _RowsAtCompile, _ColsAtCompile, RowStorage> block(int i, int j, int rows, int cols) const { + return SubMatrix<_Scalar, _RowsAtCompile, _ColsAtCompile, RowStorage>(*this, i, j, rows, cols); + } - /** - * Affecte l'identité à la matrice - */ - inline void setIdentity() - { - // TODO affecter la valeur 0.0 partour, sauf sur la diagonale principale où c'est 1.0.. - // Votre implémentation devrait aussi fonctionner pour des matrices qui ne sont pas carrées. - } + /** + * Calcule l'inverse de la matrice + */ + Matrix inverse() const { + // Do nothing. + return *this; + } - }; + /** + * Retourne la transposée de la matrice + */ + Matrix<_Scalar, _ColsAtCompile, _RowsAtCompile, ColumnStorage> transpose() const { + // TODO calcule et retourne la transposée de la matrice. + // Optimisez cette fonction en tenant compte du type de stockage utilisé. - /** - * Classe pour accéder à une sous-matrice. - * - * Un sous-matrice ne copie pas les données. Au lieu de cela, elle conserve une - * référence à la matrice originale. - */ - template - class SubMatrix - { - private: - // Référence à la matrice originale - Matrix<_Scalar, _RowsAtCompile, _ColsAtCompile, _StorageType>& m_matrix; + return Matrix<_Scalar, _ColsAtCompile, _RowsAtCompile, ColumnStorage>(); + } - // Constructeur par défaut (privé) - SubMatrix() {} + /** + * Affecte l'identité à la matrice + */ + inline void setIdentity() { + // TODO affecter la valeur 0.0 partour, sauf sur la diagonale principale où c'est 1.0.. + // Votre implémentation devrait aussi fonctionner pour des matrices qui ne sont pas carrées. + } - // (i,j) est le coin supérieur gauche de la sous-matrice - int m_i; // Décalage en ligne - int m_j; // Décalage en colonne + }; - // la sous-matrice est de dimension : m_rows x m_cols - int m_rows; // Hauteur de la sous-matrice (nombre de lignes) - int m_cols; // Largeur de la sous-matrice (nombre de colonnes) + /** + * Classe pour accéder à une sous-matrice. + * + * Un sous-matrice ne copie pas les données. Au lieu de cela, elle conserve une + * référence à la matrice originale. + */ + template + class SubMatrix { + private: + // Référence à la matrice originale + Matrix<_Scalar, _RowsAtCompile, _ColsAtCompile, _StorageType> &m_matrix; - public: + // Constructeur par défaut (privé) + SubMatrix() {} - /** - * Constructeur à partir d'une référence en lecture seule à une matrice. - */ - SubMatrix(const Matrix<_Scalar, _RowsAtCompile, _ColsAtCompile, _StorageType>& _matrix, int _i, int _j, int _rows, int _cols) : - m_matrix(const_cast&>(_matrix)), - m_i(_i), m_j(_j), m_rows(_rows), m_cols(_cols) - { - } + // (i,j) est le coin supérieur gauche de la sous-matrice + int m_i; // Décalage en ligne + int m_j; // Décalage en colonne - /** - * Constructeur à partir d'une référence en lecture et écriture à une matrice. - */ - explicit SubMatrix(Matrix<_Scalar, _RowsAtCompile, _ColsAtCompile, _StorageType>& _matrix, int _i, int _j, int _rows, int _cols) : - m_matrix(_matrix), - m_i(_i), m_j(_j), m_rows(_rows), m_cols(_cols) - { + // la sous-matrice est de dimension : m_rows x m_cols + int m_rows; // Hauteur de la sous-matrice (nombre de lignes) + int m_cols; // Largeur de la sous-matrice (nombre de colonnes) - } + public: - /** - * Constructeur de copie - */ - SubMatrix(const SubMatrix& other) : - m_matrix(other.m_matrix), - m_i(other.m_i), m_j(other.m_j), m_rows(other.m_rows), m_cols(other.m_cols) - { - } + /** + * Constructeur à partir d'une référence en lecture seule à une matrice. + */ + SubMatrix(const Matrix<_Scalar, _RowsAtCompile, _ColsAtCompile, _StorageType> &_matrix, int _i, int _j, + int _rows, int _cols) : + m_matrix(const_cast &>(_matrix)), + m_i(_i), m_j(_j), m_rows(_rows), m_cols(_cols) { + } - /** - * Destructeur - */ - ~SubMatrix() { } + /** + * Constructeur à partir d'une référence en lecture et écriture à une matrice. + */ + explicit SubMatrix(Matrix<_Scalar, _RowsAtCompile, _ColsAtCompile, _StorageType> &_matrix, int _i, int _j, + int _rows, int _cols) : + m_matrix(_matrix), + m_i(_i), m_j(_j), m_rows(_rows), m_cols(_cols) { - /** - * Opérateur de copie (à partir d'une matrice) - * - * Copies toutes les entrées de la matrice dans la sous-matrice. - * - * Note : la taille de la matrice doit correspondre à la taille de la - * sous-matrice. - */ - template - SubMatrix& operator= (const Matrix<_OtherScalar, _OtherRows, _OtherCols, _OtherStorage>& matrix) - { - // TODO Cpopie les valeurs de la matrice dans la sous-matrice. - // Note les dimensions de la matrice doivent correspondre à celle de - // la sous-matrice. - return *this; - } + } - /** - * Accesseur aux entrées de la sous-matrice (lecture seule) - * - * Note : il faut s'assurer que les indices respectent la taille de la - * sous-matrice - */ - _Scalar operator()(int i, int j) const - { - // TODO implémenter - return 0.0; - } + /** + * Constructeur de copie + */ + SubMatrix(const SubMatrix &other) : + m_matrix(other.m_matrix), + m_i(other.m_i), m_j(other.m_j), m_rows(other.m_rows), m_cols(other.m_cols) { + } - /** - * Accesseur aux entrées de la sous-matrice (lecture et écriture) - * - * Note : il faut s'assurer que les indices respectent la taille de la - * sous-matrice - */ - _Scalar& operator()(int i, int j) - { - // TODO implémenter - _Scalar x = 0.0; - return x; - } + /** + * Destructeur + */ + ~SubMatrix() {} - /** - * Retourne la transposée de la sous-matrice sous la forme d'une matrice. - */ - template - Matrix<_OtherScalar, _OtherRows, _OtherCols, _OtherStorage> transpose() const - { - // TODO implémenter - return Matrix<_OtherScalar, _OtherRows, _OtherCols, _OtherStorage>(); - } + /** + * Opérateur de copie (à partir d'une matrice) + * + * Copies toutes les entrées de la matrice dans la sous-matrice. + * + * Note : la taille de la matrice doit correspondre à la taille de la + * sous-matrice. + */ + template + SubMatrix &operator=(const Matrix<_OtherScalar, _OtherRows, _OtherCols, _OtherStorage> &matrix) { + // TODO Cpopie les valeurs de la matrice dans la sous-matrice. + // Note les dimensions de la matrice doivent correspondre à celle de + // la sous-matrice. + return *this; + } - inline int rows() const { return m_rows; } - inline int cols() const { return m_cols; } + /** + * Accesseur aux entrées de la sous-matrice (lecture seule) + * + * Note : il faut s'assurer que les indices respectent la taille de la + * sous-matrice + */ + _Scalar operator()(int i, int j) const { + assert(i > 0); + assert(i <= m_rows); + assert(j > 0); + assert(j <= m_cols); - }; + int full_i = this->m_i + i; + int full_j = this->m_j + j; + int storage_index = full_i * this->m_matrix.rows() + full_j; + + return this->m_matrix.data()[storage_index]; + } + + /** + * Accesseur aux entrées de la sous-matrice (lecture et écriture) + * + * Note : il faut s'assurer que les indices respectent la taille de la + * sous-matrice + */ + _Scalar &operator()(int i, int j) { + // TODO implémenter + _Scalar x = 0.0; + return x; + } + + /** + * Retourne la transposée de la sous-matrice sous la forme d'une matrice. + */ + template + Matrix<_OtherScalar, _OtherRows, _OtherCols, _OtherStorage> transpose() const { + // TODO implémenter + return Matrix<_OtherScalar, _OtherRows, _OtherCols, _OtherStorage>(); + } + + inline int rows() const { return m_rows; } + + inline int cols() const { return m_cols; } + + }; } diff --git a/labo01/MatrixBase.h b/labo01/MatrixBase.h index 2e5c46f..d7de45f 100644 --- a/labo01/MatrixBase.h +++ b/labo01/MatrixBase.h @@ -5,9 +5,9 @@ * * @brief Classe contenant les éléments de base des matrices et des vecteurs. * - * Nom: - * Code permanent : - * Email : + * Nom: William Nolin + * Code permanent : NOLW76060101 + * Email : william.nolin.1@ens.etsmtl.ca * */ @@ -44,7 +44,8 @@ namespace gti320 /** * Destructeur */ - ~MatrixBase() { } + ~MatrixBase() { + } /** diff --git a/labo01/Vector.h b/labo01/Vector.h index 11ef602..441a5ba 100644 --- a/labo01/Vector.h +++ b/labo01/Vector.h @@ -5,9 +5,9 @@ * * @brief Implémentation de vecteurs simples * - * Nom: - * Code permanent : - * Email : + * Nom: William Nolin + * Code permanent : NOLW76060101 + * Email : William Nolin * */ @@ -16,89 +16,91 @@ namespace gti320 { - /** - * Classe vecteur générique. - * - * Cette classe réutilise la classe `MatrixBase` et ses spécialisations de - * templates pour les manipulation bas niveau. - */ - template - class Vector : public MatrixBase<_Scalar, _Rows, 1> { - public: + /** + * Classe vecteur générique. + * + * Cette classe réutilise la classe `MatrixBase` et ses spécialisations de + * templates pour les manipulation bas niveau. + */ + template + class Vector : public MatrixBase<_Scalar, _Rows, 1> { + public: - /** - * Constructeur par défaut - */ - Vector() : MatrixBase<_Scalar, _Rows, 1>() { } + /** + * Constructeur par défaut + */ + Vector() : MatrixBase<_Scalar, _Rows, 1>() {} - /** - * Contructeur à partir d'un taille (rows). - */ - explicit Vector(int rows) : MatrixBase<_Scalar, _Rows, 1>(rows, 1) { } + /** + * Contructeur à partir d'un taille (rows). + */ + explicit Vector(int rows) : MatrixBase<_Scalar, _Rows, 1>(rows, 1) {} - /** - * Constructeur de copie - */ - Vector(const Vector& other) : MatrixBase<_Scalar, _Rows, 1>(other) { } + /** + * Constructeur de copie + */ + Vector(const Vector &other) : MatrixBase<_Scalar, _Rows, 1>(other) {} - /** - * Destructeur - */ - ~Vector() { } + /** + * Destructeur + */ + ~Vector() {} - /** - * Opérateur de copie - */ - Vector& operator=(const Vector& other) - { - // TODO implémenter - this->m_storage = other.m_storage; - return *this; - } + /** + * Opérateur de copie + */ + Vector &operator=(const Vector &other) { + // TODO implémenter + this->m_storage = other.m_storage; + return *this; + } - /** - * Accesseur à une entrée du vecteur (lecture seule) - */ - _Scalar operator()(int i) const - { - // TODO implémenter - return (double)i; - } + /** + * Accesseur à une entrée du vecteur (lecture seule) + */ + _Scalar operator()(int i) const { + return this->data()[i]; + } - /** - * Accesseur à une entrée du vecteur (lecture et écriture) - */ - _Scalar& operator()(int i) - { - // TODO implémenter - _Scalar x = (double)i; - return x; - } + /** + * Accesseur à une entrée du vecteur (lecture et écriture) + */ + _Scalar &operator()(int i) { + return this->m_storage.data()[i]; + } - /** - * Modifie le nombre de lignes du vecteur - */ - void resize(int _rows) - { - MatrixBase<_Scalar, _Rows, 1>::resize(_rows, 1); - } + /** + * Modifie le nombre de lignes du vecteur + */ + void resize(int _rows) { + MatrixBase<_Scalar, _Rows, 1>::resize(_rows, 1); + } - /** - * Produit scalaire de *this et other. - */ - inline _Scalar dot(const Vector& other) const - { - // TODO implémenter - return 0.0; - } + /** + * Produit scalaire de *this et other. + */ + inline _Scalar dot(const Vector &other) const { + assert(this->size() == other.size()); - /** - * Retourne la norme euclidienne du vecteur - */ - inline _Scalar norm() const - { - // TODO implémenter - return 0.0; - } - }; + _Scalar product = 0; + for (int i = 0; i < this->size(); i++) { + product += this->data()[i] * other.data()[i]; + } + + return product; + } + + /** + * Retourne la norme euclidienne du vecteur + */ + inline _Scalar norm() const { + _Scalar norm = 0; + + for (int i = 0; i < this->size(); i++) { + norm += std::pow(this->data()[i], 2); + } + + return std::sqrt(norm); + } + }; }