01 October 1992

The content below is simply a reformatting of text as published decades ago by 9640 NEWS. The opinions and views expressed are not my (Jedimatt42) own. The content is published here to preserve and make accessible the technical data contained within.

Taken from the disk distributions archived at http://ftp.whtech.com/Geneve/9640 News disks v1-3/pc99 disks/

FLOATS_C


/* File FLOATS_C containing floating point function calls to MDOS To work properly, the resulting C object code must be linked with the WINLIB library for windows, which contains the code for XOP calls Written by Michael J Maksimik. Permission is granted to use this source in any program. Comments, improvements and suggestions are welcome, and any improvements to these routines will be greatly appreciated. Submit improvements or comments to Michael J Maksimik, 635 Mackinaw ave, Calumet City, IL 60409-4014. */ /* to declare a string variable, use the array declaration for characters.. char sample[10]; This will allow enough space for the 64-bit radix-100 numeral, in addition to two bytes for future use. All calls to the functions are by reference, by passing the name of the variable ( example t = trunc( sample );) Integers are passed by value, and literal strings may be passed ( example getfloat( "3.14159", pi ); will assign the value 3.14159 to the string variable pi which was declared as char pi[10] earlier in the program code ) */ #include <MATH_H> /* make sure this header file is in your header directory */ int registers[7]; /* don't use these for anything but xop calls */ int trunc( fl1 ) char *fl1; /* truncates a float to integer */ { /* first truncate the fraction */ registers[0] = GRI; registers[2] = fl1; xop( MATHXOP, registers ); registers[2] = registers[1]; registers[0] = CFI; xop( MATHXOP, registers ); return registers[1]; } int round( fl1 ) /* to the nearest whole number */ char *fl1; /* input must be -32768 <= n <= 32767 */ { registers[2] = fl1; registers[0] = CFI; xop( MATHXOP, registers ); return registers[1]; } void subfloat( fl1, fl2, fl3 ) char *fl1; /* fl3 = fl2 - fl1 */ char *fl2; char *fl3; { registers[0] = FSUB; registers[1] = fl3; registers[2] = fl1; registers[3] = fl2; xop( MATHXOP, registers ); } void mpyfloat( fl1, fl2, fl3 ) /* fl3 = fl2 * fl1 */ char *fl1; char *fl2; char *fl3; { registers[0] = FMULT; registers[1] = fl3; registers[2] = fl1; registers[3] = fl2; xop( MATHXOP, registers ); } void divfloat( fl2, fl1, fl3 ) /* fl3 = fl2 / fl1 */ char *fl1; char *fl2; char *fl3; { registers[0] = FDIV; registers[1] = fl3; registers[2] = fl1; registers[3] = fl2; xop( MATHXOP, registers ); } void tostring( fl1, str1 ) /* str1 = str$( fl1 ) */ char *fl1; char *str1; { int i; for( i=0; i<=15; i++ ) str1[i] = 0; registers[0] = CNS; registers[1] = str1; registers[2] = fl1; registers[3] = 1; registers[4] = 11; registers[5] = 0; xop( MATHXOP, registers ); } void getfloat( str1, fl1 ) /* fl1 = val( str1 ) */ char *str1; char *fl1; { registers[3] = strlen( str1 ); registers[2] = str1; registers[1] = fl1; registers[0] = CSN; xop( MATHXOP, registers ); fl1[9] = NULL; } void addfloat( fl1, fl2, fl3 ) /* fl3 = fl2 + fl1 */ char *fl1; char *fl2; char *fl3; { registers[0] = FADD; registers[1] = fl3; registers[2] = fl1; registers[3] = fl2; xop( MATHXOP, registers ); } void tofloat( i1, fl1 ) /* fl1 = float( i1 ) */ int i1; /* converts an integer to a float */ char *fl1; { registers[0] = CIF; registers[1] = fl1; registers[2] = i1; xop( MATHXOP, registers ); fl1[9] = NULL; } /* compares two floating point values. The algorithm checks the strings from left to right until an unmatching character is found, for a total count of 8 characters. The MDOS XOP FCOMP could not be used, since the C xop function only returns the EQUAL bit, and not the logical > bit. */ int compfloat( fl1, fl2 ) char *fl1; /* returns -1 if fl1 < fl2, 0 if fl1 == fl2 */ char *fl2; /* and 1 if fl1 > fl2 */ { int a; for( a=0; a<=7; a++ ) { if( fl1[a] < fl2[a] ) return -1; if( fl1[a] > fl2[a] ) return 1; } return 0; } } void assign( fl1, fl2 ) /* fl1 = fl2 */ char *fl1; char *fl2; { int i; for( i=0; i<=9; i++ ) fl1[i] = fl2[i]; } void sine( fl1, fl2 ) /* fl2 = sin(fl1 ) */ char *fl1; char *fl2; { registers[0] = SIN; registers[1] = fl2; registers[2] = fl1; xop( MATHXOP, registers ); } void cosine( fl1, fl2 ) /* fl2 = cos(fl1 ) */ char *fl1; char *fl2; { registers[0] = COS; registers[1] = fl2; registers[2] = fl1; xop( MATHXOP, registers ); } /* additional routines to be added, but by now you should get the picture. other functions, such as square root, exponentiation, involution, cube root, arc tangent, etc. can be added in a similar way */

FRACD1

  FFFFF  RRR    AAA    CCC  TTTTT   AAA    L       SSSS    !
  F      R  R  A   A  C       T    A   A   L      S        !
  FFF    RRR   AAAAA  C       T    AAAAA   L      SSSSS    !
  F      R  R  A   A  C       T    A   A   L          S
  F      R  R  A   A   CCC    T    A   A   LLLLL  SSSS     !    V1.3
							     27.7.92

Ein Freeware-Programm zum Untersuchen der Mandelbrotmenge f}r den GENEVE 9640

                     von Michael Zapf
                         Homburger Stra~e 2
                         D-6367 Karben 1

Mit Hilfe dieses Programms hat der an diesem besonders sch|nen Teilgebiet der Computergrafik Interessierte umfassende M|glichkeiten, fraktale Grafiken zu erzeugen, sie platzsparend (!) abzuspeichern und Vergr|~erungen direkt am Bildschirm (mittels eines Windows) zu definieren.

  1. Was sind fraktale Grafiken, und was ist die Mandelbrotmenge?

F}r jene, die sich darin schon auskennen, wird dieser Abschnitt wahrscheinlich nichts Neues beinhalten; ich m|chte aber dennoch kurz beschreiben, um was es geht. (Es wird aber ein bi~chen mathematisch!)

