Ich mag vor allem die logarithmische Spirale. Vielleicht liegt es daran, dass sie überall in der Natur mit diversen Steigungen vorkommt, sei es bei Schneckenhäusern, der Anordnung der Kerne in den Blüten von Sonnenblumen, Galaxien oder Tiefdruckwirbeln.

Über das Jahr könnt Ihr Euch dann an 52 verschiedenen Spiralbildern erfreuen. Viel Spaß!

Hier die Basis:

Ausgangsspirale

Ach ja, hier könnt Ihr Euch die erste Spirale anschauen, schließlich habe ich ja noch ein paar nachzuarbeiten.

Bevor Ihr jetzt aber völlig planlos Eure eigenen Formeln entwickelt, solltet Ihr Euch natürlich ein paar grundlegende Gedanken machen. Was soll diese Formel können, stellt sie etwas noch nie dagewesenes dar oder reichen die von Ultra Fractal bereitgestellten Formeln für Eure Zwecke völlig aus.

Solide Grundlage für das Entwickeln eigener Formeln ist, so banal wie es klingt, ein Plan.

Deshalb möchte ich vorab einige Eckpunkte für unsere Formel definieren.

1. die Iterationsgleichung soll einen Startwert, einen Exponenten und zwei Funktionen enthalten,
2. eine Funktion soll vom Nutzer aktiviert und dann eingeblendet werden können,
3. die Daten für den Startwert, Exponent und Bailout sollen vom Nutzer eingegeben werden können und
4. zwischen den Fraktaltypen soll umgeschaltet werden können.

Dann lasst uns anfangen.

Fraktalformeldatei erstellen

Zunächst erstellt Ihr Euch eine neue Fraktal-Formel-Datei (Fractal Formula File). Dazu wählt Ihr im Datei (File) Menü den Punkt Neu (New) aus.

Daraufhin öffnet sich im Editor ein leeres Fenster mit den Namen Formula1.

Dieses Fenster bzw. diese Formeldatei nimmt nun nach und nach Eure Programmanweisungen auf. Damit Ihr nicht alles von Hand eingeben müsst, sind im Menüpunkt Einfügen (Insert) viele Anweisungen hinterlegt, die Ihr mit Klick einfügen könnt.

Die Formeln beginnen immer mit dem Eintrag-Identifikator, gefolgt von dessen Inhalt, der in geschweiften Klammern steht. Ihr solltet beachten, dass Leerzeichen und Tabulatoren nicht erlaubt sind. Ebenso darf der Eintrag-Identifikator innerhalb der Formeldatei nicht doppelt auftreten.

Meine-erste-Formel {
; Inhalt
}

Optional kann dem Identifikator ein Wert in Klammern beigefügt werden. Ultra Fractal kann somit die Symmetrie zum Beschleunigen der Berechnung nutzen.

MeinMandelbrot (XAXIS) {
; Inhalt
}

Kommentare in der Formel werden mit vorangestellten Semikolon gekennzeichnet. Zusätzliche globale Kommentare könnt Ihr mit dem speziellen '{ }'-Kommentar kennzeichnen.

Ich habe es mir angewöhnt, bevor ich die Formeln schreibe, einen globalen Kommentar anzulegen, der folgende Inhalte aufweist:

comment {
  File: Formula1.ufm
  Version: 1.0
  Author: Oliver Konow, 2012
  Last Modification:
}

Als nächstes folgt der Identifikator in dem Abschnitte, Funktionen und Parameter sowie weitere Einträge stehen können.

Im Menü Einfügen (Insert) findet Ihr den Punkt Neue Formel (New Formula…)

Es öffnet sich anschließend ein Fenster, in dem Ihr den Titel MeinMandelbrot eingeben und eine Symmetrie der verschiedenen Achsen auswählen könnt. In diesem Fall wählt Ihr XAXIS_NOPARM aus, sie erzwingt eine Symmetrie um die horizontale x-Achse bzw. real-Achse, jedoch nur, wenn alle komplexen Parameter auf (0, 0) gesetzt sind.

Den Haken am Punkt: Insert global section könnt Ihr entfernen. Falls Ihr für die verbleibenden Abschnitte keine Kommentare haben wollt, so entfernt den Haken auch am Punkt: Insert comments for each section. Drückt anschließend auf OK.

Hinweis zur Symmetrie: Damit Ultra Fractal die symmetrischen Eigenschaften von Fraktalen zum Beschleunigen der Berechnung nutzen kann, müsst Ihr die Symmetrie der Formel als optionale Einstellung in Klammern hinter dem Eintrag-Identifikator angeben.

Folgende Abschnitte sollten jetzt vorhanden sein:

MeinMandelbrot(XAXIS_NOPARM) {
init:

switch:
}

