27.11

Notizen.c

@@ -0,0 +1,13 @@
+//neuralNetwork.c - BalckBox - Erkennung der Zahlen
+
+
+//ImageInput.c - // TODO Implementieren Sie geeignete Hilfsfunktionen für das Lesen der Bildserie aus einer Datei
+                 // TODO Vervollständigen Sie die Funktion readImages unter Benutzung Ihrer Hilfsfunktionen
+                 // TODO Vervollständigen Sie die Funktion clearSeries, welche eine Bildserie vollständig aus dem Speicher freigibt
+
+// Patric Viebcodet
+
+// matrix.c -     // TODO Matrix-Funktionen implementieren - Sven die letzen 3, Felix die ersten 3
+//
+
+//

makefile_linux.variables

@@ -1,2 +0,0 @@
-LDFLAGS = -lGL -lX11 -lm
-BINARIES = ./linux

makefile_mac.variables

@@ -1,3 +0,0 @@
-LDFLAGS = -framework OpenGL -framework CoreFoundation -framework CoreGraphics -framework IOKit -framework Cocoa -framework CoreVideo
-ARCH := $(shell uname -m)
-BINARIES = ./macos-$(ARCH)

matrix.c

@@ -6,30 +6,146 @@
 
 Matrix createMatrix(unsigned int rows, unsigned int cols)
 {
-    
+    Matrix m;
+
+    if (rows == 0 || cols == 0)
+    {
+        m.rows = 0;
+        m.cols = 0;
+        m.buffer = NULL;
+        return m;
+    }
+
+    m.rows = rows;
+    m.cols = cols;
+    m.buffer = (MatrixType *)calloc(rows * cols, sizeof(MatrixType));
+
+    return m;
 }
 
 void clearMatrix(Matrix *matrix)
 {
-    
+    if (matrix != NULL)
+    {
+        if (matrix->buffer != NULL)
+        {
+            free(matrix->buffer);
+            matrix->buffer = NULL;
+        }
+
+        matrix->rows = 0;
+        matrix->cols = 0;
+    }
 }
 
 void setMatrixAt(MatrixType value, Matrix matrix, unsigned int rowIdx, unsigned int colIdx)
 {
-    
+    if (matrix.buffer != NULL)
+    {
+        if (rowIdx < matrix.rows && colIdx < matrix.cols)
+        {
+            matrix.buffer[rowIdx * matrix.cols + colIdx] = value;
+        }
+    }
 }
 
 MatrixType getMatrixAt(const Matrix matrix, unsigned int rowIdx, unsigned int colIdx)
 {
-    
+    if (matrix.buffer == NULL || rowIdx >= matrix.rows || colIdx >= matrix.cols)
+    {
+        return UNDEFINED_MATRIX_VALUE;
+    }
+
+    return matrix.buffer[rowIdx * matrix.cols + colIdx];
 }
 
 Matrix add(const Matrix matrix1, const Matrix matrix2)
 {
-    
+    Matrix result;
+
+    if (matrix1.buffer == NULL || matrix2.buffer == NULL || matrix1.rows != matrix2.rows)
+    {
+        result.rows = 0;
+        result.cols = 0;
+        result.buffer = NULL;
+        return result;
+    }
+
+    if (matrix1.cols == matrix2.cols)
+    {
+        result = createMatrix(matrix1.rows, matrix1.cols);
+        for (int i = 0; i < matrix1.rows; i++)
+        {
+            for (int j = 0; j < matrix1.cols; j++)
+            {
+                MatrixType value = getMatrixAt(matrix1, i, j) + getMatrixAt(matrix2, i, j);
+                setMatrixAt(value, result, i, j);
+            }
+        }
+        return result;
+    }
+
+    if (matrix1.cols == 1 && matrix2.cols > 1)
+    {
+        result = createMatrix(matrix1.rows, matrix2.cols);
+        for (int i = 0; i < matrix1.rows; i++)
+        {
+            for (int j = 0; j < matrix2.cols; j++)
+            {
+                MatrixType value = getMatrixAt(matrix1, i, 0) + getMatrixAt(matrix2, i, j);
+                setMatrixAt(value, result, i, j);
+            }
+        }
+        return result;
+    }
+    else if (matrix2.cols == 1 && matrix1.cols > 1)
+    {
+        result = createMatrix(matrix1.rows, matrix1.cols);
+        for (int i = 0; i < matrix1.rows; i++)
+        {
+            for (int j = 0; j < matrix1.cols; j++)
+            {
+                MatrixType value = getMatrixAt(matrix1, i, j) + getMatrixAt(matrix2, i, 0);
+                setMatrixAt(value, result, i, j);
+            }
+        }
+        return result;
+    }
+
+    //Fall: Unterschiedliche Spaltenanzahl, beide ungleich 1
+    result.rows = 0;
+    result.cols = 0;
+    result.buffer = NULL;
+    return result;
 }
 
 Matrix multiply(const Matrix matrix1, const Matrix matrix2)
 {
-    
-}
+    Matrix result;
+
+    if (matrix1.buffer == NULL || matrix2.buffer == NULL || matrix1.cols != matrix2.rows)
+    {
+        result.rows = 0;
+        result.cols = 0;
+        result.buffer = NULL;
+        return result;
+    }
+
+    result = createMatrix(matrix1.rows, matrix2.cols);
+
+    for (int i = 0; i < matrix1.rows; i++)
+    {
+        for (int j = 0; j < matrix2.cols; j++)
+        {
+            MatrixType sum = 0;
+
+            for (int k = 0; k < matrix1.cols; k++)
+            {
+                sum += getMatrixAt(matrix1, i, k) * getMatrixAt(matrix2, k, j);
+            }
+            setMatrixAt(sum, result, i, j);
+        }
+    }
+
+    return result;
+}

