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;
    }