MA-2
This commit is contained in:
parent
14ad2d456d
commit
08072dd34f
50
TestMatrix.c
Normal file
50
TestMatrix.c
Normal 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
205
matrixOp.c
Normal 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
132
matrixOp.h
Normal 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*/
|
||||
Loading…
x
Reference in New Issue
Block a user