Things
This commit is contained in:
william
parent
1dd80d61bf
commit
cc8068b8fe
|
|
@ -5,18 +5,19 @@
|
|||
*
|
||||
* @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.
|
||||
|
|
@ -27,25 +28,22 @@ namespace gti320
|
|||
* Un tampon (tableau) de taille `_Size_` est alloué sur la pile d'exécution.
|
||||
*/
|
||||
template<typename _Scalar, int _Size>
|
||||
class DenseStorage
|
||||
{
|
||||
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:
|
||||
|
||||
/**
|
||||
* Constructeur par défaut
|
||||
*/
|
||||
DenseStorage() { }
|
||||
DenseStorage() {}
|
||||
|
||||
/**
|
||||
* Constructeur de copie
|
||||
*/
|
||||
DenseStorage(const DenseStorage& other)
|
||||
{
|
||||
DenseStorage(const DenseStorage &other) {
|
||||
memcpy(m_data, other.m_data, sizeof(m_data));
|
||||
}
|
||||
|
||||
|
|
@ -54,13 +52,13 @@ namespace gti320
|
|||
*
|
||||
* (doit être la même que la taille spécifiée dans le patron)
|
||||
*/
|
||||
explicit DenseStorage(int _size) { }
|
||||
explicit DenseStorage(int _size) {
|
||||
}
|
||||
|
||||
/**
|
||||
* Constructor avec taille (_size) et données initiales (_data).
|
||||
*/
|
||||
explicit DenseStorage(const _Scalar* _data, int _size)
|
||||
{
|
||||
explicit DenseStorage(const _Scalar *_data, int _size) {
|
||||
assert(_size >= 0 && _size == _Size);
|
||||
memcpy(m_data, _data, sizeof(_Scalar) * _size);
|
||||
}
|
||||
|
|
@ -68,10 +66,8 @@ namespace gti320
|
|||
/**
|
||||
* Opérateur de copie
|
||||
*/
|
||||
DenseStorage& operator=(const DenseStorage& other)
|
||||
{
|
||||
if (this != &other)
|
||||
{
|
||||
DenseStorage &operator=(const DenseStorage &other) {
|
||||
if (this != &other) {
|
||||
assert(other.size() == _Size);
|
||||
memcpy(m_data, other.m_data, sizeof(m_data));
|
||||
}
|
||||
|
|
@ -83,38 +79,33 @@ namespace gti320
|
|||
/**
|
||||
* Redimensionne le stockage pour qu'il contienne `size` élément.
|
||||
*/
|
||||
void resize(int size)
|
||||
{
|
||||
void resize(int size) {
|
||||
// Ne rien faire. Invalide pour les matrices à taille fixe.
|
||||
}
|
||||
|
||||
/**
|
||||
* Mets tous les éléments à zéro.
|
||||
*/
|
||||
void setZero()
|
||||
{
|
||||
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;
|
||||
const _Scalar *data() const {
|
||||
return &m_data[0];
|
||||
}
|
||||
|
||||
/**
|
||||
* Accès au tampon de données (pour lecture et écriture)
|
||||
*/
|
||||
_Scalar* data()
|
||||
{
|
||||
return m_data;
|
||||
_Scalar *data() {
|
||||
return &m_data[0];
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
|
||||
/**
|
||||
* Stockage à taille dynamique.
|
||||
*
|
||||
|
|
@ -123,10 +114,9 @@ namespace gti320
|
|||
* l'opérateur `new []` et la mémoire doit être libérée avec `delete[]`
|
||||
*/
|
||||
template<typename _Scalar>
|
||||
class DenseStorage<_Scalar, Dynamic>
|
||||
{
|
||||
class DenseStorage<_Scalar, Dynamic> {
|
||||
private:
|
||||
_Scalar* m_data;
|
||||
_Scalar *m_data;
|
||||
int m_size;
|
||||
|
||||
public:
|
||||
|
|
@ -139,42 +129,34 @@ namespace gti320
|
|||
/**
|
||||
* 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.
|
||||
|
||||
// TODO initialiser ce tampon à zéro.
|
||||
explicit DenseStorage(int _size) : m_data(nullptr), m_size(_size) {
|
||||
m_data = new _Scalar[_size];
|
||||
setZero();
|
||||
}
|
||||
|
||||
/**
|
||||
* 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.
|
||||
|
||||
// TODO copier other.m_data dans m_data.
|
||||
|
||||
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);
|
||||
}
|
||||
|
||||
/**
|
||||
* Opérateur de copie
|
||||
*/
|
||||
DenseStorage& operator=(const DenseStorage& other)
|
||||
{
|
||||
// TODO implémenter !
|
||||
DenseStorage &operator=(const DenseStorage &other) {
|
||||
m_data = other.m_data;
|
||||
m_size = other.m_size;
|
||||
return *this;
|
||||
}
|
||||
|
||||
/**
|
||||
* Destructeur
|
||||
*/
|
||||
~DenseStorage()
|
||||
{
|
||||
// TODO libérer la mémoire allouée
|
||||
|
||||
~DenseStorage() {
|
||||
delete[] m_data;
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -189,29 +171,31 @@ namespace gti320
|
|||
* 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
|
||||
void resize(int _size) {
|
||||
auto *data = new _Scalar[_size];
|
||||
// memcpy(data, m_data, m_size); // ???
|
||||
|
||||
delete[] m_data;
|
||||
m_data = data;
|
||||
m_size = _size;
|
||||
}
|
||||
|
||||
/**
|
||||
* Met tous les éléments à zéro.
|
||||
*/
|
||||
void setZero()
|
||||
{
|
||||
// TODO implémenter !
|
||||
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; }
|
||||
const _Scalar *data() const { return m_data; }
|
||||
|
||||
/**
|
||||
* Accès au tampon de données (pour lecture et écriture)
|
||||
*/
|
||||
_Scalar* data() { return m_data; }
|
||||
_Scalar *data() { return m_data; }
|
||||
};
|
||||
|
||||
}
|
||||
|
|
|
|||
142
labo01/Matrix.h
142
labo01/Matrix.h
|
|
@ -5,62 +5,64 @@
|
|||
*
|
||||
* @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
|
||||
{
|
||||
namespace gti320 {
|
||||
enum StorageType {
|
||||
ColumnStorage = 0,
|
||||
RowStorage = 1
|
||||
};
|
||||
|
||||
// Déclaration avancée
|
||||
template <typename _Scalar, int _RowsAtCompile, int _ColsAtCompile, int _StorageType> class SubMatrix;
|
||||
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>
|
||||
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>() { }
|
||||
Matrix() : MatrixBase<_Scalar, _RowsAtCompile, _ColsAtCompile>() {}
|
||||
|
||||
/**
|
||||
* Constructeur de copie
|
||||
*/
|
||||
Matrix(const Matrix& other) : MatrixBase<_Scalar, _RowsAtCompile, _ColsAtCompile>(other) { }
|
||||
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) { }
|
||||
explicit Matrix(int _rows, int _cols) : MatrixBase<_Scalar, _RowsAtCompile, _ColsAtCompile>(_rows, _cols) {}
|
||||
|
||||
/**
|
||||
* Destructeur
|
||||
*/
|
||||
~Matrix() { }
|
||||
~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)
|
||||
{
|
||||
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);
|
||||
}
|
||||
|
||||
// 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.
|
||||
|
|
@ -70,36 +72,32 @@ namespace gti320
|
|||
/**
|
||||
* Accesseur à une entrée de la matrice (lecture seule)
|
||||
*/
|
||||
_Scalar operator()(int i, int j) const
|
||||
{
|
||||
_Scalar operator()(int i, int j) const {
|
||||
// TODO implementer
|
||||
return (double)(i + j);
|
||||
return (double) (i + j);
|
||||
}
|
||||
|
||||
/**
|
||||
* Accesseur à une entrée de la matrice (lecture ou écriture)
|
||||
*/
|
||||
_Scalar& operator()(int i, int j)
|
||||
{
|
||||
_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);
|
||||
_Scalar x = (double) (i + j);
|
||||
return x;
|
||||
}
|
||||
|
||||
/**
|
||||
* 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
|
||||
{
|
||||
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);
|
||||
}
|
||||
|
||||
/**
|
||||
* Calcule l'inverse de la matrice
|
||||
*/
|
||||
Matrix inverse() const
|
||||
{
|
||||
Matrix inverse() const {
|
||||
// Do nothing.
|
||||
return *this;
|
||||
}
|
||||
|
|
@ -108,8 +106,7 @@ namespace gti320
|
|||
* Retourne la transposée de la matrice
|
||||
*/
|
||||
template<typename _OtherScalar, int _OtherRows, int _OtherCols, int _OtherStorage>
|
||||
Matrix<_OtherScalar, _OtherRows, _OtherCols, _OtherStorage> transpose() const
|
||||
{
|
||||
Matrix<_OtherScalar, _OtherRows, _OtherCols, _OtherStorage> transpose() const {
|
||||
// TODO calcule et retourne la transposée de la matrice.
|
||||
|
||||
return Matrix<_OtherScalar, _OtherRows, _OtherCols, _OtherStorage>(); // pas bon, à changer
|
||||
|
|
@ -118,8 +115,7 @@ namespace gti320
|
|||
/**
|
||||
* Affecte l'identité à la matrice
|
||||
*/
|
||||
inline void setIdentity()
|
||||
{
|
||||
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.
|
||||
}
|
||||
|
|
@ -129,29 +125,30 @@ namespace gti320
|
|||
/**
|
||||
* 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> {
|
||||
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>() { }
|
||||
Matrix() : MatrixBase<_Scalar, _RowsAtCompile, _ColsAtCompile>() {}
|
||||
|
||||
/**
|
||||
* Constructeur de copie
|
||||
*/
|
||||
Matrix(const Matrix& other) : MatrixBase<_Scalar, _RowsAtCompile, _ColsAtCompile>(other) { }
|
||||
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) { }
|
||||
explicit Matrix(int rows, int cols) : MatrixBase<_Scalar, _RowsAtCompile, _ColsAtCompile>(rows, cols) {}
|
||||
|
||||
/**
|
||||
* Destructeur
|
||||
*/
|
||||
~Matrix() { }
|
||||
~Matrix() {}
|
||||
|
||||
/**
|
||||
* Opérateur de copie à partir d'une sous-matrice.
|
||||
|
|
@ -159,8 +156,9 @@ namespace gti320
|
|||
* 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)
|
||||
{
|
||||
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.
|
||||
|
|
@ -170,8 +168,7 @@ namespace gti320
|
|||
/**
|
||||
* Accesseur à une entrée de la matrice (lecture seule)
|
||||
*/
|
||||
_Scalar operator()(int i, int j) const
|
||||
{
|
||||
_Scalar operator()(int i, int j) const {
|
||||
// TODO implementer
|
||||
return 0.0;
|
||||
}
|
||||
|
|
@ -179,8 +176,7 @@ namespace gti320
|
|||
/**
|
||||
* Accesseur à une entrée de la matrice (lecture ou écriture)
|
||||
*/
|
||||
_Scalar& operator()(int i, int j)
|
||||
{
|
||||
_Scalar &operator()(int i, int j) {
|
||||
// TODO implementer
|
||||
_Scalar x = 0.0;
|
||||
return x;
|
||||
|
|
@ -196,8 +192,7 @@ namespace gti320
|
|||
/**
|
||||
* Calcule l'inverse de la matrice
|
||||
*/
|
||||
Matrix inverse() const
|
||||
{
|
||||
Matrix inverse() const {
|
||||
// Do nothing.
|
||||
return *this;
|
||||
}
|
||||
|
|
@ -205,8 +200,7 @@ namespace gti320
|
|||
/**
|
||||
* Retourne la transposée de la matrice
|
||||
*/
|
||||
Matrix<_Scalar, _ColsAtCompile, _RowsAtCompile, ColumnStorage> transpose() const
|
||||
{
|
||||
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é.
|
||||
|
||||
|
|
@ -216,8 +210,7 @@ namespace gti320
|
|||
/**
|
||||
* Affecte l'identité à la matrice
|
||||
*/
|
||||
inline void setIdentity()
|
||||
{
|
||||
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.
|
||||
}
|
||||
|
|
@ -230,12 +223,11 @@ namespace gti320
|
|||
* 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
|
||||
{
|
||||
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;
|
||||
Matrix<_Scalar, _RowsAtCompile, _ColsAtCompile, _StorageType> &m_matrix;
|
||||
|
||||
// Constructeur par défaut (privé)
|
||||
SubMatrix() {}
|
||||
|
|
@ -253,35 +245,34 @@ namespace gti320
|
|||
/**
|
||||
* 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)
|
||||
{
|
||||
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) {
|
||||
}
|
||||
|
||||
/**
|
||||
* 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) :
|
||||
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)
|
||||
{
|
||||
m_i(_i), m_j(_j), m_rows(_rows), m_cols(_cols) {
|
||||
|
||||
}
|
||||
|
||||
/**
|
||||
* Constructeur de copie
|
||||
*/
|
||||
SubMatrix(const SubMatrix& other) :
|
||||
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)
|
||||
{
|
||||
m_i(other.m_i), m_j(other.m_j), m_rows(other.m_rows), m_cols(other.m_cols) {
|
||||
}
|
||||
|
||||
/**
|
||||
* Destructeur
|
||||
*/
|
||||
~SubMatrix() { }
|
||||
~SubMatrix() {}
|
||||
|
||||
/**
|
||||
* Opérateur de copie (à partir d'une matrice)
|
||||
|
|
@ -292,8 +283,7 @@ namespace gti320
|
|||
* sous-matrice.
|
||||
*/
|
||||
template<typename _OtherScalar, int _OtherRows, int _OtherCols, int _OtherStorage>
|
||||
SubMatrix& operator= (const Matrix<_OtherScalar, _OtherRows, _OtherCols, _OtherStorage>& matrix)
|
||||
{
|
||||
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.
|
||||
|
|
@ -306,10 +296,17 @@ namespace gti320
|
|||
* 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;
|
||||
_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];
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -318,8 +315,7 @@ namespace gti320
|
|||
* Note : il faut s'assurer que les indices respectent la taille de la
|
||||
* sous-matrice
|
||||
*/
|
||||
_Scalar& operator()(int i, int j)
|
||||
{
|
||||
_Scalar &operator()(int i, int j) {
|
||||
// TODO implémenter
|
||||
_Scalar x = 0.0;
|
||||
return x;
|
||||
|
|
@ -329,13 +325,13 @@ namespace gti320
|
|||
* 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
|
||||
{
|
||||
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; }
|
||||
|
||||
};
|
||||
|
|
|
|||
|
|
@ -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() {
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
|
|
|
|||
|
|
@ -5,9 +5,9 @@
|
|||
*
|
||||
* @brief Implémentation de vecteurs simples
|
||||
*
|
||||
* Nom:
|
||||
* Code permanent :
|
||||
* Email :
|
||||
* Nom: William Nolin
|
||||
* Code permanent : NOLW76060101
|
||||
* Email : William Nolin
|
||||
*
|
||||
*/
|
||||
|
||||
|
|
@ -22,35 +22,34 @@ namespace gti320 {
|
|||
* 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>
|
||||
template<typename _Scalar = double, int _Rows = Dynamic>
|
||||
class Vector : public MatrixBase<_Scalar, _Rows, 1> {
|
||||
public:
|
||||
|
||||
/**
|
||||
* Constructeur par défaut
|
||||
*/
|
||||
Vector() : MatrixBase<_Scalar, _Rows, 1>() { }
|
||||
Vector() : MatrixBase<_Scalar, _Rows, 1>() {}
|
||||
|
||||
/**
|
||||
* Contructeur à partir d'un taille (rows).
|
||||
*/
|
||||
explicit Vector(int rows) : MatrixBase<_Scalar, _Rows, 1>(rows, 1) { }
|
||||
explicit Vector(int rows) : MatrixBase<_Scalar, _Rows, 1>(rows, 1) {}
|
||||
|
||||
/**
|
||||
* Constructeur de copie
|
||||
*/
|
||||
Vector(const Vector& other) : MatrixBase<_Scalar, _Rows, 1>(other) { }
|
||||
Vector(const Vector &other) : MatrixBase<_Scalar, _Rows, 1>(other) {}
|
||||
|
||||
/**
|
||||
* Destructeur
|
||||
*/
|
||||
~Vector() { }
|
||||
~Vector() {}
|
||||
|
||||
/**
|
||||
* Opérateur de copie
|
||||
*/
|
||||
Vector& operator=(const Vector& other)
|
||||
{
|
||||
Vector &operator=(const Vector &other) {
|
||||
// TODO implémenter
|
||||
this->m_storage = other.m_storage;
|
||||
return *this;
|
||||
|
|
@ -59,46 +58,49 @@ namespace gti320 {
|
|||
/**
|
||||
* Accesseur à une entrée du vecteur (lecture seule)
|
||||
*/
|
||||
_Scalar operator()(int i) const
|
||||
{
|
||||
// TODO implémenter
|
||||
return (double)i;
|
||||
_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;
|
||||
_Scalar &operator()(int i) {
|
||||
return this->m_storage.data()[i];
|
||||
}
|
||||
|
||||
/**
|
||||
* Modifie le nombre de lignes du vecteur
|
||||
*/
|
||||
void resize(int _rows)
|
||||
{
|
||||
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;
|
||||
inline _Scalar dot(const Vector &other) const {
|
||||
assert(this->size() == other.size());
|
||||
|
||||
_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
|
||||
{
|
||||
// TODO implémenter
|
||||
return 0.0;
|
||||
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);
|
||||
}
|
||||
};
|
||||
}
|
||||
|
|
|
|||
Loading…
Reference in New Issue