matrix.h

@@ -1,13 +1,19 @@
+
+
 #ifndef MATRIX_H
 #define MATRIX_H
 
 #define UNDEFINED_MATRIX_VALUE 0
-
 typedef float MatrixType;
 
-// TODO Matrixtyp definieren
-
+// Definition des Matrix-Typs
+typedef struct {
+    unsigned int rows;
+    unsigned int cols;
+    MatrixType *buffer; // dynamisch allokiertes Array
+} Matrix;
 
+// Funktionsdeklarationen
 Matrix createMatrix(unsigned int rows, unsigned int cols);
 void clearMatrix(Matrix *matrix);
 void setMatrixAt(MatrixType value, Matrix matrix, unsigned int rowIdx, unsigned int colIdx);
@@ -15,5 +21,4 @@ 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
+#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};
@@ -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);

matrix_neu.c

@@ -0,0 +1,151 @@
+#include <stdlib.h>
+#include <string.h>
+#include "matrix.h"
+
+// TODO Matrix-Funktionen implementieren
+
+Matrix createMatrix(unsigned int rows, unsigned int cols)
+{
+    Matrix m;
+
+    if (rows == 0 || cols == 0)
+    {
+        m.rows = 0;
+        m.cols = 0;
+        m.buffer = NULL;
+        return m;
+    }
+
+    m.rows = rows;
+    m.cols = cols;
+    m.buffer = (MatrixType *)calloc(rows * cols, sizeof(MatrixType));
+
+    return m;
+}
+
+void clearMatrix(Matrix *matrix)
+{
+    if (matrix != NULL)
+    {
+        if (matrix->buffer != NULL)
+        {
+            free(matrix->buffer);
+            matrix->buffer = NULL;
+        }
+
+        matrix->rows = 0;
+        matrix->cols = 0;
+    }
+}
+
+void setMatrixAt(MatrixType value, Matrix matrix, unsigned int rowIdx, unsigned int colIdx)
+{
+    if (matrix.buffer != NULL)
+    {
+        if (rowIdx < matrix.rows && colIdx < matrix.cols)
+        {
+            matrix.buffer[rowIdx * matrix.cols + colIdx] = value;
+        }
+    }
+}
+
+MatrixType getMatrixAt(const Matrix matrix, unsigned int rowIdx, unsigned int colIdx)
+{
+    if (matrix.buffer == NULL || rowIdx >= matrix.rows || colIdx >= matrix.cols)
+    {
+        return UNDEFINED_MATRIX_VALUE;
+    }
+
+    return matrix.buffer[rowIdx * matrix.cols + colIdx];
+}
+
+Matrix add(const Matrix matrix1, const Matrix matrix2)
+{
+    Matrix result;
+
+    if (matrix1.buffer == NULL || matrix2.buffer == NULL || matrix1.rows != matrix2.rows)
+    {
+        result.rows = 0;
+        result.cols = 0;
+        result.buffer = NULL;
+        return result;
+    }
+
+    if (matrix1.cols == matrix2.cols)
+    {
+        result = createMatrix(matrix1.rows, matrix1.cols);
+        for (int i = 0; i < matrix1.rows; i++)
+        {
+            for (int j = 0; j < matrix1.cols; j++)
+            {
+                MatrixType value = getMatrixAt(matrix1, i, j) + getMatrixAt(matrix2, i, j);
+                setMatrixAt(value, result, i, j);
+            }
+        }
+        return result;
+    }
+
+    if (matrix1.cols == 1 && matrix2.cols > 1)
+    {
+        result = createMatrix(matrix1.rows, matrix2.cols);
+        for (int i = 0; i < matrix1.rows; i++)
+        {
+            for (int j = 0; j < matrix2.cols; j++)
+            {
+                MatrixType value = getMatrixAt(matrix1, i, 0) + getMatrixAt(matrix2, i, j);
+                setMatrixAt(value, result, i, j);
+            }
+        }
+        return result;
+    }
+    else if (matrix2.cols == 1 && matrix1.cols > 1)
+    {
+        result = createMatrix(matrix1.rows, matrix1.cols);
+        for (int i = 0; i < matrix1.rows; i++)
+        {
+            for (int j = 0; j < matrix1.cols; j++)
+            {
+                MatrixType value = getMatrixAt(matrix1, i, j) + getMatrixAt(matrix2, i, 0);
+                setMatrixAt(value, result, i, j);
+            }
+        }
+        return result;
+    }
+
+    //Fall: Unterschiedliche Spaltenanzahl, beide ungleich 1
+    result.rows = 0;
+    result.cols = 0;
+    result.buffer = NULL;
+    return result;
+}
+
+Matrix multiply(const Matrix matrix1, const Matrix matrix2)
+{
+    Matrix result;
+
+    if (matrix1.buffer == NULL || matrix2.buffer == NULL || matrix1.cols != matrix2.rows)
+    {
+        result.rows = 0;
+        result.cols = 0;
+        result.buffer = NULL;
+        return result;
+    }
+
+    result = createMatrix(matrix1.rows, matrix2.cols);
+
+    for (int i = 0; i < matrix1.rows; i++)
+    {
+        for (int j = 0; j < matrix2.cols; j++)
+        {
+            MatrixType sum = 0;
+
+            for (int k = 0; k < matrix1.cols; k++)
+            {
+                sum += getMatrixAt(matrix1, i, k) * getMatrixAt(matrix2, k, j);
+            }
+            setMatrixAt(sum, result, i, j);
+        }
+    }
+
+    return result;
+}