Jeder hat schon einmal den gew|hnlichen 'Zahlenstrahl' gesehen, der von minus unendlich }ber null zu plus unendlich l{uft (langes Lineal). Dieser Zahlenstrahl stellt die Menge der reellen Zahlen ("R") dar. Wie auch bekannt ist, kann man in R keine Wurzeln aus negativen Zahlen ziehen. Dies gelingt aber, wenn man neue "Zahlen" einf}hrt, die sich jeweils aus zwei "alten" zusammensetzen und "komplex" genannt werden. Sie bilden die Menge der komplexen Zahlen. Eine solche Zahl kann man als (a,b) notieren, wobei man a den Real- und b den Imagin{rteil nennt. Man setzt au~erdem fest: (a,0) ist die reelle Zahl a, (0,b) ist die imagin{re Zahl ib; (a,b)+(c,d)=(a+c,b+d), (a,b)*(c,d) = (a*c-b*d,a*d+b*c). Damit gilt, wie man nachrechnen kann: (0,1)*(0,1)=(-1,0)=-1, also ist (0,1) die Wurzel aus -1. Man bezeichnet (0,1) mit i. Dann kann man (a,b) auch als a+ib notieren. Zur Darstellung nimmt man nun nicht mehr einen Zahlenstrahl, denn i kann ja offenbar darauf nicht liegen. Man zeichnet einen zweiten Zahlenstrahl durch die Null des ersten und senkrecht zu diesem:

                  I
                 b+   * ------------> (a,b) bzw. a+ib
                  I
        ----------+---+-------->
                  I   a
                  I
                  I

Ein Schritt nach rechts ist eine Zunahme um +1, nach oben hingegen um +i. M|chte man bei einem Ma~stab von 1:1 cm zum Beispiel die Zahl (3,-4) eintragen, so geht man erst drei cm nach rechts und dann 4 cm nach unten; bei (3,4) gilt: 3 rechts, 4 hoch. Man nennt diese Darstellung die Gau~sche Zahlenebene.

Nun zu den Grafiken. Nimmt man eine gew|hnliche (reelle) Zahl, quadriert diese und addiert einen Wert, nimmt das Ergebnis, quadriert dieses, addiert denselben Wert wie vorhin usw. (nachvollziehbar mit jedem Taschenrechner), so wird das Ergebnis sich unterschiedlich verhalten, je nachdem, mit welcher Zahl man beginnt und welchen Wert man immer hinzuz{hlt. Meist wird es "ausbrechen" und }ber alle Grenzen wachsen. Es kann aber auch immer n{her der Null kommen oder sich einem anderen "Grenzwert" n{hern. Das Verhalten l{~t sich nat}rlich mit dem Computer untersuchen. Man f{ngt bei einer reellen Zahl c an und f}hrt folgende Berechnung durch:

 (1) x := 0
 (2) x := x * x + c

(Hei~t: Beginne bei null, ersetze x mit dem Ergebnis von x*x+c.)

Schritt (2) wiederholt man so lange, bis sich abzeichnet, wohin der Wert von x strebt. F}r positive c erkennt man: Ist c>0.25, so w{chst x immer st{rker und strebt gegen unendlich. F}r c zwischen 0 und 0.25 strebt x gegen einen jeweils verschiedenen Wert, f}r negative c jedoch wird x ab -1.5 unkalkulierbar. x "h}pft" vom Negativen ins Positive, v|llig unregelm{~ig, fast wie zuf{llig. Jedoch handelt es sich nicht um Zufall, sondern um die Nichtvorhersehbarkeit der Berechnung. Mit komplexen Zahlen kann man diese Rechnung auch durchf}hren. Man definiert x=(x1,x2) und c=(c1,c2) und berechnet x * x + c mit den oben angegebenen Regeln. (Das Ergebnis ist (x1*x1-x2*x2+c1,2*x1*x2+c2).) Der Bildschirm besteht nun aus Zeilen und Spalten, die man wie ein Gitter }ber die oben erkl{rte Gau~sche Ebene legen kann. Nat}rlich betrachtet man nur einen Ausschnitt der Ebene, und so mu~ man angeben, welche Zahlen die Grenzen des Bildschirms darstellen. Dann wei~ man auch, wie gro~ die Schritte von einer Spalte (Zeile) zur n{chsten Spalte (Zeile) sind. Liegt der linke Rand bei 0, der rechte bei 511, der obere bei 211, der untere bei 0, dann liegt die Schrittweite in Spalten- und Zeilenrichtung jeweils bei 1, wenn es 212 Zeilen und 512 Spalten gibt. Nun kann man f}r jedes Pixel Zeilen- und Spaltenkoordinaten angeben, so da~ offenbar jedem Pixel auf dem Bildschirm ein genau festgelegter Wert c der Gau~schen Ebene zugeordnet wird, der sich aus Real- und Imagin{rteil als c=(c1,c2) zusammensetzt. Die oben genannte Rechnung wird nun auf dem Bildschirm derart ausgef}hrt, da~ man die Spalten jeder Zeile durchl{uft und den jeweiligen Wert c in die Formel einsetzt; dabei beginnt die Rechnung stets bei x=(0,0). Den Bildschirmr{ndern sind die schon erw{hnten Grenzen f}r c1 und c2 zugeordnet; dabei steigt c1 von links nach rechts, c2 von unten nach oben an. Seien c1min, c1max, c2min, c2max diese Grenzen. Die Eckpunkte des Bildschirms sind somit: oben links = (c1min,c2max), oben rechts = (c1max,c2max), unten links = (c1min, c2min) und unten rechts = (c1max,c2min).

Der Computer beginnt oben links und holt sich also f}r c den Wert (c1min,c2max). Dann beginnt die Berechnung (wie oben angegeben) mit diesem Wert f}r c, und der Computer beobachtet, wie sich x nach jedem Durchgang verh{lt. ]bersteigt x im Betrag einen bestimmten Wert (in diesem Programm die 10), so ist x nicht mehr zu bremsen. Der Anzahl, wie oft Schritt (2) an diesem Pixel f}r dieses c durchgef}hrt worden ist, ordnet man eine Farbe zu und gibt diese an dieser Position aus (Verf}gt man nicht }ber genug Farben, so f{ngt man wieder bei der ersten an, wenn man hinten angekommen ist, oder man benutzt eine spezielle F{rbemethode; siehe unten). Jedoch kann es sein, da~ x sich einem bestimmten Wert n{hert bzw. "wild umherh}pft", aber nicht ausbricht. Dann f{rbt man diese Stelle schwarz, sobald man eine gewisse Zahl von "Iterationen" (Berechnungsdurchg{nge) zur}ckgelegt hat. Man sagt, der Punkt (c1,c2) geh|re dann der Mandelbrotmenge an, benannt nach ihrem Entdecker Benoit Mandelbrot.

Nun l{uft der Computer eine Spalte nach rechts, um die Berechnung mit einem neuen Wert f}r c von vorne durchzuspielen. Kommt man mit c1 rechts bei c1max an, so wird c1 wieder auf c1min zur}ckgesetzt, und man geht mit c2 einen Schritt nach unten (also wie ein CR (Carriage Return) auf dem Drucker). Auch dieses wiederholt sich so lange, bis man unten bei c2min angekommen ist. Dann kann man die Grafik in ihrer Vollendung bewundern.

  1. Das Programm

FRACTALS! besteht aus einer Oberfl{che im Text-2-Modus und dem Hires-Bildschirm im Graphics-6-Modus mit 212 Zeilen und 512 Spalten. Bis jetzt wird noch kein Interlace zur Darstellung von 424 Zeilen benutzt; jedoch kann man das Interlace durch Dr}cken von CTRL-ALT-SHIFT (linke Seite) jederzeit aktivieren und wieder ausschalten (Beim Bet{tigen dieser Tasten kann auch die Bildschirmh|he mit 192 oder 212 Zeilen gew{hlt werden; sollte das Bild beim Bet{tigen kleiner werden, kann man durch mehrfaches Dr}cken derselben Tastenkombination die gew}nschte Darstellung erreichen.) Durch Interlace verschwinden die dunklen Linien in den Farbfl{chen, wobei ich aber raten w}rde, die Helligkeit des Bildschirm zu verringern, so da~ das Flackern des Bildes nicht so sehr auff{llt.

Da Interrupts erlaubt werden, wird der Bildschirm sich in der Regel nach einigen Minuten abschalten; dann gen}gt ein Druck auf eine beliebige Taste, um ihn wieder anzuschalten, was aber w{hrend der Grafikgenerierung erst am Ende einer Bildschirmzeile stattfindet. Die gedr}ckte Taste wird jedoch so lange im Tastaturpuffer gehalten, bis die Tastaturabfrage am Ende der Zeile ausgef}hrt wird.

Die Bedienung des Programms ist sehr bequem }ber Pull-Down-Men}s organisiert; zur Betrachtung und Generierung der Grafik wird auf das Hires-Bild umgeschaltet.

Zum Programmpaket geh|ren die Programme

 FRACTALS!1   --  Hauptprogramm (Teil 1)
 FRACTALS!2   --  Hauptprogramm (Teil 2)
 FRACD        --  diese Datei
 FPICT        --  das Standardbild
 FRACHIST     --  die Versionsliste

