Funktion deklarieren oder nicht?

[p80286]

Zitat von DeddyH:

Und wo soll das sein?

Na nirgens! (ich hätte geschworen das da was war)

Gruß
K-H

[DeddyH]

Achso, Missverständnis meinerseits, ich dachte, Du hättest meine Tomaten gemeint

[Ergosquare]

So, die Funktion hat jetzt eine Rückgabewert.

za scheint trotzdem durch die Funktion nicht verändert zu werden.

MfG Ergosquare

[Blup]

Um mal zusammenzufassen:
- Rekursion ist in der Regel langsamer als Iteration
- Parameter, lokale Variablen und Rückgabewerte nicht durcheinander werfen

So stelle ich mir das vor:

Delphi-Quellcode:

function zaehler(x, y, a, b: Real): Integer;
var
  x2: Real;
begin
  Result := 0;
  while (Result <= 100) and (sqrt((x * x) + (y * y)) < 2) do
  begin
    x2 := (x * x) - (y * y) + a;                                
    y  := (2 * x * y)       + b;
    x  := x2;
    Inc(Result);
  end;
end;

var
  c: TColor;

  za := zaehler(x, y, a, b);
  case za of
     0..9: c := clRed;                  
   10..19: c := clGreen;
{...}
  else     c := clBlack;
  end;
  paintbox1.canvas.Pixels[s + 50, z + 50] := c;

Pixels ist so ziemlich die langsamste Möglichkeit eine Grafik auszugeben.
Besser du verwendest eine Bitmap und greifst mit Scanline darauf zu.
Die Bitmap dann komplett oder nach jeder Zeile zeichnen.
Alternativ gleich mit einer TImage-Komponente arbeiten (Image1.Picture.Bitmap).

[Ergosquare]

Ich hatte noch einen entscheidenden Fehler:

Code:

    If (za<100) and (sqrt(x*x+y*y)<2)               
    then za:=zaehler(za+1,x,y,x2,a,b)+1 //+1 hat gefehlt             
    else za:=1;

Sonst wird za nach der Funktion nicht verändert.
Dennoch bleibt es leider bei der Einfarbigkeit.

PS: Ich würde trotzdem gerne bei Rekursion bleiben.

MfG Ergosquare

[sx2008]

Den Ausdruck (sqrt((x * x) + (y * y)) < 2) kann man übrigens zu ((x * x) + (y * y) < 4) vereinfachen.
Man kommt darauf wenn man den Ausdruck auf beiden Seiten des Kleinerzeichens quadriert.
Die Quadratwurzel sqrt() wird dann aufgehoben und das spart recht viel Zeit.

[Medium]

@Rekursion: In diesem Fall hier (Mandelbrot Fraktal) ist Geschwindigkeit nicht ganz unwichtig, da der gesamte Prozess sonst echt lahm werden kann. Und die Iteration eines Punktes geht - wie der Name der Operation schon so freundlich suggeriert - völlig klaglos und performat iterativ. Es drängt sich in meinem Hirn sogar geradezu als der "natürliche" Weg auf. (Und ja, TCanvas.Pixels[] bremst hier mindestens genau so heftig, wenn nicht sogar noch signifikanter.) (Davon ab ist 100 als Grenz-Iterationstiefe schon ziemlich fein. Bei den meisten Zooms, die das Fraktal als ganzes noch zeigen, sind Tiefen um 30-50 bei voller HD Auflösung noch sehr gut. Je näher man ran geht, desto feiner muss man allerdings werden um alle theoretisch noch sichtbaren Details zu bekommen. Ich würde die Iterationstiefe daher entweder frei wählbar (favorit), oder vom Zoom abhängig machen.)

[Furtbichler]

Um es kurz zu machen: Bloß weil etwas rekursiv definiert ist, muss es ja nicht rekursiv umgesetzt werden.

[Furtbichler]

Zitat von Blup:

Um mal zusammenzufassen:
- Rekursion ist in der Regel langsamer als Iteration

Um mal aufzuklären:
- Nein. Hm. Also eigentlich irgendwie doch aber nicht so einfach.
Eine sehr schöne Erklärung ist hier zu finden. Unabhängig davon kommt es auf die Implementierung an. So gibt es eben rekursive Lösungen, deren iteratives Äquivalent sehr umständlich umzusetzen und daher auch langsamer sind. Die hochoptimierten Compiler (ja, auch Delphi gehört dazu) widerum können (rekursive) Aufrufe durchaus über Register abbilden und so zu u.U. wirklich schnellerem Code führen.