1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:

private Drawing.Color GetMandelColor(Drawing.PointF coordinates)
{
    double x = 0, y = 0;
    int colorId = 0;
            
    while (colorId < _colors.Length - 1 && Math.Sqrt(Math.Pow(x, 2) + Math.Pow(y, 2)) < 2)
    {                
        var newX = Math.Pow(x, 2) - Math.Pow(y, 2) + coordinates.X;
        var newY = x * y * 2 + coordinates.Y;

        x = newX;
        y = newY;

        colorId++;
    }

    return _colors[colorId];
}                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:

procedure mandelbrotmenge;
var i,j,anz,b,h:integer; 
    x,y,cx,cy,xneu,yneu:double;
begin
  b:=paintbox1.width; 
  h:=paintbox1.height;
  
  for i:=1 to b do begin
   for j:=1 to h do begin
     cx:=5*i/b-2.5;          //Transformation des Pixels in komplexe Zahl
     cy:=5*j/h-2.5; 
     x:=0; y:=0; 
     anz:=0;
     repeat
       xneu:=x*x-y*y+cx;     //klassisches Apfelmännchen 
       yneu:=2*x*y+cy; 
       x:=xneu; 
       y:=yneu; 
       inc(anz);
     until (x*x+y*y>4) or    //bei Betrag der komplexen Zahl >=2 ist die Divergenz der Folge sicher
           (anz>100);        //Genauigkeit der Berechnung
     paintbox1.canvas.pixels[i,j]:=rgb(2*anz, 2*anz, 2*anz);   //keine schöne Farbwahl
  end end;
end;                    

1:
2:
3:
4:
5:
6:

Für jeden Pixel in deinem Bild:
  Transfomiere den Pixel in eine Komplexe Zahl z
        z = z^2 + z;
  Zähle nach wie vielen Iterationen z noch in der Mandelbrotmenge enthalten ist. 
            Oder breche ab wenn Anzahl der Iterationen > Konstante
  Färbe den Pixel entsprechend der Anzahl der Iterationen.                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:

private double Mandelbrot(double value)
{
    var result = 0d;

    for (int i = 0; i < 100; i++)
    {
        result = result * result + value;
    }

    return result;
}                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:

using System.Numeric;

private int Mandelbrot(Complex<double> value)
{
    var result = value;
    var i = 0;

    while(i < 100 && Complex<double>.Abs(value) < 2)
    {
        result = Complex<double>.Pow(result, 2) + value;
  i++;
    }

    return i;
}                    

1:
2:
3:
4:
5:
6:
7:
8:
9:

// in Pseudocode

// statt
IF (SQRT((x1-x2)^2 + (y1-y2)^2) < R)

// dann
IF ((x1-x2)^2 + (y1-y2)^2 < R^2)
// bzw.
IF ((x1-x2)*(x1-x2) + (y1-y2)*(y1-y2) < R*R)                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:

PROCEDURE PaintApple;
VAR radius,a,b,da,db,xf,yf,invers : double;
          i,it,xs,ys : word;
    rowrgb : pbytearray;
BEGIN
  it :=ein_int(e1);
  da := (_x2-_x1) / breite;
  db := (_y2-_y1) / hoehe;
  radius := 9;
  QueryPerformanceCounter(Time1);
  b := _y2;
  FOR ys:=0 TO hoehe-1 DO BEGIN
    rowrgb:=tempbitmap.scanline[ys];
    b := b - db;
    a := _x1;
    FOR xs:=0 TO breite-1 DO BEGIN
      a := a + da;
      xf:=a;
      yf:=b;
    ASM
         FLD     radius
         FLD     xf
         FLD     yf
         FLD     st
         FMUL    st,st
         FLD     st(2)
         FMUL    st,st
         FLD     st(2)
         FLD     st(4)
         XOR     cx,cx
@itloop: INC     cx
         CMP     cx,it
         JE      @noloop
         FMUL
         FADD    st,st
         FADD    st,st(3)
         FLD     st(1)
         FSUB    st,st(3)
         FADD    st,st(5)
         FST     st(3)
         FMUL    st,st
         FSTP    st(2)
         FLD     st
         FMUL    st,st
         FADD    st,st(2)
         FCOM    st(6)
         FSTSW   ax
         FSUB    st,st(2)
         FXCH    st(3)
         AND     ah,1
         JNZ     @itloop