Das Programm ist mit Editor/Assembler-Option 5 ladbar, der einzugebende Dateiname ist 'FRACTALS!1'. Au~erdem ist ein Start aus MDOS }ber EXEC13 m|glich (TIMODE nicht vergessen!); das Programm l{uft (zumindest) auf den MDOS-Versionen 0.97H, 1.14, 1.14F.

Zur Generierung der Mandelbrotbilder werden KEINE INTEGERs benutzt, aber auch nicht das Flie~kommaformat des Betriebssystems. Vielmehr wird eine Art von Fixkommaarithmetik verwendet, die auf die schriftliche Addition und Multiplikation zur}ckgeht und wesentlich schneller abl{uft als das RADIX-100-Format. Dabei werden je Zahl 8 Bytes benutzt, wobei die ersten zwei die Vorkommastellen, die n{chsten jeweils eine (negative) Potenz von 256 darstellen. Die Zahl mit dem kleinsten Betrag ist demnach 1*(256 hoch -6), etwa 3.55E-15; die gr|~te Zahl liegt knapp unter 32768. Dies erscheint unn|tig, da die Iteration bei einem Betrag von x }ber 10 schon abbrechen kann und nicht einmal 127 erreicht, ist aber aus Zeitgr}nden zweckm{~iger (Orientierung auf Worten, Maschinenbefehle A und MPY!)

Au~erdem werden Addition, Fixkommabewegungen usw. und die Register im Bereich >F000 abgelegt - f}r Geneve-Kenner der hei~e Tip f}r schnelle Software, denn dieses On-Chip-RAM bewirkt eine bis zu 27 Prozent schnellere Berechnung! Zur Zeit ist dieses Programm nicht f}r den TI-99/4A tauglich, der mit einem V9938-Videoprozessor ausgestattet ist, denn es ist stark mausorientiert und verlangt eine Taste auf CRU >0038, was meines Wissens auf dem TI nicht gegeben ist; aber der Geneve ist doch weitaus besser geeignet, schon allein wegen der Geschwindigkeit. So erh{lt man beides - genaue und schnelle Berechnung.

Die Bedienung der Pull-Down-Men}s erfolgt mit der rechten Maustaste. Man dr}ckt sie und h{lt sie gedr}ckt, w{hrend man zuerst in der ersten Zeile die richtige Abteilung und dann im Men} den erw}nschten Punkt anf{hrt. Dort l{~t man sie los, und das jeweilige Unterprogramm wird gestartet. (Die Bedienung l{uft analog zur Workbench des Amiga.)

Zur Speicherung und zum Laden gibt es zwei Formate. Zum einen ist es das Format des Grafikprogramms MYART, das sich aber als zu platzaufwendig zur Speicherung von stark zerkl}fteten Grafiken erwies. Daher habe ich ein anderes Format entworfen, das diesem Problem Rechnung tr{gt.

 MYART-Format

 +----+-+------------+
 0    3 4           15    Bitnummer im Wort
  Farbe     Anzahl

'Anzahl' gibt an, wieviele Punkte gleicher Farbe (Bits 0-3) hintereinander in der Zeile stehen. Die Anzahl liegt allerdings immer unter 512, da jede Zeile f}r sich abgespeichert wird. Daher kann man ausn}tzen, da~ z.B. Bit 4 'frei' ist:

 FRACTALS-Format

 (1) +----+-0-+------------+      identisch mit MYART-Format
     0    3 4 5           15

 (2) +----+-1-+------------+
     0    3 4 5           15

Das Format (2) wird so interpretiert: Bits 0-3 geben die Farbe des Punktes an der aktuellen Position an. Bits 5-15 geben an, wieviele Nybbles (Halbbytes) nun noch folgen, die direkt auf den Bildschirm als Punkte gebracht werden. Diese werden in den folgenden Bytes genannt (wobei notfalls ein schwarzes Nybble erg{nzt wird, um auf Bytes zu kommen).

Beispiel: Statt 1002 4001 3003 F001 im MYART-Format hei~t es nun: 1806 1433 3F. Ein Algorithmus entscheidet, welches Format f}r die folgenden Pixel wohl g}nstiger sein k|nnte. Dies bringt eine wirklich {u~erst gute Platzeinsparung mit sich (f}r die Informatiker: Die Einsparung gegen}ber dem MYART-Format betr{gt im best-case fast 75%, im worst-case 0% und im average-case empirisch etwa 50%).

Au~erdem werden im ersten Sektor die Daten zum Bild festgehalten. Das Format ist DIS/FIX 255 (auch, um von den MYART-Bildern sich zu unterscheiden); der erste Sektor hat folgende Aufteilung:

 Byte 0: Hintergrundfarbe
 Byte 1: 'C' oder 'M'
 Bytes 2-33: Palette
 Bytes 34-67: xmin,xmax,ymin,ymax in RADIX-100, iter in INTEGER
 Bytes 68-71: Future Expansion, wie es so sch|n hei~t
 Bytes 72-254: Kommentartext in ASCII

Die folgenden Sektoren beinhalten dann Daten in den zwei m|glichen Formaten (1)/(2).

  1. Die Grafikgenerierung

