This commit is contained in:
Tamer Oeztuerk 2025-05-20 18:41:53 +02:00
parent 08072dd34f
commit 9c53700d01
2 changed files with 176 additions and 106 deletions

View File

@ -26,25 +26,89 @@
/*--- Funktionsdefinitionen ------------------------------------------*/
/*--- main -----------------------------------------------------------*/
int main(void)
{
unsigned int z, s;
float firstElem;
int main(void) {
unsigned int zeilen, spalten;
float startWert;
printf("Test verschiedener Funktionen der Bibliothek\n");
printf("Gew\x81nschte Matrizen-Gr\x94sse eingeben\n Zeilen, Spalten (> 0; z.B.: 3,4):");
scanf("%d,%d", &z, &s);
printf("Matrix Elemente eingeben (F. Test nur 1.Elem.,\n weitere Elemente werden mit +1 erzeugt)\n");
printf(" Element in [1,1] (z.B.: 4.5):");
scanf("%f", &firstElem);
printf("Gewuenschte Matrizen-Groesse eingeben\n");
printf(" Zeilen, Spalten (> 0; z.B. 3,4): ");
scanf("%u,%u", &zeilen, &spalten);
createMatrix(s, z);
printf("Test Create Zero und Rand:\n");
printf("CreateMatrixZero: a[%u,%u]=\n", z, s);
Matrix zeroMat = createMatrixZero(s, z);
printMatrix(zeroMat);
Matrix a = createMatrix(spalten, zeilen);
printf("CreateMatrixRand: a[%u,%u]=\n", z, s);
Matrix randMat = createMatrixRand(s, z);
printf("Matrix Elemente eingeben (F. Test nur 1.Elem., weitere Elemente werden mit +1 erzeugt)\n");
printf(" Element in [1,1] (z.B.: 4.5): ");
scanf("%f", &startWert);
float wert = startWert;
for (unsigned int y = 0; y < zeilen; y++) {
for (unsigned int x = 0; x < spalten; x++) {
setEntryAt(a, x, y, wert);
wert += 1.0f;
}
}
printf("\nTest Create Zero und Rand:\n");
Matrix zero = createMatrixZero(spalten, zeilen);
printf("CreateMatrixZero: a[%d,%d]=\n", spalten, zeilen);
printMatrix(zero);
printf("\nInfo: Called srand!\n");
srand((unsigned int)time(NULL));
Matrix randMat = createMatrixRand(spalten, zeilen);
printf("CreateMatrixRand: a[%d,%d]=\n", spalten, zeilen);
printMatrix(randMat);
printf("\nTests mit eingegebenen Werten:\n");
printf("CreateMatrix: a[%d,%d]=\n", spalten, zeilen);
printMatrix(a);
Matrix b = copyMatrix(a);
printf("\nCreateMatrix: b[%d,%d]=\n", spalten, zeilen);
printMatrix(b);
Matrix sum = addMatrix(a, b);
printf("\nc[%d,%d]= a + b =\n", sum.spalten, sum.zeilen);
printMatrix(sum);
Matrix diff = subMatrix(a, b);
printf("\nc[%d,%d]= a - b =\n", diff.spalten, diff.zeilen);
printMatrix(diff);
Matrix bT = transposeMatrix(b);
printf("\nc[%d,%d]= b^T\n", bT.spalten, bT.zeilen);
printMatrix(bT);
Matrix c = multMatrix(a, bT); // a * b^T
printf("a * b^T = c\n");
// Nur die obere linke 2x2-Matrix drucken
printf("{\n");
for (int y = 0; y < 2; y++) {
printf(" ");
for (int x = 0; x < 2; x++) {
printf("%6.2f", getEntryAt(c, x, y));
if (x < 1) printf(" ");
}
printf("\n");
}
printf("}\n");
printf("\ndet(c) = %.2f\n", determMatrix(c));
// Speicher freigeben
destroyMatrix(&a);
destroyMatrix(&b);
destroyMatrix(&sum);
destroyMatrix(&diff);
destroyMatrix(&zero);
destroyMatrix(&randMat);
destroyMatrix(&bT);
destroyMatrix(&c);
return 0;
}

View File

@ -14,29 +14,18 @@
#include <time.h>
#include "matrixOp.h"
/*--- #defines -------------------------------------------------------*/
/*--- Lokale Datentypen (typedef) ------------------------------------*/
/*--- Modulglobale static Variablen ----------------------------------*/
/*--- Prototypen lokaler Funktionen ----------------------------------*/
/*--- Funktionsdefinitionen ------------------------------------------*/
/*--------------------------------------------------------------------*\
/*--------------------------------------------------------------------*\
* Erstellt eine neue Matrix (cM)
* - reserviert lediglich den notwendigen Speicher
* - dynamische Verwaltung von Speicher muss mit malloc() und free()
* - dynamische Verwaltung von Speicher muss mit malloc() und free()
* durchgef<EFBFBD>hrt werden; dynamische Arrays sind nicht erlaubt !!!
\*--------------------------------------------------------------------*/
Matrix createMatrix(unsigned int spalten, unsigned int zeilen)
{
Matrix matrix1;
matrix1.mElement = (float *)malloc(spalten * zeilen * sizeof(float));
matrix1.zeilen = zeilen;
matrix1.spalten = spalten;
return matrix1;
Matrix createMatrix(unsigned int spalten, unsigned int zeilen) {
Matrix m;
m.spalten = spalten;
m.zeilen = zeilen;
m.mElement = (MatTyp *)malloc(sizeof(MatTyp) * spalten * zeilen);
return m;
}
/*--------------------------------------------------------------------*\
@ -44,19 +33,14 @@ Matrix createMatrix(unsigned int spalten, unsigned int zeilen)
* - reserviert den notwendigen Speicher
* - befuellt die Matrix mit 0
\*--------------------------------------------------------------------*/
Matrix createMatrixZero(unsigned int spalten, unsigned int zeilen)
{
Matrix matrix1 = createMatrix(spalten,zeilen);
float inhalt[zeilen][spalten];
//matrix1.mElement = *inhalt;
for (int i = 0; i < zeilen; ++i) {
for (int j = 0; j < spalten; ++j) {
inhalt[i][j] = 0;
Matrix createMatrixZero(unsigned int spalten, unsigned int zeilen) {
Matrix m = createMatrix(spalten, zeilen);
if (m.mElement != NULL) {
for (unsigned int i = 0; i < spalten * zeilen; i++) {
m.mElement[i] = 0.0f;
}
}
return matrix1;
return m;
}
/*--------------------------------------------------------------------*\
@ -64,28 +48,24 @@ Matrix createMatrixZero(unsigned int spalten, unsigned int zeilen)
* - reserviert den notwendigen Speicher
* - befuellt die Matrix mit Zufallszahlen
\*--------------------------------------------------------------------*/
Matrix createMatrixRand(unsigned int spalten, unsigned int zeilen)
{
Matrix matrix1 = createMatrix(spalten,zeilen);
float inhalt[zeilen][spalten];
for (int i = 0; i < zeilen; ++i) {
for (int j = 0; j < spalten; ++j) {
inhalt[i][j] = 69;
}
Matrix createMatrixRand(unsigned int spalten, unsigned int zeilen) {
Matrix m = createMatrix(spalten, zeilen);
srand((unsigned int)time(NULL));
for (unsigned int i = 0; i < spalten * zeilen; i++) {
m.mElement[i] = ((float)rand() / RAND_MAX) * 200.0f - 100.0f;
}
return matrix1;
return m;
}
/*--------------------------------------------------------------------*\
* Kopiert eine Matrix und gibt die Kopie zurueck (yM)
\*--------------------------------------------------------------------*/
Matrix copyMatrix(const Matrix toCopy)
{
// TODO
return toCopy;
Matrix copyMatrix(const Matrix toCopy) {
Matrix copy = createMatrix(toCopy.spalten, toCopy.zeilen);
for (unsigned int i = 0; i < toCopy.spalten * toCopy.zeilen; i++) {
copy.mElement[i] = toCopy.mElement[i];
}
return copy;
}
/*--------------------------------------------------------------------*\
@ -93,54 +73,55 @@ Matrix copyMatrix(const Matrix toCopy)
* - gibt reservierten Speicher wieder frei !
* - in der urspruenglichen, uebergebenen Matrix bleiben die Werte erhalten!
\*--------------------------------------------------------------------*/
void deleteMatrix(Matrix toDelete)
{
// TODO
void deleteMatrix(Matrix toDelete) {
free(toDelete.mElement);
}
/*--------------------------------------------------------------------*\
* "Loescht / Zerstoert" eine uebergegebene Matrix (ddM)
* - gibt Speicher wieder frei, setzt alle Werte auf NULL bzw. "0" !
* - Beachte Unterschiede zur vorigen Funktion !!!
* - Beachte Unterschiede zur vorigen Funktion !!!
\*--------------------------------------------------------------------*/
void destroyMatrix(Matrix *pToDestroy)
{
// TODO
void destroyMatrix(Matrix *pToDestroy) {
if (pToDestroy->mElement != NULL) {
free(pToDestroy->mElement);
pToDestroy->mElement = NULL;
pToDestroy->spalten = 0;
pToDestroy->zeilen = 0;
}
}
/*--------------------------------------------------------------------*\
* Gibt den Eintrag der Matrix an der Stelle (xPos, yPos) zurueck (gE)
* Rueckgabe im Fehlerfall: ERROR
\*--------------------------------------------------------------------*/
MatTyp getEntryAt(const Matrix ma, unsigned int xPos, unsigned int yPos)
{
// TODO
return *ma.mElement;
MatTyp getEntryAt(const Matrix ma, unsigned int xPos, unsigned int yPos) {
if (xPos >= ma.spalten || yPos >= ma.zeilen) return ERROR;
return ma.mElement[yPos * ma.spalten + xPos];
}
/*--------------------------------------------------------------------*\
* Setzt den Eintrag der Matrix an der Stelle (xPos, yPos) (sE)
* Rueckgabe: TRUE, im Fehlerfall: FALSE
\*--------------------------------------------------------------------*/
Bool setEntryAt(Matrix ma, unsigned int xPos, unsigned int yPos, MatTyp value)
{
// TODO
Bool setEntryAt(Matrix ma, unsigned int xPos, unsigned int yPos, MatTyp value) {
if (xPos >= ma.spalten || yPos >= ma.zeilen) return FALSE;
ma.mElement[yPos * ma.spalten + xPos] = value;
return TRUE;
}
/*--------------------------------------------------------------------*\
* Gibt eine Matrix im Kommandofenster "schoen formatiert" aus (pM)
\*--------------------------------------------------------------------*/
void printMatrix(const Matrix ma)
{
float inhalt[ma.zeilen][ma.spalten];
//inhalt[0][0] = *ma.mElement;
for (int i = 0; i < ma.zeilen; ++i) {
for (int j = 0; j < ma.spalten; ++j) {
printf("%.2f\t", inhalt[i][j]);
void printMatrix(const Matrix ma) {
printf("(\n");
for (unsigned int y = 0; y < ma.zeilen; y++) {
printf(" ");
for (unsigned int x = 0; x < ma.spalten; x++) {
printf("%6.2f ", getEntryAt(ma, x, y));
}
printf("\n");
printf(")\n");
}
}
@ -150,10 +131,15 @@ void printMatrix(const Matrix ma)
* - Ergebnis der Addition in neu erzeugter Matrix
* - Rueckgabe im Fehlerfall: Matrix der Groesse "0"
\*--------------------------------------------------------------------*/
Matrix addMatrix(const Matrix ma, const Matrix mb)
{
// TODO
return ma;
Matrix addMatrix(const Matrix ma, const Matrix mb) {
if (ma.spalten != mb.spalten || ma.zeilen != mb.zeilen) {
return createMatrix(0, 0);
}
Matrix result = createMatrix(ma.spalten, ma.zeilen);
for (unsigned int i = 0; i < ma.spalten * ma.zeilen; i++) {
result.mElement[i] = ma.mElement[i] + mb.mElement[i];
}
return result;
}
/*--------------------------------------------------------------------*\
@ -162,10 +148,15 @@ Matrix addMatrix(const Matrix ma, const Matrix mb)
* - Ergebnis der Subtraktion in neu erzeugter Matrix
* - Rueckgabe im Fehlerfall: Matrix der Groesse "0"
\*--------------------------------------------------------------------*/
Matrix subMatrix(const Matrix ma, const Matrix mb)
{
// TODO
return ma;
Matrix subMatrix(const Matrix ma, const Matrix mb) {
if (ma.spalten != mb.spalten || ma.zeilen != mb.zeilen) {
return createMatrix(0, 0);
}
Matrix result = createMatrix(ma.spalten, ma.zeilen);
for (unsigned int i = 0; i < ma.spalten * ma.zeilen; i++) {
result.mElement[i] = ma.mElement[i] - mb.mElement[i];
}
return result;
}
/*--------------------------------------------------------------------*\
@ -174,20 +165,33 @@ Matrix subMatrix(const Matrix ma, const Matrix mb)
* - Ergebnis der Multiplikation in neu erzeugter Matrix
* - Rueckgabe im Fehlerfall: Matrix der Groesse "0"
\*--------------------------------------------------------------------*/
Matrix multMatrix(const Matrix ma, const Matrix mb)
{
// TODO
return ma;
Matrix multMatrix(const Matrix ma, const Matrix mb) {
if (ma.spalten != mb.zeilen) return createMatrix(0, 0);
Matrix result = createMatrix(mb.spalten, ma.zeilen);
for (unsigned int y = 0; y < result.zeilen; y++) {
for (unsigned int x = 0; x < result.spalten; x++) {
float sum = 0.0f;
for (unsigned int k = 0; k < ma.spalten; k++) {
sum += getEntryAt(ma, k, y) * getEntryAt(mb, x, k);
}
setEntryAt(result, x, y, sum);
}
}
return result;
}
/*--------------------------------------------------------------------*\
* Transponiert eine Matrix (tM)
* Rueckgabe: "ma^T"
\*--------------------------------------------------------------------*/
Matrix transposeMatrix(const Matrix ma)
{
// TODO
return ma;
Matrix transposeMatrix(const Matrix ma) {
Matrix transposed = createMatrix(ma.zeilen, ma.spalten);
for (unsigned int y = 0; y < ma.zeilen; y++) {
for (unsigned int x = 0; x < ma.spalten; x++) {
setEntryAt(transposed, y, x, getEntryAt(ma, x, y));
}
}
return transposed;
}
/*--------------------------------------------------------------------*\
@ -197,9 +201,11 @@ Matrix transposeMatrix(const Matrix ma)
* fuer kleine Matrizen reicht ein einfacher Algorithmus
* wer moechte kann auch ein effizientes Verfahren implementieren
\*--------------------------------------------------------------------*/
double determMatrix(const Matrix ma)
{
// TODO
return 6.9;
double determMatrix(const Matrix ma) {
if (ma.spalten != 2 || ma.zeilen != 2) return ERROR;
float a = getEntryAt(ma, 0, 0);
float b = getEntryAt(ma, 1, 0);
float c = getEntryAt(ma, 0, 1);
float d = getEntryAt(ma, 1, 1);
return a * d - b * c;
}