ETS_GTI320
/
lib_math
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Things

This commit is contained in:
william 2024-01-23 21:00:14 -05:00
parent 1dd80d61bf
commit cc8068b8fe
4 changed files with 524 additions and 541 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

334
labo01/DenseStorage.h
View File

@ -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 <cstring>
#include <cassert>
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<typename _Scalar, int _Size>
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<typename _Scalar, int _Size>
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<typename _Scalar>
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<typename _Scalar>
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; }
};
}

564
labo01/Matrix.h
View File

@ -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 <typename _Scalar, int _RowsAtCompile, int _ColsAtCompile, int _StorageType> class SubMatrix;
// Déclaration avancée
template<typename _Scalar, int _RowsAtCompile, int _ColsAtCompile, int _StorageType>
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 <typename _Scalar = double, int _RowsAtCompile = Dynamic, int _ColsAtCompile = Dynamic, int _StorageType = ColumnStorage>
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<typename _Scalar = double, int _RowsAtCompile = Dynamic, int _ColsAtCompile = Dynamic, int _StorageType = ColumnStorage>
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<typename _OtherScalar, int OtherRows, int _OtherCols, int _OtherStorage>
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<typename _OtherScalar, int _OtherRows, int _OtherCols, int _OtherStorage>
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<typename _OtherScalar, int _OtherRows, int _OtherCols, int _OtherStorage>
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<typename _OtherScalar, int _OtherRows, int _OtherCols, int _OtherStorage>
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 <typename _Scalar, int _RowsAtCompile, int _ColsAtCompile>
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<typename _Scalar, int _RowsAtCompile, int _ColsAtCompile>
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<typename _OtherScalar, int OtherRows, int _OtherCols, int _OtherStorage>
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<typename _OtherScalar, int OtherRows, int _OtherCols, int _OtherStorage>
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 <typename _Scalar, int _RowsAtCompile, int _ColsAtCompile, int _StorageType>
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<typename _Scalar, int _RowsAtCompile, int _ColsAtCompile, int _StorageType>
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<_Scalar, _RowsAtCompile, _ColsAtCompile, _StorageType>&>(_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<_Scalar, _RowsAtCompile, _ColsAtCompile, _StorageType> &>(_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<typename _OtherScalar, int _OtherRows, int _OtherCols, int _OtherStorage>
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<typename _OtherScalar, int _OtherRows, int _OtherCols, int _OtherStorage>
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<typename _OtherScalar, int _OtherRows, int _OtherCols, int _OtherStorage>
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<typename _OtherScalar, int _OtherRows, int _OtherCols, int _OtherStorage>
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; }
};
}

9
labo01/MatrixBase.h
View File

@ -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() {
}
/**

158
labo01/Vector.h
View File

@ -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 <typename _Scalar = double, int _Rows = Dynamic>
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<typename _Scalar = double, int _Rows = Dynamic>
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);
}
};
}