Von links nach rechts erstreckt sich die x-Koordinate mit der linken Grenze xmin und der rechten xmax, von unten nach oben (gem{~ der Orientierung der imagin{ren Achse) l{uft die y-Koordinate von der unteren Grenze ymin zur oberen ymax.

Damit beginnt die Generierung gem{~ der obigen Erl{uterung im Punkt (xmin,ymax), l{uft nach rechts bis xmax, kehrt wieder zu xmin zur}ck und erniedrigt die y-Koordinate (in Richtung ymin), l{uft durch diese Zeile usw.

Die Generierung kann man mit dem Sprite verfolgen, was sich als besonders angenehm erweist, wenn sich die Berechnung in der Mandelbrotmenge befindet, wo schwarze Pixel auf schwarzen Hintergrund geplottet werden. Dann kann man erkennen, wo sich die Berechnung zur Zeit befindet.

Die Generierung kann durch Dr}cken der Taste ESC am Zeilenende unterbrochen werden. Zur Wiederaufnahme der Generierung siehe "Fortsetzung" unten. Ist die Grafik fertig, wartet der Computer auf den Druck der linken Maustaste oder ESC.

Neu in dieser Version sind die zwei F{rbemodi. Bekannt ist der hier als 'zyklisch' bezeichnete Modus; hier werden die 15 Farben zyklisch immer wieder durchlaufen, wobei die nullte Farbe (schwarz) f}r die Mandelbrotmenge benutzt wird. Der Vorteil dieser Methode ist eine leichte Berechnung der zur jeweiligen Iteration geh|renden Farbe. Das Problem hierbei ist jedoch, da~ gerade die interessanten Gebiete am Rand f|rmlich 'im Chaos versinken', weil dunkle und helle Farben willk}rlich beieinander stehen und alle Konturen 'verschmieren'.

Der andere, neue Modus ist der halbmonotone F{rbemodus. Hier wird ein wirkungsvoller Trick angewendet: Je zwei Farben werden abgewechselt, wobei man in der Farbpalette immer h|her klettert. Ein Beispiel:

zyklische Farbfolge (mit 8 Farben, 0=schwarz):

 1 2 3 4 5 6 7 1 2 3 4 5 6 7 1 2 3 4 5 6 7 ....

halbmonotone Farbfolge (mit 8 Farben, 0=schwarz):

 1 2 1 2 1 2 3 2 3 2 3 2 3 4 3 4 3 4 3 4 5 4 5 ...

Die Bezeichnung 'halbmonoton' habe ich gew{hlt, da die Farbnummern der ungeraden bzw. der geraden Iterationen f}r sich genommen eine monoton steigende Folge bilden.

Die Berechnung hier ist jedoch nicht ganz einfach. Da 'fr}he' Farben nur bei niedrigen Iterationen auftauchen d}rfen, gingen sie verloren, wenn man stets bei Iteration Nummer 1 losrechnen w}rde, aber auf dem ganzen Bild kein Punkt mit weniger als z.B. 10 Iterationen auftaucht. Daher mu~ vor Beginn der Generierung erst die minimale Iterationszahl bestimmt werden; dies findet in der Zeit statt, w{hrend 'Bitte warten...' hinter 'Status' gemeldet wird. Der Computer tastet hierbei nicht das ganze Bild ab, sondern nur den Rand.

Leider ist bei dieser F{rbemethode keine Nachiteration m|glich, da die Farbfolge aus der maximalen und der minimalen Iterationszahl errechnet werden mu~. Die maximale Iterationszahl kann also nicht ver{ndert werden. Hingegen ist ein Abbruch und die Fortsetzung m|glich.

Der F{rbemodus wird im Byte 1 des ersten Datensatzes im Fractals!-Format festgehalten (C f}r zyklisch, M f}r halbmonoton).

  1. Die Bedienung

Datei

Gegen}ber fr}heren Versionen dieses Programms hat sich hier einiges getan. Es stehen nur noch die Optionen 'Laden' und 'Speichern' zur Verf}gung. Hat man eine ausgew{hlt, wird ein Pop-Up-Fenster angezeigt, den Dateimanager. Er besteht aus einem Feld in der linken H{lfte, in dem Dateien und Verzeichnisse angezeigt werden, und aus Eingabe- und Schalterfelder in der rechten H{lfte. Schalter, Eingabefelder, Dateien und Verzeichnisse sind hier alle mit der linken Maustaste anzuw{hlen. Im Feld 'Ger{t' kann ein g}ltiger Ger{tename (ohne Punkt) wie DSK1, HDS1 usw. angegeben werden. Dann versucht der Computer, das Verzeichnis zu laden und zeigt den Inhalt links an, der mit den nebenstehenden Tasten auf- und abgerollt werden kann. Ein Name mit einem Dreieck stellt ein Unterverzeichnis dar, in das man einfach durch Anklicken kommt; das '..'-Verzeichnis ist das Vaterverzeichnis. Das Anklicken eines Dateinamens bef|rdert diesen in das Feld 'Datei' und erm|glicht das Laden oder Speichern. Beim Speichern ist es au~erdem m|glich, den Namen einzutippen.

Je nach Stellung des Schalters Myart-Fractals werden verschiedene Dateien angezeigt, und zwar nur solche mit passendem Format, so da~ es nicht m|glich ist, eine falsche Datei zu laden. Beim Speichern werden alle Dateien des Verzeichnissen angezeigt (damit man nicht versehentlich eine nichtangezeigte Datei }berschreibt).

Der aktuelle Pfad wird oben im Fenster angezeigt. In der unteren Zeile der Oberfl{che wird nun nur noch der Bildname angezeigt; nach Verlassen des Dateimanagers wird der Pfad aufbewahrt. Mit 'Abbruch' kann der Dateimanager, ohne zu laden oder zu speichern, verlassen werden. Ansonsten sollte die Bedienung des Dateimanagers keine Probleme bereiten.

Bild

'Bild zeigen' dient zum unbegrenzten Bewundern des Hires-Bildschirms, ungeachtet dessen Inhalts. R}ckkehr mit linker Maustaste oder ESC.

'Start global' l{~t die Berechnung starten, falls Bilddaten vorhanden sind. Diese erh{lt man aus geladenen Bildern oder durch Eingabe }ber Tastatur oder Window und nach dem ]bertragen. Der Bildschirm wird gel|scht, bevor die Generierung startet. Sollte der Bildschirm sich w{hrend der Generierung abschalten, gen}gt ein Tastendruck (au~er ESC). Zum Ende der aktuellen Zeile wird dann das Bild wieder angezeigt.

'Start lokal' dient der Erzeugung von Ausschnitten, die nicht den ganzen Bildschirm einnehmen oder der 'Nachiteration' auf bestehenden Grafiken . Hierbei kann man lokal eine u.U. weitaus h|here Iterationsgrenze w{hlen, um durch eine zu niedrig gew{hlte Grenze entstandene schwarze Bereiche neu zu berechnen. Achtung: Dieser Men}punkt ist nur im zyklischen F{rbemodus anw{hlbar!

Nach Wahl des Men}punkts fordert der Computer die Eingabe einer Iterationsgrenze im Kasten 'Bilddaten', wobei Bilddaten vorhanden sein m}ssen. (Diese erh{lt man n|tigenfalls durch ']bertragen' von eingetippten Ausschnittsdaten.) Durch Dr}cken der Enter-Taste kann man den vorgegebenen Wert akzeptieren. Auf dem Grafikbildschirm mu~ man nun mit der Maus den betroffenen Bereich eingrenzen (siehe dazu 'Zoom-Fenster' unten). Die Generierung kann mit der Taste ESC an jedem Zeilenende (innerhalb des Bereichs) unterbrochen werden.

Lokal erh|hte Iterationsgrenzen werden nicht gespeichert; man kann sie nat}rlich ggf. im Kommentarfeld anf}hren.

'Fortsetzung': Hiermit kann die Generierung nach Abbruch wiederaufgenommen werden, dabei kann das zu vollendende Bild auch zuvor geladen worden sein. Als neue Startzeile nimmt der Computer die oberste (komplett) schwarze Zeile, von der ab der Bildschirm rein schwarz ist.

Parameter

'Eingabe': Eingabe }ber Tastatur. Erlaubt sind f}r die Randwerte nur Werte zwischen -10 und +10; f}r die Iterationen von 10 bis 9999 (wer mehr m|chte, sei an andere handliche Computer wie z.B. Cray-X2 verwiesen, um keine unn|tige Zeit zu vergeuden). Au~erdem ist xmin < xmax und ymin < ymax. Der Editor l{~t nur bestimmte Zeichen zu, immer jedoch ENTER, DEL, ESC (nicht F9), Pfeil links und ERASE (F3).

'Zoom-Fenster': Hiermit ist es m|glich, auf dem Bildschirm einen Ausschnitt einzugrenzen und damit die Ausschnittsdaten zu erhalten (vorausgesetzt, es existieren Bilddaten). Als Zahl der Iterationen wird der Wert aus den Bilddaten angenommen. Bei Bedarf sind diese Werte per Tastatur editierbar. Zum Definieren des Windows Cursorpfeil in Position der oberen linken Ecke bringen, linke Maustaste dr}cken und halten, zur unteren rechten Ecke fahren, Maustaste loslassen. Es ist ratsam, das Verh{ltnis von Breite und H|he des Windows dem des Bildschirms anzun{hern, um Verzerrungen zu vermeiden. Den Grad der Verzerrung kann man im 'XY-Verh{ltnis' entdecken; der Wert sollte ziemlich genau 1 sein.

']bertragen': Die Ausschnittsdaten werden nochmals auf Plausibilit{t gepr}ft und als Bilddaten }bernommen. Das Bild wird nicht gel|scht, die alten Bilddaten sind jedoch verloren. (Dies erm|glicht, alte Bilder mit Werten auszustatten.) Nach Anwahl diesen Men}punktes ist die Fortsetzung einer abgebrochenen Generierung nat}rlich sinnlos und daher nicht m|glich.

'Kommentar': Editieren des Kommentars.

Verschiedenes

