NeuNeuronalesNetz/matrix.c

#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include "matrix.h"
 
// TODO Matrix-Funktionen implementieren
 
enum addModes{sameDimensions, colVec, rowVec};
 
Matrix createMatrix(unsigned int rows, unsigned int cols)
{
    Matrix m;
    m.rows = rows;
    m.cols = cols;
    m.buffer = NULL;
 
    if(rows == 0 || cols == 0)
    {
       
        m.rows = 0;
        m.cols = 0;
        m.buffer = NULL;
        return m;
    }
 
    m.buffer = calloc(rows * cols, sizeof(MatrixType));
   
    if (m.buffer == NULL)
    {
       
        m.rows = 0;
        m.cols = 0;
        m.buffer = NULL;
        return m;
    }
 
    return m;
}
 
void clearMatrix(Matrix *matrix)
{
    if (matrix->buffer == NULL)
    {
        matrix->rows = 0;
        matrix->cols = 0;
        matrix->buffer = NULL;
        return matrix;
    }
    else
    {
   
    free(matrix->buffer);
   
    matrix->rows = 0;
    matrix->cols = 0;
    matrix->buffer = NULL;
 
    }
}
 
void setMatrixAt(MatrixType value, Matrix matrix, unsigned int rowIdx, unsigned int colIdx)
{
 
    if(matrix.buffer == NULL || rowIdx >= matrix.rows || colIdx >= matrix.cols)
    {
        return;
    }
    else
    {
        matrix.buffer[(rowIdx * matrix.cols) + colIdx] = value;   //wir setzen den data-Wert an der Stelle (rowIdx*Spalten + colIdx) auf den Wert von 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];
}
 
static int get_add_mode(Matrix matrix1, Matrix matrix2) {
 
    int get_add_mode;
 
    if(matrix1.cols == matrix2.cols && matrix1.rows == matrix2.rows){
 
        get_add_mode = sameDimensions;
 
    }
    else if(matrix1.cols == 1 && matrix1.rows == matrix2.rows){
 
        get_add_mode = colVec;
 
    }
    else if(matrix2.cols == 1 && matrix1.rows == matrix2.rows){
 
        get_add_mode = colVec;
 
    }
    else if(matrix1.rows == 1 && matrix1.cols == matrix2.cols){
 
        get_add_mode = rowVec;
 
    }
    else if(matrix2.rows == 1 && matrix1.cols == matrix2.cols){
 
        get_add_mode = rowVec;
 
    }
    return get_add_mode;
   
}
 
 
    Matrix addSameDim(Matrix matrix1, Matrix matrix2)
    {
        Matrix matrix_erg = createMatrix(matrix1.rows, matrix1.cols);
 
        for(int i = 0; i < (matrix1.rows * matrix1.cols); i++)
 
            matrix_erg.buffer[i] = matrix1.buffer[i] + matrix2.buffer[i];
 
        return matrix_erg;    
 
    }
 
    Matrix addColVec(Matrix matrix1, Matrix matrix2)
    {
        Matrix matrix_erg;
        if(matrix1.cols == 1)
        {
            matrix_erg = createMatrix(matrix2.rows, matrix2.cols);
 
            for(int i = 0; i < matrix2.rows; i++)
            {
                for(int j = 0; j < matrix2.cols; j++)
 
                    matrix_erg.buffer[i * matrix2.cols + j] = matrix1.buffer[i * matrix2.cols + j] + matrix2.buffer[i];
            }
           
 
        }
        if(matrix2.cols == 1)
        {
            matrix_erg = createMatrix(matrix1.rows, matrix1.cols);
 
            for(int i = 0; i < matrix1.rows; i++)
            {
                for(int j = 0; j < matrix1.cols; j++)
 
                    matrix_erg.buffer[i * matrix1.cols + j] = matrix1.buffer[i] + matrix2.buffer[i * matrix1.cols + j];
            }
        }
        return matrix_erg;
 
 
    }
 
    Matrix addRowVec(Matrix matrix1, Matrix matrix2)
    {
        Matrix matrix_erg;
        if(matrix1.rows == 1)
        {
            matrix_erg = createMatrix(matrix2.rows, matrix2.cols);
 
            for(int i = 0; i < matrix2.rows; i++)
            {
                for(int j = 0; j < matrix2.cols; j++)
 
                    matrix_erg.buffer[i * matrix2.cols + j] = matrix1.buffer[i * matrix2.cols + j] + matrix2.buffer[j];
            }
           
 
        }
        if(matrix2.rows == 1)
        {
            matrix_erg = createMatrix(matrix1.rows, matrix1.cols);
 
            for(int i = 0; i < matrix1.rows; i++)
            {
                for(int j = 0; j < matrix1.cols; j++)
 
                    matrix_erg.buffer[i * matrix1.cols + j] = matrix1.buffer[j] + matrix2.buffer[i * matrix1.cols + j];
            }
        }
        return matrix_erg;
    }
 
 
   
 
    Matrix add(const Matrix matrix1, const Matrix matrix2)
    {
        int ok = get_add_mode(matrix1,matrix2);
       
        Matrix matrix_erg = createMatrix(0, 0);
   
 
    switch(ok)
    {
   
 
    case sameDimensions:
   
        addSameDim(matrix1, matrix2);
           
        break;
 
    case colVec:
 
        addColVec(matrix1, matrix2);
 
        break;
 
    case rowVec:
   
        addRowVec(matrix1, matrix2);
 
        break;
 
    }
 
    return matrix_erg;
 
   
   
}
static int can_multiply (Matrix matrix1, Matrix matrix2)
{
    int can_multiply = 0;
 
    if(matrix1.cols == matrix2.rows)
        can_multiply = 1;
       
    return can_multiply;
}
 
 
Matrix multiply(const Matrix matrix1, const Matrix matrix2)
{
    int ok = can_multiply(matrix1,matrix2);
    unsigned int erg_rows = matrix1.rows;
    unsigned int erg_cols = matrix2.cols;
    Matrix matrix_erg = createMatrix(0, 0);
   
    if (ok == 1)
    {
        Matrix matrix_erg = createMatrix(erg_rows, erg_cols);
 
        for (int i = 0; i < erg_rows; i++)
        {
            for (int j = 0; j < erg_cols; j++)
            {
                MatrixType sum = 0;
               
                for (int k = 0; k < matrix1.cols; k++)
                {
                    sum += getMatrixAt(matrix1, k, j) * getMatrixAt(matrix2, j, k);
                }
               
                setMatrixAt(sum, matrix_erg, i, j);
            }
 
        }
 
        return matrix_erg;
    }  
   
}