RoboidControl/RoboidControl-cpp
RoboidControl/RoboidControl-cpp
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Added access functions

Browse Source
This commit is contained in:
Pascal Serrarens 2024-02-14 10:54:26 +01:00
parent 26dd62b379
commit 59f8d9982f
3 changed files with 86 additions and 64 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

34
Matrix.cpp
View File

@ -6,7 +6,7 @@ void MatrixOf<float>::Transpose(MatrixOf<float>* r) {
// We dont care about the rows and cols (we overwrite them)
// but the data size should be equal to avoid problems
// We cannot check the data size directly, but the row*col should be equal
int matrixSize = this->cols * this->rows;
unsigned int matrixSize = this->cols * this->rows;
if (matrixSize != r->rows * r->cols)
// Exception??? For now we don't do anything
return;
@ -15,9 +15,9 @@ void MatrixOf<float>::Transpose(MatrixOf<float>* r) {
r->rows = this->cols;
for (int rDataIx = 0; rDataIx < matrixSize; rDataIx++) {
int rowIx = rDataIx / this->rows;
int colIx = rDataIx % this->rows;
int mDataIx = this->cols * colIx + rowIx;
unsigned int rowIx = rDataIx / this->rows;
unsigned int colIx = rDataIx % this->rows;
unsigned int mDataIx = this->cols * colIx + rowIx;
r->data[rDataIx] = this->data[mDataIx];
}
}
@ -26,13 +26,13 @@ template <>
void MatrixOf<float>::Multiply(MatrixOf<float>* m1,
MatrixOf<float>* m2,
MatrixOf<float>* r) {
for (int rowIx1 = 0; rowIx1 < m1->rows; rowIx1++) {
for (int colIx2 = 0; colIx2 < m2->cols; colIx2++) {
int rDataIx = colIx2 * m2->cols + rowIx1;
for (unsigned int rowIx1 = 0; rowIx1 < m1->rows; rowIx1++) {
for (unsigned int colIx2 = 0; colIx2 < m2->cols; colIx2++) {
unsigned int rDataIx = colIx2 * m2->cols + rowIx1;
r->data[rDataIx] = 0.0F;
for (int kIx = 0; kIx < m2->rows; kIx++) {
int dataIx1 = rowIx1 * m1->cols + kIx;
int dataIx2 = kIx * m2->cols + colIx2;
unsigned int dataIx1 = rowIx1 * m1->cols + kIx;
unsigned int dataIx2 = kIx * m2->cols + colIx2;
r->data[rDataIx] += m1->data[dataIx1] * m2->data[dataIx2];
}
}
@ -57,4 +57,20 @@ Vector3 MatrixOf<float>::Multiply(MatrixOf<float>* m, Vector3 v) {
delete[] vData;
delete[] rData;
return r;
}
template <typename T>
T MatrixOf<T>::Get(unsigned int rowIx, unsigned int colIx) {
unsigned int dataIx = rowIx * this->cols + colIx;
return this->data[dataIx];
}
template <typename T>
unsigned int MatrixOf<T>::RowCount() {
return rows;
}
template <typename T>
unsigned int MatrixOf<T>::ColCount() {
return cols;
}

30
Matrix.h
View File

@ -4,24 +4,30 @@
#include "Vector3.h"
/// @brief Single precision float matrix
template <typename T> class MatrixOf {
public:
MatrixOf(int rows, int cols, T *data) : rows(rows), cols(cols), data(data) {}
MatrixOf(Vector3 v); // creates a 3,1 matrix
template <typename T>
class MatrixOf {
public:
MatrixOf(unsigned int rows, unsigned int cols, T* data)
: rows(rows), cols(cols), data(data) {}
MatrixOf(Vector3 v); // creates a 3,1 matrix
/// @brief Transpose with result in matrix m
/// @param r The matrix in which the transposed matrix is stored
void Transpose(MatrixOf<T> *r);
void Transpose(MatrixOf<T>* r);
static void Multiply(MatrixOf<T> *m1, MatrixOf<T> *m2, MatrixOf<T> *r);
void Multiply(MatrixOf<T> *m, MatrixOf<T> *r);
static void Multiply(MatrixOf<T>* m1, MatrixOf<T>* m2, MatrixOf<T>* r);
void Multiply(MatrixOf<T>* m, MatrixOf<T>* r);
static Vector3 Multiply(MatrixOf<T> *m, Vector3 v);
static Vector3 Multiply(MatrixOf<T>* m, Vector3 v);
private:
int rows;
int cols;
T *data;
T Get(unsigned int rowIx, unsigned int colIx);
unsigned int RowCount();
unsigned int ColCount();
private:
unsigned int rows;
unsigned int cols;
T* data;
};
#endif

86
test/Matrix_test.cc
View File

@ -34,89 +34,89 @@ TEST(MatrixSingle, Transpose) {
float data3[] = {1.0F, 2.0F, 3.0F, 4.0F};
MatrixOf<float> m22 = MatrixOf<float>(2, 2, data3);
EXPECT_EQ(m22.rows, 2);
EXPECT_EQ(m22.cols, 2);
EXPECT_EQ(m22.RowCount(), 2);
EXPECT_EQ(m22.ColCount(), 2);
float data4[] = {0.0F, 0.0F, 0.0F, 0.0F};
MatrixOf<float> r22 = MatrixOf<float>(2, 2, data4);
EXPECT_EQ(r22.rows, 2);
EXPECT_EQ(r22.cols, 2);
EXPECT_EQ(r22.RowCount(), 2);
EXPECT_EQ(r22.ColCount(), 2);
m22.Transpose(&r22);
EXPECT_EQ(r22.rows, 2);
EXPECT_EQ(r22.cols, 2);
EXPECT_FLOAT_EQ(r22.data[0], 1.0F);
EXPECT_FLOAT_EQ(r22.data[1], 3.0F);
EXPECT_FLOAT_EQ(r22.data[2], 2.0F);
EXPECT_FLOAT_EQ(r22.data[3], 4.0F);
EXPECT_EQ(r22.RowCount(), 2);
EXPECT_EQ(r22.ColCount(), 2);
EXPECT_FLOAT_EQ(r22.Get(0, 0), 1.0F);
EXPECT_FLOAT_EQ(r22.Get(0, 1), 3.0F);
EXPECT_FLOAT_EQ(r22.Get(1, 0), 2.0F);
EXPECT_FLOAT_EQ(r22.Get(1, 1), 4.0F);
// 1 x 2
float data12[] = {1.0F, 2.0F};
MatrixOf<float> m12 = MatrixOf<float>(1, 2, data12);
EXPECT_EQ(m12.rows, 1);
EXPECT_EQ(m12.cols, 2);
EXPECT_EQ(m12.RowCount(), 1);
EXPECT_EQ(m12.ColCount(), 2);
float data21[] = {0.0F, 0.0F};
MatrixOf<float> r21 = MatrixOf<float>(2, 1, data21);
EXPECT_EQ(r21.rows, 2);
EXPECT_EQ(r21.cols, 1);
EXPECT_EQ(r21.RowCount(), 2);
EXPECT_EQ(r21.ColCount(), 1);
m12.Transpose(&r21);
EXPECT_EQ(r21.rows, 2);
EXPECT_EQ(r21.cols, 1);
EXPECT_FLOAT_EQ(r21.data[0], 1.0F);
EXPECT_FLOAT_EQ(r21.data[1], 2.0F);
EXPECT_EQ(r21.RowCount(), 2);
EXPECT_EQ(r21.ColCount(), 1);
EXPECT_FLOAT_EQ(r21.Get(0, 0), 1.0F);
EXPECT_FLOAT_EQ(r21.Get(1, 0), 2.0F);
// changing dimensions, same size is okay
MatrixOf<float> r12 = MatrixOf<float>(1, 2, data21);
EXPECT_EQ(r12.rows, 1);
EXPECT_EQ(r12.cols, 2);
EXPECT_EQ(r12.RowCount(), 1);
EXPECT_EQ(r12.ColCount(), 2);
m12.Transpose(&r12);
EXPECT_EQ(r12.rows, 2);
EXPECT_EQ(r12.cols, 1);
EXPECT_FLOAT_EQ(r12.data[0], 1.0F);
EXPECT_FLOAT_EQ(r12.data[1], 2.0F);
EXPECT_EQ(r12.RowCount(), 2);
EXPECT_EQ(r12.ColCount(), 1);
EXPECT_FLOAT_EQ(r12.Get(0, 0), 1.0F);
EXPECT_FLOAT_EQ(r12.Get(0, 1), 2.0F);
}
TEST(MatrixSingle, Multiply) {
float m12data[] = {1.0F, 2.0F};
MatrixOf<float> m12 = MatrixOf<float>(1, 2, m12data);
EXPECT_EQ(m12.rows, 1);
EXPECT_EQ(m12.cols, 2);
EXPECT_FLOAT_EQ(m12.data[0], 1.0F);
EXPECT_FLOAT_EQ(m12.data[1], 2.0F);
EXPECT_EQ(m12.RowCount(), 1);
EXPECT_EQ(m12.ColCount(), 2);
EXPECT_FLOAT_EQ(m12.Get(0, 0), 1.0F);
EXPECT_FLOAT_EQ(m12.Get(0, 1), 2.0F);
float m21data[] = {3.0F, 4.0F};
MatrixOf<float> m21 = MatrixOf<float>(2, 1, m21data);
EXPECT_EQ(m21.rows, 2);
EXPECT_EQ(m21.cols, 1);
EXPECT_FLOAT_EQ(m21.data[0], 3.0F);
EXPECT_FLOAT_EQ(m21.data[1], 4.0F);
EXPECT_EQ(m21.RowCount(), 2);
EXPECT_EQ(m21.ColCount(), 1);
EXPECT_FLOAT_EQ(m21.Get(0, 0), 3.0F);
EXPECT_FLOAT_EQ(m21.Get(1, 0), 4.0F);
float r11data[] = {0.0F};
MatrixOf<float> r11 = MatrixOf<float>(1, 1, r11data);
EXPECT_EQ(r11.rows, 1);
EXPECT_EQ(r11.cols, 1);
EXPECT_EQ(r11.RowCount(), 1);
EXPECT_EQ(r11.ColCount(), 1);
MatrixOf<float>::Multiply(&m12, &m21, &r11);
EXPECT_EQ(r11.rows, 1);
EXPECT_EQ(r11.cols, 1);
EXPECT_FLOAT_EQ(r11.data[0], 11.0F);
EXPECT_EQ(r11.RowCount(), 1);
EXPECT_EQ(r11.ColCount(), 1);
EXPECT_FLOAT_EQ(r11.Get(0, 0), 11.0F);
float r22data[] = {0.0F, 0.0F, 0.0F, 0.0F};
MatrixOf<float> r22 = MatrixOf<float>(2, 2, r22data);
MatrixOf<float>::Multiply(&m21, &m12, &r22);
EXPECT_EQ(r22.rows, 2);
EXPECT_EQ(r22.cols, 2);
EXPECT_FLOAT_EQ(r22.data[0], 3.0F);
EXPECT_FLOAT_EQ(r22.data[1], 4.0F);
EXPECT_FLOAT_EQ(r22.data[2], 6.0F);
EXPECT_FLOAT_EQ(r22.data[3], 8.0F);
EXPECT_EQ(r22.RowCount(), 2);
EXPECT_EQ(r22.ColCount(), 2);
EXPECT_FLOAT_EQ(r22.Get(0, 0), 3.0F);
EXPECT_FLOAT_EQ(r22.Get(0, 1), 4.0F);
EXPECT_FLOAT_EQ(r22.Get(1, 0), 6.0F);
EXPECT_FLOAT_EQ(r22.Get(1, 1), 8.0F);
}
#endif