@noloop: MOV     i, cx
         FINIT
      END;
      if i>=it then begin
        if farbverlauf then i:=(round(100.0*modus*(sqr(a)+sqr(b)))) mod 256
                       else i:=0
      end
      else i:=(modus*i) mod 256;
      farbfeld[xs,ys]:=i;
      rowrgb[3*xs]:=pal[i].b;
      rowrgb[3*xs+1]:=pal[i].g;
      rowrgb[3*xs+2]:=pal[i].r;
    END;
    QueryPerformanceCounter(Time2);
    if time2-time1>abbruchtime then begin
      application.processmessages;
      if abbruch then exit;
      PB1.canvas.draw(0,0,tempbitmap);
      time1:=time2;
    end;
  END;
  PB1.canvas.draw(0,0,tempbitmap);
END;                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:

      ASM
         FLD     radius    { 9        }
         FLD     a         { cx       9 }
         FLD     b         { cy       cx    9     }
         FLD     st        { y        cy    cx    9    }
         FMUL    st,st     { y²       cy    cx    9    }
         FLD     st(2)     { x        y²    cy    cx    9     }
         FMUL    st,st     { x²       y²    cy    cx    9     }
         FLD     st(2)     { y        x²    y²    cy    cx    9     }
         FLD     st(4)     { x        y     x²    y²    cy    cx    9   }

         XOR     cx,cx
@itloop: INC     cx        // CX ist der Iterationszähler
         CMP     cx,it     // überschreitet CX den Wert it,
         JE      @noloop   // dann keinen Bildpunkt setzen.

         { y = 2xy + cy }
         FMUL              { xy       x²    y²    cy    cx    9     }
         FADD    st,st     { 2xy      x²    y²    cy    cx    9     }
         FADD    st,st(3)  { (y)      x²    y²    cy    cx    9     }
         { x = x² - y² + cx }
         FLD     st(1)     { x²       (y)   x²    y²    cy    cx    9     }
         FSUB    st,st(3)  { x²-y²    (y)   x²    y²    cy    cx    9     }
         FADD    st,st(5)  { (x)      (y)   x²    y²    cy    cx    9     }
         { x² = x*x }
         FST     st(3)     { (x)      (y)   x²    (x)   cy    cx    9     }
         FMUL    st,st     { (x²)     (y)   x²    (x)   cy    cx    9     }
         FSTP    st(2)     { (y)      (x²)  (x)   cy    cx    9     }
         { y² = y*y }
         FLD     st        { (y)      (y)   (x²)  (x)   cy    cx    9     }
         FMUL    st,st     { (y²)     (y)   (x²)  (x)   cy    cx    9     }
         { x² + y² < 9 ??? }
         FADD    st,st(2)  { (x²+y²)  (y)   (x²)  (x)   cy    cx    9     }
         FCOM    st(6)     { (x²+y²)  (y)   (x²)  (x)   cy    cx    9     }
         FSTSW   ax
         FSUB    st,st(2)  { (y²)     (y)   (x²)  (x)   cy    cx    9     }
         FXCH    st(3)     { (x)      (y)   (x²)  (y²)  cy    cx    9     }
         AND     ah,1
         JNZ     @itloop   { falls Folge innerhalb des Kreises, dann weiter }
@noloop: MOV     i, cx
         FINIT
      END;                    

1:
2:
3:

         FLD     radius    { 9        }
         FLD     a         { cx       9 }
         FLD     b         { cy       cx    9     }                    

1:

         FLD     st        { y        cy    cx    9    }                    

1:

         FMUL    st,st     { y²       cy    cx    9    }                    

1:

         FLD     st(2)     { x        y²    cy    cx    9     }                    

1:

         FMUL    st,st     { x²       y²    cy    cx    9     }                    

1:
2:

         FLD     st(2)     { y        x²    y²    cy    cx    9     }
         FLD     st(4)     { x        y     x²    y²    cy    cx    9   }                    

1:

         XOR     cx,cx                    

1:
2:
3:

