Merge pull request 'matrixTests korrigiert.' (#4) from schroederen/info2Praktikum-NeuronalesNetz:main into main

Reviewed-on: freudenreichan/info2Praktikum-NeuronalesNetz#4

.gitignore

@@ -1,5 +1,4 @@
 mnist
 runTests
 *.o
-*.exe
-runMatrixTests
+*.exe

matrix.c

@@ -2,84 +2,34 @@
 #include <string.h>
 #include "matrix.h"
 
+// TODO Matrix-Funktionen implementieren
+
 Matrix createMatrix(unsigned int rows, unsigned int cols)
 {
-    Matrix mat = {.rows = rows, .cols = cols};
-    // If one dimension is 0, return both dimensions as 0 and don't init the array/buffer.
-    if (rows == 0 || cols == 0)
-    {
-        mat.rows = 0;
-        mat.cols = 0;
-        return mat;
-    }
-
-    // allocate contiguous and 0 initialized memory
-    mat.buffer = calloc(rows * cols, sizeof(MatrixType));
-
-    // check if calloc failed
-    if (mat.buffer == NULL)
-    {
-        clearMatrix(&mat);
-    }
-
-    return mat;
+    
 }
 
-// reduce the dimensions to (0, 0) and free the memory
 void clearMatrix(Matrix *matrix)
 {
-    free(matrix->buffer);
-    matrix->buffer = NULL;
-    matrix->cols = 0;
-    matrix->rows = 0;
+    
 }
 
 void setMatrixAt(MatrixType value, Matrix matrix, unsigned int rowIdx, unsigned int colIdx)
 {
-    // do nothing if idx is not in array or matrix buffer is NULL
-    if (!(rowIdx < matrix.rows) || !(colIdx < matrix.cols) || matrix.buffer == NULL)
-    {
-        return;
-    }
-
-    matrix.buffer[rowIdx * matrix.cols + colIdx] = value;
+    
 }
 
 MatrixType getMatrixAt(const Matrix matrix, unsigned int rowIdx, unsigned int colIdx)
 {
-    // return UNDEFINED_MATRIX_VALUE if idx is not in array or matrix buffer is NULL
-    if (!(rowIdx < matrix.rows) || !(colIdx < matrix.cols) || matrix.buffer == NULL)
-    {
-        return UNDEFINED_MATRIX_VALUE;
-    }
-
-    return matrix.buffer[rowIdx * matrix.cols + colIdx];
-};
+    
+}
 
 Matrix add(const Matrix matrix1, const Matrix matrix2)
 {
-    Matrix resMat = createMatrix(matrix1.rows, matrix1.cols);
-
-    // clear matrix and return if the dimensions of the input matrices differ from each other
-    if (matrix1.rows != matrix2.rows || matrix1.cols != matrix2.cols)
-    {
-        clearMatrix(&resMat);
-        return resMat;
-    }
-
-    for (size_t m = 0; m < matrix1.rows; m++)
-    {
-        for (size_t n = 0; n < matrix1.cols; n++)
-        {
-            // this is unnecessarily complicated because at this point we already know that the matrices are compatible
-            setMatrixAt(getMatrixAt(matrix1, m, n) + getMatrixAt(matrix2, m, n), resMat, m, n);
-        }
-    }
-
-    return resMat;
+    
 }
 
-// TODO implement
 Matrix multiply(const Matrix matrix1, const Matrix matrix2)
 {
+    
 }

matrix.h

@@ -5,14 +5,8 @@
 
 typedef float MatrixType;
 
-// Matrixtyp
-typedef struct Matrix
-{
-    size_t rows;
-    size_t cols;
-    MatrixType *buffer;
+// TODO Matrixtyp definieren
 
-} Matrix;
 
 Matrix createMatrix(unsigned int rows, unsigned int cols);
 void clearMatrix(Matrix *matrix);
@@ -21,4 +15,5 @@ MatrixType getMatrixAt(const Matrix matrix, unsigned int rowIdx, unsigned int co
 Matrix add(const Matrix matrix1, const Matrix matrix2);
 Matrix multiply(const Matrix matrix1, const Matrix matrix2);
 
+
 #endif

matrixTests.c

@@ -71,6 +71,32 @@ void test_addFailsOnDifferentInputDimensions(void)
     TEST_ASSERT_EQUAL_UINT32(0, result.cols);
 }
 
+void test_addSupportsBroadcasting(void)
+{
+    MatrixType buffer1[] = {1, 2, 3, 4, 5, 6};
+    MatrixType buffer2[] = {7, 8};
+    Matrix matrix1 = {.rows=2, .cols=3, .buffer=buffer1};
+    Matrix matrix2 = {.rows=2, .cols=1, .buffer=buffer2};
+
+    Matrix result1 = add(matrix1, matrix2);
+    Matrix result2 = add(matrix2, matrix1);
+
+    float expectedResults[] = {8, 9, 10, 12, 13, 14};
+
+    TEST_ASSERT_EQUAL_UINT32(matrix1.rows, result1.rows);
+    TEST_ASSERT_EQUAL_UINT32(matrix1.cols, result1.cols);
+    TEST_ASSERT_EQUAL_UINT32(matrix1.rows, result2.rows);
+    TEST_ASSERT_EQUAL_UINT32(matrix1.cols, result2.cols);
+
+    TEST_ASSERT_EQUAL_INT(sizeof(expectedResults)/sizeof(expectedResults[0]), result1.rows * result1.cols);
+    TEST_ASSERT_EQUAL_FLOAT_ARRAY(expectedResults, result1.buffer, result1.cols * result1.rows);
+    TEST_ASSERT_EQUAL_INT(sizeof(expectedResults)/sizeof(expectedResults[0]), result2.rows * result2.cols);
+    TEST_ASSERT_EQUAL_FLOAT_ARRAY(expectedResults, result2.buffer, result2.cols * result2.rows);
+
+    free(result1.buffer);
+    free(result2.buffer);
+}
+
 void test_multiplyReturnsCorrectResults(void)
 {
     MatrixType buffer1[] = {1, 2, 3, 4, 5, 6};
@@ -138,7 +164,7 @@ void test_setMatrixAtFailsOnIndicesOutOfRange(void)
     Matrix matrixToTest = {.rows=2, .cols=3, .buffer=buffer};
 
     setMatrixAt(-1, matrixToTest, 2, 3);
-    TEST_ASSERT_EQUAL_FLOAT_ARRAY(expectedResults, matrixToTest.buffer, matrixToTest.cols * matrixToTest.rows);
+    TEST_ASSERT_EQUAL_FLOAT_ARRAY(expectedResults, matrixToTest.buffer, sizeof(buffer)/sizeof(MatrixType));
 }
 
 void setUp(void) {
@@ -159,6 +185,7 @@ int main()
     RUN_TEST(test_clearMatrixSetsMembersToNull);
     RUN_TEST(test_addReturnsCorrectResult);
     RUN_TEST(test_addFailsOnDifferentInputDimensions);
+    RUN_TEST(test_addSupportsBroadcasting);
     RUN_TEST(test_multiplyReturnsCorrectResults);
     RUN_TEST(test_multiplyFailsOnWrongInputDimensions);
     RUN_TEST(test_getMatrixAtReturnsCorrectResult);