'Standardpalette': Stellt die Standardfarben wieder her, abh{ngig vom F{rbemodus, da geladene Bilder die Farben ver{ndert haben k|nnen. In einer sp{teren Version wird es auch eine M|glichkeit geben, die Palette einzustellen.

'F{rbemodus': Wechselt den F{rbemodus zwischen zyklisch und halbmonoton und l|scht den Bildschirm. Der aktuelle Modus wird in der unteren Zeile der Oberfl{che angezeigt.

'Bild l|schen': L|scht den Grafikbildschirm, verhindert aber auch die Fortsetzung einer Generierung.

'Beenden': Setzt die Videoregister wieder richtig und kehrt zum 'Master Title Screen' bzw. ins MDOS zur}ck. Bitte nicht CTRL-ALT-DEL benutzen, da sonst die Videoregister verstellt sind.

  1. Fehlermeldungen

Die Fehlermeldungen werden stets rechts unten hinter 'Status' angezeigt. Nach Tastendruck oder Dr}cken der linken Maustaste wird die Meldung durch 'OK.' ersetzt.

'Werte nicht plausibel': Die eingegebenen oder eingeladenen Werte k|nnen keine Randwerte f}r ein Fraktalbild sein. Sie k|nnen nicht als Bilddaten }bernommen werden. (Siehe auch oben (Eingabe))

'Keine Werte definiert': Es wurde versucht, die globale oder lokale Generierung zu starten oder ein Zoom-Fenster zu definieren, ohne da~ Bilddaten vorhanden sind.

'Keine Datei gew{hlt' erscheint, wenn im Dateimanager 'Laden' oder 'Speichern' gew{hlt wurde, ohne da~ ein Dateiname hinter 'Datei:' steht.

'Ger{t ung}ltig' bis 'Datei nicht gefunden' entsprechen den I/O-Fehlern 0 bis 7, deren Bedeutung bekannt sein sollte.

'Pfad zu lange' tritt auf, wenn im Dateimanager ein }ber 38 Zeichen langer Pfad (ohne Dateinamen) entsteht. Jedoch verhindern die derzeitigen DSR-Routinen einen solchen langen Pfad, so da~ diese Meldung gar nicht auftreten sollte.

'Falscher F{rbemodus': Es wurde ein 'lokaler Start' versucht, obwohl der F{rbemodus nicht zyklisch ist.

'Bitte warten...' ist keine Fehlermeldung und tritt nach Anwahl von 'Start global' bzw. 'Fortsetzung' auf. Es ist, je nach Iterationsh|he und Beschaffenheit der Grafik, eine Wartezeit von einigen Sekunden bis wenige Minuten zu erwarten.

'Fortsetzung unm|glich' wird angezeigt, wenn aus einem der oben genannten Gr}nde die Wiederaufnahme der Grafikgenerierung unzul{ssig ist.

  1. Schlu~bemerkungen

Dies sei soweit die Erkl{rung zu meinem Programm. Es wurde in 100% Maschinensprache geschrieben, modular aufgebaut und erlaubt zu jeder Zeit Interrupts. (Dies ist gerade beim Geneve etwas, was man sich angew|hnen sollte, um die Multitaskingf{higkeiten auszunutzen; auch wenn dies im TI-Modus kaum zum Tragen kommt. Eventuell k|nnte man aber auch eine Soundliste abarbeiten lassen, um w{hrend der Generierung ein wenig Musik zu h|ren.) Zur Erstellung wurde ein Geneve mit MDOS 0.97H benutzt.

Ob diese Version v|llig fehlerfrei ist, wird sich bei der Benutzung zeigen; ich habe bislang alle offensichtlichen 'Bugs' aufgesp}rt und beheben k|nnen. Beim Test mit der 'Standardversion' des GPL-Interpreters, welcher mit dem Geneve geliefert wird, habe ich keine Probleme feststellen k|nnen.

Wer weitere spezielle Informationen bekommen m|chte, m|ge sich doch einfach an mich wenden (Adresse siehe oben). Zu dem Themengebiet gibt es unz{hlige Publikationen in den Buchl{den; ich m|chte mich hier aber nicht zur Schleichwerbung f}r spezielle B}cher verleiten lassen.

Ich hoffe, dieses Programm erweist sich den interessierten Anwendern als n}tzlich und dem TI, vor allem dem Geneve, als ein Beitrag zum ]berleben.

Die M}he, diese Anleitung gelesen zu haben, hat sich gelohnt, denn hiermit teile ich mit, da~ man den Vorspann durch Dr}cken einer Taste w{hrend des Ladevorgangs }berspringen kann.

Wem dieses Programm gef{llt, der kann mir dies am besten durch die Zusendung eines kleinen Betrags, sagen wir mindestens 10 Mark, beweisen. Es freut mich, sagen zu k|nnen, da~ immerhin einige es }ber sich gebracht haben, mir wirklich 10 Mark zu schicken. All jene haben den Vorteil, gleich von mir die neuesten Versionen zu bekommen.

Der Inhalt der Dateien des Programmpakets ist weiterhin urheberrechtlich gesch}tzt (daher '(c)'), auch wenn ich jedem erlaube, das Programm in beliebiger Zahl zu vervielf{ltigen, sofern keine Geb}hren daf}r berechnet werden.

Das Recht auf Weiterentwicklung und Herausgabe neuer Versionen verbleibt bei mir. Das Programm darf nicht disassembliert oder in irgendeiner Weise ver{ndert werden. Jedoch bin ich bereit, Informationen }ber das Programm anzubieten (sogar kommentierte Quellcodes!)

