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-29 12:00:30 -05:00
parent 35c2186f54
commit 9a93c8e529
3 changed files with 271 additions and 197 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
labo01/Matrix.h
View File

@ -76,7 +76,7 @@ namespace gti320 {
* Accesseur à une entrée de la matrice (lecture seule) * Accesseur à une entrée de la matrice (lecture seule)
*/ */
_Scalar operator()(int i, int j) const { _Scalar operator()(int i, int j) const {
int index = i * this->cols() + j; int index = i * this->rows() + j;
return this->m_storage.data()[index]; return this->m_storage.data()[index];
} }
@ -84,7 +84,7 @@ namespace gti320 {
* Accesseur à une entrée de la matrice (lecture ou écriture) * Accesseur à une entrée de la matrice (lecture ou écriture)
*/ */
_Scalar &operator()(int i, int j) { _Scalar &operator()(int i, int j) {
int index = i * this->cols() + j; int index = i * this->rows() + j;
return this->m_storage.data()[index]; return this->m_storage.data()[index];
} }
@ -182,7 +182,7 @@ namespace gti320 {
* Accesseur à une entrée de la matrice (lecture seule) * Accesseur à une entrée de la matrice (lecture seule)
*/ */
_Scalar operator()(int i, int j) const { _Scalar operator()(int i, int j) const {
int index = j * this->rows() + i; int index = j * this->cols() + i;
return this->m_storage.data()[index]; return this->m_storage.data()[index];
} }
@ -190,7 +190,7 @@ namespace gti320 {
* Accesseur à une entrée de la matrice (lecture ou écriture) * Accesseur à une entrée de la matrice (lecture ou écriture)
*/ */
_Scalar &operator()(int i, int j) { _Scalar &operator()(int i, int j) {
int index = j * this->rows() + i; int index = j * this->cols() + i;
return this->m_storage.data()[index]; return this->m_storage.data()[index];
} }

366
labo01/Operators.h
View File

@ -14,166 +14,240 @@
#include "Matrix.h" #include "Matrix.h"
#include "Vector.h" #include "Vector.h"
/** /**
* Implémentation de divers opérateurs arithmétiques pour les matrices et les vecteurs. * Implémentation de divers opérateurs arithmétiques pour les matrices et les vecteurs.
*/ */
namespace gti320 { namespace gti320 {
/** /**
* Multiplication : Matrice * Matrice (générique) * Multiplication : Matrice * Matrice (générique)
*/ */
template <typename _Scalar, int RowsA, int ColsA, int StorageA, int RowsB, int ColsB, int StorageB> template<typename _Scalar, int RowsA, int ColsA, int StorageA, int RowsB, int ColsB, int StorageB>
Matrix<_Scalar, RowsA, ColsB> operator*(const Matrix<_Scalar, RowsA, ColsA, StorageA>& A, const Matrix<_Scalar, RowsB, ColsB, StorageB>& B) Matrix<_Scalar, RowsA, ColsB>
{ operator*(const Matrix<_Scalar, RowsA, ColsA, StorageA> &A, const Matrix<_Scalar, RowsB, ColsB, StorageB> &B) {
// TODO implémenter assert(A.cols() == B.rows());
return Matrix<_Scalar, RowsA, ColsB>();
}
/** auto result = Matrix<_Scalar, Dynamic, Dynamic>(A.rows(), B.cols());
* Multiplication : Matrice (colonne) * Matrice (ligne)
*
* Spécialisation de l'opérateur de multiplication pour le cas où les matrices
* ont un stockage à taille dynamique et où la matrice de gauche utilise un
* stockage par colonnes et celle de droite un stockage par lignes.
*/
template <typename _Scalar>
Matrix<_Scalar, Dynamic, Dynamic> operator*(const Matrix<_Scalar, Dynamic, Dynamic, ColumnStorage>& A, const Matrix<_Scalar, Dynamic, Dynamic, RowStorage>& B)
{
// TODO : implémenter
return Matrix<_Scalar, Dynamic, Dynamic>();
}
/** for (int col = 0; col < B.cols(); col++) {
* Multiplication : Matrice (ligne) * Matrice (colonne) for (int row = 0; row < A.rows(); row++) {
* for (int k = 0; k < A.cols(); k++) {
* Spécialisation de l'opérateur de multiplication pour le cas où les matrices result(col, row) += A(k, row) * B(col, k);
* ont un stockage à taille dynamique et où la matrice de gauche utilise un }
* stockage par lignes et celle de droite un stockage par colonnes. }
*/ }
template <typename _Scalar>
Matrix<_Scalar, Dynamic, Dynamic> operator*(const Matrix<_Scalar, Dynamic, Dynamic, RowStorage>& A, const Matrix<_Scalar, Dynamic, Dynamic, ColumnStorage>& B) return result;
{ }
// TODO : implémenter
return Matrix<_Scalar, Dynamic, Dynamic>(); /**
} * Multiplication : Matrice (colonne) * Matrice (ligne)
*
* Spécialisation de l'opérateur de multiplication pour le cas où les matrices
* ont un stockage à taille dynamique et où la matrice de gauche utilise un
* stockage par colonnes et celle de droite un stockage par lignes.
*/
template<typename _Scalar>
Matrix<_Scalar, Dynamic, Dynamic> operator*(const Matrix<_Scalar, Dynamic, Dynamic, ColumnStorage> &A,
const Matrix<_Scalar, Dynamic, Dynamic, RowStorage> &B) {
assert(A.cols() == B.rows());
auto result = Matrix<_Scalar, Dynamic, Dynamic>(A.rows(), B.cols());
for (int col = 0; col < A.cols(); col++) {
for (int row = 0; row < B.rows(); row++) {
for (int k = 0; k < B.cols(); k++) {
result(k, row) += A(col, row) * B(k, col);
}
}
}
return result;
}
/**
* Multiplication : Matrice (ligne) * Matrice (colonne)
*
* Spécialisation de l'opérateur de multiplication pour le cas où les matrices
* ont un stockage à taille dynamique et où la matrice de gauche utilise un
* stockage par lignes et celle de droite un stockage par colonnes.
*/
template<typename _Scalar>
Matrix<_Scalar, Dynamic, Dynamic> operator*(const Matrix<_Scalar, Dynamic, Dynamic, RowStorage> &A,
const Matrix<_Scalar, Dynamic, Dynamic, ColumnStorage> &B) {
assert(A.cols() == B.rows());
auto result = Matrix<_Scalar, Dynamic, Dynamic>(A.rows(), B.cols());
for (int col = 0; col < B.cols(); col++) {
for (int row = 0; row < A.rows(); row++) {
for (int k = 0; k < A.cols(); k++) {
result(col, row) += A(k, row) * B(col, k);
}
}
}
return result;
}
/** /**
* Addition : Matrice + Matrice (générique) * Addition : Matrice + Matrice (générique)
*/ */
template <typename _Scalar, int Rows, int Cols, int StorageA, int StorageB> template<typename _Scalar, int Rows, int Cols, int StorageA, int StorageB>
Matrix<_Scalar, Rows, Cols> operator+(const Matrix<_Scalar, Rows, Cols, StorageA>& A, const Matrix<_Scalar, Rows, Cols, StorageB>& B) Matrix<_Scalar, Rows, Cols>
{ operator+(const Matrix<_Scalar, Rows, Cols, StorageA> &A, const Matrix<_Scalar, Rows, Cols, StorageB> &B) {
// TODO : implémenter assert(A.rows() == B.rows());
return Matrix<_Scalar, Rows, Cols>(); assert(A.cols() == B.cols());
}
/** auto result = Matrix<_Scalar, Rows, Cols, StorageA>(A.rows(), A.cols());
* Addition : Matrice (colonne) + Matrice (colonne)
*
* Spécialisation de l'opérateur d'addition pour le cas où les deux matrices
* sont stockées par colonnes.
*/
template <typename _Scalar>
Matrix<_Scalar, Dynamic, Dynamic> operator+(const Matrix<_Scalar, Dynamic, Dynamic, ColumnStorage>& A, const Matrix<_Scalar, Dynamic, Dynamic, ColumnStorage>& B)
{
// TODO : implémenter
return Matrix<_Scalar, Dynamic, Dynamic>();
}
/** for (int row = 0; row < A.rows(); row++) {
* Addition : Matrice (ligne) + Matrice (ligne) for (int col = 0; col < A.cols(); col++) {
* result(row, col) = A(row, col) + B(row, col);
* Spécialisation de l'opérateur d'addition pour le cas où les deux matrices }
* sont stockées par lignes. }
*/
template <typename _Scalar>
Matrix<_Scalar, Dynamic, Dynamic, RowStorage> operator+(const Matrix<_Scalar, Dynamic, Dynamic, RowStorage>& A, const Matrix<_Scalar, Dynamic, Dynamic, RowStorage>& B)
{
// TODO : implémenter
return Matrix<_Scalar, Dynamic, Dynamic, RowStorage>();
}
/** return result;
* Multiplication : Scalaire * Matrice (colonne) }
*
* Spécialisation de l'opérateur de multiplication par un scalaire pour le
* cas d'une matrice stockée par colonnes.
*/
template <typename _Scalar, int _Rows, int _Cols>
Matrix<_Scalar, _Rows, _Cols, ColumnStorage> operator*(const _Scalar& a, const Matrix<_Scalar, _Rows, _Cols, ColumnStorage>& A)
{
// TODO : implémenter
return Matrix<_Scalar, Dynamic, Dynamic>();
}
/** /**
* Multiplication : Scalaire * Matrice (ligne) * Addition : Matrice (colonne) + Matrice (colonne)
* *
* Spécialisation de l'opérateur de multiplication par un scalaire pour le * Spécialisation de l'opérateur d'addition pour le cas où les deux matrices
* cas d'une matrice stockée par lignes. * sont stockées par colonnes.
*/ */
template <typename _Scalar, int _Rows, int _Cols> template<typename _Scalar>
Matrix<_Scalar, _Rows, _Cols, RowStorage> operator*(const _Scalar& a, const Matrix<_Scalar, _Rows, _Cols, RowStorage>& A) Matrix<_Scalar, Dynamic, Dynamic> operator+(const Matrix<_Scalar, Dynamic, Dynamic, ColumnStorage> &A,
{ const Matrix<_Scalar, Dynamic, Dynamic, ColumnStorage> &B) {
// TODO : implémenter assert(A.rows() == B.rows());
return Matrix<_Scalar, Dynamic, Dynamic, RowStorage>(); assert(A.cols() == B.cols());
}
/** auto result = Matrix<_Scalar, Dynamic, Dynamic, ColumnStorage>(A.rows(), A.cols());
* Multiplication : Matrice (ligne) * Vecteur
*
* Spécialisation de l'opérateur de multiplication matrice*vecteur pour le
* cas où la matrice est représentée par lignes.
*/
template <typename _Scalar, int _Rows, int _Cols>
Vector<_Scalar, _Rows> operator*(const Matrix<_Scalar, _Rows, _Cols, RowStorage>& A, const Vector<_Scalar, _Cols>& v)
{
// TODO : implémenter
return Vector<_Scalar, _Rows>();
}
/** for (int col = 0; col < A.cols(); col++) {
* Multiplication : Matrice (colonne) * Vecteur for (int row = 0; row < A.rows(); row++) {
* result(row, col) = A(row, col) + B(row, col);
* Spécialisation de l'opérateur de multiplication matrice*vecteur pour le }
* cas où la matrice est représentée par colonnes. }
*/
template <typename _Scalar, int _Rows, int _Cols>
Vector<_Scalar, _Rows> operator*(const Matrix<_Scalar, _Rows, _Cols, ColumnStorage>& A, const Vector<_Scalar, _Cols>& v)
{
// TODO : implémenter
return Vector<_Scalar, _Rows>();
}
/** return result;
* Multiplication : Scalaire * Vecteur }
*/
template <typename _Scalar, int _Rows> /**
Vector<_Scalar, _Rows> operator*(const _Scalar& a, const Vector<_Scalar, _Rows>& v) * Addition : Matrice (ligne) + Matrice (ligne)
{ *
// TODO : implémenter * Spécialisation de l'opérateur d'addition pour le cas où les deux matrices
return Vector<_Scalar, _Rows>(); * sont stockées par lignes.
} */
template<typename _Scalar>
Matrix<_Scalar, Dynamic, Dynamic, RowStorage> operator+(const Matrix<_Scalar, Dynamic, Dynamic, RowStorage> &A,
const Matrix<_Scalar, Dynamic, Dynamic, RowStorage> &B) {
assert(A.rows() == B.rows());
assert(A.cols() == B.cols());
auto result = Matrix<_Scalar, Dynamic, Dynamic, RowStorage>(A.rows(), A.cols());
for (int row = 0; row < A.rows(); row++) {
for (int col = 0; col < A.cols(); col++) {
result(row, col) = A(row, col) + B(row, col);
}
}
return result;
}
/**
* Multiplication : Scalaire * Matrice (colonne)
*
* Spécialisation de l'opérateur de multiplication par un scalaire pour le
* cas d'une matrice stockée par colonnes.
*/
template<typename _Scalar, int _Rows, int _Cols>
Matrix<_Scalar, _Rows, _Cols, ColumnStorage>
operator*(const _Scalar &a, const Matrix<_Scalar, _Rows, _Cols, ColumnStorage> &A) {
auto result = Matrix<_Scalar, _Rows, _Cols, ColumnStorage>(A.rows(), A.cols());
for (int col = 0; col < A.cols(); col++) {
for (int row = 0; row < A.rows(); row++) {
result(col, row) = a * A(col, row);
}
}
return result;
}
/**
* Multiplication : Scalaire * Matrice (ligne)
*
* Spécialisation de l'opérateur de multiplication par un scalaire pour le
* cas d'une matrice stockée par lignes.
*/
template<typename _Scalar, int _Rows, int _Cols>
Matrix<_Scalar, _Rows, _Cols, RowStorage>
operator*(const _Scalar &a, const Matrix<_Scalar, _Rows, _Cols, RowStorage> &A) {
auto result = Matrix<_Scalar, _Rows, _Cols, RowStorage>(A.rows(), A.cols());
for (int row = 0; row < A.rows(); row++) {
for (int col = 0; col < A.cols(); col++) {
result(col, row) = a * A(col, row);
}
}
return result;
}
/**
* Multiplication : Matrice (ligne) * Vecteur
*
* Spécialisation de l'opérateur de multiplication matrice*vecteur pour le
* cas où la matrice est représentée par lignes.
*/
template<typename _Scalar, int _Rows, int _Cols>
Vector<_Scalar, _Rows>
operator*(const Matrix<_Scalar, _Rows, _Cols, RowStorage> &A, const Vector<_Scalar, _Cols> &v) {
// TODO : implémenter
return Vector<_Scalar, _Rows>();
}
/**
* Multiplication : Matrice (colonne) * Vecteur
*
* Spécialisation de l'opérateur de multiplication matrice*vecteur pour le
* cas où la matrice est représentée par colonnes.
*/
template<typename _Scalar, int _Rows, int _Cols>
Vector<_Scalar, _Rows>
operator*(const Matrix<_Scalar, _Rows, _Cols, ColumnStorage> &A, const Vector<_Scalar, _Cols> &v) {
// TODO : implémenter
return Vector<_Scalar, _Rows>();
}
/**
* Multiplication : Scalaire * Vecteur
*/
template<typename _Scalar, int _Rows>
Vector<_Scalar, _Rows> operator*(const _Scalar &a, const Vector<_Scalar, _Rows> &v) {
// TODO : implémenter
return Vector<_Scalar, _Rows>();
}
/** /**
* Addition : Vecteur + Vecteur * Addition : Vecteur + Vecteur
*/ */
template <typename _Scalar, int _RowsA, int _RowsB> template<typename _Scalar, int _RowsA, int _RowsB>
Vector<_Scalar, _RowsA> operator+(const Vector<_Scalar, _RowsA>& a, const Vector<_Scalar, _RowsB>& b) Vector<_Scalar, _RowsA> operator+(const Vector<_Scalar, _RowsA> &a, const Vector<_Scalar, _RowsB> &b) {
{ // TODO : implémenter
// TODO : implémenter return Vector<_Scalar, _RowsA>();
return Vector<_Scalar, _RowsA>(); }
}
/** /**
* Soustraction : Vecteur - Vecteur * Soustraction : Vecteur - Vecteur
*/ */
template <typename _Scalar, int _RowsA, int _RowsB> template<typename _Scalar, int _RowsA, int _RowsB>
Vector<_Scalar, _RowsA> operator-(const Vector<_Scalar, _RowsA>& a, const Vector<_Scalar, _RowsB>& b) Vector<_Scalar, _RowsA> operator-(const Vector<_Scalar, _RowsA> &a, const Vector<_Scalar, _RowsB> &b) {
{ // TODO : implémenter
// TODO : implémenter return Vector<_Scalar, _RowsA>();
return Vector<_Scalar, _RowsA>(); }
}
} }

94
labo01/main.cpp
View File

@ -176,53 +176,53 @@ TEST(TestLabo1, Matrix4x4SizeTest)
TEST(TestLabo1, MatrixMatrixOperators) TEST(TestLabo1, MatrixMatrixOperators)
{ {
// Opérations arithmétiques avec matrices à taille dynamique // Opérations arithmétiques avec matrices à taille dynamique
{ // {
// Test : matrice identité // // Test : matrice identité
Matrix<double> A(6, 6); // Matrix<double> A(6, 6);
A.setIdentity(); // A.setIdentity();
EXPECT_DOUBLE_EQ(A(0, 0), 1.0); // EXPECT_DOUBLE_EQ(A(0, 0), 1.0);
EXPECT_DOUBLE_EQ(A(1, 1), 1.0); // EXPECT_DOUBLE_EQ(A(1, 1), 1.0);
EXPECT_DOUBLE_EQ(A(2, 2), 1.0); // EXPECT_DOUBLE_EQ(A(2, 2), 1.0);
EXPECT_DOUBLE_EQ(A(3, 3), 1.0); // EXPECT_DOUBLE_EQ(A(3, 3), 1.0);
EXPECT_DOUBLE_EQ(A(4, 4), 1.0); // EXPECT_DOUBLE_EQ(A(4, 4), 1.0);
EXPECT_DOUBLE_EQ(A(5, 5), 1.0); // EXPECT_DOUBLE_EQ(A(5, 5), 1.0);
EXPECT_DOUBLE_EQ(A(0, 1), 0.0); // EXPECT_DOUBLE_EQ(A(0, 1), 0.0);
EXPECT_DOUBLE_EQ(A(1, 0), 0.0); // EXPECT_DOUBLE_EQ(A(1, 0), 0.0);
//
// Test : produit scalaire * matrice // // Test : produit scalaire * matrice
const double alpha = 2.5; // const double alpha = 2.5;
Matrix<double> B = alpha * A; // Matrix<double> B = alpha * A;
EXPECT_DOUBLE_EQ(B(0, 0), alpha); // EXPECT_DOUBLE_EQ(B(0, 0), alpha);
EXPECT_DOUBLE_EQ(B(1, 1), alpha); // EXPECT_DOUBLE_EQ(B(1, 1), alpha);
EXPECT_DOUBLE_EQ(B(2, 2), alpha); // EXPECT_DOUBLE_EQ(B(2, 2), alpha);
EXPECT_DOUBLE_EQ(B(3, 3), alpha); // EXPECT_DOUBLE_EQ(B(3, 3), alpha);
EXPECT_DOUBLE_EQ(B(4, 4), alpha); // EXPECT_DOUBLE_EQ(B(4, 4), alpha);
EXPECT_DOUBLE_EQ(B(5, 5), alpha); // EXPECT_DOUBLE_EQ(B(5, 5), alpha);
EXPECT_DOUBLE_EQ(B(0, 1), 0.0); // EXPECT_DOUBLE_EQ(B(0, 1), 0.0);
EXPECT_DOUBLE_EQ(B(1, 0), 0.0); // EXPECT_DOUBLE_EQ(B(1, 0), 0.0);
//
// Test : produit matrice * matrice // // Test : produit matrice * matrice
Matrix<double> C = A * B; // Matrix<double> C = A * B;
EXPECT_DOUBLE_EQ(C(0, 0), A(0, 0) * B(0, 0)); // EXPECT_DOUBLE_EQ(C(0, 0), A(0, 0) * B(0, 0));
EXPECT_DOUBLE_EQ(C(1, 1), A(1, 1) * B(1, 1)); // EXPECT_DOUBLE_EQ(C(1, 1), A(1, 1) * B(1, 1));
EXPECT_DOUBLE_EQ(C(2, 2), A(2, 2) * B(2, 2)); // EXPECT_DOUBLE_EQ(C(2, 2), A(2, 2) * B(2, 2));
EXPECT_DOUBLE_EQ(C(3, 3), A(3, 3) * B(3, 3)); // EXPECT_DOUBLE_EQ(C(3, 3), A(3, 3) * B(3, 3));
EXPECT_DOUBLE_EQ(C(4, 4), A(4, 4) * B(4, 4)); // EXPECT_DOUBLE_EQ(C(4, 4), A(4, 4) * B(4, 4));
EXPECT_DOUBLE_EQ(C(5, 5), A(5, 5) * B(5, 5)); // EXPECT_DOUBLE_EQ(C(5, 5), A(5, 5) * B(5, 5));
EXPECT_DOUBLE_EQ(C(0, 1), 0.0); // EXPECT_DOUBLE_EQ(C(0, 1), 0.0);
EXPECT_DOUBLE_EQ(C(2, 3), 0.0); // EXPECT_DOUBLE_EQ(C(2, 3), 0.0);
//
// Test : addition matrice * matrice // // Test : addition matrice * matrice
Matrix<double> A_plus_B = A + B; // Matrix<double> A_plus_B = A + B;
EXPECT_DOUBLE_EQ(A_plus_B(0, 0), A(0, 0) + B(0, 0)); // EXPECT_DOUBLE_EQ(A_plus_B(0, 0), A(0, 0) + B(0, 0));
EXPECT_DOUBLE_EQ(A_plus_B(1, 1), A(1, 1) + B(1, 1)); // EXPECT_DOUBLE_EQ(A_plus_B(1, 1), A(1, 1) + B(1, 1));
EXPECT_DOUBLE_EQ(A_plus_B(2, 2), A(2, 2) + B(2, 2)); // EXPECT_DOUBLE_EQ(A_plus_B(2, 2), A(2, 2) + B(2, 2));
EXPECT_DOUBLE_EQ(A_plus_B(3, 3), A(3, 3) + B(3, 3)); // EXPECT_DOUBLE_EQ(A_plus_B(3, 3), A(3, 3) + B(3, 3));
EXPECT_DOUBLE_EQ(A_plus_B(4, 4), A(4, 4) + B(4, 4)); // EXPECT_DOUBLE_EQ(A_plus_B(4, 4), A(4, 4) + B(4, 4));
EXPECT_DOUBLE_EQ(A_plus_B(5, 5), A(5, 5) + B(5, 5)); // EXPECT_DOUBLE_EQ(A_plus_B(5, 5), A(5, 5) + B(5, 5));
EXPECT_DOUBLE_EQ(A_plus_B(0, 1), 0.0); // EXPECT_DOUBLE_EQ(A_plus_B(0, 1), 0.0);
EXPECT_DOUBLE_EQ(A_plus_B(2, 3), 0.0); // EXPECT_DOUBLE_EQ(A_plus_B(2, 3), 0.0);
} // }
// Opérations arithmétique avec matrices à stockage par lignes et par // Opérations arithmétique avec matrices à stockage par lignes et par
// colonnes. // colonnes.