Implementation der Mandelbrot-Menge:

Sobald während des Iterierens der Betrag von z > 2 Folge konvergiert definitiv nicht.
Falls Betrag von z nach z.B. 100 Iterationen noch < 2 Folge konvergiert vermutlich.
D.h., bei Erreichen einer vorgegebenen Iterationenzahl wird das Pixel, welches der komplexen Zahl c entspricht, schwarz gefärbt, da c vermutlich zur Konvergenz führt.

void mandel ()
{
     Point p;
     int zaehler;
     Komplex c, z;

     for (p.x = 0; p.x < WIDTH;  p.x++)
     for (p.y = 0; p.y < HEIGHT; p.y++)
     {
          zaehler = 0; 
          c       = new Komplex(p, start, schritt);
          z       = new Komplex(c);

          while ((betrag (z) < 2.0) && (zaehler++ < max_iter))

             z = f(z);

          if (betrag(z) < 2.0) set_pixel(p);
      }
}

Bemerkung:

Bei Erhöhung der Iterationszahl können einige Pixel weiß werden, da sich herausgestellt hat, daß durch weitere Iterationen die Betragsgrenze 2 überschritten wird.
Um die Zahlen c , die nicht zur Konvergenz geführt haben, weiter zu klassifizieren, setzt man

Also ergibt sich:

   if (betrag < 2.0)        set_pixel (p); else
   if ((zaehler %  2) != 0) set_pixel (p);

Bei Farbbildschirmen gibt es folgende Möglichkeit, die Divergenzgeschwindigkeit der Folge für ein c zu veranschaulichen:

Es seien die Farben farbe[0], ..., farbe[NUM_COL-1] vorhanden

    set_col_pixel (p, farbe [zaehler % NUM_COL])

Vom Mandelbrot-Algorithmus erzeugtes Bild mit Modulo 2 und 100 Iterationen
- 1.2548 Re - 1.2544 , 0.3816 Im 0.3822

/*****************************************************************************/
/*                    Mandelbrotmenge                                        */
/*****************************************************************************/
void  mandel(                   // berechnet und zeichnet Mandelbrotmenge ab 
        Komplex start,          // linker oberer Ecke start der komplexen Flaeche
        double  schritt,        // mit Schrittweite schritt und 
        int     max_iter,       // Iterationsanzahl max_iter (muss gerade sein)
        int     fall)           // gemaess Fall fall
                                // Abbruch erfolgt, wenn der Betrag groesser als 2 ist 
                                // oder wenn Iterationszahl erreicht ist 
{
    Point p = new Point();
    int zaehler ;
    Komplex c;
    Komplex z;
    double tmp;

    for (p.x = 0; p.x < WIDTH;  p.x++)
    for (p.y = 0; p.y < HEIGHT; p.y++)
    {
        c = new Komplex(p, start, schritt);
        z = new Komplex(0.0, 0.0);
        zaehler = 0;

        while( (q_betrag(z) < 4.0)  && (zaehler++ < max_iter) ) {    // berechne f(z)
                tmp    = z.re;
                z.re   = z.re * z.re - z.im * z.im + c.re;
                z.im   = 2 * tmp * z.im + c.im;
        }
                
        switch (fall) {

        case 1: if (q_betrag(z) < 4.0) set_pixel(p); break;          // schwarz

        case 2: if (q_betrag(z) < 4.0) set_pixel(p); else            // schwarz
                if ((zaehler %2) != 0) set_pixel(p); break;     // mit modulo

        case 3: if(zaehler == max_iter+1)
                set_col_pixel(p,farbe[0]); else                 // Mandelbrotmenge selbst
                set_col_pixel(p,farbe[zaehler%NUM_COL]); break; // farbe modulo
        }
    }
}