Erw{hnen m|chte ich noch, da~ es zu diesem Softwaregebiet bereits weitere gute Programme wie FRACTALS (ohne '!') von Roland Meier (system-99-Group) gibt, das auch auf dem TI-99/4A mit 80-Zeichenkarte voll lauff{hig ist.

Ich glaube, es ist unn|tig darauf hinzuweisen, was passiert, wenn ich mein Programm trotz Warnung ver{ndert bei irgend jemandem vorfinde. Letztlich schneidet sich jener, der die paar Softwareautoren verprellt, die in der Zeit des i486 noch Programme f}r den Geneve oder TI schreiben, ins eigene Fleisch.

Michael Zapf

FRACD2

  FFFFF  RRR    AAA    CCC  TTTTT   AAA    L       SSSS    !
  F      R  R  A   A  C       T    A   A   L      S        !
  FFF    RRR   AAAAA  C       T    AAAAA   L      SSSSS    !
  F      R  R  A   A  C       T    A   A   L          S
  F      R  R  A   A   CCC    T    A   A   LLLLL  SSSS     !   V1.3E
							     7/27/92

A Freeware Program For Examining The Mandelbrot Set on the GENEVE 9640

                     by  Michael Zapf
                         Homburger Str. 2
                         D-6367 Karben 1
                         Federal Republic of Germany

This program is intended for those users interested in computer graphics to generate wonderful fractalish graphics; it can save the pictures in small-sized (!) files and magnify parts of loaded graphic screens by defining a zoom window.

1 - What are fractalish graphics, and what is the Mandelbrot set?

I suppose those of you familiar with the basics of Mandelbrot set generation could skip this paragraph as it does not contain anything new about it. However, I would like to describe some basic concepts (it could become a little mathematical!)

Most of you have already seen the representation of the real numbers using a long (exactly: infinite) ruler, going from minus infinity over zero to plus infinity. Furthermore, you should know that no square root exists of negative numbers; however, this can be solved by defining a new class of numbers consisting of two "old" real numbers which is called the "set of complex numbers C". An element of this set is represented as (a,b), where a is called real part and b is called imaginary part of the complex number (a,b). (a,0) is identified with a, thus being a real number. The addition and multiplication in this set is performed by the formulae: (a,b) * (c,d) = (a*c-b*d,a*d+b*c), (a,b) + (c,d) = (a+c,b+d). Obviously (0,1) * (0,1) = (-1,0) = -1, so that (0,1) may be called the square root of -1. (0,1) is also called "i", the imaginary unit. You can also write (a,b) as a+ib. Certainly i cannot be found in the real numbers, and therefore the set of complex numbers cannot be represented by a single "ruler" but with two of them crossed in a right angle with the zero being the common point of both axes:

                  I
                 b+   * ------------> (a,b) or a+ib
                  I
        ----------+---+-------->
                  I   a
                  I
                  I

One step to the right is equal to an increase by +1, one step upward is an increase by +i. If you want to mark the number (3,-4) you will have to move three units right and four down (+4 would mean: four up). This representation of complex numbers is called "Gaussian plane" (named after the German mathematician Carl Friedrich Gauss, 1777-1855). Now let's take a look at the graphic generation.

Take an ordinary (real) number, square it, add a special value, square this again, add the same special value and so on and watch the behaviour of the result (reproduceable with every calculator). In general it depends on the start value and the special value; in most cases, the results "explode", racing against infinity after some iterations (an iteration is the part of the calculation which is repeated). Another possibility is that the results converge toward a special number or jump between two or more seperate values. The process described in words is formally explained by the following lines:

Be c any real number; go through the following steps:

 (1) x := 0
 (2) x := x * x + c

(Meaning: Start with zero, replace x by the result of x*x+c.)

Step (2) must be repeated until it is obvious how the results behave. With c>0.25, x heads for infinity; between 0 and 0.25, x converges to a specific value, depending on c. However, with c<-1.5, x leaps frantically between different values, completely unpredictably. This calculation also be done using complex numbers: Defining x by (x1,x2) and c by (c1,c2) calculate x * x + c by using the above definitions of addition and multiplication (the result is (x1*x1-x2*x2+c1, 2*x1*x2+c2).

The computer screen consists of rows and columns, arranged as a grid which may be placed on the Gaussian plane. First, the values in the Gaussian Plane which stand for the left, right, upper and lower edge of the screen must be declared so that the steps from one row (or column) to another are known to the computer. For example, if the left edge rests on 0, the right one on 511, the upper edge on 211 and the lower one at 0, the increase is 1 for both rows and columns if the screen has a resolution of 212 rows by 512 columns. Now every pixel may be assigned a complex value (c1,c2) from the Gaussian plane; the iteration explained above is now performed for every pixel in a row and every row so that the iteration is started 110452 times until the whole screen is built up. The iteration always begins with x = (0,0).

As I already described the screen edges are borders for c1 and c2, where c1 rises from left to right and c2 from down to up. Be c1min, c1max, c2min, c2max these borders. Then the upper left corner is (c1min, c2max), the upper right corner (c1max,c2max), the lower left one (c1min,c2min) and the lower right one (c1max,c2min).

The computer starts at the upper left corner using (c1min,c2max) as the value for c. The iteration (as described above) starts with this value for c, and the computer watches the result after every iteration. In case the absolute value of x exceeds a certain value (in this program 10), it cannot be stopped but drifts away to infinity. The number of iterations needed to let the absolute value of x pass the number 10 is assigned a color which is plotted at the current position. (If the number of colors is limited, say n, simply start over with the first color instead of the n+1st color; that means, cycle through the colors, or use a special trick for coloring, see below.) In case the absolute value of x has not exceeded the 10 after the maximum number of iterations have been performed (which surely has to be specified before) x is considered to be element of the Mandelbrot set and is plotted in black color (named after Benoit Mandelbrot). Therefore you should reserve the black color for the Mandelbrot set and skip it when cycling through the colors. After plotting the point the computer advances to the next column and re-starts the iteration with a new value for c. This process continues until the right edge is reached; then the next line will be begun until line 211 is completed.

Now you may look at the marvellous result on your computer screen.

2 - The program

FRACTALS! consists of a menu screen in text-2 mode and the high resolution screen in graphics-6 mode using 212 rows and 512 columns. Currently no interlace is used for the display of 424 rows; however, you may switch to interlace mode by pressing CTRL-ALT-SHIFT on the left side of the keyboard. (Sometimes the screen height is reduced after pressing these keys. Then you have switched to 192 rows. Repeat pressing these keys until you have reached the desired display mode.) With interlace on, the dark lines in colored areas disappear; yet I would suggest to reduce the screen brightness or contrast to avoid flickering pictures.

The program allows interrupts; therefore the screen will blank out after some minutes. You can turn on the screen again when you press any key; during graphics generation, however, this will not take any effect until the end of a screen line is reached (at this point the key scan routine is invoked). You need not take care to catch the end of the screen line (what should be impossible because the screen is blank!) as any keystroke is stored in the keyboard buffer until the key scan routine is called.

The menu screen is organized by pull down menus; you can swap to the hires screen to look at the graphics.

The program package contains the following files:

 FRACTALS!1   --  Main program (part 1)
 FRACTALS!2   --  Main program (part 2)
 FRACD        --  This very file
 FPICT        --  The standard Mandelbrot set picture
 FRACHIST     --  A list of versions

The program can be loaded via Editor/Assembler option 5; the file name to be entered is 'FRACTALS!1'. You may also start FRACTALS! via EXEC13 in MDOS (do not forget TIMODE!); supported MDOS versions are 0.97H, 1.14, 1.14F (at least).

The graphic generation neither uses integers nor the build-in slow floating point routines. I have written special routines that take full advantage of the 'MPY' and 'A' commands of the microprocessor. A number in this format is coded in eight bytes (better: four words) where every byte specifies a power of 256, like in the decimal system where powers of 10 are used. The first word stands for the whole portion of the number and the remaining three words for the fractional part. Thus the smallest positive value is 256 raised to the -6th power (equal to 65536 power -3), approximately 3.55E-15, the greatest positive number is 32767.9999... This may seem unnecessary since the iteration breaks up an absolute value of 10, but the calculation is faster than using only one byte for the integer part. The negative value of a number is computed by calculating the 2's complement of the 64 bit number, that means, invert all bits and add a one to the last position (considering all subsequent carries).

All frequently used arithmetical operations are stored in RAM positions starting at >F000 - this means FAST calculation since the Geneve microprocessor TMS 9995 has got its on-chip RAM at this position. Currently this program may not be used on the TI with a V9938 video chip because it requires a three-button mouse with one button at CRU >0038 which is not available on the TI; furthermore, the TI does not have on-chip RAM and therefore calculation is significantly slower.

The selection of items in the pull down menus is possible with the right mouse button. Depress this button and hold it while selecting the correct topic in the head line, then proceed to the right item in the selected pull down menu; here you have to release the mouse button (similar to the Workbench of the Amiga).

There are two safe and load formats for the pictures. The first is the MyArt compatible format (Dis/Fix 128) which proved to be too space-consuming for complex fractalish pictures. To reduce file sizes I invented a new format, referred to as the Fractals format.

MyArt format

 +----+-+------------+
 0    3 4           15    Bit position
  Color     Length

Length describes the number of consecutive pixels of the same color (bits 0-3) starting from the current position in a row. Length cannot grow larger than 512 since the format is line-oriented and stops at the end of every line. This means that there are vacant bit position (e.g. bit number 4) useful for further information:

Fractals format

 (1) +----+-0-+------------+      identical with MyArt format
     0    3 4 5           15

 (2) +----+-1-+------------+
     0    3 4 5           15

Format (2) is to be interpreted as follows: Bits 0-3 are the color of the pixel at the current position; bits 5-15 inform about the number of nybbles following this word which have to be plotted as consecutive points, each with its own color. One dummy nybble may be added to get to the byte boundary.

Example: Instead of 1002 4001 3003 F001 in the MyArt format the Fractals format would read like this: 1806 1433 3F. An algorithm decides which format ((1) or (2)) to take to save as much space as possible. This works out in a considerably reduced file size (for the computer scientists among you: best case appr. 75%, worst case 0%, average case (empirically) appr. 50% reduction compared to MyArt format).

Furthermore, picture data are stored in the first sector of the file which format is DIS/FIX 255 (also to be distinguished from the MyArt files). The structure of the first sector is listed below:

 Byte 0: Backdrop color
 Byte 1: 'C' or 'M'
 Bytes 2-33: Color palette
 Bytes 34-67: xmin,xmax,ymin,ymax in RADIX-100, iter in INTEGER
 Bytes 68-71: Future Expansion (hopefully)
 Bytes 72-254: Comments in ASCII

The following sectors are filled with picture data in the formats (1) and (2).

3 - The graphic generation

The x axis spreads from xmin on the left edge to xmax on the right, the y axis goes from ymin (down) to ymax (up) (according to the orientation of the imaginary axis). Thus the graphic generation starts at (xmin,ymax), proceeding to (xmax,ymax), returns to the left edge on the next line until the screen bottom is reached.

The generation may be observed with the multi-colored sprite. This has proved to be quite comfortable while the computer plots black pixels on the black screen (during calculating in the Mandelbrot set).

Depressing the ESC key interrupts the graphic generation at the end of the current line (to resume the generation refer to 'Continue' below). When the screen is complete, press the ESC key or the left mouse button to return to the menu screen.

This version includes a new, interesting feature, the semimonotonous coloring. The known coloring mode is referred to as 'cyclic mode'; here the color palette is wandered through several times as iterations grow, leaving out the color 0 which stands for the black Mandelbrot set. The advantage of this method is a simple and fast computation of the right color (in fact, it is a modulo calculation). The disadvantage is that the most interesting parts of the picture are washed away in chaos as the colors are cycling through rapidly and appear randomly next to each other, bright or dark.

To improve the display I added this new mode which uses an effective trick: Two colors are changed alternately, and the higher the iteration, the higher the two colors. Example:

cyclic color sequence (8 colors, 0=black):

 1 2 3 4 5 6 7 1 2 3 4 5 6 7 1 2 3 4 5 6 7 ...

semimonotonous color sequence (8 colors, 0=black):

 1 2 1 2 1 2 3 2 3 2 3 4 3 4 3 4 3 4 5 4 5 ...

Computation of the color is not so easy any more. If the computer did not consider the minimum iterations of a point on the screen, 'early' colors would be lost since they can only appear with low iterations. The minimum iterations are determined while 'Please wait...' is issued behind 'Status'.

However, no recomputation of parts of the picture is allowed since the color sequence needs the minimum and maximum iterations. Other values result in another coloring.

The coloring mode is stored in byte 1 of the first record in Fractals! format (C for cyclic, M for semimonotonous).

4 - Program usage

Files

A lot has happened here since the last versions of Fractals!. The user is provided a real file manager, including selecting files from a directory and handling subdirectories. The only options remaining are 'Save' and 'Load'. After selecting a pop-up window appears, the file manager. It consists of a list of files and directories on the left half and input fields and switches on the right half. Switches, input fields, files and directories are selected using the left mouse button. You can enter any valid device name (without period) in the input field 'Device:' such as DSK1, HDS1 and so on. The computer tries to load the directory and displays its contents on the left side which can be scrolled using the 'arrow' switches. A triangle before the directory entry specifies a subdirectory; the '..' directory represents the parent directory. Clicking on a file name copies it into the 'File:' field and enables saving or loading. If you want to save the file, you may as well type in the file name.

The position of the MyArt-Fractals! switch determines which files are displayed in the directory. Only those files are shown that are loadable as MyArt or Fractals! pictures. When you want to save a file, the complete directory is displayed so that no files are overwritten unintentionally.

The current path name is printed in the upper part of the window. Now the bottom line of the menu screen only contains the file name, whereas the path name is saved until the next call of the file manager.

The file manager can be left without saving or loading by selecting 'Abort'.

Picture

'Show picture' is used to look at the graphic screen (spending hours on wondering about the beauty of these pictures...). Return by depressing ESC or the left mouse button.

'Global start' starts the graphic generation if picture data are present which can be loaded from a saved file, keyed in or defined by a zoom window and transferred from window to picture data. The screen is cleared before the generation starts. During the picture generation the screen will blank out after some minutes; just press any key (except ESC) to restore it (this will happen when the computation reaches the end of the current line)

'Local start' is used to generate small areas of the picture or to re-compute areas of a given picture which became black due to too few iterations. Here the number of iterations can be chosen much higher than the iterations used to generate the picture. Note that this feature can only be selected in cyclic coloring mode!

After selecting this menu item the computer prompts for the entry of the maximum iteration number in the picture data box, provided that picture data are present (which can be typed in and transferred if necessary). You may also accept the default from the picture by pressing Enter.

On the graphic screen the computer allows a rectangular area to be defined for the local generation using the mouse (see 'Zoom window'). The local iterations are not saved to disk unless you mention them within the comments.

'Continue': This enables you to resume an interrupted graphic generation; the picture may even be loaded before. The new start line for the generation is the first black line of the black area filling the lower part of the graphics screen.

Parameters

'Key in': Enter the values with the keyboard. Valid values are between -10 and +10 for the coordinates and 10 to 9999 for the number of iterations (those of you who want more iterations are advised to refer to some faster handy computers like a Cray-X2 to avoid spending too much time). In addition, xmin is less than xmax, and ymin is less than ymax. The editor only allows special keys to be used; however, ENTER, DEL, ESC (not F9), arrow left and ERASE are active at any time.

'Zoom window': This feature allows the definition of a window (on an existing picture) the data of which are useable as new picture data so that rectangular portions may be magnified. To use this feature picture data must be present. The number of iterations is supposed to be the number of iterations of the main picture but can be edited manually. The definition of the window is achieved as follows: Move the pointer to the upper left edge of the desired portion, depress the left button, move to the lower right edge; then release the mouse button. It is strongly recommended that the window have the same proportions as the monitor screen to avoid distortions. You can watch the distortion with the XY-ratio which should be near 1.

'Transfer': The window data are checked for validity and then moved to the picture data box, replacing the old values. The graphic screen is not cleared, thus making it possible to assign values to a loaded file with false or no data. After selecting this menu item the 'Continue' feature is disabled and issues an error when being chosen.

'Comments': Editing the comments.

Miscellaneous

'Default palette': Restores the standard colors, depending on the coloring mode. After loading a picture file the colors could have been modified. Later versions of this program include the modification of the palette.

'Coloring mode': Toggles between 'cyclic' and 'semimonotonous' and clears the screen. Disables 'Continue'.

'Clear screen': Clears the graphic screen. Disables 'Continue'.

'End of session': Places the standard values in the video registers and returns to the master title screen or to MDOS. Please do not use CTRL-ALT-DEL.

  1. Error messages

All error messages are displayed behind 'Status:'. After depressing any key or the left mouse button the message is replaced by 'OK.

'Invalid values': The values entered from keyboard or from a loaded file cannot be used for graphic generation and are not accepted as picture data. Cf. 'Key in'.

'No values defined': You have attempted to start the generation (global or local) or to define a zoom window without valid picture data.

'No file selected' appears when you try to save or load a picture and no file name is standing behind 'File:' in the file manager.

'Invalid device' ... 'File not found' correspond to the well-known I/O errors 0 to 7.

'Path too long' appears when the path name in the file manager exceeds 38 characters (without the file name). However, the current DSR routines do not support path names of this length, so this message should never come.

'Wrong coloring mode': You have tried to perform a 'Local start' in the semimonotonous coloring mode.

'Please wait...' is no error message and is issued after acivating a global start or continue in the semimonotonous coloring mode. Please allow for a delay time from some seconds to some minutes.

'Continue impossible' is displayed if 'Continue' is disabled for one of the above reasons.

6 . Some last words

This concludes the description of my program which is written in 100% machine language consisting of several program modules on a Geneve 9640 with MDOS 1.14F. Interrupts are enabled through all the time. (This should become a good habit for Geneve programmers because the Geneve is capable of multitasking; even though this is not very relevant for the TI mode. However, you might want to add some music to the graphic generation; the computer can process interrupt sound lists.)

I hope that I found all errors in the program, but I cannot guarantee it so you are welcome to report to me any bug you dicovered. However, I have not found any problem using the 'standard' GPL interpreter delivered with the Geneve.

If you would like to get more specific information on my program, please write to the address listed at the beginning of this file. Computer graphics and Mandelbrot set generation is discussed thoroughly in many scientific magazines and other publications which are available at most book stores for little money.

I hope this program proves to be useful for those of you interested in computer graphics and to be my contribution for the survival of the TI and the Geneve.

Now you have nearly made it to the end of this manual, and I reward you by telling that the introduction screen can be skipped when a key is pressed during loading.

If some of you are pleased by this program please get a letter ready and send at least 10 dollars to my address as your freeware donation.

I still remain the only author of this program and keep the right to issue new versions of FRACTALS!. You must not disassemble or change this program. Yet everyone is asked to spread this program widely (charging special fees - more than the costs of postage and disks - is not allowed).

I guess it is not necessary to point out what will happen if I get any modified copy of my program by chance. I think everyone should be sensible enough to see that in times of the i486, Amigas, Ataris, work stations and so on fair play among the shrinking group of Geneve and TI users is very, very important.

Michael Zapf

GEME-DOCS

GEME

GEME is a product of Myarc, Inc., and recent updates by Beery Miller of 9640 News. Septemeber of this year (1991), Lou Phillips gave me permission to complete whatever I could on GEME and make it available to Geneve Owners however I desired. The Good guy that I am (grin), it will be released in it's finished form in 9640 News to all subscribers that are maintaining their subscription. There will be no additional fees, etc. incurred from this product.

During my development part of this program, several needs and interests to maintain compatibility across the whole possible Geneve User Base has been attempted. In doing such, I have set one standard that I am going to adhere too.

1) It will work with MDOS 0.97H.

I can make no other guarantees, except only say that it should work. If it doesn't work, UPGRADE!!!

Due to the various hardware configurations available and memory limitations, I am attempting to "solve" this by using disk based video memory overlays.

In other words, when a 'window' has been expanded to full screen, it's graphics page is stored as a 256 to 260 sector size file for rapid loading and saveing. Hard Drive usage is highly recommended. If it is not available, a separate version of the program (WM5) is available. Filename of WM will use the hard drive for all Screen storages.

Installation

To install the program on a HARD DRIVE, create a directory call GEME2 on HDS1 device. Anything other than that, you will have problems.

To use on Floppy based systems Only, initially create a RAMDISK large enough to hold 260 sectors X the number of graphic screens requiring storage. The DEMONSTRATION program can use up to 1040 sectors, possibly 1300 sectors if utilizing an additional option explained later.

If you wish to use a FLOPPY bases access other than DSK5, then sector edit the appropriate file (WM5) and change all occurences of DSK5 to DSK1/DSK9, etc.

Once you have installed the system (all files on the disk), type either WM or WM5 (hard drive or floppy drive versions) and you will see the introductory screen.

Now, what can you do once you are this far?????

Well, let's first discuss some things that are being fixed.

The most likely problem you will see happen is that the graphic characters are not always 100 % representative of their 80 column text mode friends. This is solvable, but is related to a bug caused by operating system in not correctly defining the table. This was going to be fixed once other things were in place instead of fixing a "cosmetic" bug.

This is essentially the only bug I know about right now, so how's that?

Well, once you have loaded the program, and pressed ENTER after seeing the introductory screen, several things can and will happen.

Next, you MUST press the MIDDLE mouse button to pull up a menu of menus that allow you to do things. The middle menu is the only thing that will allow you do something at this point. Select DEMONSTRATION at this point and the DEMO program will load according to which program (WM/WM5) you are using from the installed device (oh, allow enought room for those demo programs too on your installed device, I forgot that, sorry).

Here you will see 4 WINDOWS pop up in brilliant colors and text start printing in each area. After a few seconds, it will stop. Essentially this is the end of the DEMO, but the start of the Windows Manager (WM). The mouse buttons all play a very very important role here.

I am not going to go into detail here, I will save it for the official release, but you can do the following with the mouse.

NOTE: Being on different Menu Bars with the mouse pointer, or in the middle of screens, will all pull up different features.

Features that are available include:

Resizing a WINDOW
Moving a WINDOW
Expanding a WINDOW
Scrolling a previously Expanded window in a small screen
Shift the vertical split line left or right.
Hiding a WINDOW
Redisplaying a WINDOW
Proportionizing all WINDOWS (make them all same height)
Zapping a WINDOW permanently.

and much much more.

That's about all the instructions on the program I am going to give, the programming aspect is next.

As a programmer, 8 open WINDOWS are available at any single point in time. You must make sure on any coding that you account for the WINDOWS MANAGER closing the WINDOW and you must be prepared to take action if it happens (exiting, recreating, etc.)

Also, WM does all the graphics printing. You should not use any VIDEO XOP's as DRASTIC results can happen if they interfere with information that GEME is doing. GEME writes directly to the video ports and does not use the VIDEO XOP's once past the introduction screen.

GEME's screen is in the first 64K of VDP. The second page of VDP (64K) is not available as overlays are stored here. No IFS, ANDS, or BUTS.

A listing of the XOP's is included, although this list is not 100 % bug free, but should allow something simple to be used.

The GEME XOP is number >000C, whereas the VIDEO XOP is >0006.

You should not invoke interrupts in your program or use the KSCAN feature of MDOS. An opcode of GEME is available. Keys will be returned to the WINDOW that has the mouse pointer in it (and will be buffered if necessary). If the mouse pointer is not in it, no key will be detected.

A DROP to CLI is available, same interface as that available in WINDOWS 9640.

This program does not support any program currently available. WINDOWS 9640 will be supported as a hook to toggle between WINDOWS 9640 and GEME. GEME will never control previously written programs, and no attempt to do such will be made in the next year. They are two totally different BEASTS!!!

When handling the printing of text strings, it is recommended that all text lines be 80 chars in width. Anything less, when lines scroll a line will not be erased, anything more than 80 chars, they will not be printed. Routines were written to be quick (faster than MDOS).

Several other things. All video interrupts have been removed. If you write for some unknown reason to video (either XOP's or through ports), chances are that on MEMEX systems your programs will NOT run. It must be done by GEME, or you must check VIDEO STATUS after each command issued. Otherwise, distorted screens will appear (this is documented!!!!!).

For now, this is it. The rest will be published in a future issue of 9640 News. The source code for a demo program is included.

Beery Miller
10/13/91

P.S.

I have just "discovered" something that should be useful while you are experimenting. If you choose the command to SCROLL X or SCROLL Y in a minature window, the middle mouse button will toggle SCROLL X or SCROLLY direction. Use the Left and Right buttons to move either left and right or Up and Down. To ESCape from the scrolling feature. Release all mouse buttons then press the middle and right mouse button to retrieve the normal mouse pointer. If it doesn't immediately return, release the buttons again and repeat TOGETHER!!!

Enjoy for now!

SFX-DOCS

SFX PLAYER

MDOS Version

Copyright 1992 by 9640 News and Beery Miller

MDOS Requirements: Requires MDOS 0.97H or 1.14F. It may run using 1.14 if NOT using WINDOWS 9640 and ONLY the Windows Driver (WIN-DRIVE).

IMPORTANT NOTES

This program is being released with the permission of Barry Boone. All MDOS development has been my work excluding that portion of code that does the actual playing, written by Barry Boone, but obtained by disassembling source code. This program will ONLY play Sound FX files that have already been converted. If you find a VOC file you would like to convert, please buy Sound FX from Texaments.

Several people may see a similarity between SFX and DIGI-PORT. The screens and options are identical, method of playing is different. SFX plays sound directly to your monitor via your computer sound chip, while DIGI-PORT plays directly out the parallel port which is then plugged into your monitor. Two distinct differences can be noted. Sound FX is about $15 to $20, while DIGI-PORT is around $45 to $50. The second difference is that DIGI-PORT plays 8 bit data while SFX and Sound FX plays ~ 6 bit quality. There are differences in quality and they depend upon the sound file. DIGI-PORT is available from Bud Mills.

To Load:

1) First, either load the program WIN-DRIVE, or if you have WINDOWS 9640, run it.

2) Next, you must either select the Load Task Option of WINDOWS 9640, or load your specific version from the MDOS Command line.

3) If WINDOWS 9640 support is present, you will be presented with a Menu. If not, see the Suggestions area below.