test.c

@@ -0,0 +1,107 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include "matrix.h"
+    Matrix createMatrix(unsigned int rows, unsigned int cols) {
+        Matrix m;
+        if (rows == 0 || cols == 0) {
+            m.rows = 0;
+            m.cols = 0;
+            m.buffer = NULL;
+            return m;
+        }
+
+        m.rows = rows;
+        m.cols = cols;
+        m.buffer = (MatrixType *)malloc(rows * cols * sizeof(MatrixType));
+        if (m.buffer == NULL) {
+            fprintf(stderr, "Fehler: Speicher konnte nicht allokiert werden.\n");
+            m.rows = m.cols = 0;
+        } else {
+            for (unsigned int i = 0; i < rows * cols; i++) {
+                m.buffer[i] = UNDEFINED_MATRIX_VALUE;
+            }
+        }
+        return m;
+    }
+
+    void clearMatrix(Matrix *matrix) {
+        if (matrix->buffer != NULL) {
+            free(matrix->buffer);
+            matrix->buffer = NULL;
+        }
+        matrix->rows = 0;
+        matrix->cols = 0;
+    }
+
+    void setMatrixAt(MatrixType value, Matrix matrix, unsigned int rowIdx, unsigned int colIdx) {
+        if (rowIdx < matrix.rows && colIdx < matrix.cols) {
+            matrix.buffer[rowIdx * matrix.cols + colIdx] = value;
+        }
+    }
+
+    MatrixType getMatrixAt(const Matrix matrix, unsigned int rowIdx, unsigned int colIdx) {
+        if (rowIdx < matrix.rows && colIdx < matrix.cols) {
+            return matrix.buffer[rowIdx * matrix.cols + colIdx];
+        }
+        return UNDEFINED_MATRIX_VALUE;
+    }
+
+    Matrix add(const Matrix matrix1, const Matrix matrix2) {
+        Matrix result = {0, 0, NULL};
+
+        // Prüfe Dimensionen und Broadcasting
+        if ((matrix1.rows == matrix2.rows && matrix1.cols == matrix2.cols) ||
+            (matrix1.rows == matrix2.rows && matrix2.cols == 1) ||
+            (matrix1.cols == matrix2.cols && matrix2.rows == 1) ||
+            (matrix2.rows == matrix1.rows && matrix1.cols == 1) ||
+            (matrix2.cols == matrix1.cols && matrix1.rows == 1)) {
+
+            result = createMatrix(matrix1.rows, matrix1.cols);
+
+            for (unsigned int i = 0; i < matrix1.rows; i++) {
+                for (unsigned int j = 0; j < matrix1.cols; j++) {
+                    MatrixType val1 = getMatrixAt(matrix1, i, j);
+                    MatrixType val2;
+
+                    // Broadcasting
+                    if (matrix2.rows == matrix1.rows && matrix2.cols == matrix1.cols) {
+                        val2 = getMatrixAt(matrix2, i, j);
+                    } else if (matrix2.rows == matrix1.rows && matrix2.cols == 1) {
+                        val2 = getMatrixAt(matrix2, i, 0);
+                    } else if (matrix2.rows == 1 && matrix2.cols == matrix1.cols) {
+                        val2 = getMatrixAt(matrix2, 0, j);
+                    } else if (matrix1.rows == matrix2.rows && matrix1.cols == 1) {
+                        val2 = getMatrixAt(matrix2, i, 0);
+                    } else if (matrix1.rows == 1 && matrix1.cols == matrix2.cols) {
+                        val2 = getMatrixAt(matrix2, 0, j);
+                    } else {
+                        val2 = UNDEFINED_MATRIX_VALUE;
+                    }
+
+                    setMatrixAt(val1 + val2, result, i, j);
+                }
+            }
+            }
+        return result;
+    }
+
+    Matrix multiply(const Matrix matrix1, const Matrix matrix2) {
+        Matrix result = {0, 0, NULL};
+
+        if (matrix1.cols != matrix2.rows) {
+            return result; // inkompatible Dimensionen
+        }
+
+        result = createMatrix(matrix1.rows, matrix2.cols);
+
+        for (unsigned int i = 0; i < matrix1.rows; i++) {
+            for (unsigned int j = 0; j < matrix2.cols; j++) {
+                MatrixType sum = 0;
+                for (unsigned int k = 0; k < matrix1.cols; k++) {
+                    sum += getMatrixAt(matrix1, i, k) * getMatrixAt(matrix2, k, j);
+                }
+                setMatrixAt(sum, result, i, j);
+            }
+        }
+        return result;
+    }

test.h

@@ -0,0 +1,24 @@
+
+
+#ifndef MATRIX_H
+#define MATRIX_H
+
+#define UNDEFINED_MATRIX_VALUE 0
+typedef float MatrixType;
+
+// Definition des Matrix-Typs
+typedef struct {
+    unsigned int rows;
+    unsigned int cols;
+    MatrixType *buffer; // dynamisch allokiertes Array
+} Matrix;
+
+// Funktionsdeklarationen
+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