Zurück (C) Christof Ermer, Regensburg

von 20.08.2006
bis 07..24

Links
Formel
LabView 9.0 Programm: MyFrak.vi
Programmier-Knowhow_DEV_C++
Mathe_Programmieren
Mathe-Info

#Sinclair_ZX81 mein erster Basic Computer (1981) mit dem Komplexe Zahlen erarbeitet werden konnten.



Vor ~40
Jahren (--> etwa 1984)  habe ich mich mich mal für das damalige Modethema Chaos Mathematik interessiert.
Um dies zugänglich zu machen und weil ich einen Spiegelartikel dazu gefunden habe, wollte ich die Methode und Bilder mal wieder vorstellen.
So hübsch kann Mathe sein.
Der Spiegelartikel :  
http://www.spiegel.de/wissenschaft/mens



DAS APFELMÄNNCHEN

Hinter dem berühmten Apfelmännchen steckt die sogenannte Mandelbrot-Menge. Ob eine komplexe Zahl c zur Mandelbrot-Menge gehört oder nicht, entscheidet sich bei einer Rekursion, also der wiederholten Berechnung mit einer Formel, in die immer wieder das Ergebnis der vorherigen Berechnung eingesetzt wird.
Die Zahl c gehört zur gesuchten Menge, wenn die Folge mit der Bildungsregel zn+1 = zn 2 + c nicht divergiert, also die Werte nicht Richtung unendlich laufen.
Ist dies der Fall, dann wird der Punkt der Zahl c in der komplexen Zahlebene schwarz gezeichnet.
Die x-Achse repräsentiert dabei den Realteil der Zahl c, die y-Achse den imaginären Teil.
Auf diese Weise entsteht das bekannte Apfelmännchen, das immer feinere Strukturen aufweist, je genauer man rechnet.
Auch wenn man sofort an Selbstähnlichkeit denkt, ist die Mandelbrot-Menge kein Fraktal im engeren Sinn, denn ihre Strukturen wiederholen sich nicht auf identische Weise wie etwa bei der Koch-Kurve oder dem Sierpinski-Dreieck.





Software zum Download

Sowaresammlung:  NUR UNTER DOS ( DOSBOX unter WIn10)  lauffähig 
FraktalPascal.zip   inclusive notwendigem Bildschirmtreiber.
Einzelne PASCAL Programme: 
FRAKCOLO.EXE
FRACK.EXE
Pascal Quellfiles.
FRAKCOLO.PAS
FRACK.PAS



Meine Youtube Videos dazu:
Zum Thema Fraktale  habe ich hier das Youtube einer Software von mir, die ich noch habe:

Das Tapetenprogramm
:
Aus dem Softwarearchiv.
Tapeten Fraktal Programm:   
https://youtu.be/aQzyvwN4QIQ
Aus dem Softwarearchiv.
Tapeten Fraktal Programm (2) 
  https://youtu.be/Y_gyGLqkZK8

Fraktal-Kunst
Eine Spielerei war eine ATMega Mikrocontroller PinkPong Spiel zu missbrauchen um Fraktal-Kunst zu machen
Siehe Video:     https://youtu.be/q_FECRtilEk



So wird ein Fraktal zufuß programmiert:   (Die Auflösung ist natürlich variabel.)

Start: Z=0
C = Koordinate im Komplexen Zahlenfeld ( Real=X, Imaginär=Y)        ->Grafische Koordinaten  --> Plot(X,Y,color)
Wertebereich Real(X) = -2- bis +1, Imagniär(Y) = -1bis +1
Dann Rekursion  der Formel  bis
Betrag von Z  --> |Z|  größer 4   -->  Dann ist N (Schleifenzähler oder Counter) die Farbe des Punktes ( Modulo )  an der  X=Realzahl oder Y=Imaginärzahl Koordinate
ODER!-->   Lege einen maximale Schleifendurchlaufzahl fest BSp. 250..
Wenn diese Erreicht wird, ohne das Z-Betrag |Z| > 4 geworden ist, dann ist der Punkt SCHWARZ
Noch ist die Grafikauflösung zu skalieren:
BSp X-Achse=800, Y=600 Grafikpunkte    -> 
Wertebereich von Z-Real = -2 zu + 1 = Länge 3 von Z-Real
Wertebereich von Z-Imagniär  = -1 zu + 1 = Länge 23 von Z-Imaginär
X--> also 3/800= 3.75^-3    Dies ist nun zu X zu Addieren
Y--> also 2/600 = 3.33333333^-3 Dies ist nun zu Y zu Addieren

Hier nur das Prinzip. Zwei Hauptschleifen     PSEUDOCODE !!
 {Auflösung} = z.B. 0.0000001