@itloop: INC     cx        // CX ist der Iterationszähler
         CMP     cx,it     // überschreitet CX den Wert it,
         JE      @noloop   // dann keinen Bildpunkt setzen.                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:

         { y = 2xy + cy }
         FMUL              { xy       x²    y²    cy    cx    9     }
         FADD    st,st     { 2xy      x²    y²    cy    cx    9     }
         FADD    st,st(3)  { (y)      x²    y²    cy    cx    9     }
         { x = x² - y² + cx }
         FLD     st(1)     { x²       (y)   x²    y²    cy    cx    9     }
         FSUB    st,st(3)  { x²-y²    (y)   x²    y²    cy    cx    9     }
         FADD    st,st(5)  { (x)      (y)   x²    y²    cy    cx    9     }
         { x² = x*x }
         FST     st(3)     { (x)      (y)   x²    (x)   cy    cx    9     }
         FMUL    st,st     { (x²)     (y)   x²    (x)   cy    cx    9     }
         FSTP    st(2)     { (y)      (x²)  (x)   cy    cx    9     }
         { y² = y*y }
         FLD     st        { (y)      (y)   (x²)  (x)   cy    cx    9     }
         FMUL    st,st     { (y²)     (y)   (x²)  (x)   cy    cx    9     }
         { x² + y² < 9 ??? }
         FADD    st,st(2)  { (x²+y²)  (y)   (x²)  (x)   cy    cx    9     }
         FCOM    st(6)     { (x²+y²)  (y)   (x²)  (x)   cy    cx    9     }
         FSTSW   ax
         FSUB    st,st(2)  { (y²)     (y)   (x²)  (x)   cy    cx    9     }
         FXCH    st(3)     { (x)      (y)   (x²)  (y²)  cy    cx    9     }
         AND     ah,1
         JNZ     @itloop   { falls Folge innerhalb des Kreises, dann weiter }                    

1:
2:
3:

@noloop: MOV     i, cx
         FINIT
      END;                    

1:
2:

FLD     st        { y        cy    cx    9    }
FMUL    st,st     { y²       cy    cx    9    }                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:
112:
113:
114:
115:
116:
117:
118:
119:
120:
121:
122:
123:
124:
125:
126:
127:
128:
129:
130:
131:
132:
133:
134:
135:
136:
137:
138:
139:
140:
141:
142:
143:
144:
145:
146:
147:
148:
149:
150:
151:
152:
153:
154:
155:
156:
157:
158:
159:
160:
161:
162:
163:
164:
165:
166:

public abstract class Fractal
{
    private static Color[] BlackWhiteColorSet { get; } = new Color[] { Color.Black, Color.White };

    private double _minX, _minY, _maxX, _maxY;
    private Color[] _colorSet;

    // Maße des Koordinatensystems
    public double MinX
    {
        get { return _minX; }
        set { _minX = value; }
    }
    public double MinY
    {
        get { return _minY; }
        set { _minY = value; }
    }
    public double MaxX
    {
        get { return _maxX; }
        set { _maxX = value; }
    }
    public double MaxY
    {
        get { return _maxY; }
        set { _maxY = value; }
    }

    public int MaxIterations { get; set; }
    public Color[] ColorSet
    {
        get { return _colorSet; }
        set
        {
            // Ist value == null, dann wir ein ColorSet mit schwarz/weiß verwendet
            _colorSet = value ?? BlackWhiteColorSet;
        }
    }

    protected Fractal()
    {
        ColorSet = BlackWhiteColorSet;
        MaxIterations = 100;
    }
        
    // zoomt schrittweise in das Koordinatensystem
    public void Zoom(double zoomRate)
    {
        Zoom(ref _minX, ref _maxX, zoomRate);
        Zoom(ref _minY, ref _maxY, zoomRate);
    }
    public void Zoom(double zoomRate, double centerX, double centerY)
    {
        Zoom(ref _minX, ref _maxX, zoomRate, centerX);
        Zoom(ref _minY, ref _maxY, zoomRate, centerY);
    }

    private void Zoom(ref double min, ref double max, double zoomRate)
    {
        Zoom(ref min, ref max, zoomRate, max + (max - min) / 2);
    }
    private void Zoom(ref double min, ref double max, double zoomRate, double center)
    {
        var distanceX = max - min;
        var newDistanceX = distanceX / zoomRate;
        var oldCenter = min + (max - min) / 2;

        min = min + (distanceX - newDistanceX) / 2 + center - oldCenter;
        max = min + newDistanceX;
    }