Damit ist das Grundgerüst Eurer Formel fertig, welches Ihr an dieser Stelle speichern solltet. Im nächsten Schritt werde ich die Abschnitte näher erläutern bevor wir sie anschließend mit Variablen befüllen.

Die Abschnitte der Formel

Abschnitt: init

In diesem Abschnitt wird die Hauptvariable z initialisiert. Sie ist ein vordefiniertes Symbol, weshalb sie korrekterweise '#z' bezeichnet werden müsste. In Fraktalformeln kann das #-Präfix vor '#z' weggelassen werden. In Kolorierungs-Algorithmen wird es jedoch benötigt.

Dieser Abschnitt wird pro Pixel nur einmal ausgeführt und eignet sich, um Variablen zu initialisieren.

Abschnitt: loop

Hier steht unsere Hauptgleichung, die nur einmal pro Iteration ausgeführt wird. Der Abschnitt soll den Wert der vordefinierten komplexen Variable #z unter Berücksichtigung des alten Wertes von 'z' aktualisieren.

Abschnitt: bailout

Dieser Abschnitt enthält einen einzelnen Boole'schen Ausdruck, der den loop-Abschnitt solange ausführt, wie dieser Wert true ist. Er wird mindestens einmal ausgeführt.

Abschnitt: default

Grundeinstellungen unserer Formel betreffend sind in diesem Abschnitt zu finden. Er kann Einstellungen wie title, angle, center, maxiter, helpfile und/oder helptopic beinhalten. Parametereinstellungen innerhalb der Blöcke param und endparam können ebenfalls verwendet werden.

Weitere Einstellungen sind in der Hilfedatei zu finden.

Abschnitt: switch

Dieser Abschnitt ermöglicht das Umschalten zwischen verwandten Fraktaltypen, z.B. von Mandelbrot in Julia.

Darüber hinaus gibt es noch zwei weitere Abschnitte, die hier nicht aufgeführt, ich aber dennoch kurz erläutern möchte:

Abschnitt: global

In der Fraktalformel ist dies der erste Abschnitt und wird nur einmal pro Bild ausgeführt. Er kann dazu verwendet werden, Suchtabellen zu füllen und Nur-Lese-Variablen zu initialisieren. Somit können viele wiederholte Berechnungen vermeiden werden.

Abschnitt: builtin

Mit diesem Abschnitt könnt Ihr auf fest eingebaute Fraktalformeln zurückgreifen. Wenn dieser Abschnitt verwendet wird, sind die Abschnitte global, init, loop und bailout nicht zulässig. Der Abschnitt kann folgende Einstellung enthalten: type.

Einsetzen der Variablen in die Formel

Nachdem das Grundgerüst steht, können nun Variablen, Ausdrücke und Formeln in die entsprechenden Abschnitte eingesetzt werden.

Hinweis! Hinsichtlich der Parameter möchte ich auf den Artikel Formel schreiben – Teil 1 verweisen.

Inhalt des init-Abschnitts

z = @start

Die komplexe Variable z wird mittels dem benutzerdefinierten Parameter @start initialisiert. Die Werte können im Karteireiter Formel (Formula) eingegeben werden.

Weitere Informationen zum Parameter @start werden im Parameterblock erläutert.

Inhalt des loop-Abschnitts

if @auswahl == true
  z = z^p1 + @myfunc1(z) + @myfunc2(z) + #pixel
else
  z = z^p1 + @myfunc1(z) + #pixel
endif

Hier befinden sich zwei Iterationsgleichungen, die fortlaufend die komplexe Variable z berechnen. Die Auswahl der ersten Gleichung erfolgt, wenn der Parameter @auswahl == wahr, also ausgewählt wurde. Falls nicht, wird die zweite Gleichung verwendet.

In den Gleichungen befinden sich die Parameter p1, @myfunc1 sowie @myfunc2 deren Exponent bzw. deren Funktionen durch den Nutzer im Karteireiter Formel (Formula) eingegeben bzw. ausgewählt werden kann.

Weitere Informationen zu den Parametern p1, @myfunc1 sowie @myfunc2 werden in den Parameter- sowie den Funktionsblöcken erläutert.

Desweiteren befindet sich das vordefinierte Symbol #pixel in der Gleichung, welches die komplexen Koordinaten des berechneten Pixels zurückgibt.

Inhalt des bailout-Abschnitts

|z| <= @bailout

Der loop-Abschnitt wird solange iteriert, bis die Bedingung Betrag z kleiner gleich dem benutzerdefinierten Parameterwert @bailout erfüllt ist. Der Wert kann im Karteireiter Formel (Formula) geändert werden.

Nähere Informationen zum Parameter @bailout werden im Parameterblock erläutert.

