Matrix in Matrix.h definiert.

.vscode/settings.json

@@ -0,0 +1,3 @@
+{
+    "makefile.configureOnOpen": false
+}

JD/main.c_.txt

@@ -0,0 +1,68 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include "imageInput.h"
+#include "mnistVisualization.h"
+#include "neuralNetwork.h"
+
+int main(int argc, char *argv[])
+{
+    const unsigned int windowWidth = 800;
+    const unsigned int windowHeight = 600;
+
+    int exitCode = EXIT_FAILURE;
+
+    if(argc == 3)
+    {
+        const char *pathToMnist = argv[1];
+        const char *pathToModel = argv[2];
+        GrayScaleImageSeries *series = readImages(pathToMnist);
+
+        if(series != NULL)
+        {
+            NeuralNetwork model = {NULL, 0};
+            printf("Loaded %u images ... \n", series->count);
+
+            model = loadModel(pathToModel);
+
+            if(model.numberOfLayers > 0)
+            {
+                unsigned char *predictions = NULL;
+                
+                printf("Processing %u images ...\n", series->count);
+
+                predictions = predict(model, series->images, series->count);
+
+                if(predictions != NULL)
+                {
+                    showMnist(windowWidth, windowHeight, series, predictions);
+                    free(predictions);
+                    exitCode = EXIT_SUCCESS;
+                }
+                else
+                {
+                    fprintf(stderr, "Error while processing images ...\n");
+                    exitCode = EXIT_FAILURE;
+                }
+                clearModel(&model);
+            }
+            else
+            {
+                fprintf(stderr, "Error while loading model from %s ...\n", pathToModel);
+                exitCode = EXIT_FAILURE;
+            }
+        }
+        else
+        {
+            fprintf(stderr, "Error while reading images from %s ...\n", pathToMnist);
+            exitCode = EXIT_FAILURE;
+        }
+        clearSeries(series);
+    }
+    else
+    {
+        fprintf(stderr, "Usage: %s <mnist file> <model file>\n", argv[0]);
+        exitCode = EXIT_FAILURE;
+    }
+
+    return exitCode;
+}

JD/matrix.c_.txt

@@ -0,0 +1,35 @@
+#include <stdlib.h>
+#include <string.h>
+#include "matrix.h"
+
+// TODO Matrix-Funktionen implementieren
+
+Matrix createMatrix(unsigned int rows, unsigned int cols)
+{
+    
+}
+
+void clearMatrix(Matrix *matrix)
+{
+    
+}
+
+void setMatrixAt(MatrixType value, Matrix matrix, unsigned int rowIdx, unsigned int colIdx)
+{
+    
+}
+
+MatrixType getMatrixAt(const Matrix matrix, unsigned int rowIdx, unsigned int colIdx)
+{
+    
+}
+
+Matrix add(const Matrix matrix1, const Matrix matrix2)
+{
+    
+}
+
+Matrix multiply(const Matrix matrix1, const Matrix matrix2)
+{
+    
+}

JD/matrix.h_.txt

@@ -0,0 +1,19 @@
+#ifndef MATRIX_H
+#define MATRIX_H
+
+#define UNDEFINED_MATRIX_VALUE 0
+
+typedef float MatrixType;
+
+// TODO Matrixtyp definieren
+
+
+Matrix createMatrix(unsigned int rows, unsigned int cols);
+void clearMatrix(Matrix *matrix);
+void setMatrixAt(MatrixType value, Matrix matrix, unsigned int rowIdx, unsigned int colIdx);
+MatrixType getMatrixAt(const Matrix matrix, unsigned int rowIdx, unsigned int colIdx);
+Matrix add(const Matrix matrix1, const Matrix matrix2);
+Matrix multiply(const Matrix matrix1, const Matrix matrix2);
+
+
+#endif

JD/matrixTests.c_.txt