    public Bitmap DrawBitmap(int width, int height)
    {
        // Stellt im RAM ein Bild dar, auf dem gezeichnet werden kann
        var bitmap = new Bitmap(width, height);

        try
        {
            DrawFractal(bitmap);
        }
        catch
        {
            // Tritt ein Fehler auf, wird das Bild nicht mehr benötigt und frei gegeben werden
            bitmap.Dispose();
            throw;
        }

        return bitmap;
    }
    public unsafe void DrawFractal(Bitmap bitmap)
    {
        var width = bitmap.Width;
        var height = bitmap.Height;

        // Wie viele Pixel gibt es pro Coordinaten-Schritt
        var xSteps = (MaxX - MinX) / width;
        var ySteps = (MaxY - MinY) / height;

        // blockiert die Menge der Pixel von dem Bild im RAM und macht sie über das zurückgegebene Objekt änderbar
        // Dadurch kann ich die Pixel direkt im RAM setzen und manuell optimieren
        var bitmapData = bitmap.LockBits(new Rectangle(0, 0, bitmap.Width, bitmap.Height), ImageLockMode.ReadWrite, bitmap.PixelFormat);

        try
        {
            var pixelFormatSize = Bitmap.GetPixelFormatSize(bitmap.PixelFormat);
            var bytesPerPixel = pixelFormatSize / 8;
            var firstPixelPtr = (byte*)bitmapData.Scan0;
                
            // Parallel.For ist eine for-Schleife, welche die Durchläufe in eigenen Threads ausführt
            // Beginnt bei 0, endet bei (width * height)
            // Der Zähler ist pixelId
            Parallel.For(0, width * height, pixelId =>
            {// begin Parallel.For

                // Da ich durch die gesamte Menge der Pixel zähle, muss die eigentliche Position berechnet werden
                var yPos = pixelId / width;
                var xPos = pixelId - width * yPos;
                    
                var xCoord = xPos * xSteps + MinX;
                var yCoord = yPos * ySteps + MinY;
                    
                var line = firstPixelPtr + yPos * bitmapData.Stride;
                var byteX = xPos * bytesPerPixel;
                var color = CalculateColor(xCoord, yCoord);

                // Farb-Werte setzen:
                // Je nach Pixel-Format ist ein Pixel unterschiedlich groß
                // 32bit - 4 Byte - ARGB
                // 24bit - 3 Byte - RGB
                // 8bit  - 1 Byte - Alle Farbwerte sind gleich
                if (pixelFormatSize == 32)
                {
                    line[byteX] = color.B;
                    line[byteX + 1] = color.G;
                    line[byteX + 2] = color.R;
                    line[byteX + 3] = color.A;
                }
                else if (pixelFormatSize == 24)
                {
                    line[byteX] = color.B;
                    line[byteX + 1] = color.G;
                    line[byteX + 2] = color.R;
                }
                else if (pixelFormatSize == 8)
                    line[byteX] = color.B;

            }); // end Parallel.For
        }
        finally
        {
            // Sicher stellen, dass die Bild-Daten auch bei einer Exception wieder frei gegeben werden
            bitmap.UnlockBits(bitmapData);
        }
    }
    private Color CalculateColor(double xCoord, double yCoord)
    {
        // Berechnung für das Fractal
        var iterations = IterateFractal(xCoord, yCoord);
        // Ein bisschen Prozentrechnung
        var colorIndex = (double)iterations / MaxIterations * (ColorSet.Length - 1);
        return ColorSet[(int)colorIndex];
    }

    protected abstract int IterateFractal(double x, double y);
}                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:

public class MandelbrotFractal : Fractal
{
    public MandelbrotFractal()
    {
        // Standart-Werte setzen
        MaxIterations = 100;
        MinX = -2;
        MinY = -1;
        MaxX = 1;
        MaxY = 1;
    }

    protected override int IterateFractal(double x, double y)
    {
        // Die Berechnung
        var xBuffer = x;
        var yBuffer = y;
        var maxIterations = MaxIterations;
        var usedIterations = 0;

        while (usedIterations < maxIterations && xBuffer * xBuffer + yBuffer * yBuffer < 4)
        {
            var newXBuffer = xBuffer * xBuffer - yBuffer * yBuffer + x;
            var newYBuffer = xBuffer * yBuffer * 2 + y;

            yBuffer = newYBuffer;
            xBuffer = newXBuffer;

            usedIterations++;
        }

        return usedIterations;
    }
}                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:

 var xBuffer2 = xBuffer * xBuffer;
 var yBuffer2 = yBuffer * yBuffer;

 while (usedIterations < maxIterations && xBuffer2 + yBuffer2 < 4)
        {
            yBuffer = xBuffer * yBuffer * 2 + y;
            xBuffer = xBuffer2 - yBuffer2 + x;

            usedIterations++;

            xBuffer2 = xBuffer * xBuffer;
            yBuffer2 = yBuffer * yBuffer;
        }

 return usedIterations;                    

1:

colorIndex = iterations % ColorSet.Length;                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:

protected override int IterateFractal(double x, double y)
    {
        // Die Berechnung
        var xBuffer = x;
        var yBuffer = y;
        var maxIterations = MaxIterations;
        var usedIterations = 0;

        while (usedIterations < maxIterations && xBuffer * xBuffer + yBuffer * yBuffer < 4)
        {
            xBuffer = xBuffer * xBuffer - yBuffer * yBuffer + x;
            yBuffer = xBuffer * yBuffer * 2 + y;

            usedIterations++;
        }

        return usedIterations;
    }