Wie kann man den Mandelbrot algorithmus optimieren ?

void TForm1::ZeichneGrafik()
 {      korr a;
 const char * vendor = glGetString(GL_VENDOR);
 mem->Lines->Add(vendor);
 Randomize();
  wglMakeCurrent(
wglGetCurrentDC(),
wglGetCurrentContext());
// Imaginär und Reele Zahlen
// Die Variable c ist nun eine konstante komplexe Zahl
//und unser z ist ebenfalls komplex
// Bei der Iteration müssen wir mit irgendeinem z anfangen
// und wir fangen am Besten mit z=0 an, z wird quadriert und c addiert
// nach den Regeln von oben. Das Ergbenis setzen wir jetzt als neues z ein
// und machen dieselbe Rechnung usw. usw., eine Iteration eben.

   glMatrixMode(GL_PROJECTION);  // Aktuelle Matrix setztn


    glLoadIdentity();

 glOrtho(-5.5,5.5,5.5,-5.5,-38.0,38.0);
   // glOrtho(0,160,490,0,-38.0,38.0);
 /*void glOrtho(	GLdouble left,
			GLdouble right,
			GLdouble bottom,
			GLdouble top,
			GLdouble zNear,
			GLdouble zFar )

                              */
glClearColor(0.0f,0.0f,0.0f,0.0f);

glClear(GL_COLOR_BUFFER_BIT|
     GL_DEPTH_BUFFER_BIT);
            glEnable(GL_NORMALIZE);
 glEnable(GL_DEPTH_TEST);

 glShadeModel(GL_SMOOTH);
 glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
 glEnable(GL_COLOR_MATERIAL);
 glEnable(GL_LIGHT0);
 glEnable(GL_LIGHTING);
 glEnable(  GL_POINT_SMOOTH);
  glHint(  GL_POINT_SMOOTH_HINT , GL_NICEST );

glDisable(GL_CULL_FACE);
     
     


   double x, y; //  '          Laufvariablen
    double x1, y1, x2, y2; // ' Mandelbrot-Ausschnitts-Koordinaten
     int depth ;         // Berechnungstiefe
      int d;          //     Laufvariable für Tiefe
      double dx, dy ; //         Schrittweite pro Pixel
     double px, py;  //         aktuelle Weltkoordinate
      double u, v;  //           Berechnungsvariablen
      double ax, ay ; //         Berechnungsvariablen
                 double  r[255];
      double g[255];
      double b[255];
      int zahler=0;

      // 255 Zufallsfarben erzeugen
      for ( zahler = 0;zahler<255;zahler++)
      {
     r[zahler]=random(11)/10.0;
      g[zahler]=random(11)/10.0;
      b[zahler]=random(11)/10.0;

      }
     // mem->Lines->SaveToFile("f:\\FARBEN.txt");
      // Ausschnitt der Grafik
      x1 = -2.0 ;
      y1 = -1.6  ;
      x2 = 1  ;
      y2 = 1.6 ;
      depth = 255; // maximal 255 (sonst mehr Zufallsfarben erzeugen!)
      dx = (x2 - x1) /3.5 ;
      dy = (y2 - y1) / 3.5 ;
      // Erzeugung des Bitmap
    for ( y = -5.5 ;y<=8.5;y=y+0.01) //5.5

       for ( x = -5.5;x<=8.5;x=x+0.01) //-5.5
         {


            px = x1 + x * dx  ;
            py = y1 + y * dy ;
            d = 0 ;
            ax = 0 ;
            ay = 0  ;
            do
             {
               u = ax * ax - ay * ay + px;
               v = 2 * ax * ay + py ;
                 ax = u ;
               ay = v  ;


               d += 1   ;
               a.rr=r[d];
               a.gg=g[d];
               a.bb=b[d];
               a.xx=ax;
               a.ii=v;
               test.push_back(a);


            }
         while ( ((ax * ax + ay * ay )<4) && (d<depth));
            }


      // Fertiges Bitmap darstellen

                              mem->Lines->Add(test.size());
               mem->Lines->Add(test.capacity());

                  if (rg->ItemIndex==0)
                  {
                      glBegin(GL_POINTS);
                }
                if (rg->ItemIndex==1)
                 {     Auswahl=1;
                 glBegin(GL_LINES);
                 }      
               for (int i=0;i<test.size()-1;i++)
                {
                glColor3f(test[i].rr,test[i].gg,test[i].bb);
                glVertex2d(test[i].xx,test[i].ii);
                glColor3f(test[i+1].rr,test[i+1].gg,test[i].bb);
                 glVertex2d(test[i+1].xx,test[i+1].ii);
                 }


                  glEnd();

             

       mem->Lines->Add("Bild wird jetzt dargestellt");

 glFlush();
glFinish();
 SwapBuffers(wglGetCurrentDC());

for ( y = -5.5 ;y<=8.5;y=y+0.01) //5.5

       for ( x = -5.5;x<=8.5;x=x+0.01) //-5.5

double x, y; //  '          Laufvariablen
double x1, y1, x2, y2; // ' Mandelbrot-Ausschnitts-Koordinaten
double dx, dy ; //         Schrittweite pro Pixel

double  r[255];
double g[255];
double b[255];
int zahler=0;
[color=red]int i, k; [/color] // für die geschachtelten for-Schleifen

// 255 Zufallsfarben erzeugen
for ( zahler = 0;zahler<255;zahler++)
{
	r[zahler]=random(11)/10.0;
	g[zahler]=random(11)/10.0;
	b[zahler]=random(11)/10.0;
}
// mem->Lines->SaveToFile("f:\\FARBEN.txt");
// Ausschnitt der Grafik
x1 = -2.0 ;
y1 = -1.6  ;
x2 = 1  ;
y2 = 1.6 ;

dx = (x2 - x1) / 3.5 ;
dy = (y2 - y1) / 3.5 ;
 
// Erzeugung des Bitmap
for ( i = 0, x = -5.5; i < 1400; ++i, y+=0.01) // falls ich mich nicht verrechnet habe ;)
	for ( k = 0, y = 8.5; k < 1400; ++k, x+=0.01)// dito
   	{
		double px, py;  //         aktuelle Weltkoordinate
		double ax, ay ; //         Berechnungsvariablen
		[color=red]const[/color] int depth = 255 ; // Berechnungstiefe
		int d;          //     Laufvariable für Tiefe
		          	
		ax = 0.0;
		ay = 0.0;
		d = 1; // [color=red]warum mit 0 starten, wenn vorm ersten Benutzen um 1 inkrementiert wird ? [/color]
		
		px = x1 + x * dx  ;
		py = y1 + y * dy ;
		
		do
		{
			double tmp = ax * ax - ay * ay + px;
			ay = 2.0 * ax * ay + py ;
			ax = tmp;
			
			a.rr=r[d]; // [color=red]r[0] [/color] soll niemals verwendet werden?
			a.gg=g[d]; // dito
			a.bb=b[d]; // dito
			a.xx=ax;
			a.ii=ay;
			test.push_back(a);
		}
		while ( ((ax * ax + ay * ay )<4.0) && (d++<depth)); // man beachte [color=red]Postinkrement[/color] von d
	}

 for ( y = -5.5 ;y<=8.5;y=y+0.01) //5.5
        
       for ( x = -5.5;x<=8.5;x=x+0.01) //-5.5
         {
         merker++;

--------------------------------------------------------------------------------
 for ( y = -5.5 ;y<=8.5;y=y+0.01) //5.5
        
       for ( x = -5.5;x<=8.5;x=x+0.01) //-5.5
         {