This commit is contained in:
Daniel Zwanzig 2025-05-19 22:48:47 +02:00
parent 14ad2d456d
commit 08072dd34f
3 changed files with 387 additions and 0 deletions

50
TestMatrix.c Normal file
View File

@ -0,0 +1,50 @@
/**********************************************************************\
* Kurzbeschreibung:
* "Funktionstest" - Matrizen mit Werten erzeugen
* und alle implementierten Funktionen aus matrixOp.c zum Test aufrufen
*
* Datum: Autor:
*
*
\**********************************************************************/
/*--- #includes ------------------------------------------------------*/
#define _CRT_SECURE_NO_WARNINGS //VC++: keine scanf() Warnungen
#include <stdlib.h>
#include <stdio.h>
#include <time.h>
#include "matrixOp.h"
/*--- #defines -------------------------------------------------------*/
/*--- Lokale Datentypen (typedef) ------------------------------------*/
/*--- Modulglobale static Variablen ----------------------------------*/
/*--- Prototypen lokaler Funktionen ----------------------------------*/
/*--- Funktionsdefinitionen ------------------------------------------*/
/*--- main -----------------------------------------------------------*/
int main(void)
{
unsigned int z, s;
float firstElem;
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);
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);
printf("CreateMatrixRand: a[%u,%u]=\n", z, s);
Matrix randMat = createMatrixRand(s, z);
printMatrix(randMat);
}

205
matrixOp.c Normal file
View File

@ -0,0 +1,205 @@
/**********************************************************************\
* Kurzbeschreibung: matrixOp.c
* Bietet Funktionen fuer Operationen mit Matrizen
*
* Datum: Autor: Grund der Aenderung:
*
*
\**********************************************************************/
/*--- #includes ------------------------------------------------------*/
#include <float.h>
#include <stdlib.h>
#include <stdio.h>
#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()
* 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;
}
/*--------------------------------------------------------------------*\
* Erstellt und initialisiert eine neue Matrix (zM)
* - 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;
}
}
return matrix1;
}
/*--------------------------------------------------------------------*\
* Erstellt und initialisiert eine neue Matrix (rM)
* - 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;
}
}
return matrix1;
}
/*--------------------------------------------------------------------*\
* Kopiert eine Matrix und gibt die Kopie zurueck (yM)
\*--------------------------------------------------------------------*/
Matrix copyMatrix(const Matrix toCopy)
{
// TODO
return toCopy;
}
/*--------------------------------------------------------------------*\
* "Loescht" eine Matrix (dM)
* - gibt reservierten Speicher wieder frei !
* - in der urspruenglichen, uebergebenen Matrix bleiben die Werte erhalten!
\*--------------------------------------------------------------------*/
void deleteMatrix(Matrix toDelete)
{
// TODO
}
/*--------------------------------------------------------------------*\
* "Loescht / Zerstoert" eine uebergegebene Matrix (ddM)
* - gibt Speicher wieder frei, setzt alle Werte auf NULL bzw. "0" !
* - Beachte Unterschiede zur vorigen Funktion !!!
\*--------------------------------------------------------------------*/
void destroyMatrix(Matrix *pToDestroy)
{
// TODO
}
/*--------------------------------------------------------------------*\
* 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;
}
/*--------------------------------------------------------------------*\
* 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
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]);
}
printf("\n");
}
}
/*--------------------------------------------------------------------*\
* Addiert zwei Matrizen (aM)
* Rueckgabe:
* - 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;
}
/*--------------------------------------------------------------------*\
* Subtrahiert zwei Matrizen (sM)
* Rueckgabe: "ma - 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;
}
/*--------------------------------------------------------------------*\
* Multipliziert zwei Matrizen (mM)
* Rueckgabe: "ma * 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;
}
/*--------------------------------------------------------------------*\
* Transponiert eine Matrix (tM)
* Rueckgabe: "ma^T"
\*--------------------------------------------------------------------*/
Matrix transposeMatrix(const Matrix ma)
{
// TODO
return ma;
}
/*--------------------------------------------------------------------*\
* Gibt die Determinante der Matrix ma zurueck (dt)
* Rueckgabe im Fehlerfall: ERROR
* !!! Optional / Implementation freiwillig !!!
* fuer kleine Matrizen reicht ein einfacher Algorithmus
* wer moechte kann auch ein effizientes Verfahren implementieren
\*--------------------------------------------------------------------*/
double determMatrix(const Matrix ma)
{
// TODO
return 6.9;
}

132
matrixOp.h Normal file
View File