Inhalt des default-Abschnitts

title = "MeinMandelbrot"
center = (-1, 0)
helpfile = "Formula1.txt"
helptopic = "Hilfe zu MeinMandelbrot"

Die Einstellung title beinhaltet den Namen der Formel, in diesem Fall MeinMandelbrot, der auch im Karteireiter Formel (Formula) angezeigt wird, in der Abbildung gelb markiert.

Die zweite Einstellung center legt die komplexen Koordinaten im Karteireiter Standort (Location) fest.

Mit den Einstellungen helpfile und helptopic könnt Ihr eine Hilfedatei, hier die Datei Formula1.txt, und einen speziellen Hinweistext zur Formel anbieten.

Die Hilfedatei wird durch Klick auf das Fragezeichen im Karteireiter Formel (Formula) geöffnet, siehe rote Markierung in der folgenden Abbildung.

heading
  caption = " Change Functions ... "
  text = "cosh, sqr and zero for standard mandelbrot set. Have fun!"
endheading

Mit Hilfe von Überschriften könnt Ihr Parameter- und Funktionsblöcke logisch mit caption gruppieren und mit Hilfe der Einstellung text genauer beschreiben. Sie werden für den Benutzer angezeigt, siehe folgendes Bild. Überschriften werden mit heading eingeleitet und mit endheading abgeschlossen.

Anschließend folgt der erste Funktionsblock, der zunächst mit einer Überschrift eingeleitet wird.

heading
  text = "First function"
endheading
func @myfunc1
  caption = "Function 1"
  default = atanh()
  hint = "Wähle eine Funktion aus, um die Formel zu verändern."
endfunc

Funktionen werden in der Form [type] func <Parameter-Bezeichner> eingeleitet und mit endfunc beendet. Die Funktion ist vom Typ entweder 'complex' oder 'color'. Wird der Typ nicht angegeben, so wird 'complex' angenommen. Der Parameterbezeichner @myfunc1 ist identisch mit dem benutzerdefinierten Parameter aus dem loop-Abschnitt.

Die Einstellung caption spezifiziert den Parameter @myfunc1 genauer und default setzt den Standardwert der Funktion auf atanh. Mit hint wird ein kleiner Hinweistext erzeugt, der dann sichtbar ist, wenn Ihr den ?-Button oben in der Titelleiste des Werkzeugfensters Ebenen-Eigenschaften (Layer Properties) und anschließend auf den Parameter klickt.

Der zweite Funktionsblock wird ebenfalls mit einer Überschrift eingeleitet. Im Gegensatz zum ersten Funktionsblock wird der zweite Funktionsblock @myfunc2 nur dann eingeblendet, wenn der Nutzer ein Häkchen in das Kontrollkästchen Use Function 2 des Parameterblocks @auswahl macht. Der ist durch default = false standardmäßig ausgeblendet. Durch visible = @auswahl wird das Einblenden gesteuert.

Mit Hilfe der if-Bedingung im loop-Abschnitt wird nun die entsprechende Formel zum Berechnen des Fraktals herangezogen.

heading
  text = "Second function"
endheading
param @auswahl
  caption = "Use Function 2"
  default = false
endparam
func @myfunc2
  caption = "Function 2"
  default = cosh()
  hint = "Wähle eine Funktion aus, um die Formel zu verändern."
  visible = @auswahl
endfunc

Alle anderen Einstellungen sind wie beim vorangegangenen Funktionsblock. Hier die Liste aller Funktionen in Ultra Fractal.

Auch die Parameterblöck werden in der Form [type] param <Parameter-Bezeichner> eingeleitet und mit endparam beendet.

Die folgenden Parameterblöcke werden der Übersicht halber und in gewohnter Weise mit einer Überschrift eingeleitet.

heading
  caption = "... and Values"
endheading

Der Parameter @start initialisiert in der Standardeinstellung den Real- und Imaginärteil der komplexe Variable z auf (0, 0). Die anderen Einstellungen wurden bereits weiter oben beschrieben.

param @start
  caption = "Start Value"
  default = (0,0)
  hint = "Mit dem Parameter Startwert kann die Mandelbrotmenge \
          verändert werden. Verwende (0, 0) für die Standard- \
          Mandelbrotmenge."
endparam

Der vordefinierte Parameter p1 ist für den Exponenten unserer Gleichung zuständig. Für den Realteil beträgt der Exponent 2 und für den Imaginärteil 0.

param p1
  caption = "Exponent"
  default = (2,0)
  hint = "Dieser Parameter wird für den Exponenten der Formel \
          verwendet. Die Eingabe von 3, 4 und größer im Realteil, \
          lässt die Mandelbrotmenge runder werden. \
          Nicht-Integer-Werte sowie Nicht-Null-Werte im \
          Imaginärteil verzerren das Afelmännchen. \
          Benutzen Sie (2, 0) für die Standard-Mandelbrotmenge."
