#include <stdlib.h>
#include <string.h>
#include "matrix.h"
static void addRows(struct Matrix *M, float factor, unsigned int row1, unsigned int row2)
{
for(unsigned int i=0; i<M->numcolumns; i++)
{
float sum = Matrix_getValue(M, row1, i) + Matrix_getValue(M, row2, i) * factor;
puts("NAczh float sum");
//DEBUG
for(int a=0; a<M->numrows; a++)
{
for(int j=0; j<M->numcolumns; j++)
{
printf("%4.0f ", Matrix_getValue(M, a, j));
}
printf("\n");
}
printf("\n");printf("\n");
//DEBUG ENDE
//Matrix_setValue(M, Matrix_getValue(M, row1, i) + Matrix_getValue(M, row2, i) * factor, row1, i);
Matrix_setValue(M, sum, row1, i);
puts("Nach setValue");
//DEBUG
for(int a=0; a<M->numrows; a++)
{
for(int j=0; j<M->numcolumns; j++)
{
printf("%4.0f ", Matrix_getValue(M, a, j));
}
printf("\n");
}
printf("\n");printf("\n");
//DEBUG ENDE
}
}
static unsigned int orderRows(struct Matrix *M)
{
char modified = 0;
unsigned int swaps = 0;
do
{
modified = 0;
unsigned int c1 = 0;
unsigned int c2 = 0;
for(unsigned int i = 0; i < M->numrows-1; i++)
{
//Anzahl der Nullen zählen
c1 = 0;
c2 = 0;
for(unsigned int j = 0; j < M->numcolumns; j++)
{
if(Matrix_getValue(M, i, j) == 0)
{
c1++;
}
else
{
break;
}
}
for(unsigned int j = 0; j < M->numcolumns; j++)
{
if(Matrix_getValue(M, i+1, j) == 0)
{
c2++;
}
else
{
break;
}
}
//Eventuell Zeilen vertauschen
if(c1 > c2)
{
//Reihen tauschen
float temp = 0;
for(unsigned int l=0; l<M->numcolumns; l++)
{
temp = Matrix_getValue(M, i, l);
Matrix_setValue(M, Matrix_getValue(M, i+1, l),i, l);
Matrix_setValue(M, temp, i+1, l);
}
swaps++;
modified = 1;
}
}
}
while(modified == 1);
return swaps;
}
struct Matrix *Matrix_newMatrix(unsigned int numrows, unsigned int numcolumns)
{
struct Matrix *M = malloc(sizeof(struct Matrix));
if(M == NULL)
{
return NULL;
}
M->matrix = malloc(sizeof(float) * numrows * numcolumns);
if(M->matrix == NULL)
{
free(M);
return NULL;
}
//Matrix mit Nullen füllen
memset(M->matrix, 0, sizeof(float) * numrows * numcolumns);
M->numrows = numrows;
M->numcolumns = numcolumns;
return M;
}
void Matrix_deleteMatrix(struct Matrix *Matrix)
{
free(Matrix->matrix);
free(Matrix);
}
struct Matrix *Matrix_add(struct Matrix *Matrix1, struct Matrix *Matrix2, struct Matrix *Solution)
{
struct Matrix *T = Solution;
if(Solution == NULL)
{
T = Matrix_newMatrix(Matrix1->numrows, Matrix1->numcolumns);
if(T == NULL)
{
return NULL;
}
}
if((Matrix1->numrows != Matrix2->numrows) || (Matrix1->numcolumns != Matrix2->numcolumns) || (Matrix1->numrows != T->numrows) || (Matrix1->numcolumns != T->numcolumns))
{
return NULL;
}
for(unsigned int i=0; i<Matrix1->numrows; i++)
{
for(unsigned int j=0; j<Matrix2->numcolumns; j++)
{
Matrix_setValue(T, Matrix_getValue(Matrix1, i, j) + Matrix_getValue(Matrix2, i, j), i, j);
}
}
return T;
}
struct Matrix *Matrix_multiplyMatrix(struct Matrix *Matrix1, struct Matrix *Matrix2, struct Matrix *Solution)
{
struct Matrix *T = Solution;
if(Solution == NULL)
{
T = Matrix_newMatrix(Matrix1->numrows, Matrix2->numcolumns);
if(T == NULL)
{
return NULL;
}
}
if((Matrix1->numcolumns != Matrix2->numrows) || (T->numrows != Matrix1->numrows) || (T->numcolumns != Matrix2->numcolumns))
{
return NULL;
}
float temp = 0;
//Zeilen der 1. Matrix
for(unsigned int i=0; i<Matrix1->numrows; i++)
{
//Spalten der 2. Matrix
for(unsigned int j=0; j<Matrix2->numcolumns; j++)
{
//Zähler für die Spalten der 1. und die Zeilen der 2. MAtrix
for(unsigned int k=0; k<Matrix1->numcolumns; k++)
{
temp += Matrix_getValue(Matrix1, i, k) * Matrix_getValue(Matrix2, k, j);
}
Matrix_setValue(T, temp, i, j);
temp = 0;
}
}
return T;
}
void Matrix_multiplyScalar(struct Matrix *Matrix, float scalar, struct Matrix *Solution)
{
struct Matrix *T = Solution;
if(Solution == NULL)
{
T = Matrix;
}
for(unsigned int i=0; i<Matrix->numrows; i++)
{
for(unsigned int j=0; j<Matrix->numcolumns; j++)
{
Matrix_setValue(T, Matrix_getValue(Matrix, i, j) * scalar, i, j);
}
}
}
float Matrix_getDeterminant(struct Matrix *Matrix)
{
if(Matrix->numrows != Matrix->numcolumns)
{
return 0;
}
//Matrix in den Stack kopieren
float Mat[sizeof(float) * Matrix->numrows * Matrix->numcolumns];
struct Matrix M;
M.matrix = Mat;
M.numrows = Matrix->numrows;
M.numcolumns = Matrix->numcolumns;
for(int i=0; i<Matrix->numrows; i++)
{
for(int j=0; j<Matrix->numrows; j++)
{
Matrix_setValue(&M, Matrix_getValue(Matrix, i, j), i, j);
}
}
//Matrix ordnen und Faktor bestimmen
int koeff = (orderRows(&M)%2 == 0)? 1 : -1;
//Gauß Algorithmus
for(unsigned int i=0; i<M.numrows-1; i++)
{
//Stelle des ersten Koeff != 0 bestimmen (wahrscheinlich 0 bei erster Zeile, 1 bei 2. ...)
unsigned int s = 0;
for(unsigned int j=0; j<M.numcolumns; j++)
{
if(Matrix_getValue(&M, i, j) == 0)
{
s++;
}
else
{
break;
}
}
//Alle Zeilen mit gleich viel Koeffs woe Zeile i verkürzen
for(unsigned int j=i+1; j<M.numrows; j++)
{
//Zeile gleich lang wir Zele i?
if(Matrix_getValue(&M, j, s) != 0)
{
puts("div wird berechnet");
//Nun wird diese Zeile verkürzt
float div = Matrix_getValue(&M, j, s) / Matrix_getValue(&M, i, s);
puts("Reihen werden addiert");
addRows(&M, -div, j, i);
puts("Reihen sind addiert worden");
//Reihe j hat nun eine Null mehr, wegen numerischen Runduingsfehlern explizit auf 0 setzen
//Matrix_setValue(&M, 0, j, s);
}
else
{
break;
}
//DEBUG
for(int i=0; i<M.numrows; i++)
{
for(int j=0; j<M.numcolumns; j++)
{
printf("%4.0f ", Matrix_getValue(&M, i, j));
}
printf("\n");
}
printf("\n");printf("\n");
//DEBUG ENDE
}
}
//Matrix hat nun ZSF, Determinante ist Produkt der Hauptdiagonale
float d = 1;
for(unsigned int i=0; i<M.numrows; i++)
{
d *= Matrix_getValue(&M, i, i);
}
d *= koeff;
//DEBUG
for(int i=0; i<M.numrows; i++)
{
for(int j=0; j<M.numcolumns; j++)
{
printf("%4.0f ", Matrix_getValue(&M, i, j));
}
printf("\n");
}
printf("\n");printf("\n");
//DEBUG ENDE
return d;
}
struct Matrix *Matrix_duplicate(struct Matrix *Matrix)
{
struct Matrix *M = Matrix_newMatrix(Matrix->numrows, Matrix->numcolumns);
if(M == NULL)
{
return NULL;
}
for(unsigned int i=0; i<Matrix->numrows; i++)
{
for(unsigned int j = 0; j<Matrix->numcolumns; j++)
{
Matrix_setValue(M, Matrix_getValue(Matrix, i,j), i, j);
}
}
return M;
}
void Matrix_setValue(struct Matrix *Matrix, float value, unsigned int row, unsigned int column)
{
if((row >= Matrix->numrows) || (column >= Matrix->numcolumns))
{
return;
}
Matrix->matrix[row * sizeof(float) + column] = value;
}
float Matrix_getValue(struct Matrix *Matrix, unsigned int row, unsigned int column)
{
if((row >= Matrix->numrows) || (column >= Matrix->numcolumns))
{
return 1;
}
return Matrix->matrix[row * sizeof(float) + column];
}
