added shellscript for matrixTests

.gitignore

@@ -1,5 +1,7 @@
 mnist
 runTests
 runMatrixTests
+runImageInputTests
+runNeuralNetworkTests
 *.o
 *.exe

matrix.c

@@ -42,7 +42,7 @@ Matrix createMatrix(unsigned int rows, unsigned int cols)
 }
 */
 
-Matrix createMatrix(size_t cols, size_t rows)
+Matrix createMatrix(size_t rows, size_t cols)
 {
     Matrix m;
     m.rows = rows;
@@ -73,25 +73,151 @@ Matrix createMatrix(size_t cols, size_t rows)
 
 void clearMatrix(Matrix *matrix)
 {
-    
+    for (int i = 0; i < matrix->rows; i++) {
+        for (int j = 0; j < matrix->cols;j++) {
+            // Normally one would expect to work matrices like this, but it is supposed to be the other way around. 
+            // matrix->buffer[i + matrix->rows * j] = UNDEFINED_MATRIX_VALUE;
+            matrix->buffer[j + matrix->cols * i] = UNDEFINED_MATRIX_VALUE;
+        }
+    }
+    free(matrix->buffer);
+    matrix->rows = 0;
+    matrix->cols = 0;
+    matrix->buffer = NULL;
 }
 
 void setMatrixAt(MatrixType value, Matrix matrix, unsigned int rowIdx, unsigned int colIdx)
 {
-    
+    //checks, if the given incies are allowed
+    if((rowIdx) < matrix.rows && (colIdx) < matrix.cols) {
+        // Normally one would expect to work matrices like this, but it is supposed to be the other way around. 
+        // matrix.buffer[rowIdx + matrix.rows*(colIdx)] = value;
+        matrix.buffer[colIdx + matrix.cols * rowIdx] = value;
+    }
 }
 
 MatrixType getMatrixAt(const Matrix matrix, unsigned int rowIdx, unsigned int colIdx)
 {
+    //checks, if the given indices are allowed
+    if((rowIdx) < matrix.rows && (colIdx) < matrix.cols) {
+        MatrixType returnVal;
+        // Normally one would expect to work matrices like this, but it is supposed to be the other way around.
+        // returnVal = matrix.buffer[rowIdx + matrix.rows*(colIdx)];
+        returnVal = matrix.buffer[colIdx + rowIdx * matrix.cols];
+        return returnVal;
+    }
+    else return 0;
+}
+
+/*
+Matrix add(const Matrix matrix1, const Matrix matrix2)
+{
+    //check if the matrices are able to be added (same size)
+    if (matrix1.cols == matrix2.cols && matrix1.rows == matrix2.rows){
+        //size of the matrices should be the same, if the addition is supposed to happen
+        // Matrix outputMatrix = createMatrix(matrix1.rows, matrix1.cols);
+        Matrix outputMatrix = createMatrix(matrix1.rows, matrix1.cols);
+        for (int i = 0; i < matrix1.rows;i++) {
+            for (int j = 0; j < matrix1.cols; j++) {
+                // how this should work in normal Matrix version:
+                // outputmatrix.buffer[i][j] = matrix1.buffer[i][j] + matrix2.buffer[i][j];
+                outputMatrix.buffer[i + outputMatrix.rows* j] = matrix1.buffer[i + matrix1.rows* j] + matrix2.buffer[i + matrix2.rows * j];
+            }
+        }
+        return outputMatrix;
+    } else {
+        //the matrix could not be added, since the matrix sizes are not set correct.
+        Matrix m;
+        m.rows = 0; 
+        m.cols = 0;
+        m.buffer = NULL;
+        return m;
+    }
 
 }
+*/
 
 Matrix add(const Matrix matrix1, const Matrix matrix2)
 {
+    //check if the matrices are able to be added (same size)
+    if (matrix1.cols != matrix2.cols && matrix1.rows != matrix2.rows){
+        Matrix m = {NULL, 0, 0};
+        return m;
+    }
+        
+
+    //size of the matrices should be the same, if the addition is supposed to happen
+    Matrix outputMatrix = createMatrix(matrix1.rows, matrix1.cols);
+
+    if(!outputMatrix.buffer){
+        Matrix m = {NULL, 0, 0};
+        return m;
+    }
+
+    for (int i = 0; i < matrix1.rows;i++) {
+        for (int j = 0; j < matrix1.cols; j++) {
+            // how this should work in normal Matrix version:
+            // outputmatrix.buffer[i][j] = matrix1.buffer[i][j] + matrix2.buffer[i][j];
+            outputMatrix.buffer[i * outputMatrix.cols + j] = matrix1.buffer[i * matrix1.cols + j] + matrix2.buffer[i * matrix2.cols + j];
+        }
+    }
+    return outputMatrix;
 
 }
 
+/*
 Matrix multiply(const Matrix matrix1, const Matrix matrix2)
 {
     
+    //check, if the matrices can be multiplied
+    if (matrix1.rows == matrix2.cols) {
+        Matrix outputMatrix = createMatrix(matrix1.rows, matrix2.cols);
+        //Matrix outputMatrix = createMatrix(matrix2.cols, matrix1.rows);
+        for(int i = 0; i < matrix1.rows; i++) {
+            for (int j = 0; j < matrix2.cols; j++) {
+                for (int k = 0; k < matrix2.rows; k++) {
+                    // how this should work in normal Matrix version:
+                    // outputMatrix.buffer[i][j] = matrix1.buffer[i][k] * matrix2.buffer[k][j];
+                    outputMatrix.buffer[i + outputMatrix.rows * j] += matrix1.buffer[i + matrix1.rows * k] * matrix2.buffer[k + matrix2.rows * j];
+                }
+            }
+        }
+        return outputMatrix;
+    } else {
+        //the matrix could not be added, since the matrix sizes are not set correct.
+        Matrix m;
+        m.rows = 0; 
+        m.cols = 0;
+        m.buffer = NULL;
+        return m;
+    }
+}
+*/
+
+
+Matrix multiply(const Matrix matrix1, const Matrix matrix2)
+{
+    if(matrix1.cols != matrix2.rows){
+        Matrix m = {NULL, 0, 0};
+        return m;
+    }
+    
+    Matrix outputMatrix = createMatrix(matrix1.rows, matrix2.cols);
+    if(!outputMatrix.buffer){
+        Matrix m = {NULL, 0, 0};
+        return m;
+    }
+
+    //Matrix outputMatrix = createMatrix(matrix2.cols, matrix1.rows);
+    for(int i = 0; i < matrix1.rows; i++) {
+        for (int j = 0; j < matrix2.cols; j++) {
+            for (int k = 0; k < matrix1.cols; k++) {
+                // how this should work in normal Matrix version:
+                // outputMatrix.buffer[i][j] = matrix1.buffer[i][k] * matrix2.buffer[k][j];
+                //outputMatrix.buffer[i + outputMatrix.rows * j] += matrix1.buffer[i + matrix1.rows * k] * matrix2.buffer[k + matrix2.rows * j];
+                outputMatrix.buffer[i * outputMatrix.cols + j] += matrix1.buffer[i * matrix1.cols + k] * matrix2.buffer[j + matrix2.cols * k];
+            }
+        }
+    }
+    return outputMatrix;
 }

matrix.h

@@ -7,9 +7,9 @@ typedef float MatrixType;
 // TODO Matrixtyp definieren
 
 typedef struct Matrix {
-    size_t rows;
-    size_t cols;
     MatrixType *buffer;
+    size_t rows; //X-Element
+    size_t cols; //Y-Element
 } Matrix;
 
 

matrixTests.sh

@@ -0,0 +1 @@
+make clean && make matrixTests && ./runMatrixTests