4) Several options are available. You may Play a program, Load a Program, set the Delay Factor, Play the file in Reverse mode, or Quit.

Loading a File

A) Only sound files that have been converted with Barry Boone's Sound FX program will work with this program. No option is available to convert the file. If you want to convert the file, BUY Barry Boone's Sound FX program from Texaments.

B) Once a file is loaded, a default value is displayed for the format type along with information on the origination of the file. Included with this display is a Default Delay value that may be changed to Speed up or Slow down the file.

Delay

A) A delay value of 0 to 99 may be entered. Zero is the fasted, 99 is the slowest. Once a file has started playing, interrupting the file is not possible. Only change this factor if the speed of your file is not correct OR you want to distort the playback sound.

Playing a File

A) Press P to play a file. This will play the file from start to finish and return control to you once the file data has been played.

Reverse Playing a File

A) Pressing R will play the file in reverse. This will produce some very interesting sound effects. Use your imagination.

Cataloging a Device

A) Pressing C will prompt you for a Device Path to catalog. Enter any drive device (A:, B:, C:, DSK1., DSK2., etc) or any Path (F:\MDOS\, A:\SUB1\, etc.) and press enter. This will pass the string you entered to the MDOS CLI which will then present a directory to you. A normal display will include the file name and type, size, and the time and date stamp. If the optional /W is appended to the end of a Device path name, only the Filenames will be presented.