endparam

Der Ausstiegswert @bailout, ab wann die Iteration im loop-Abschnitt abgebrochen werden soll, ist vom Typ her eine Fließkommazahl und somit float. Der Standardwert default ist mit 1.0E20 und der Minimalwert min mit 1 festgelegt.

float param @bailout
  caption = "Bailout"
  default = 1.0e20
  min = 1.0

Ob ein Fließkommaparameter die exponentielle Interpolation nutzen soll oder nicht, kann mittels exponential eingestellt werden. Standardmäßig ist dieser Wert auf false voreingestellt. Ihr könnt diesen Wert später im Werkzeugfenster Zeitstrahl (Timeline) ändern.

Wenn Eure Formel auch in früheren Versionen von Ultra Fractal laufen soll, in denen die exponential-Einstellung nicht verfügbar war, testet Ihr das mit dem VER40-Symbol. Der Aufruf erfolgt durch die sogenannte Compiler-Direktive.

Mittels $ifdef VER40 wird die Version von Ultra Fractal abgefragt und sichergestellt, dass in Ultra Fractal 4 der Parameter exponentiell interpoliert wird. Beendet wird die Direktive mit $endif.

$ifdef VER40
  exponential = true
  ; In Ultra Fractal 4 stellt Ihr sicher, dass dieser Parameter
  ; exponentiell interpoliert wird.
$endif
  hint = "Dieser Parameter definiert, wie lange die Formel \
          iteriert wird und ob ein Pixel zur Mandelbrotmenge \
          gehört oder nicht. Entsprechend wird er eingefärbt. \
          Größere Werte liefern eine klarere Konturen; \
          Werte kleiner als 4 verzerren die Fraktale."
endparam

Der Vollständigkeit halber sollen die anderen Versionen nicht unerwähnt bleiben: ULTRAFRACTAL, VER20, VER30, VER40 sowie VER50.

Die Compiler-Direktiven lauten: $define, $undef, $ifdef, $else sowie $endif.

Inhalt des switch-Abschnitts

Um vom Fraktaltyp MeinMandelbrot zum Typ MeinJuliabrot schalten zu können, müsst Ihr in der Einstellung type den Formelbezeichner eintragen.

Die Einstellung für den Zielparameter @seed = #pixel sorgt dafür, dass das Schaltfeature abhängig vom Punkt ist, den der Nutzer innerhalb des Fraktalfensters klickte. Der Parameter in der Zielformel muss komplex sein, sonst wird die Einstellung ignoriert.

Abschließend werden die Einstellungen für die Parameter p1, @myfunc1, @myfunc2 und @bailout aus der Quellformel in die Zielformel kopiert. Dabei müsst Ihr sicherstellen, dass Quell- und Zielparameter gleich sind, ansonsten werden die Einstellungen ignoriert.

Parameter, die nicht explizit kopiert werden, erhalten voreingestellte Werte.

type = "MeinJuliabrot"
@seed = #pixel
p1 = p1
@myfunc1 = @myfunc1
@myfunc2 = @myfunc2
@bailout = @bailout

Zielformel erstellen

Jetzt müsst Ihr nur noch die Zielformel schreiben. Hört sich kompliziert an, ist aber ganz einfach.

Dazu kopiert Ihr zunächst die Formel MeinMandelbrot und benennt diese in MeinJuliabrot um. Zu ändernde Stellen habe ich rot markiert.

