baumgaertnerya98874/NeuronalesNetz_Team5
1
0
Fork 0
generated from freudenreichan/info2Praktikum-NeuronalesNetz
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Überflüssigen Ordner gelöscht.

Browse Source
This commit is contained in:
Jochen Duernberger 2025-11-13 14:43:13 +01:00
parent d802593175
commit ea24a8e34e
5 changed files with 0 additions and 329 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

68
JD/main.c_.txt
View File

@ -1,68 +0,0 @@
#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;
}

35
JD/matrix.c_.txt
View File

@ -1,35 +0,0 @@
#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)
{
}

19
JD/matrix.h_.txt
View File

@ -1,19 +0,0 @@
#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

197
JD/matrixTests.c_.txt
View File

@ -1,197 +0,0 @@
#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();
}

10
JD/unittests.h_.txt
View File

@ -1,10 +0,0 @@
#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