#Sinclair_ZX81 mein
erster Basic Computer (1981) mit dem Komplexe Zahlen erarbeitet werden
konnten.
Vor ~40 Jahren (--> etwa 1985) 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.
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:
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"
Zn+1= Z^2 +C Z^2 wird als Binom aufgefasst : (
Real+Imag)^2 = R^2 + 2*R*I + I^2 //Hier
ein Beispiel in der
Programmiersprache ANSI-C ohne Grosse Bibliotheken oder dem Datentyp
COMPLEX.
//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+Imag)^2 = R^2 + 2*R*I + I^2
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.
//
-------------------------------------------------------------------
Z80 Assembler spielerei, ( keine Berechenung )
Anzeige des Apfelmänchens im Terminal als ASCII
; assembly ;
Z80 Assembler Code zur Ausgabe eines einfachen Männchens
ORG 0x0000 ; Startadresse
START:
LD A, 0 ; Setze A auf 0 (Cursor Position)
CALL CLEAR_SCREEN ; Bildschirm löschen
CALL PRINT_MAN ; Männchen drucken
JP START ; Endlosschleife
;
Unterprogramm zum Löschen des Bildschirms CLEAR_SCREEN:
LD HL, 0x8000 ; Adresse des Bildschirms
LD DE, 0x8000 ; Startadresse
LD BC, 0x1FFF ; Anzahl der zu löschenden Bytes
LD A, ' ' ; Leerzeichen CLEAR_LOOP:
(HL) = A ; Setze das Zeichen auf Leerzeichen
INC HL ; Nächste Adresse
DEC BC ; Zähle herunter
JP NZ, CLEAR_LOOP ; Wiederhole bis BC = 0
RET
;
Unterprogramm zum Drucken des Männchens PRINT_MAN:
LD HL, 0x8000 ; Adresse des Bildschirms
LD A, 'O' ; Kopf
(HL) = A
INC HL
LD A, '/' ; Linker Arm
(HL) = A
INC HL
LD A, '|' ; Körper
(HL) = A
INC HL
LD A, '\\' ; Rechter Arm
(HL) = A
INC HL
LD A, '/' ; Linkes Bein
(HL) = A
INC HL
LD A, ' ' ; Leerzeichen für den rechten Fuß
(HL) = A
INC HL
RET
END START ; Ende des Programms Z80 Assembler Hier
ist ein einfaches Beispiel für einen Z80 Assembler-Code, der die
Berechnung von \( Z = Z^2 + c \) durchführt. In diesem Beispiel gehen
wir davon aus, dass \( Z \) und \( c \) als 8-Bit-Werte gespeichert
sind. Beachte, dass dies eine sehr vereinfachte Version ist und in der
Praxis zusätzliche Überlegungen zur Handhabung von Überläufen und
komplexeren Datentypen erforderlich sind.
;assembly ;
Z80 Assembler Code zur Berechnung von Z = Z^2 + c
;
Annahme: Z ist in Register A und c ist in Register B ;
Ergebnis wird in Register A gespeichert
START:
; Z^2 berechnen
LD A, Z ; Lade Z in Register A
LD D, A ; Kopiere Z nach D
LD A, Z ; Lade Z erneut in A
CALL MULTIPLY ; Multipliziere Z * Z, Ergebnis in A
; c hinzufügen
LD B, c ; Lade c in Register B
ADD A, B ; Addiere c zu Z^2
; Ergebnis in A ist jetzt Z = Z^2 + c
RET
;
Unterprogramm zur Multiplikation von zwei 8-Bit-Zahlen ;
A enthält die erste Zahl, D enthält die zweite Zahl MULTIPLY:
LD E, 0 ; E wird für das Ergebnis verwendet
LD C, A ; C speichert die Kopie von Z
MULTIPLY_LOOP:
ADD E, D ; Addiere D (Z) zu E
DEC C ; Verringere C
JP NZ, MULTIPLY_LOOP ; Wiederhole, solange C nicht null ist
LD A, E ; Lade das Ergebnis zurück in A
RET
;
Hier sollten die Werte für Z und c definiert werden Z:
DB 2 ; Beispielwert für Z c:
DB 3 ; Beispielwert für c Meine Mandelbrotmengen von 1985
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..82) mit dem auch Komplexe Zahlen
algebraisch erarbeitet
werden konnten.
Mein Erlebnis wo Mathe begonnen hat richtig Spaß zu
machen war
Formeln, Funktionen grafisch
darzustellen.
Aus abstrakten algebraischen Formen,
algorithmisch „angewendet“ entstanden ästhetisch
anspruchsvolle Grafiken die eine Reise in die Tiefe zuließen und zum
Experimentieren
geradezu einladen.
Hier ien Chaos-mathematisches Experiment. Ein sogenanntes
Feigenbaumdiagram: Feigenbaum.zip
zum Artikel:https://www.heise.de/newsticker/meldung/Zahlen-bitte-Die-Feigenbaum-Konstante-beschreibt-Ordnung-im-Chaos-4141733.html
Arbeitsweise:
a...get von 2...5, ab 3.2 wird es interessant, ab
3.4 gibt es 4 Wertem , ab
a = 0.2
x = 4.0
for i in range(200):
a = X*a*(1-a)
print(a)
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?