MeinJuliabrot(XAXIS_NOPARM) {

Als nächstes ändert Ihr den Wert der komplexen Variable z im init-Abschnitt von

z = @start

in

z = #pixel

Anschließend werden die Iterationsgleichungen im loop-Abschnitt von

z = z^p1 + @myfunc1(z) + @myfunc2(z) + #pixel

und

z = z^p1 + @myfunc1(z) + #pixel

in

z = z^p1 + @myfunc1(z) + @myfunc2(z) + @seed

und

z = z^p1 + @myfunc1(z) + @seed

angepasst.

Als letztes müsst Ihr noch im switch-Abschnitt Änderungen von

type = "MeinJuliabrot"
@seed = #pixel
p1 = p1
@myfunc1 = @myfunc1
@myfunc2 = @myfunc2
@bailout = @bailout

in

type = "MeinMandelbrot"
p1 = p1
@myfunc1 = @myfunc1
@myfunc2 = @myfunc2
@bailout = @bailout

vornehmen.

Sicherlich fragt Ihr Euch jetzt, wie das Umschalten eigentlich funktioniert?

1. In der Formel MeinMandelbrot wird zunächst der Startwert initialisiert und danach die Iterationsgleichungen ausgeführt.
2. Dem vordefinierten Symbol #pixel werden die komplexen Koordinaten zurückgegeben.
3. Klickt der Nutzer innerhalb des Fraktalfensters, so schaltet er zum Fraktaltyp MeinJuliabrot um, dem als Startwert @seed die komplexen Koordinaten von #pixel übergeben werden.
4. Der Startwert für die Formel MeinJuliabrot wird mit den komplexen Koordinaten, die von #pixel übergeben wurden, initialisiert.
5. Anschließend werden wie gewohnt die Iterationsgleichungen ausgeführt. Ein erneutes klicken in das Fraktalfenster schaltet wieder zum Fraktaltyp MeinMandelbrot zurück.

Hier die Datei formula1.ufm sowie die entsprechende Hilfedatei formula1.txt.

Ich wünsche Euch viel Spaß beim Experimentieren!

Mit diesem Tutorial möchte ich Euch zeigen, wie Ihr mit Hilfe des Formel-Editors Eure eigenen Formeln entwickeln könnt. Je nach Aufgabentyp wird zum Berechnen von Fraktalen zwischen folgenden Formeldateien unterschieden:

• Fraktalformeln .ufm (fractal formula files),
• Kolorierungsalgorithmen .ucl (coloring algorithm files) sowie
• Transformationen .uxf (transformation files).

Aufgrund dieses Aufgabentyps gliedert sich das Tutorial in folgende Teile:

1. Grundlegende Konventionen (Ausdrücke, Variablen, Typen, Schleifen etc.),
2. Erstellen von Fraktalformeln,
3. Erstellen von Kolorierungsalgorithmen sowie
4. Erstellen von Transformationen.

Weitergehende Informationen bekommt Ihr in der Ultra Fractal Hilfe.

Grundlegende Konventionen

Wie in der Umgangssprache gelten für eine Programmiersprachen gewisse grammatikalische Regeln. Wenn Ihr diese Regeln ignoriert, dann ist der Compiler nicht in der Lage, die Anweisungen der Formeldatei korrekt auszuführen und gibt Euch eine Fehlermeldung aus.

Ausdrücke

Einige Abschnitte (init und loop) können Anweisungen in Form von Ausdrücken enthalten. Darüber hinaus können auch Variablen, Parameter und Konstanten einen Ausdruck darstellen. Die Kombination von Operatoren und Werten bezeichnet man als Ausdrücke.

Ausdrücke können in Programmen an verschiedenen Stellen verwendet werden:

• auf der rechten Seite von Zuweisungen

z = z^@power + #pixel

• im Aufruf von Funktionen

e1 = sqrt(2 * log(cabs(z1)) * cabs(z1) / cabs(o1)) * @zscale

• in Bedingungen

if(real(z2) > 0.0)

Datentypen und Datentypenkompatibilität

Die oben beschriebenen Ausdrücke können vom verschiedenen Typ sein. In Ultra Fractal gibt es folgende Typen:

b o o l

Wenn zwei Ausdrücke miteinander verglichen werden, so können sie nur zwei Werte annehmen: true bzw. false

3 < 4 ; true

i n t

Die Integerwerte liegen Werte im Bereich von -2.147.483.648 bis 2.147.483.647 und sie werden zum Zählen sowie für arithmetische Operationen benötigt.

-3, 2

f l o a t

Mithilfe von Fließkommazahlen können gebrochene Zahlen dargestellt werden; ihre Präzision ist praktisch unbegrenzt.

-3.734, 2.5e8

c o m p l e x

Komplexe Zahlen werden durch komplexe Ausdrücke repräsentiert, die aus zwei Fließkommazahlen bestehen. Sie ermöglichen fraktale Berechnungen.

(1.4, 3) = 1.4+3i

c o l o r

Mit diesem Ausdruck, der eine Farbe repräsentiert, können Operationen durchgeführt und in color-Variablen gespeichert werden. Eine Farbe wird entsprechend den Farbkomponenten Rot, Grün, Blau und Alpha-Kanal (Opazität) intern aus vier Fließkommazahlen zusammengesetzt. Die Werte liegen zwischen 0 und 1. Dieser Typ ist nur für direkte Kolorierungsalgorithmen vorgesehen.

Wenn zwei Ausdrücke unterschiedlichen Datentyps miteinander berechnet werden, dann erhält das Ergebnis den höherwertigen Datentyp der Einzelausdrücke.

Im folgenden Beispiel ist das Ergebnis von 3 + 2.1 vom Typ float, da der Wert 2.1 (float) höherwertiger ist, als der Wert 3 (int). Der Datentyp complex ist höherwertiger als der Typ float.

Der Compiler kann nur in höhere Datentypen umwandeln. Das folgende Beispiel würde in eine Fehlermeldung münden:

int i = 3 / 2.

Konstanten

Boole'sche Konstanten

Sie sind vom Typ 'bool' und es gibt zwei Konstanten: true und false.

Integer-Konstanten

Sie sind vorzeichenbehaftete Zahlen vom Typ 'int' und liegen im Bereich von -2.147.483.648 bis 2.147.483.647.

-23

Fließkomma-Konstanten

Sie sind vom Typ 'float' und bestehen einer vorzeichenbehafteten Mantisse, optional gefolgt von einem 'E' sowie einem vorzeichenbehafteten Exponent, der die Zehnerpotenz darstellt. Der Exponent liegt im Bereich von -4.931 bis 4.931.

98.283E-3 ; 0,098283

Komplexe Konstanten

Sie sind vom Typ 'complex' und bestehen aus zwei in Klammern stehenden Fließkommazahlen, die durch ein Komma voneinander getrennt sind. Imaginäre Zahlen können alternativ durch ein dahinterstehendes i gekennzeichnet werden.

2 + 1.63i ; (2, 1.63)

Farb-Konstanten

Sie sind vom Typ 'color' und werden erzeugt, indem konstante Argumente den rgb-, rgba-, hsl- und hsla-Funktionen zugewiesen werden.

hsla(0, 0, 0.5, 0.5) ; transparent rot

Variablen

Formeln setzen sich aus einer Vielzahl von Berechnungen zusammen, deren Ergebnisse mit Hilfe von Variablen im Speicher bewahrt werden. Bezeichner, die mit einem Buchstaben beginnen müssen, verweisen auf Variablen.

x
MeineVariable
var_32

Bezeichner können sowohl in Klein- als auch in Großbuchstaben geschrieben werden, es dürfen jedoch keine Schlüsselworte verwendet werden (siehe letzte Überschrift). Diese sind ausschließlich für den Compiler reserviert und erzeugen bei Verwenden eine Fehlermeldung.

Bevor Variablen gelesen werden können, muss in sie hineingeschrieben werden. Dazu wird der Zuweisungsoperator '=' verwendet.

z = @start

Eine Variable wird angelegt, wenn zum ersten Mal in sie hineingeschrieben wird. Die Voreinstellung für den Variablentyp ist 'complex'. Durch Vorstellen eines Typenschlüsselwortes (bool, int, float oder complex) kann der Variablentyp geändert werden. Es ist auch möglich, eine Variable vor dem Benutzen zu deklarieren.

int i
i = 10
complex y = (0,0)

Zuweisungen können ihrerseits wieder Ausdrücke sein, deren Resultate wiederum zugewiesen werden können. Den Werten x und y wird der Wert 1 zugewiesen.

x = y = 1

Um Variablen auszulesen, wird der Bezeichner des Ausruckes verwendet. Der Wert x wird ausgelesen und im Wert y gespeichert.

y = x

Auch folgende Berechnung ist möglich:

y = x * 3 + 7

Parameter

Damit ihr die Formeln anpassen könnt, ohne sie neu zu schreiben, werden Parameter benutzt. Diese werden wie Variablen benutzt, allerdings mit zwei Ausnahmen: es kann nicht in sie hineingeschrieben werden und es muss das @ vorangestellt werden, damit der Compiler sie als Parameter erkennt.

MeinMandelbrot(XAXIS_NOPARM) {
init:
  z = @start
loop:
  z = z^@power + #pixel
bailout:
  |z| <= @bailout

Die hier benutzten Parameter @start, @power und @bailout erscheinen nun im Karteireiter Formel (Formula), in denen ihr entsprechende Werte eintragen und somit das Aussehen des Fraktals beeinflussen könnt.

Der Parametertyp ist auf 'complex' voreingestellt, der jedoch im param-Block des default-Abschnitts der Formel verändert werden kann. In diesen param-Blöcken könnt ihr weitere Parameteraufzählungen spezifizieren.

default:
  title = "MeinMandelbrot"
  center = (-0.5, 0)
  helpfile = "Uf*.chm"
  helptopic = "Html\formulas\standard\mandelbrot.html"

  param start
    caption = "Starting point"
    default = (0,0)
    hint = "The starting point parameter..."
  endparam
  param power
    caption = "Power"
    default = (2,0)
    hint = "This parameter sets the exponent..."
  endparam
  float param bailout
    caption = "Bailout value"
    default = 4.0
    min = 1.0
    hint = "This parameter defines..."
  endparam
}

Auf diese Weise könnt ihr Parameter für Benutzerfunktionen erstellen, die wie normale Funktionen angewendet werden können, jedoch mit der Ausnahme, dass ihr die aktuelle Funktion aus einer Liste weiterer Funktionen auswählen könnt.

Hier eine Beispiel mit geändertem loop-Block:

loop:
  z = z^@power + @myfunc(z) + #pixel

Der hier verwendete Parameter @myfunc sorgt im Karteireiter Formel (Formula) dafür, dass nun eine Drop-Down-Liste mit einer Reihe weiterer Funktionen (sin, sqr, ident etc.) erscheint.

Die Parameteraufzählungen werden im func-Block des default-Abschnitts genauer spezifiziert.

  heading
    caption = "Change Function"
  endheading

  func myfunc
    caption = "first"
    default = atanh()
    hint = "Select a function to change the formula."
  endfunc

Zum Abschluss seien noch einige Hinweise aus der Hilfedatei von Ultra Fractal zitiert:

• Es ist zwar möglich in Parameter hineinzuschreiben, aber dies wird nicht empfohlen und kann Ihre Formel langsamer machen. Diese Möglichkeit wird nur aus Kompatibilitätsgründen zu alten Fractint-Formeln bereitgestellt.
• Es gibt sechs vordefinierte Parameter: p1…p6, dazu vier vordefinierte Funktionen: fn1…fn4. Sie brauchen bei diesen Parametern und Benutzerfunktionen das Präfix '@' nicht benutzen. Es wird dennoch empfohlen, dass Sie stattdessen ihre eigenen Namen benutzen (mit dem '@'-Präfix), damit die Formeln besser zu verstehen sind.
• Die 'param' und 'func'-Blöcke stellen zusätzlich Einstellungen zum Ändern der Werte für Benutzerfunktionen und der Parameter 'caption', 'minimum' und 'maximum' bereit. Zusätzlich können kleine Hilfe-Texte angegeben werden.
• Parameter werden im User-Interface solange alphabetisch sortiert, bis Sie einen 'param'-Block für jeden Parameter angeben. In diesem Fall erscheinen die Parameter in der Reihenfolge der 'param'-Blocks in der Formel-Datei.
• Im User-Interface können Sie durch zusätzliche Überschriften ebenfalls Parameter gruppieren.

Arrays

Ein Array ist eine Datenstruktur, die vom Programmierer selbst definiert wird und in der er mehrere Werte eines Datentyps ablegen kann. Bevor ihr das Array nutzen könnt, müsst ihr es deklarieren.

Der in eckigen Klammern stehende Index muss ein Integerwert zwischen 0 und der Anzahl der Elemente minus 1 sein.

int MeinArray[23]

Die Elemente in diesem Array könnt ihr wie normale Variablen nutzen. Es können auch mehrdimensionale Arrays deklariert warden, indem mehrere Werte innerhalb der eckigen Klammern stehen. Der Wert jeder Dimension muss ein konstanter Integerausdruck sein.

Parameter und die meisten vordefinierten Symbole sind als Konstaten verwendbar.

Farbe[255, 255, 255]
bool flags[#width, #height]
a[5, 10 – 2] = 1.5

Zu beachten ist, dass das Array nicht bei der Deklaration initialisiert wird. Stattdessen müssen die Elemente des Arrays explizit initialisiert werden, bevor auf sie zugegriffen wird.

Bedingungen

Gewisse Programmteile sollen nur ausgeführt werden, wenn bestimmte Kriterien erfüllt sind. Basis dieser Entscheidungen sind die sogenannten if-Statements.

Die Syntax lautet wie folgt:

if <Boole'scher Ausdruck>
  <Statements>
[elseif <Boole'scher Ausdruck>
  <Statements>]
[else
  <Statements>]
endif

Der Teil zwischen den eckigen Klammern ist optional.

Bool'sche Ausdrücke können mittels Vergleichsoperatoren verglichen bzw. durch logische Operatoren miteinander verknüpft werden. (siehe Operatoren)

if 8 > 4 && 8 > 2
  x = 8
elseif 4 > 2
  x = 4
else
  x = 2
endif

Die obige Konstruktion kann so gelesen werden: "Wenn die Bedingung 8 größer 4 UND 8 größer 2 erfüllt ist, dann (und nur dann) ist x gleich 8. Sonst wenn die Bedingung 4 größer 2 erfüllt ist, dann (und nur dann) ist x gleich 4, sonst ist x gleich 2."

Ihr könnt auch if-Statements so oft ineinander verschachteln wir ihr wollt, nur verliert dabei nicht irgendwann den Überblick.

Schleifen

In Ultra Fractal existieren zwei Konstrukte für Schleifen, zum Einen die while-Schleife und zum Anderen die repeat-Schleife.

Die Syntax beider Schleifen lautet wie folgt:

while <Boole'scher Ausdruck>
  <Statements>
endwhile

repeat
  <Statements>
until <Boole'scher Ausdruck>

Im Gegensatz zum if-Statement, das die Anweisung bei erfüllter Bedingung nur einmal ausgeführt und anschließend das Programm fortsetzt, wird bei der while-Schleife nach Ausführen der Anweisung wieder zurück zur Schleifenbedingung gesprungen und so lange wiederholt, wie der Bool'sche Ausdruck wahr ist. Ist der Bool'sche Ausdruck dagegen falsch, werden die Anweisungen gar nicht erst ausgeführt.

Die repeat-Schleife wiederholt die Anweisung so lange, bis der Bool'sche Ausdruck wahr wird.

Es ist wichtig dafür zu sorgen, dass Schleifen nicht nur bei Bedarf aufgerufen, sondern vor allem auch wieder abgebrochen werden.

Nachfolgend zwei Beispiele zum Ermitteln der Fakultät von 23.

int n = 23
float x = 1
while (n > 1)
  x = x * n
  n = n - 1
endwhile

int n = 23
float x = 1
if n > 1
  repeat
    x = x * n
    n = n - 1
  until n == 1
endif

Auch Schleifen könnt ihr beliebig oft verschachteln.

Schlüsselworte

Schlüsselworte sind Wörter, die ausschließlich dem Compiler vorbehalten sind und dürfen in Parametern sowie Variablen nicht verwendet werden. Hier die Liste der Schlüsselworte:

Ich wünsche Euch viel Spaß!

Neuron

Mit dem Programm Context Free könnt Ihr mit Hilfe einer kontextfreien Grammatik komplexe Bilder mit fraktalen Strukturen erzeugen. Dabei dienen Quadrate, Kreise, Dreiecke, Füllungen oder benutzerdefiniert Formen als Ausgangsbasis, die anschließend durch rekursives Wiederholen gedreht, verschoben bzw. verändert werden.

Context Free

Die generierten Bilder können als Grafik, als skalierbare Vektorgrafik (SVG) oder als Animation gespeichert werden. Hier die Animation für das oben dargestellte Bild.

Neuron von Oliver Konow.

Das Programm ist für unterschiedliche Betriebssysteme verfügbar und Ihr könnt es auf der Seite von Context Free Art runterladen.

Cumulus fractus

Cumulus fractus (Cu fra)

Weitere Objekte mit fraktaler Struktur sind am Himmel zu finden, die Wolken.

Um genau zu sein betrifft es "die Form der Grenze jenes Gebietes, in dem ein gewisses Merkmal des Fluids angetroffen wird."¹ Weil dadurch die Wolke keine bestimmbare Grenze besitzt, auch wenn es nicht so aussieht, muss die Wolkengrenze eine fraktale Fläche sein.

Die Dimension des Umfangs beträgt etwa 4/3.

Romanesco (Brassica oleracea convar. botrytis var. botrytis)

Romanesco

Eine Variante des Blumenkohls ist der Romanesco und in seinem Blütenstand ist die Selbstähnlichkeit zu erkennen, d.h. die Form des Gesamtobjektes spiegelt sich in der Form der kleinen Einzelrosetten wieder.

Ein weiterer Aspekt ist, dass die Rosetten spiralförmig angeordnet sind, deren Anzahl durch die Fibonacci-Folge gegeben ist. Bezüglich der Pflanzenachse sind die Rosetten im goldenen Winkel angeordnet, so dass die Pflanze damit die beste Lichtausbeute erreicht.

Der Versatz um ein irrationales Verhältnis des goldenen Winkels lässt zudem keine Perioden entstehen.

Abgesehen davon besticht der Romanesco durch seinen hohen Gehalt an Vitamin C. Guten Appetit!

Das Hintergrundbild steht Euch im Downloadbereich zur Verfügung.

Das Hintergrundbild steht Euch im Downloadbereich zur Verfügung.

Zwar ist Mode nicht so mein Ding, das sollte aber kein Grund sein, mich von den Farben inspirieren zu lassen.

Das folgende Fraktal diente als Ausgangsbasis:

Sommermode (Ausgangsbasis)

Hier die Fraktalbilder in den entsprechenden Farben:

Brombeer

Sommermode (Brombeer)

Hier der Link zum Originalbild.

Zitronengelb

Sommermode (Zitronengelb)

Hier der Link zum Originalbild.

Orange und Violett

Sommermode (Orange und Violett)

Hier der Link zum Originalbild.

Weiss

Sommermode (Weiss)

Hier der Link zum Originalbild.

Pastell

Sommermode (Pastell)

Hier der Link zum Originalbild.

Rot und Pink

Sommermode (Rot und Pink)

Hier der Link zum Originalbild.

Viel Spaß und genießt den Sommer!