048
05.01.2004, 11:46 Uhr
Lumina
|
mein main:
| C++: |
# include "Fkt_Sammlung.h"
const char Wahl_MatInv = '1',
Wahl_DetBer = '2',
Wahl_LinGlS = '3',
WahlAbbruch = '4';
void main(void)
{
char wahl;
int Rang = 0;
double mat[100] = {0};
do
{
system("cls");
printf("\n Waehlen Sie aus den folgenden Alternativen:\n"
" *********************************************************\n"
" * *\n"
" * %c) Matrixinvertierung *\n"
" * %c) Determinantenberechnung *\n"
" * %c) Loesung eines linearen Gleichungssystems *\n"
" * %c) Abbruch *\n"
" * *\n"
" *********************************************************\n\n",
Wahl_MatInv, Wahl_DetBer, Wahl_LinGlS, WahlAbbruch);
wahl=getch();
printf("\n");
switch(wahl)
{
case '1': /* Matrixinvertierung */
{
int i, j, n = 3;
double *matrix;
matrix = (double*)malloc (n*n*sizeof(double));
printf(" \"Matrixinvertierung\" gewaehlt\n\n"
" Geben Sie den Rang/die Dimension der zu invertierenden Matrix an\n"
" (maximal 10): ");
scanf("%d", &Rang);
EingabeDerMatrix(mat, Rang);
/* Bedingungen fuer Invertierbarkeit:
- Matrix ist quadratisch
- es muss eine regulaere Matrix mit vollem Rang vorliegen */
if (Det(mat,Rang) != 0) MatrInv(mat, Rang);
else printf(" Diese Matrix ist nicht invertierbar, da sie nicht vollen Rang\n"
" hat und ihre Determinante folglich auch nicht ungleich 0 ist!");
/* Ausgabe der inversen Matrix: */
for(j = 0; j<n; j++)
{
for(i = 0; i<n; i++) printf("%0.2f\t", matrix[i+j*n]);
printf("\n");
}
free(matrix);
getch();
break;
}
case '2': /* Determinantenberechnung */
{
printf(" \"Determinantenberechnung\" gewaehlt\n\n"
" Geben Sie den Rang/die Dimension der Matrix an, von der die"
" Determinante\n berechnet werden soll: ");
scanf("%d", &Rang);
EingabeDerMatrix(mat, Rang);
printf("\n Die Determinante der Matrix ist: %lf", Det(mat,Rang));
getch();
break;
}
case '3': /* Loesung eines linearen Gleichungssystems */
{
printf(" \"Loesung eines linearen Gleichungssystems\" gewaehlt\n\n");
LoesLinGS();
break;
}
case '4': /* Keine weiteren Aktionen. */
{
printf(" Abbruch!\n\n");
break;
}
default:
{
printf("Fehlerhafte Auswahl!\n");
}
} /* Ende des SWITCH */
}
while(wahl!=WahlAbbruch); /* Ende der DO-WHILE-Schleife */
}
|
meine Headerdatei:
| C++: |
# include <stdio.h>
# include <conio.h>
# include <stdlib.h>
# include <malloc.h>
# include <string.h>
void EingabeDerMatrix(double mat[100], int Rang);
double Det(double *matrix, int Rang);
void MatrInv(double *m, int Rang);
void LoesLinGS();
|
meine Funktionendatei:
| C++: |
/* STUDIENARBEIT TEIL 2 IN SOFTWARE-SYSTEMTECHNIK, WS 2003/2004 */
/* Autor: Sonja Birner */
/* Mat.-Nr.: 025001830122 01ST1 */
# include "Fkt_Sammlung.h"
/****************************************************************/
/* Funktion: EingabeDerMatrix */
/* Zweck: Eingabe einer Matrix zur späteren Bearbeitung */
/* */
/****************************************************************/
void EingabeDerMatrix(double matrix[], int Rang)
{
int Spalte, Zeile;
int n=0;
for (Zeile = 0; Zeile < Rang; Zeile++)
for (Spalte = 0; Spalte < Rang; Spalte++)
{
printf("%d. Zeile, %d. Spalte: ", Zeile+1, Spalte+1);
scanf("%lf", &matrix[n]);
n++;
}
}
/****************************************************************/
/* Funktion: Det */
/* Zweck: Berechnung der Determinante einer Matrix */
/* */
/****************************************************************/
double Det(double *matrix, int Rang)
{
double *h;
double r = matrix[0] * matrix[3] - matrix[1] * matrix[2];
int i, j, k, x = Rang-1, b = 1;
if(Rang-2)
{
r = 0;
for(i = -1; ++i<Rang; b = -b)
{
h = (double*)malloc(x*x*sizeof(double));
for(j = 0; j<x; j++)
for(k=0;k<x;k++)
h[k+j * Rang-j] = matrix[(k<i?0:1) + Rang + k + j*Rang];
r+= b * matrix[i] * Det(h,x);
free(h);
}
}
return r;
}
/****************************************************************/
/* Funktion: MatrInv */
/* Zweck: Bildung der Inversen einer Matrix */
/* */
/****************************************************************/
void MatrInv(double *m, int Rang)
{
int i, j, k;
double h;
double *mat;
mat = (double*)malloc (Rang*Rang*sizeof(double));
for(j = 0; j<Rang; j++)
for(i = 0; i<Rang; i++) mat[i+j*Rang] = i != j ? 0:1;
for(j = 0; j<Rang; j++)
{
h = m[j*Rang+j];
for(k = 0; k<Rang; k++)
{
m[k+j*Rang] /= h;
mat[k+j*Rang] /= h;
}
for(i = 0; i<Rang; i++)
if(i != j && m[i*Rang+j] != 0)
{
h = -m[i*Rang+j];
for(k=0; k<Rang; k++)
{
m[k+i*Rang] += h * m[k+j*Rang];
mat[k+i*Rang] += h * mat[k+j*Rang];
}
}
}
//memcpy(m, mat, Rang*Rang*sizeof(double));
for(j=0; j<Rang*Rang; ++j) m[j] = mat[j];
free(mat);
}
/****************************************************************/
/* Funktion: LoesLinGS */
/* Zweck: Loesung eines linearen Gleichungssystems */
/* */
/****************************************************************/
void LoesLinGS()
{
printf(" Lineares Gleichungssystem loesen!");
getch();
}
|
getestet habe ich mit genau den Werten, die du in deinem Rätsel verwendet hast...
--
*******************************************
Willst du glücklich sein im Leben, trage bei zu and'rer Glück,
denn die Freude, die wir geben, kehrt ins eig'ne Herz zurück!
******************************************* |
