Plasmawolke Rekursion

86fireblade86

Ich habe aber keine Möglichkeit es in Matlab zu schreiben, da ich noch nie mit Matlab gearbeitet habe. Und wenn ich es schon in C nicht schaffe wie soll ich das dann in Matlab machen???

Du weißt ja schon mal, dass du 129 Punkte brauchst. (WArum nicht 128?)
Nimm einen Zettel und fang mal mit 17*17 an und notiere dir was du machst.
Zufallszahlen gibt es mit rand()
Rechnen kannst du mit + - * / und noch ein paar anderen Funktionen.

86fireblade86

Keine 128 weil: C bei null anfängt zu zählen.
Aber wenn ich 129x129 Felder mit + - * / ausrechne hab ich ja ein Prog.
was du einmal um die Welt wickeln kannst gibt es da keine Funktion für?
Wie z.B. Matrix Anfang + Matrix Ende = Matrix Mitte.
MFG
86fireblade86

86fireblade86

Ich stell ma rein was ich bis jetzt habe:
# include <stdio.h>
# include <time.h>
# include <stdlib.h>

void main ()
{
double Matrix[9][9];
int x,y;
double Phi;
printf("Dieses Programm gibt eine Matrix mit einer Groesse von 9X9 aus.\n"); //Funktion des Programms

srand (time_t(NULL)); //Zufallszahl generieren
double Zufallszahl1 = rand() / ((double)RAND_MAX + 1);
//printf("Zufallszahl lautet %f\n",Zufallszahl1); Test Zufallszahl
double Zufallszahl2 = rand() / ((double)RAND_MAX + 1);
double Zufallszahl3 = rand() / ((double)RAND_MAX + 1);
double Zufallszahl4 = rand() / ((double)RAND_MAX + 1);
Phi = (double)rand() / RAND_MAX;
//printf("%.4f\n",Phi); Test Phi
for (x=0;x<9;x++)
//Matrix
{
for (y=0;y<9;y++)
{
Matrix[x][y]=0;
Matrix[0][0]=Zufallszahl1;
Matrix[0][8]=Zufallszahl2;
Matrix[8][0]=Zufallszahl3;
Matrix[8][8]=Zufallszahl4;
Matrix[0][4]=(Matrix[0][0]+Matrix[0][8])/2;
Matrix[4][0]=(Matrix[0][0]+Matrix[8][0])/2;
Matrix[8][4]=(Matrix[8][0]+Matrix[8][8])/2;
Matrix[4][8]=(Matrix[0][8]+Matrix[8][8])/2;
Matrix[4][4]=((Matrix[0]0]+Matrix[0[8]+Matrix[8[0]+Matrix[8][8])/4)+Phi;

}
}
for (x=0;x<9;x++)
{
for (y=0;y<9;y++)
{
printf("%.4f ",Matrix[x][y]);
}
printf("\n");
}

}
MFG
86fireblade86

Nochmal mit cpp-Tags: (Code markieren und C/C++ Button unter den anklicken)

# include <stdio.h>
# include <time.h>
# include <stdlib.h>

int main ()  //  :warning: in C gibt main immer ein int zurück
{
	double Matrix[9][9];
	int x,y;
	double Phi;
	printf("Dieses Programm gibt eine Matrix mit einer Groesse von 9X9 aus.\n");			//Funktion des Programms

	srand (time_t(NULL));	//Zufallszahl generieren
	double Zufallszahl1 = rand() / ((double)RAND_MAX + 1);
    //printf("Zufallszahl lautet %f\n",Zufallszahl1);										Test Zufallszahl
	double Zufallszahl2 = rand() / ((double)RAND_MAX + 1);
	double Zufallszahl3 = rand() / ((double)RAND_MAX + 1);
	double Zufallszahl4 = rand() / ((double)RAND_MAX + 1);
	Phi = (double)rand() / RAND_MAX;   //  Warum denn so früh?
	//printf("%.4f\n",Phi);			Test Phi
//  :warning: Das brauchst du nur einmal machen und nicht 81 mal.
			Matrix[0][0]=Zufallszahl1;
			Matrix[0][8]=Zufallszahl2;
			Matrix[8][0]=Zufallszahl3;
			Matrix[8][8]=Zufallszahl4;
	for (x=0;x<9;x++) 			
	//Matrix vorbesetzten 
	{
		for (y=0;y<9;y++)
		{
			Matrix[x][y]=0;  // Was anderes als Null wäre auch nicht schlecht.

		}
	}
	for (x=0;x<9;x++) 	//  :warning: Welche Schrittweite musst du nehmen		
	//Matrix
	{
		for (y=0;y<9;y++)  //  :warning: und hier auch , damit du
		{  // die 0, 4 und 8  :warning: 
			Matrix[0][4]=(Matrix[0][0]+Matrix[0][8])/2;  // hier durch y und x ersetzten kannst ?  :warning: 
			Matrix[4][0]=(Matrix[0][0]+Matrix[8][0])/2;
			Matrix[8][4]=(Matrix[8][0]+Matrix[8][8])/2;
			Matrix[4][8]=(Matrix[0][8]+Matrix[8][8])/2;
			Matrix[4][4]=((Matrix[0]0]+Matrix[0[8]+Matrix[8[0]+Matrix[8][8])/4)+Phi; // meinst du nicht, das unterschiedliche Zufallswerte hübscher sind?
//  :warning: oder wie kannst du aus x und y mit geschickter Schrittweite die Elemente berechnen?			
		}
	}
	for (x=0;x<9;x++)
	{
		for (y=0;y<9;y++)
		{
			printf("%.4f ",Matrix[x][y]);
		}
		printf("\n");
	}

}

86fireblade86

@ DirkB
Ähhh ja,
erstmal danke das du dich meinem Prog. gewidmet hast aber ich muss ehrlicher weise
zugeben das ich nicht viel davon verstanden habe was du geschrieben hast.
Wenn ich das Prog. laufen lasse bekomme ich nur den Mittelwert ausgegeben, aber laut Aufgabenstellung muss ich die 4 Ecken der Matrix mit Zufallszahlen belegen
und diese dann oben in der mitte, rechts in der mitte, links in der mitte, unten in der mitte, sowie in der mitte der Matrix miteinander verrechen.
1. Wie meinst du das mit "welche Schrittweise musst du nehmen"?
Mit den for Schleifen stelle ich doch nur die Matrix auf und fülle diese mit Null
oder irre ich mich da?
2. Wie kann ich ein Prog. schreiben das mir bei jedem erneuten Start andere
Zufallszahlen ausgibt?
Vielen Dank für deine Hilfe
MFG
86fireblade86

Sone

86fireblade86 schrieb:

2. Wie kann ich ein Prog. schreiben das mir bei jedem erneuten Start andere
Zufallszahlen ausgibt?

Na er hat doch schon geseedet, was willste noch?

86fireblade86 schrieb:

2. Wie kann ich ein Prog. schreiben das mir bei jedem erneuten Start andere Zufallszahlen ausgibt?

Indem du das Vorbesetzten der Matrix vor dem zuweisen der Eckwerte machst. (ich hatte es dummerweise vor die Schleife gesetzt.

86fireblade86 schrieb:

Wenn ich das Prog. laufen lasse bekomme ich nur den Mittelwert ausgegeben, aber laut Aufgabenstellung muss ich die 4 Ecken der Matrix mit Zufallszahlen belegen

Das hast du jetzt.

86fireblade86 schrieb:

und diese dann oben in der mitte, rechts in der mitte, links in der mitte, unten in der mitte, sowie in der mitte der Matrix miteinander verrechen.

Dann hast du die Elemente mit der 4 als Index berechnet. Da fehlen jetzt noch die mit 2 und 6 und dann die mit 1, 3, 5, 7
Bedenke dein: (c) Wiederholen Sie dieses Verfahren auf den erzeugten vier Quadranten.

86fireblade86 schrieb:

1. Wie meinst du das mit "welche Schrittweise musst du nehmen"?
Mit den for Schleifen stelle ich doch nur die Matrix auf und fülle diese mit Null
oder irre ich mich da?

Du hast mit einem Quadrat angefangen. Nach dem ersten Schritt hast du 4 Quadrate.
Darauf sollst du das verfahren auch nochmal anwenden => 16 Quadrate. Und darauf ...
Die Quadrate werden jedesmal kleiner.
Im Augenblick hast du die Mittelwertberechnung hart programmiert, indem du die Ziel- und Quell-Indizes der Elemente direkt in das Programm geschrieben hast.
Spätestens bei den 16 Quadraten, oder wenn dir 9*9 nicht mehr reicht stehst du damit blöd da.

Also musst du dir etwas überlegenn, um diese Indizes zu berechnen.
Du hast erst 0 und 8 -> daraus wird 4
Dann hast du 0 und 4 -> daraus wird 2, und du hast 4 und 8 -> daraus wird 6

Da kommst du mit deinem x++ und y++ (Schrittweite 1) nicht weiter.
Du musst dir eine andere Schrittweite überlegen. Eine die berechnet wird.
Wie kommst du von 0 und 8 auf 4? Welche Schrittweite ist da sinnvoll?
Wie komst du im nächsten Durchlauf von 0 nach 4 um die 2 zu berechnen. Und dann weiter zur 8 um die 6 zu berechnen? Welche Schrittweite ist da sinnvoll?

for-Schleife müssen nicht mit ++ oder -- weitergezählt werden.

Darum nochmal: Nimm dir mal einen Zettel und Stift und ,mach das Beispiel mal per Hand.

Du darfst dir auch Informationen ausdrucken. z.B: printf("berechne Position (%d|%d)\n", x,y); oder ähnliches.
Oder du nimmst den Debugger um zu sehen was das Programm gerade berechnet.

knivil

86fireblade86 schrieb:

Ich habe aber keine Möglichkeit es in Matlab zu schreiben, da ich noch nie mit Matlab gearbeitet habe. Und wenn ich es schon in C nicht schaffe wie soll ich das dann in Matlab machen???

Dann nimm eben eine Programmiersprache die du kannst. Wenn du keine kannst, dann lern vorher eine.

würde das vllt allgemeiner ausdrücken wenn de immer wieder neue Quadrate aus deinen Quadraten haben willst also immer nach dem gleichen Schema macht es natürlich Sinn die ganze sache rekursiv zu machen. Hier mein Ansatz dafür:

w[xa][ym]=(w[xa][ya]+w[xa][ye])/2;
w[xm][ye]=(w[xa][ye]+w[xe][ye])/2;
w[xe][ym]=(w[xe][ya]+w[xe][ye])/2;
w[xm][ya]=(w[xa][ya]+w[xe][ya])/2;
w[xm][ym]=(w[xa][ye]+w[xa][ye]+w[xe][ya]+w[xe][ya])/4;

// xa=Anfang vom Fled (oben links)
// xm=Mitte vom Feld (oben mittig)
// xe=Ende vom Feld (oben rechts)
// ya=Anfang vom Fled (oben links)
// ym=Mitte vom Feld (links mittig)
// ye=Ende vom Feld (links unten)

jetzt musst du nur noch deinen Feldindexen die Zufallszahl zuweisen kannst du die Feldindexe für deine neuen Quadrate nutzen und so weiter.

86fireblade86

Also danke erstmal für eure Hilfen ich habe das Programm nach einigem
Hin und Her hinbekommen.

# include <stdio.h>
# include <stdlib.h> 
# include <time.h>
# define Länge 129																				//Um die Matrixgrösse zu ändern
																								//muss nur die Länge geändert werden

void Berechnung_Matrix (double Plasmawolke [][Länge],int xa, int xe, int ya, int ye)
{
	int ym,xm;
	double Phi;
	Phi= (double)(rand())/(RAND_MAX);
	if (xe-xa>=2)
	{
	xm=((xe-xa)/2)+xa;
	ym=((ye-ya)/2)+ya;
	Plasmawolke[xa][ym]=(Plasmawolke[xa][ya]+Plasmawolke[xa][ye])/2;
	Plasmawolke[xm][ye]=(Plasmawolke[xa][ye]+Plasmawolke[xe][ye])/2;
	Plasmawolke[xe][ym]=(Plasmawolke[xe][ya]+Plasmawolke[xe][ye])/2;
	Plasmawolke[xm][ya]=(Plasmawolke[xa][ya]+Plasmawolke[xe][ya])/2;
	Plasmawolke[xm][ym]=((Plasmawolke[xa][ye]+Plasmawolke[xa][ye]+Plasmawolke[xe][ya]+Plasmawolke[xe][ya])/4)+Phi;

	Berechnung_Matrix(Plasmawolke,xa,xm,ya,ym);
	Berechnung_Matrix(Plasmawolke,xm,xe,ya,ym);
	Berechnung_Matrix(Plasmawolke,xa,xm,ym,ye);
	Berechnung_Matrix(Plasmawolke,xm,xe,ym,ye);
	}

	// xa=Anfang vom Fled (oben links)				xa=ya------xm----------xe
	// xm=Mitte vom Feld (oben mittig)				|						|
	// xe=Ende vom Feld (oben rechts)				ym--------Feld5-----Feld4+xe
	// ya=Anfang vom Fled (oben links)				|						|
	// ym=Mitte vom Feld (links mittig)				ye-------Feld4+ye-----Feld4
	// ye=Ende vom Feld (links unten)
}

int main ()
{	
	int x,y;
	int Zufallszahl_1_3,I_MIN=0,I_MAX=3;														//Zufallszahl 1-3
	double xa=0,xe=Länge,ye=0,Feld4=Länge;
	double Feld5,Phi;																			//Felder deffinieren
	double Plasmawolke[Länge][Länge];
	srand ((unsigned)time(NULL));
	FILE*Datei;

	Datei=fopen("Plasmawolke.m","w");

	printf_s("Dieses Programm gibt eine Plasmawolke von %dX%d Feldern aus.\n",Länge,Länge);		//Programm Name bzw. Funktion

	Zufallszahl_1_3=rand()%(I_MAX)-(I_MIN-1);

	//printf("%d\n",Zufallszahl_1_3);															//Test Zufallszahl

			xa=((double)(rand())/(double)(RAND_MAX))+Zufallszahl_1_3;
			Plasmawolke[0][0]=xa;
			xe=((double)(rand())/(double)(RAND_MAX))+Zufallszahl_1_3;
			Plasmawolke[0][Länge-1]=xe;														
			ye=((double)(rand())/(double)(RAND_MAX))+Zufallszahl_1_3;
			Plasmawolke[Länge-1][0]=ye;
			Feld4=((double)(rand())/(double)(RAND_MAX))+Zufallszahl_1_3;
			Plasmawolke[Länge-1][Länge-1]=Feld4;

			Berechnung_Matrix (Plasmawolke,0,Länge-1,0,Länge-1);

	for (x=0;x<Länge;x++)
	{
		for (y=0;y<Länge;y++)
		{
			printf("%.3f ",Plasmawolke[x][y]);														//Matrix Ausgabe
			fprintf(Datei,"%.3f ",Plasmawolke[x][y]);
		}
		printf("\n");
		fprintf(Datei,"\n");

	}
	fclose(Datei);
	//printf_s("%.3f\n",Phi);																		//Test Phi
}

LG
86Fireblade86

Wozu ist denn das Zufallszahl_1_3 da ?

86fireblade86 schrieb:

Plasma-Wolke:
Starten Sie mit einem Quadrat und zufälligen Intensitätswerten ci an den Ecken Ei,
1 <= i <= 4 und 0 < ci <= 1.

Deine Intensität in den Ecken soll zwischen 0 und 1 liegen. Da machst du dir mit dem Zufallszahl_1_3 als Offset aber kaputt.

86fireblade86

Ja, aber in diesem Fall wollte ich eine Zufallszahl zwischen 1 und 3
um die Darstellung in Matlab ein bisschen zu verändern, desshalb habe ich zu meiner Zufallszahl zwischen 0 und 1 noch eine zwischen 1 und 3 dazu addiert.
LG
86Fireblade86

Wutz

Im Sinne einer guten Zufallsverteilung solltest du möglichst auf 2-Vielfache als Bereich eingrenzen, also

rand() % 2
rand() % 4
...
(rand() % 2) +1
(rand() % 4) +1
...

Außerdem sind deutsche Umlaute in Bezeichnern ('Länge') nicht erlaubt.

86fireblade86

@ Wutz
Also bei mir hat er den Bezeichner genommen ohne zu meckern, hat mich zwar auch gewundert aber naja.
LG
86Fireblade86