Plasmawolke Rekursion

86fireblade86

Hallo alle zusammen,
ich hoffe jemand kann mir bei meinem Problem helfen und zwar haben wir die Aufgabe
bekommen eine Plasmawolke zu Programmieren, die aus N Feldern besteht.
Ich poste mal die Aufgebe dann wird es vielleicht ein wenig klarer .

Plasma-Wolke:
Starten Sie mit einem Quadrat und zufälligen Intensitätswerten ci an den Ecken Ei,
1 <= i <= 4 und 0 < ci <= 1.
Teilen Sie das Quadrat in vier Quadranten. Der Wert an jeder neuen Ecke ist der Durchschnitt von anderen.
(a) Mitte: c1+c2+c3+c4/4 + φ wobei φ eine zufallsbedingte Größe ist mit 0 <= φ <= 1.
(b) andere: Durchschnitt der beiden nächstgelegenen Originalecken, z. B. c1+c2/2 ; c3+c4/2 ;
(c) Wiederholen Sie dieses Verfahren auf den erzeugten vier Quadranten.

MFG
86fireblade86

knivil

Und wobei genau brauchst du Hilfe?

Sone

knivil schrieb:

Und wobei genau brauchst du Hilfe?

Er will ein fertiges Beispiel einer Implementation.

Eh Hacker und wenn du jetzt noch dazu schreibst ob der Beitragsersteller das nur berechnet oder auch noch grafisch dargestellt haben will, sind wir wieder ein wenig weiter. Und wenn grafisch, was darf man programmiertechnisch dafür einsetzen.

Aber ein wenig Vorleistung in Form von Quelltext wird hier gern gesehen, damit wir einen Eindruck vom Programmierstil bekommen.

In C gibt es oft mehrere Lösungswege. Was hilft es dem Beitragssteller, wenn der Aufgabensteller sagt: Den Lösungsweg kenne ich nicht -> 6. Okay 6 in D

Mach Deine Hausaufgaben selber!

@Hacker wieso lässt du deinen Account löschen und erstellst dann einen neuen unter dem gleichen Namen? Gefiel dir die Zahl nicht die angezeigt wird wie viele Beiträge du schon geschrieben hast?

@86fireblade86
Schreib mal genau wo dein Problem liegt, leute die dir die Hausaufgaben erledigen sind hier ehr selten Anwesen.

86fireblade86

Also
das Programm soll so geschrieben sein das in c also quasi im .exe Fenster die matrix angezeigt wird. Dieses soll anschließend in eine m.file umgewandelt werden
so dass Matlab sie graphisch darstellen kann.
So nun nochmal zu meinem Problem, wie ich eine Matrix von sagen wir mal 129x129
erstelle ist nicht so das Ding aber 1. wie bekommen ich die Zufallszahlen in die Matrix, so das sie an den Ecken sitzen und 2. wie kann ich in c dann schreiben das es die beiden Ecken der Matrix addiert, durch 2 dividiert und in die obere mitte der Matrix legt (also 1 Zeile 64 Spalte).

MFG
86fireblade86

knivil

Dann schreib es doch erstmal in Matlab.

86fireblade86

Matlab hab ich nicht @ home sondern nur in der FH und die Aufgabe war ja die Matrix in C zu programmieren und dann in Matlab zu überführen.

knivil

Ach und wenn die Aufgabe lautet: Baue ein Haus? Dann verzichtest du auch auf Plan und Modell. Wenn du es in einer Sprache schaffst, dann koennen wir ueber die C-Portierung sprechen ...

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.