Quiting the Program

A) Press Q to quit and terminate the program.

Additional Information

Memory requirements of this program are tremendous. SFX PLAYER requires 80K to run, plus memory for the WINDOWS driver or program. It is suggested that while this program is compatible with WINDOWS, that it be run independent so that one can use very large data files.

When SFX Player for MDOS is loaded, it will try to use all available memory except for the last 16K. For maximum use, it is recommended that the RAMDISK and TIMODE options not be enabled. This allows for much larger sound files to be played back by SFX Player.

On a fully configured MEMEX system, run the program at 1 wait state, not TURBO speed. This allows all the memory access to be at one uniform speed and this does not play a data file that is occasionally fast or occasionally slow.

The 9640 News Auto Speed Detect File is a File that was a VOC file with a modified header to include the new filetype that has the appropriate delay value in the file.

The first sector of a VOC file begins with "Creative Voice". To convert this to a 9640 News Auto Speed Detect Filetype, Sector Edit the "tive" characters and replace with "NEWS" (Must be capitalized). At offset >8 (the word immediately following NEWS), is the delay value for the MDOS version of the data file. Modifying files in this format will insure that they are always played at the proper speed on your system and others using the MDOS version of DIGI-PORT.

Hopefully this short document file will answer all questions you have on it's use. If you have questions, please ask.