for(X=-2 ;X = X+{Auflösung}; X >= 1)
    {
    for(Y=1;Y = Y -  {Auflösung} Y <= -1)
       {
        while( (Betrag < 4 ) && (IterNN < IterationMax) )
            {
            Real = RN * RN;
            Imag = IN * IN;
            Betrag = Real + Imag;
            IN = (IN *  RN * 2) - YC;
            RN = Real - Imag - XC;
            IterNN++;
            };
        PLOT (X,Y,IterNN);    //IterNN=Modulo Color  -->PseudoCode
       }
    };
und das ergibt_


 Quick & Dirty DEV-C++ Programm von mir: Graf_Fraktal8-neu.zip



So sieht es in meinem LabView (Test)Programm aus:
Matheknoten Inhalt:

float64 RN;
float64 IN;
float64 Real;
float64 Imag;
float64 Betrag;
int32 IterNN;
IterNN = Betrag = RN = IN =  0;

while( (Betrag < 4 ) && (IterNN < IterationMax) )
{
Real = RN * RN;
Imag = IN * IN;
Betrag = Real + Imag;
IN = (IN *  RN * 2) - YC;
RN = Real - Imag - XC;
IterNN++;
};

if( IterNN >=  IterationMax )
{
IterNN = 0;
};




und jetzt in die "Grundfigur" hieneinvergrössern





Benoit Mandelbrot


Fraktal Algorythmus: Algebraische Ausformung von "KOMPLEX"    

//Hier ein Beispiel in der Programmiersprache ANSI-C ohne Grosse Bibliotheken oder dem Datentyp COMPLEX.

//Variablen mit Datentypen
float64 RN; float64 IN; float64 Real; float64 Imag; float64 Betrag; int32 IterNN;

/*
Achtung: Berechnungsschleife ist für EINEN Punkt!

Zwei weitere Schleifen für X & Y Grafik Position Grafikauflösung zählen die real & imaginär Startwerte in diesen Intervallen  in Z hoch

Definiere noch
Real_Start = -1.5;
Real_End = 0.5;
Imaginär_Start = 1.5;
Imaginär_End = -1.5 
//
BSP:  (Koordinaten des vollständigen Apfelmännchens)

Real = Real_Start;
Imag = Imaginär_Start;

#Dann:
X_Grafik = 1024;  //Grafik Auflösung in X_Achse
R_DIFF = Real_End - Real_Start = 0.5 - (-1,5) = 2
I_DIFF = Imaginär_End - Imaginär_Start = 1.5 - (-1,5) = 3

//X_Achse
X_Add-Segment = R_DIFF/X_Grafik;   // = 2/1024 = 1,953.....
Real  = Real + X_Add Segment;

Das selbe nochmals für die Y-Achse = (Imaginär Achse)
Imag = Imag + Y_Add     Segment.......
*/
// -------------------------------------------------------------------
// Punkt Berechnung:
IterNN = Betrag = RN = IN =  0;
while( (Betrag < 4 ) && (IterNN < IterationMax) )
{
Real = RN * RN;
Imag = IN * IN;
Betrag = Real + Imag;
IN = (IN *  RN * 2) - YC;
RN = Real - Imag - XC;
IterNN++;
};

if( IterNN >=  IterationMax )
{
IterNN = 0;
};
  // Es folgt pro Schleifendurchlauf noch die Prüfung ob Betrag von Z > 4, 
Dann setze den Punkt mit Modulo des Durchlaufzählers = Farbe.

// -------------------------------------------------------------------



ORIGINAL:
Meine Mandelbrotmengen von 1982.
   Berechnet mit dem Sinclair ZX81 ( Wirklich !! )
4Mhz, 2 KByte Speicher. Drucker war kein Nadel, sondern ein Einpunkt-Balkenschlagdrucker... im Selbstbau:


Der Sinclair ZX81 ( ..modifiziert auf 2K RAM durch  Chiptausch --1K auslöten, besseren 2K RAM einlöten )
...mein erster Basic Computer (1981) mit dem Komplexe Zahlen erarbeitet werden konnten.


Arikel dazu aus der Zeitung




Ich habe mit einem C Programm  versucht mal die Inneren Bereiche,die sonst Schwarz dargestellt werden zu untersuchen.
Diese "stabilen Zonen" sind Iterationen gegen unendlich und  |Z| < 4.
Habe die Iterationen bis zum Abbruch auch farbig dargestellt. Der graue Punkt,,extra  außerhalb der 0 Linie war eine Sonderanalyse und ist nicht relevant.
Das kam dabei heraus. Interessant, nicht?