home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
Inside Multimedia 1995 August
/
IMM0895.ISO01.iso
/
magazin
/
optix
/
disk2
/
optxfpac.set
/
VARIABLE.INF
< prev
next >
Wrap
Text File
|
1995-01-18
|
13KB
|
337 lines
Variablen
Variablen haben in einem Programm dieselbe Funktion, wie wir sie aus der
Mathematik kennen. Sie werden als Platzhalter für Größen oder Ausdrücke
(numerische oder alphanumerisch) eingesetzt, deren Inhalte erst im Programm-
verlauf ermittelt und zugewiesen werden und sich im weiteren Programm ständig
verändern können. Wir wissen also entweder zum Zeitpunkt der Programmentwicklung
nur, 'daß' etwas in diesen Variablen abgelegt wird, aber noch nicht 'was', oder
wir weisen ihnen im Programmlisting Inhalte zu, die wir an den gegebenen Stellen
für notwendig halten.
Um keine Mißverständnisse aufkommen zu lassen, auf eine Art wissen wir im
ersten Fall schon, 'was' diese Variablen aufzunehmen haben (Texte oder Werte),
wir wissen nur nicht, welcher konkrete Inhalt es sein wird. Eine Entscheidung
hat man also von vorneherein selbst zu treffen. Nämlich, welcher Variablentyp
einzusetzen ist.
Es gibt zwei grundlegend verschiedene Typen von Variablen. Das eine sind die
numerischen, bzw. Werte-Variablen und das andere die alphanumerischen, bzw.
Text- oder auch Stringvariablen genannt.
Numerische Variablen haben die Aufgabe, Werte zu speichern.
NumVar:=(22+13/3)*36
Das Ergebnis dieser Berechnung wird der Variablen 'NumVar' zugewiesen. Solange
keine weiteren Werte an diese Variable übergeben werden, enthält sie nun also
das Ergebnis der rechtsstehenden Berechnung. Dieser Wert kann im Laufe des
Programms beliebig oft erfragt oder auch durch Neuzuweisungen verändert werden.
Bei arithmetischen Operationen ist zu beachten, daß OPTIX200 vorerst nicht über
Realberechnung verfügt. Diese Entscheidung wurde getroffen, da in einem
Animationssystem eine interne Realarithmetik den größten Teil aller
arithmetischen Vorgänge bis zum Faktor 20 langsamer werden lassen würde,
wodurch ein erheblicher Teil der Animationsdynamik zunichte gemacht werden
würde. Da die internen Zwischenrechnungen ebenfalls mit Integerwerten
durchgeführt werden, ist darauf zu achten, daß so - abhängig von der
Klammerstellung und von der Reihenfolge der Operationen - aus einem
arithmetischen Ausdruck mehrere Ergebnisse folgen können:
13/3*36 ergibt 144 (Integer(13/3) =4)*36
13*36/3 ergibt 156 (Integer(13*36)=468)/3
Daraus ergibt sich, daß z.B. bei möglichst genau gewünschten Interpolations-
ergebnissen zuerst zu multiplizieren und dann zu dividieren ist.
OPTIX verfügt über den numerischen Variablentyp LONG-INTEGER. Erlaubt sind
also nur Ganzzahlen, die intern als vorzeichenbehaftetes Longformat mit 4 Byte
Länge im Wertebereich von ca. -2.7Mrd. bis ca. +2.7Mrd. abgespeichert werden.
Integerzahlen sind Zahlen, die keine Nachkommastellen beinhalten können.
In Text-, bzw. Stringvariablen (String; engl.: Kette / Reihe / Schnur / Saite)
werden dagegen keine Werte, sondern Textzeichen abgelegt. Genaugenommen sind
diese Zeichen ebenfalls Werte, wie wir es an anderer Stelle schon kennengelernt
haben (ASCII-Zeichen). Nur bei dieser Art der Variablen 'weiß' OPTIX200, daß es
die hier abgelegten Werte nicht als Zahlen, sondern als ASCII-Zeichen zu
interpretieren hat. Vorausgesetzt, es wurde ihm klargemacht, daß es sich hier
um eine Stringvariable handelt. Das tut man, indem man durch den DEFS-Befehl
am Programmanfang den Namen der Variablen bei OPTIX200 anmeldet (deklariert).
In OPTIX200 ist es zwar nicht zwingend notwendig, aber als bessere Kennzeichnung
(zum Zwecke der eindeutigen Identifikation) innerhalb des Programms empfiehlt
es sich - wie auch z.B. in BASIC-Dialekten üblich, dem Variablennamen ein '$'
(Dollarzeichen - z.B. Var$) anzuhängen. Dieses ist dann nicht zu verwechseln
mit dem anführenden Dollarzeichen von Hexadezimal-werten (z.B. $A1F7)
Eine Stringvariable kann in OPTIX200 eine Zeichenkette mit einer Anzahl von bis
zu 255 einzelner Textzeichen aufnehmen. Die Länge, die eine solche Variable
speicherintern annimmt, hängt jeweils davon ab, wieviele Zeichen zugeordnet
wurden.
A$ :='OPTIX'
LEN(A$,Ln)
Die Funktion LEN liefert Ihnen in der num. Rückgabevariablen (hier: Ln) die
tatsächlich Zeichenlänge des übergebenen Textstrings (in diesem Fall den
Wert 5). Wenn Sie den ganzen Variableninhalt auf dem Bildschirm sehen wollen,
geben Sie
PRINT(A$)
ein und der String wird auf dem Bildschirm ausgegeben.
Wie bereits gesagt, muß eine Variable vor dem eigentlichen Beginn des Programms
definiert werden, d.h. bevor die Variable zum erstenmal benutzt wird, muß sie
dem Compiler/Encoder bekannt sein:
DEF(ZEIT, 100)
BEGIN
CLEARSCREEN(8)
PAUSE(1000)
SETCOLOR(14)
LINE(0,0,639,479,Zeit)
LINE(639,0,0,479,Zeit)
PAUSE(0)
END
Der Befehl DEF definiert einen numerischen Variablenbezeichner. Dieser
Variablenname hat 16 signifikante Stellen, d.h. nur die ersten 16 Buchstaben
werden zur Erkennung ausgewertet. Zulässig sind die Buchstaben A bis Z und @
als erstes Zeichen, sowie die Sonderzeichen $, %, & als mögliche Kennung
verschiedener Variablentypen (num. oder String). Für alle weiteren Zeichen
dürfen auch die Ziffern 0 bis 9 verwendet werden. Groß- oder Kleinschreibung
ist hierbei unerheblich.
Beispiel:
DEF(A)
DEF(ABC) (entspr. DEF(abc))
DEF(X0)
DEF(PUNKT23, 320)
DEF(I, -15)
DEF(K, $A0) (hexadezimale Eingabe mit
vorangestelltem $)
DEFS(Var)
DEFS(A_2$)
DEFS(Text$,'ABCabc123')
Optional kann hinter dem Variablenbezeichner ein Wert eingetragen werden.
Dieser Wert wird der Variable als Anfangswert zugewiesen. Wird kein Wert
angegeben, wird als Anfangswert Null eingesetzt. Weitere Wertzuweisungen
innerhalb des Programms sind mit folgendem Ausdruck möglich:
ZEIT := 100
Text$ := 'XYZxyz'
Alternativ könnte unser Programm dann folgendermassen aussehen:
DEF(ZEIT)
DEFS(Text$)
BEGIN
ZEIT := 100
STR(ZEIT,4,Text$)
CLEARSCREEN(8)
....
LINE(0,0,xmax,ymax,Zeit)
LINE(xmax,0,0,ymax,Zeit)
....
PRINTAT(100,100,Text$)
END
Es gelten folgende Werte-Systemvariablen intern als vorab definiert:
ON für 1
und
OFF für 0 (hier nicht verwendet; z.B. KEY(ON) )
oder:
TRUE für ungleich Null
und
FALSE für 0 (z.B. IF Flag=FALSE)
Matritzen und Vektoren
OPTIX ist ein Programmiersystem, daß auch komplexe Multimedia-Anwendungen
ermöglichen soll. In einem solchen System kommt man ohne eine weitere Gattung
der Variablentypen nicht aus. Man nennt sie FELDER oder ARRAYS ('array';
engl.: Aufstellung/Reihe/Ordnung).
Wer in der Schule gut aufgepaßt hat, weiß, daß man zur Berechnung einer
Funktionskurve mindestens zwei Größen benötigt. In den meisten Fällen werden
dies die Größen 'X' und 'Y' gewesen sein. Der Berechnungsvorgang ist der,
daß zu jeder angenommenen Größe 'X' anhand einer Funktionsgleichung die
Größe 'Y' zu ermitteln war. Aus den Schnittpunkten dieser beiden Größen
ergaben sich dann die Punkte der Kurve. Diese beiden Werte stellten auf die
jeweilige Funktion bezogen ein KOORDINATENPAAR dar. Um nun mit den jeweils
zusammengehörenden Ordinaten-Werten nicht durcheinanderzukommen, kann man
sich ein Feld einrichten.
Dieser Vorgang ist nichts anderes, als das, was wohl die meisten unter dem
Begriff WERTETABELLE kennen. Solch ein zweidimensionales Feld wird auch als
MATRIX bezeichnet, wovon jede einzelne Dimension einen VEKTOR darstellt.
MATRIX-Grafik (im Handbuch)
Ein VEKTOR (hier im Sinne von 'Einheitsvektor') ist dagegen im allgemeinen
Verständnis ein Feld, das nur eine Dimension besitzt und meist dazu verwendet
wird, um mehrere Werte, die zu einer bestimmten Gruppe gehören, unter einer
gemeinsamen 'Überschrift' (dem Variablennamen) zusammenfassen und ordnen zu
können.
Aufbau eines mehrdimensionalen Feldes
Stellen Sie sich bitte einen Schrank vor. Dieser Schrank wird nun in zwei
Hälften geteilt. Eine rechte und eine linke Hälfte. Innerhalb der Hälften
sind Schubladen untergebracht. Nehmen wir an, jede Hälfte besitzt zwei
Schubladen. Diese Schubladen werden nun wiederum in einzelne Fächer
unterteilt. In unserem Beispielfall erhält jede Schublade vier Fächer,
die jedes wiederum ein Register mit 50 Elementen enthält.
Wir haben nun also einen Schrank mit insgesamt 800 Register-Elementen
(2*2*4*50) eingerichtet. Die entsprechende Dimensionierung dazu:
DEFAI(Schrank,2,2,4,50)
Wir nehmen hier an, daß uns ein Datenformat in Wortbreite (2 Byte = -32.768
bis +32.767) ausreicht (deshalb DEFAI) woraus sich ein Speichergesamtbedarf
für dieses Feld von 800*2 = 1.600 Byte ergibt.
Angesichts der Tatsache, daß sich alle numerischen OPTIX-Felder den momentan
verbleibenden DOS-Arbeitsspeicher teilen können, wird erkennbar, daß es ohne
weiteres möglich ist, mehrere derartige Felder parallel zu verwalten. Bei
verbleibenden 64 KB RAM wären in unserem Beispielfall 40 Felder bei gleicher
Dimensionierung gleichzeitig möglich (64.000/1.600=40).
In diesem Schrank sollen nun verschiedene 'Dinge' untergebracht werden. In
unserem Fall sind dies Zahlen (hier z.B. : Datenbank-Index).
Zur besseren Orientierung ordnen wir den beiden Schrankseiten ersteinmal
Begriffe zu:
linke Seite => 'Bilder' (Index der 1.Dim = Schrank(1,...)
rechte Seite => 'Texte' (Index der 1.Dim = Schrank(2,...)
Den beiden Schubladen der 'Bilder'-Seite geben wir die Aufschriften:
1. Schublade => 'Photos' (Index der 2.Dim = Schrank(1,1,..)
2. Schublade => 'Grafiken' (Index der 2.Dim = Schrank(1,2,..)
Die Schubladen der 'Texte'-Seite bekommen die Namen:
1. Schublade => 'Prosa' (Index der 2.Dim = Schrank(2,1,..)
2. Schublade => 'Gedichte' (Index der 2.Dim = Schrank(2,2,..)
Grafik:Schrank1 (im Handbuch)
Nun erhalten die einzelnen Elementen ebenfalls einen Namen:
Grafik:Schrank2 (im Handbuch)
Bis hierhin mag es manchem als übertrieben erscheinen. Der Sinn der Sache ist
aber der, daß nun anhand von sogenannten 'Indizes' auf jedes einzelne 'Blatt'
der untersten Ebene zugegriffen werden kann.
Unter 'Index' versteht man allgemein ein Unterscheidungsmerkmal bzw. eine
Kennzeichnung gleichartiger Größen, die dann statt durch ihren Namen durch
einen ihnen zugewiesen Tabellenwert (Tabellenposition = 'Index') identifiziert
werden können.
z.B. Oberbegriff 'Tier'
----------------------------------
1 = 'Haus-'
2 = 'Nutz-'
3 = 'Raub-'
4 = 'Schalen-'
5 = 'Stachel-'
Statt des Begriffs 'Raubtier' könnte man nun auch 'Tier(3)' sagen und dann -
um die Bedeutung von (3) zu erfahren - in der Tabelle unter dem Index 3
nachschauen.
In unserem Fall hat jedes Fach der dritten Dimension noch 50 'Unter-Elemente'
zugewiesen bekommen, die nun belegt werden können. Die Titel der oberen
Dimensionen (Prosa, Erotik etc.) sind Sinnbegriffe, die die Orientierung
erleichtern sollen.
Um diesen Sinnbegriffen 'echte' Begriffe zuzuordnen - also um die
Identifikation der einzelnen Schrankseiten, Schubladen und der darin
enthaltenen Fächer zu vereinfachen - kann man Variablen definieren, die den
mit dem Begriff verbundenen Index speichern:
Bilder:=1
Photos:=1
Erotik:=1
Landschaft:=2
Makros:=3
Portrait:=4
Grafiken:=2
Layouts:=1
Raytrace:=2
Logos:=3
Skizzen:=4
Texte:=2
Prosa=1
Drama:=1
Tragödie:=2
Komödie:=3
Essay:=4
Gedichte:=2
Aphorismen:=0
Balladen:=1
Klassik:=2
Humor:=4
Jetzt fällt es natürlich leicht, z.B. gezielt in Erfahrung zu bringen,
welchen Datenbank-Zugriffsindex das 41. Blatt der Abteilung 'Logos' im
Fach 'Grafiken' der Schublade 'Bilder'im Feld 'Schrank' hat. Anhand dieser
Index-Variablen sind nun z.B. Ausdrücke folgender Art denkbar:
Index:=Schrank[Bilder,Grafiken,Logos,41]
Readdbentry(Index)
Readdbpic....
etc.
Mit diesem Ausdruck würde der Eintrag mit dem Index 41 (im übertragenen Sinn:
das 41. Blatt) aus der Abteilung 'Logos' des Faches 'Grafiken' der Schublade
'Bilder' im Feld 'Schrank' an die allgemeine Variable 'Index' zugewiesen.
oder:
IF Schrank(Texte,Prosa,Komödie,1]=0
PRINT "Haben Sie nichts zu lachen??'
ENDIF
oder durch
Schrank[Bilder,Photos,Erotik,6]:=286
kann natürlich auch etwas in dem Schrank abgelegt werden.