@ -0,0 +1,132 @@
/**********************************************************************\
* Kurzbeschreibung: matrixOp.h
* Bietet Funktionen fuer Operationen mit Matrizen
*
* Datum: Autor: Grund der Aenderung:
* 01.10.2015 Dr. Lurz Neuerstellung
*
\**********************************************************************/
#ifndef MATRIXOP_H
#define MATRIXOP_H
/*--- #includes ------------------------------------------------------*/
#include <float.h>
/*--- #defines -------------------------------------------------------*/
#define TRUE 1
#define FALSE 0
#define ERROR FLT_MAX
/*--- Datentypen (typedef) -------------------------------------------*/
typedef float MatTyp;
typedef struct t_matrix {
MatTyp *mElement;
unsigned int spalten;
unsigned int zeilen;
} Matrix;
typedef int Bool;
/*--- Prototypen globaler Funktionen ---------------------------------*/
/*--------------------------------------------------------------------*\
* Erstellt eine neue Matrix (cM)
* - reserviert lediglich den notwendigen Speicher
* - dynamische Verwaltung von Speicher muss mit malloc() und free()
* durchgeführt werden; dynamische Arrays sind nicht erlaubt !!!
\*--------------------------------------------------------------------*/
Matrix createMatrix(unsigned int spalten, unsigned int zeilen);
/*--------------------------------------------------------------------*\
* Erstellt und initialisiert eine neue Matrix (zM)
* - reserviert den notwendigen Speicher
* - befuellt die Matrix mit 0
\*--------------------------------------------------------------------*/
Matrix createMatrixZero(unsigned int spalten, unsigned int zeilen);
/*--------------------------------------------------------------------*\
* Erstellt und initialisiert eine neue Matrix (rM)
* - reserviert den notwendigen Speicher
* - befuellt die Matrix mit Zufallszahlen
\*--------------------------------------------------------------------*/
Matrix createMatrixRand(unsigned int spalten, unsigned int zeilen);
/*--------------------------------------------------------------------*\
* Kopiert eine Matrix und gibt die Kopie zurueck (yM)
\*--------------------------------------------------------------------*/
Matrix copyMatrix(const Matrix toCopy);
/*--------------------------------------------------------------------*\
* "Loescht" eine Matrix (dM)
* - gibt reservierten Speicher wieder frei !
* - in der urspruenglichen, uebergebenen Matrix bleiben die Werte erhalten!
\*--------------------------------------------------------------------*/
void deleteMatrix(Matrix toDelete);
/*--------------------------------------------------------------------*\
* "Loescht / Zerstoert" eine uebergegebene Matrix (ddM)
* - gibt Speicher wieder frei, setzt alle Werte auf NULL bzw. "0" !
* - Beachte Unterschiede zur vorigen Funktion !!!
\*--------------------------------------------------------------------*/
void destroyMatrix(Matrix *pToDestroy);
/*--------------------------------------------------------------------*\
* 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);
/*--------------------------------------------------------------------*\
* 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);
/*--------------------------------------------------------------------*\
* Gibt eine Matrix im Kommandofenster "schoen formatiert" aus (pM)
\*--------------------------------------------------------------------*/
void printMatrix(const Matrix ma);
/*--------------------------------------------------------------------*\
* Addiert zwei Matrizen (aM)
* Rueckgabe:
* - Ergebnis der Addition in neu erzeugter Matrix
* - Rueckgabe im Fehlerfall: Matrix der Groesse "0"
\*--------------------------------------------------------------------*/
Matrix addMatrix(const Matrix ma, const Matrix mb);
/*--------------------------------------------------------------------*\
* Subtrahiert zwei Matrizen (sM)
* Rueckgabe: "ma - mb"
* - Ergebnis der Subtraktion in neu erzeugter Matrix
* - Rueckgabe im Fehlerfall: Matrix der Groesse "0"
\*--------------------------------------------------------------------*/
Matrix subMatrix(const Matrix ma, const Matrix mb);
/*--------------------------------------------------------------------*\
* Multipliziert zwei Matrizen (mM)
* Rueckgabe: "ma * mb"
* - Ergebnis der Multiplikation in neu erzeugter Matrix
* - Rueckgabe im Fehlerfall: Matrix der Groesse "0"
\*--------------------------------------------------------------------*/
Matrix multMatrix(const Matrix ma, const Matrix mb);
/*--------------------------------------------------------------------*\
* Transponiert eine Matrix (tM)
* Rueckgabe: "ma^T"
\*--------------------------------------------------------------------*/
Matrix transposeMatrix(const Matrix ma);
/*--------------------------------------------------------------------*\
* Gibt die Determinante der Matrix ma zurueck (dt)
* Rueckgabe im Fehlerfall: ERROR
* !!! Optional / Implementation freiwillig !!!
* fuer kleine Matrizen reicht ein einfacher Algorithmus
* wer moechte kann auch ein effizientes Verfahren implementieren
\*--------------------------------------------------------------------*/
double determMatrix(const Matrix ma);
#endif /*MATRIXOP_H*/