@@ -0,0 +1,197 @@
+
+#include <stdio.h>
+#include <stdlib.h>
+#include "matrix.h"
+#include "unity.h"
+
+
+void test_createMatrixFailsOnZeroDimensions(void)
+{
+    Matrix matrixToTest1 = createMatrix(0, 1);
+    Matrix matrixToTest2 = createMatrix(1, 0);
+    TEST_ASSERT_NULL(matrixToTest1.buffer);
+    TEST_ASSERT_EQUAL_UINT32(0, matrixToTest1.rows);
+    TEST_ASSERT_EQUAL_UINT32(0, matrixToTest1.cols);
+    TEST_ASSERT_NULL(matrixToTest2.buffer);
+    TEST_ASSERT_EQUAL_UINT32(0, matrixToTest2.rows);
+    TEST_ASSERT_EQUAL_UINT32(0, matrixToTest2.cols);
+}
+
+void test_createMatrixReturnsCorrectMatrixDimensions(void)
+{
+    const unsigned int expectedRows = 15;
+    const unsigned int expectedCols = 10;
+    
+    Matrix matrixToTest = createMatrix(expectedRows, expectedCols);
+    TEST_ASSERT_EQUAL_UINT32(expectedRows, matrixToTest.rows);
+    TEST_ASSERT_EQUAL_UINT32(expectedCols, matrixToTest.cols);
+    free(matrixToTest.buffer);
+}
+
+void test_clearMatrixSetsMembersToNull(void)
+{
+    Matrix matrixToTest = createMatrix(10, 10);
+    clearMatrix(&matrixToTest);
+    TEST_ASSERT_NULL(matrixToTest.buffer);
+    TEST_ASSERT_EQUAL_UINT32(0, matrixToTest.rows);
+    TEST_ASSERT_EQUAL_UINT32(0, matrixToTest.cols);
+}
+
+void test_addReturnsCorrectResult(void)
+{
+    MatrixType buffer1[] = {1, 2, 3, 4, 5, 6};
+    MatrixType buffer2[] = {7, 8, 9, 10, 11, 12};
+    Matrix matrix1 = {.rows=2, .cols=3, .buffer=buffer1};
+    Matrix matrix2 = {.rows=2, .cols=3, .buffer=buffer2};
+
+    Matrix result = add(matrix1, matrix2);
+
+    float expectedResults[] = {8, 10, 12, 14, 16, 18};
+
+    TEST_ASSERT_EQUAL_UINT32(matrix1.rows, result.rows);
+    TEST_ASSERT_EQUAL_UINT32(matrix2.rows, result.rows);
+    TEST_ASSERT_EQUAL_UINT32(matrix1.cols, result.cols);
+    TEST_ASSERT_EQUAL_UINT32(matrix2.cols, result.cols);
+    TEST_ASSERT_EQUAL_INT(sizeof(expectedResults)/sizeof(expectedResults[0]), result.rows * result.cols);
+    TEST_ASSERT_EQUAL_FLOAT_ARRAY(expectedResults, result.buffer, result.cols * result.rows);
+    free(result.buffer);
+}
+
+void test_addFailsOnDifferentInputDimensions(void)
+{
+    MatrixType buffer1[] = {1, 2, 3, 4, 5, 6};
+    MatrixType buffer2[] = {7, 8, 9, 10, 11, 12};
+    Matrix matrix1 = {.rows=2, .cols=3, .buffer=buffer1};
+    Matrix matrix2 = {.rows=3, .cols=2, .buffer=buffer2};
+    
+    Matrix result = add(matrix1, matrix2);
+
+    TEST_ASSERT_NULL(result.buffer);
+    TEST_ASSERT_EQUAL_UINT32(0, result.rows);
+    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};
+    MatrixType buffer2[] = {7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18};
+    Matrix matrix1 = {.rows=2, .cols=3, .buffer=buffer1};
+    Matrix matrix2 = {.rows=3, .cols=4, .buffer=buffer2};
+    
+    Matrix result = multiply(matrix1, matrix2);
+
+    float expectedResults[] = {74, 80, 86, 92, 173, 188, 203, 218};
+
+    TEST_ASSERT_EQUAL_UINT32(matrix1.rows, result.rows);
+    TEST_ASSERT_EQUAL_UINT32(matrix2.cols, result.cols);
+    TEST_ASSERT_EQUAL_INT(sizeof(expectedResults)/sizeof(expectedResults[0]), result.rows * result.cols);
+    TEST_ASSERT_EQUAL_FLOAT_ARRAY(expectedResults, result.buffer, result.cols * result.rows);
+
+    free(result.buffer);
+}
+
+void test_multiplyFailsOnWrongInputDimensions(void)
+{
+    MatrixType buffer1[] = {1, 2, 3, 4, 5, 6};
+    MatrixType buffer2[] = {7, 8, 9, 10, 11, 12};
+    Matrix matrix1 = {.rows=2, .cols=3, .buffer=buffer1};
+    Matrix matrix2 = {.rows=2, .cols=3, .buffer=buffer2};
+
+    Matrix result = multiply(matrix1, matrix2);
+
+    TEST_ASSERT_NULL(result.buffer);
+    TEST_ASSERT_EQUAL_UINT32(0, result.rows);
+    TEST_ASSERT_EQUAL_UINT32(0, result.cols);
+}
+
+void test_getMatrixAtReturnsCorrectResult(void)
+{
+    MatrixType buffer[] = {1, 2, 3, 4, 5, 6};
+    Matrix matrixToTest = {.rows=2, .cols=3, .buffer=buffer};
+    int expectedResult = buffer[4];
+
+    TEST_ASSERT_EQUAL_INT(expectedResult, getMatrixAt(matrixToTest, 1, 1));
+}
+
+void test_getMatrixAtFailsOnIndicesOutOfRange(void)
+{
+    MatrixType buffer[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
+    Matrix matrixToTest = {.rows=2, .cols=3, .buffer=buffer};
+
+    TEST_ASSERT_EQUAL_INT(UNDEFINED_MATRIX_VALUE, getMatrixAt(matrixToTest, 2, 3));
+}
+
+void test_setMatrixAtSetsCorrectValue(void)
+{
+    const int expectedResult = -1;
+    MatrixType buffer[] = {1, 2, 3, 4, 5, 6};
+    Matrix matrixUnderTest = {.rows=2, .cols=3, .buffer=buffer};
+
+    setMatrixAt(expectedResult, matrixUnderTest, 1, 2);
+    TEST_ASSERT_EQUAL_INT(expectedResult, buffer[5]);
+}
+
+void test_setMatrixAtFailsOnIndicesOutOfRange(void)
+{
+    const float expectedResults[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
+    MatrixType buffer[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
+    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);
+}
+
+void setUp(void) {
+    // Falls notwendig, kann hier Vorbereitungsarbeit gemacht werden
+}
+
+void tearDown(void) {
+    // Hier kann Bereinigungsarbeit nach jedem Test durchgeführt werden
+}
+
+int main()
+{
+    UNITY_BEGIN();
+
+    printf("============================\nMatrix tests\n============================\n");
+    RUN_TEST(test_createMatrixReturnsCorrectMatrixDimensions);
+    RUN_TEST(test_createMatrixFailsOnZeroDimensions);
+    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);
+    RUN_TEST(test_getMatrixAtFailsOnIndicesOutOfRange);
+    RUN_TEST(test_setMatrixAtSetsCorrectValue);
+    RUN_TEST(test_setMatrixAtFailsOnIndicesOutOfRange);
+
+    return UNITY_END();
+}

JD/unittests.h_.txt

@@ -0,0 +1,10 @@
+#ifndef UNITTTESTS_H
+#define UNITTTESTS_H
+
+#include <stdio.h>
+
+typedef int (*UnitTestType)(void);
+
+#define RUN_UNIT_TEST(fct) printf("%80s: %d\n", #fct, fct())
+
+#endif

matrix.h

@@ -6,6 +6,13 @@
 typedef float MatrixType;
 
 // TODO Matrixtyp definieren
+typedef struct {
+    unsigned int rows;
+    unsigned int cols;
+    MatrixType *buffer;
+} Matrix;
+// *****************************************************
+
 
 
 Matrix createMatrix(unsigned int rows, unsigned int cols);