075
05.01.2004, 14:38 Uhr
Windalf
Der wo fast so viele Posts wie FloSoft...
(Operator)
|
so ich hab das mal ein wenig verbessert das man nicht immer gleich nen anfall bekommt wenn man eine matrix ständig neu eingeben muss....
das mit der dummen rumallokierererei sieht ein bisschen "sch**se" aus weil du das nicht so machen wolltest wie beefy vorgeschlagen hat (das mit dem struct).... In c gibt es keine Referenzen und die können einem das leben manchmal doch stark vereinfachen....
wenn du schon meine Matrixinvertierlösung kopierst solltest du auch die aktuellste version nehmen und nicht die die buggy war....
| C++: |
#include "Fkt_Sammlung.h"
int main(){
char wahl=9; //oder was auch immer nur nicht 8
int Rang=3;
double *matrix;
matrix = (double*)malloc (Rang*Rang*sizeof(double));
matrix[0]=-1;matrix[1]=-2;matrix[2]=0;matrix[3]=-2;matrix[4]=3;matrix[5]=-3;matrix[6]=0;matrix[7]=3;matrix[8]=3;//defaultmatrix
while(wahl!='8'){
system("cls");
printf("\n Waehlen Sie aus den folgenden Alternativenn"
" *********************************************************\n"
" * *\n"
" * 1) Matrix eingeben *\n"
" * 2) Matrixinvertierung *\n"
" * 3) Determinantenberechnung *\n"
" * 4) Loesung eines linearen Gleichungssystems *\n"
" * 5) Aktuelle Matrix ausgeben *\n"
" * 6) Aktuelle Matrix speichern *\n"
" * 7) Aktuelle Matrix einlesen *\n"
" * 8) Abbruch *\n"
" * *\n"
" *********************************************************\n\n");
printf("Ihre Wahl? : ");
scanf("%c",&wahl);
switch(wahl){
case '1': EingabeDerMatrix(&matrix,&Rang);break;
case '2':
printf(" Matrix wird invertiert....");
if (Det(matrix,Rang) != 0) MatrInv(matrix, Rang);
else printf("Determinante ist gleich Null. Matrix kann nicht invertiert werden");
break;
case '3': /* Determinantenberechnung */
printf("\n Die Determinante der Matrix ist: %f", Det(matrix,Rang));
getch();
break;
case '4': /* Loesung eines linearen Gleichungssystems */
printf(" \"Loesung eines linearen Gleichungssystems\" gewaehlt\n\n");
LoesLinGS();
break;
case '5': Matrix_ausgeben(matrix,Rang);break;
case '6': Matrix_speichern("test.txt",matrix,Rang);break;
case '7': Matrix_einlesen("test.txt",&matrix,&Rang);break;
case '8': printf(" Abbruch!\n\n");break;
default: printf("Fehlerhafte Auswahl!\n");
} /* Ende des SWITCH */
}
free(matrix);
return 0;
}
|
| C++: |
# include <stdio.h>
# include <conio.h>
# include <stdlib.h>
# include <malloc.h>
# include <string.h>
void EingabeDerMatrix(double**mat, int*Rang);
double Det(double *matrix, int Rang);
void MatrInv(double *m, int Rang);
void Matrix_ausgeben(double *m,int Rang);
void Matrix_einlesen(const char* filename,double**m,int*Rang);
void Matrix_speichern(const char* filename,double* m,int Rang);
void LoesLinGS();
|
| 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**m, int*Rang){
int i,j;
printf("Matrix eingeben gewaehlt\n\nBitte Geben sie die Dimension der Matrix an: ");
scanf("%d", Rang);
free(*m);
*m=(double*)malloc((*Rang)*(*Rang)*sizeof(double));
for (j=0;j<*Rang;++j)
for (i=0;i<*Rang;++i){
printf("%d. Zeile, %d. Spalte: ", i+1, j+1);
scanf("%lf",(*m+i+j*(*Rang)) );
}
}
/****************************************************************/
/* 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 n){
int i,j,k;
double h,*mat;
mat = (double*)malloc (n*n*sizeof(double));
for(j=0;j<n;j++)for(i=0;i<n;i++)mat[i+j*n]=i!=j?0:1;
for(j=0;j<n;j++){
if(!m[j*n+j])
for(k=j+1;k<n;++k)
if(m[k*n+j]){
for(i=0;i<n;++i){
h=m[j*n+i];m[j*n+i]=m[k*n+i];m[k*n+i]=h;
h=mat[j*n+i];mat[j*n+i]=mat[k*n+i];mat[k*n+i]=h;
}
break;
}
h=m[j*n+j];
for(k=0;k<n;k++){m[k+j*n]/=h;mat[k+j*n]/=h;}
for(i=0;i<n;i++)
if(i!=j && m[i*n+j]!=0){
h=-m[i*n+j];
for(k=0;k<n;k++){m[k+i*n]+=h*m[k+j*n];mat[k+i*n]+=h*mat[k+j*n];}
}
}
memcpy(m,mat,n*n*sizeof(double));
free(mat);
}
/****************************************************************/
/* Funktion: LoesLinGS */
/* Zweck: Loesung eines linearen Gleichungssystems */
/* */
/****************************************************************/
void LoesLinGS()
{
printf(" Lineares Gleichungssystem loesen!");
getch();
}
void Matrix_ausgeben(double *m,int Rang){
int i,j;
for(j = 0; j<Rang; j++){
for(i = 0; i<Rang; i++)
printf("%0.2f\t", m[i+j*Rang]);
printf("\n");
}
printf("<ENTER>");
getch();
}
void Matrix_einlesen(const char* filename,double**m,int*Rang){
int j,i;
FILE *fp;
if(!(fp=fopen(filename,"r")))printf("Fehler beim lesen der Datei\n");
else{
fscanf(fp,"%d",Rang);
free(*m);
*m=(double*)malloc((*Rang)*(*Rang)*sizeof(double));
for(j=0;j<(*Rang);++j)
for(i=0;i<(*Rang);++i)
fscanf(fp,"%lf",(*m+i+j*(*Rang)) );
fclose(fp);
printf("Neue Matrix wurde eingelesen....");
printf("<ENTER>");
getch();
}
}
void Matrix_speichern(const char* filename,double* m,int Rang){
int j,i;
FILE *fp;
if(!(fp=fopen(filename,"w")))printf("Fehler beim schreiben der Datei\n");
else{
fprintf(fp,"%d\t",Rang);
for(j=0;j<Rang;j++)
for(i=0;i<Rang;i++)
fprintf(fp,"%f\t",m[i+j*Rang]);
fclose(fp);
printf("Matrix wurde gespeichert....");
printf("<ENTER>");
getch();
}
}
|
vermutlich wäre es auch schlauer zum invertieren dies hier zu nehmen....
| C++: |
bool matrix_inv(double*m,int n){
int i,j,k;
double h,*mat=new double[n*n];
//Array mit Werten einer Einheitsmatrix erzeugen
for(j=0;j<n;j++)for(i=0;i<n;i++)mat[i+j*n]=i!=j?0:1;
//für jede Zeile der Matrix
for(j=0;j<n;j++){
k=0;
if(!m[j*n+j]) //wenn das zu normierende element 0 ist zeilentausch
for(k=j+1;k<n;++k) //für jede zeile nach der jten
if(m[k*n+j]){ //wenn element ungleich 0 gefunden zeilen tauschen und schleife abbrechen
for(i=0;i<n;++i){
h=m[j*n+i];m[j*n+i]=m[k*n+i];m[k*n+i]=h;
h=mat[j*n+i];mat[j*n+i]=mat[k*n+i];mat[k*n+i]=h;
}
break;
}
if(k==n){delete [] mat; return false;}
h=m[j*n+j];//wert des zu normierenden elements
for(k=0;k<n;k++){m[k+j*n]/=h;mat[k+j*n]/=h;}//die komplette zeile normieren
for(i=0;i<n;i++)// gauss über die matrix jagen
if(i!=j && m[i*n+j]!=0){
h=-m[i*n+j];
for(k=0;k<n;k++){m[k+i*n]+=h*m[k+j*n];mat[k+i*n]+=h*mat[k+j*n];}
}
}
memcpy(m,mat,n*n*sizeof(double));//invertierte matrix in übergebenen speicher schreiben
delete [] mat;
return true;
}
|
--
...fleißig wie zwei Weißbrote |
und welche Probleme gibt es noch?
