Seltsamerweise erwähnt die meiste Literatur zu Assemblersprachen nicht einmal die Existenz der FPU, oder floating point unit (Fließkomma-Recheneinheit), geschweige denn, daß auf die Programmierung mit dieser eingegangen wird.
Dabei kann die Assemblerprogrammierung gerade bei hoch optimiertem FPU-Code, der nur mit einer Assemblersprache realisiert werden kann, ihre große Stärke ausspielen.
Die FPU besteht aus 8 80–bit
Fließkomma-Registern. Diese sind in Form eines
Stacks organisiert—Sie können einen Wert durch
den Befehl push
auf dem
TOS (top of stack)
ablegen, oder durch pop
von diesem
holen.
Da also die Befehle push
und pop
schon verwendet
werden, kann es keine op-Codes in Assemblersprache mit diesen
Namen geben.
Sie können mit einen Wert auf dem
TOS ablegen, indem Sie
fld
, fild
, und fbld
verwenden. Mit weiteren op-Codes
lassen sich Konstanten—wie z.B.
Pi—auf dem TOS
ablegen.
Analog dazu können Sie einen Wert
holen, indem Sie fst
,
fstp
, fist
, fistp
, und fbstp
verwenden. Eigentlich
holen (pop
) nur die op-Codes, die auf
p enden, einen Wert, während die
anderen den Wert irgendwo speichern (store
)
ohne ihn vom TOS zu entfernen.
Daten können zwischen dem TOS und dem Hauptspeicher als 32–bit, 64–bit oder 80–bit real, oder als 16–bit, 32–bit oder 64–bit Integer, oder als 80–bit packed decimal übertragen werden.
Das 80–bit packed decimal-Format ist ein Spezialfall des binary coded decimal-Formates, welches üblicherweise bei der Konvertierung zwischen der ASCII- und FPU-Darstellung von Daten verwendet wird. Dieses erlaubt die Verwendung von 18 signifikanten Stellen.
Unabhängig davon, wie Daten im Speicher dargestellt werden, speichert die FPU ihre Daten immer im 80–bit real-Format in den Registern.
Ihre interne Genauigkeit beträgt mindestens 19 Dezimalstellen. Selbst wenn wir also Ergebnisse im ASCII-Format mit voller 18–stelliger Genauigkeit darstellen lassen, werden immer noch korrekte Werte angezeigt.
Des weiteren können mathematische Operationen auf dem TOS ausgeführt werden: Wir können dessen Sinus berechnen, wir können ihn skalieren (z.B. können wir ihn mit dem Faktor 2 Multiplizieren oder Dividieren), wir können dessen Logarithmus zur Basis 2 nehmen, und viele weitere Dinge.
Wir können auch FPU-Register multiplizieren, dividieren, addieren und subtrahieren, sogar einzelne Register mit sich selbst.
Der offizielle Intel op-Code für den
TOS ist st
und für die
Register st(0)
– st(7)
. st
und st(0)
beziehen sich dabei auf das
gleiche Register.
Aus welchen Gründen auch immer hat sich der
Originalautor von nasm dafür
entschieden, andere op-Codes zu verwenden, nämlich
st0
– st7
. Mit anderen Worten, es gibt
keine Klammern, und der TOS ist immer
st0
, niemals einfach nur
st
.
Das packed decimal-Format verwendet 10 Bytes (80 Bits) zur Darstellung von 18 Ziffern. Die so dargestellte Zahl ist immer ein Integer.
Sie können durch Multiplikation des TOS mit Potenzen von 10 die einzelnen Dezimalstellen verschieben.
Das höchste Bit des höchsten Bytes (Byte 9) ist das Vorzeichenbit: Wenn es gesetzt ist, ist die Zahl negativ, ansonsten positiv. Die restlichen Bits dieses Bytes werden nicht verwendet bzw. ignoriert.
Die restlichen 9 Bytes enthalten die 18 Ziffern der gespeicherten Zahl: 2 Ziffern pro Byte.
Die signifikantere Ziffer wird in der oberen Hälfte (4 Bits) eines Bytes gespeichert, die andere in der unteren Hälfte.
Vielleicht würden Sie jetzt annehmen, das
-1234567
auf die folgende Art im
Speicher abgelegt wird (in hexadezimaler Notation):
Dem ist aber nicht so! Bei Intel werden alle Daten im little–endian-Format gespeichert, auch das packed decimal-Format.
Dies bedeutet, daß -1234567
wie folgt gespeichert wird:
Erinnern Sie sich an diesen Umstand, bevor Sie sich aus lauter Verzweiflung die Haare ausreißen.
Das lesenswerte Buch—falls Sie es finden können—ist Richard Startz' 8087/80287/80387 for the IBM PC & Compatibles. Obwohl es anscheinend die Speicherung der packed decimal im little–endian-Format für gegeben annimmt. Ich mache keine Witze über meine Verzweiflung, als ich den Fehler im unten stehenden Filter gesucht habe, bevor mir einfiel, daß ich einfach mal versuchen sollte, das little–endian-Format, selbst für diesen Typ von Daten, anzuwenden.
Um sinnvolle Programme zu schreiben, müssen wir nicht nur unsere Programmierwerkzeuge beherrschen, sondern auch das Umfeld, für das die Programme gedacht sind.
Unser nächster Filter wird uns dabei helfen, wann immer wir wollen, eine Lochkamera zu bauen. Wir brauchen also etwas Hintergrundwissen über die Lochblendenphotographie, bevor wir weiter machen können.
Die einfachste Form, eine Kamera zu beschreiben, ist die eines abgeschlossenen, lichtundurchlässigen Raumes, in dessen Abdeckung sich ein kleines Loch befindet.
Die Abdeckung ist normalerweise fest (z.B. eine Schachtel), manchmal jedoch auch flexibel (z.B. ein Balgen). Innerhalb der Kamera ist es sehr dunkel. Nur durch ein kleines Loch kann Licht von einem einzigen Punkt aus in den Raum eindringen (in manchen Fällen sind es mehrere Löcher). Diese Lichtstrahlen kommen von einem Bild, einer Darstellung von dem was sich außerhalb der Kamera, vor dem kleinen Loch, befindet.
Wenn ein lichtempfindliches Material (wie z.B. ein Film) in der Kamera angebracht wird, so kann dieses das Bild einfangen.
Das Loch enthält häufig eine Linse, oder etwas linsenartiges, häufig auch einfach Objektiv genannt.
Streng genommen ist die Linse nicht notwendig: Die ursprünglichen Kameras verwendeten keine Linse, sondern eine Lochblende. Selbst heutzutage werden noch Lochblenden verwendet, zum einen, um die Funktionsweise einer Kamera zu erlernen, und zum anderen, um eine spezielle Art von Bildern zu erzeugen.
Das Bild, das von einer Lochblende erzeugt wird, ist überall scharf. Oder unscharf. Es gibt eine ideale Größe für eine Lochblende: Wenn sie größer oder kleiner ist, verliert das Bild seine Schärfe.
Dieser ideale Lochblendendurchmesser ist eine Funktion der Quadratwurzel der Brennweite, welche dem Abstand der Lochblende von dem Film entspricht.
Hier ist D
der ideale Durchmesser der
Lochblende, FL
die Brennweite und
PC
eine Konstante der Brennweite. Nach
Jay Bender hat die Konstante den Wert
0.04
, nach Kenneth Connors
0.037
. Andere Leute
haben andere Werte vorgeschlagen. Des weiteren gelten diese
Werte nur für Tageslicht: Andere Arten von
Licht benötigen andere konstante Werte, welche nur
durch Experimente bestimmt werden können.
Der f–Wert ist eine sehr nützliche Größe, die angibt, wieviel Licht den Film erreicht. Ein Belichtungsmesser kann dies messen, um z.B. für einen Film mit einer Empfindlichkeit von f5.6 eine Belichtungsdauer von 1/1000 Sekunden auszurechnen.
Es spielt keine Rolle, ob es eine 35–mm- oder eine 6x9cm-Kamera ist, usw. Solange wir den f–Wert kennen, können wir die benötigte Belichtungszeit berechnen.
Der f–Wert läßt sich einfach wie folgt berechnen:
Mit anderen Worten, der f–Wert ergibt sich aus der Brennweite (FL), dividiert durch den Durchmesser (D) der Lochblende. Ein großer f–Wert impliziert also entweder eine kleine Lochblende, oder eine große Brennweite, oder beides. Je größer also der f–Wert ist, um so länger muß die Belichtungszeit sein.
Des weiteren sind der Lochblendendurchmesser und die
Brennweite eindimensionale Meßgrößen,
während der Film und die Lochblende an sich
zweidimensionale Objekte darstellen. Das bedeutet, wenn
man für einen f–Wert A
eine Belichtungsdauer t
bestimmt hat,
dann ergibt sich daraus für einen f–Wert
B
eine Belichtungszeit von:
Während heutige moderne Kameras den Durchmesser der Lochblende, und damit deren f–Wert, weich und schrittweise verändern können, war dies früher nicht der Fall.
Um unterschiedliche f–Werte einstellen zu können, besaßen Kameras typischerweise eine Metallplatte mit Löchern unterschiedlichen Durchmessers als Lochblende.
Die Durchmesser wurden entsprechend obiger Formel gewählt, daß der resultierende f–Wert ein fester Standardwert war, der für alle Kameras verwendet wurde. Z.B. hat eine sehr alte Kodak Duaflex IV Kamera in meinem Besitz drei solche Löcher für die f–Werte 8, 11 und 16.
Eine neuere Kamera könnte f–Werte wie 2.8, 4, 5.6, 8, 11, 16, 22, und 32 (und weitere) besitzen. Diese Werte wurden nicht zufällig ausgewählt: Sie sind alle vielfache der Quadratwurzel aus 2, wobei manche Werte gerundet wurden.
Eine typische Kamera ist so konzipiert, daß die Nummernscheibe bei den normalisierten f–Werten einrastet. Die Nummernscheibe stoppt an diesen Positionen. Daher werden diese Positionen auch f–Stopps genannt.
Da die f–Werte bei jedem Stopp vielfache der Quadratwurzel aus 2 sind, verdoppelt die Drehung der Nummernscheibe um einen Stopp die für die gleiche Belichtung benötigte Lichtmenge. Eine Drehung um 2 Stopps vervierfacht die benötigte Belichtungszeit. Eine Drehung um 3 Stopps verachtfacht sie, etc.
Wir können jetzt festlegen, was genau unsere Lochblenden-Software tun soll.
Da der Hauptzweck des Programms darin besteht, uns beim Entwurf einer funktionierenden Lochkamera zu helfen, wird die Brennweite die Programmeingabe sein. Dies ist etwas, das wir ohne zusätzliche Programme feststellen können: Die geeignete Brennweite ergibt sich aus der Größe des Films und der Art des Fotos, ob dieses ein "normales" Bild, ein Weitwinkelbild oder ein Telebild sein soll.
Die meisten bisher geschriebenen Programme arbeiteten mit einzelnen Zeichen, oder Bytes, als Eingabe: Das hex-Programm konvertierte einzelne Bytes in hexadezimale Werte, das csv-Programm ließ entweder einzelne Zeichen unverändert, löschte oder veränderte sie, etc.
Das Programm ftuc verwendete einen Zustandsautomaten, um höchstens zwei gleichzeitig eingegebene Bytes zu verarbeiten.
Das pinhole-Programm dagegen kann nicht nur mit einzelnen Zeichen arbeiten, sondern muß mit größeren syntaktischen Einheiten zurrecht kommen.
Wenn wir z.B. möchten, daß unser Programm den
Lochblendendurchmesser (und weitere Werte, die wir
später noch diskutieren werden) für die Brennweiten
100 mm
, 150 mm
und
210 mm
berechnet, wollen wir etwa
folgendes eingeben:
100, 150, 210
Unser Programm muß mit der gleichzeitigen Eingabe
von mehr als nur einem einzelnen Byte zurecht kommen. Wenn
es eine 1
erkennt, muß es wissen,
daß dies die erste Stelle einer dezimalen Zahl ist.
Wenn es eine 0
, gefolgt von einer
weiteren 0
sieht, muß es wissen,
daß dies zwei unterschiedliche Stellen mit der
gleichen Zahl sind.
Wenn es auf das erste Komma trifft, muß es wissen,
daß die folgenden Stellen nicht mehr zur ersten
Zahl gehören. Es muß die Stellen der ersten
Zahl in den Wert 100
konvertieren
können. Und die Stellen der zweiten Zahl müssen
in den Wert 150
konvertiert werden.
Und die Stellen der dritten Zahl müssen in den Wert
210
konvertiert werden.
Wir müssen festlegen, welche Trennsymbole zulässig sind: Sollen die Eingabewerte durch Kommas voneinander getrennt werden? Wenn ja, wie sollen zwei Zahlen behandelt werden, die durch ein anderes Zeichen getrennt sind?
Ich persönlich mag es einfach. Entweder etwas ist eine Zahl, dann wird es verarbeitet, oder es ist keine Zahl, dann wird es verworfen. Ich mag es nicht, wenn sich der Computer bei der offensichtlichen Eingabe eines zusätzlichen Zeichens beschwert. Duh!
Zusätzlich erlaubt es mir, die Monotonie des Tippens zu durchbrechen, und eine Anfrage anstelle einer simplen Zahl zu stellen:
Was ist der beste Lochblendendurchmesser
bei einer Brennweite von 150?
Es gibt keinen Grund dafür, die Ausgabe mehrerer Fehlermeldungen aufzuteilen:
Et cetera, et cetera, et cetera.
Zweitens mag ich das #
-Zeichen, um
Kommentare zu markieren, die ab dem Zeichen bis zum Ende der
jeweiligen Zeile gehen. Dies verlangt nicht viel
Programmieraufwand, und ermöglicht es mir, Eingabedateien
für meine Programme als ausführbare Skripte zu
handhaben.
In unserem Fall müssen wir auch entscheiden, in welchen Einheiten die Dateneingabe erfolgen soll: Wir wählen Millimeter, da die meisten Photographen die Brennweite in dieser Einheit messen.
Letztendlich müssen wir noch entscheiden, ob wir die Verwendung des dezimalen Punktes erlauben (in diesem Fall müssen wir berücksichtigen, daß in vielen Ländern der Welt das dezimale Komma verwendet wird).
In unserem Fall würde das Zulassen eines dezimalen
Punktes/Kommas zu einer fälschlicherweise angenommenen,
höheren Genauigkeit führen: Der Unterschied
zwischen den Brennweiten 50
und
51
ist fast nicht wahrnehmbar. Die
Zulassung von Eingaben wie 50.5
ist
also keine gute Idee. Beachten Sie bitte, das dies meine
Meinung ist. In diesem Fall bin ich der Autor des Programmes.
Bei Ihren eigenen Programmen müssen Sie selbst solche
Entscheidungen treffen.
Das wichtigste, was wir zum Bau einer Lochkamera
wissen müssen, ist der Durchmesser der Lochblende. Da
wir scharfe Bilder schießen wollen, werden wir obige
Formel für die Berechnung des korrekten Durchmessers zu
gegebener Brennweite verwenden. Da Experten mehrere
Werte für die PC
-Konstante
anbieten, müssen wir uns hier für einen Wert
entscheiden.
In der Programmierung unter UNIX® ist es üblich, zwei Hauptvarianten anzubieten, um Parameter an Programme zu übergeben, und des weiteren eine Standardeinstellung für den Fall zu haben, das der Benutzer gar keine Parameter angibt.
Warum zwei Varianten, Parameter anzugeben?
Ein Grund ist, eine (relativ) feste Einstellung anzubieten, die automatisch bei jedem Programmaufruf verwendet wird, ohne das wir diese Einstellung immer und immer wieder mit angeben müssen.
Die feste Einstellung kann in einer Konfigurationsdatei
gespeichert sein, typischerweise im Heimatverzeichnis des
Benutzers. Die Datei hat üblicherweise denselben Namen
wie das zugehörige Programm, beginnt jedoch mit einem
Punkt. Häufig wird "rc" dem
Dateinamen hinzugefügt. Unsere Konfigurationsdatei
könnte also ~/.pinhole
oder
~/.pinholerc
heißen. (Die
Zeichenfolge ~/
steht für das
Heimatverzeichnis des aktuellen Benutzers.)
Konfigurationsdateien werden häufig von Programmen
verwendet, die viele konfigurierbare Parameter besitzen.
Programme, die nur eine (oder wenige) Parameter anbieten,
verwenden häufig eine andere Methode: Sie erwarten die
Parameter in einer Umgebungsvariablen.
In unserem Fall könnten wir eine Umgebungsvariable mit
dem Namen PINHOLE
benutzen.
Normalerweise verwendet ein Programm entweder die eine, oder die andere der beiden obigen Methoden. Ansonsten könnte ein Programm verwirrt werden, wenn eine Konfigurationsdatei das eine sagt, die Umgebungsvariable jedoch etwas anderes.
Da wir nur einen Parameter
unterstützen müssen, verwenden wir die zweite
Methode, und benutzen eine Umgebungsvariable mit dem
Namen PINHOLE
.
Der andere Weg erlaubt uns, ad hoc Entscheidungen zu treffen: "Obwohl ich normalerweise einen Wert von 0.039 verwende, will ich dieses eine Mal einen Wert von 0.03872 anwenden." Mit anderen Worten, dies erlaubt uns, die Standardeinstellung außer Kraft zu setzen.
Diese Art der Auswahl wird häufig über Kommandozeilenparameter gemacht.
Schließlich braucht ein Programm immer eine Standardeinstellung. Der Benutzer könnte keine Parameter angeben. Vielleicht weiß er auch gar nicht, was er einstellen sollte. Vielleicht will er es "einfach nur ausprobieren". Vorzugsweise wird die Standardeinstellung eine sein, die die meisten Benutzer sowieso wählen würden. Somit müssen diese keine zusätzlichen Parameter angeben, bzw. können die Standardeinstellung ohne zusätzlichen Aufwand benutzen.
Bei diesem System könnte das Programm widersprüchliche Optionen vorfinden, und auf die folgende Weise reagieren:
Wenn es eine ad hoc-Einstellung vorfindet (z.B. ein Kommandozeilenparameter), dann sollte es diese Einstellung annehmen. Es muß alle vorher festgelegten sowie die standardmäßige Einstellung ignorieren.
Andererseits, wenn es eine festgelegte Option (z.B. eine Umgebungsvariable) vorfindet, dann sollte es diese akzeptieren und die Standardeinstellung ignorieren.
Ansonsten sollte es die Standardeinstellung verwenden.
Wir müssen auch entscheiden, welches
Format unsere
PC
-Option haben soll.
Auf den ersten Blick scheint es einleuchtend, das
Format PINHOLE=0.04
für die
Umgebungsvariable, und -p0.04
für die Kommandozeile zu verwenden.
Dies zuzulassen wäre eigentlich eine
Sicherheitslücke. Die PC
-Konstante
ist eine sehr kleine Zahl. Daher würden wir unsere
Anwendung mit verschiedenen, kleinen Werten für
PC
testen. Aber was würde
passieren, wenn jemand das Programm mit einem sehr
großen Wert aufrufen würde?
Es könnte abstürzen, weil wir das Programm nicht für den Umgang mit großen Werten entworfen haben.
Oder wir investieren noch weiter Zeit in das Programm, so daß dieses dann auch mit großen Zahlen umgehen kann. Wir könnten dies machen, wenn wir kommerzielle Software für computertechnisch unerfahrene Benutzer schreiben würden.
Oder wir könnten auch sagen "Pech gehabt! Der Benutzer sollte es besser wissen."
Oder wir könnten es für den Benutzer unmöglich machen, große Zahlen einzugeben. Dies ist die Variante, die wir verwenden werden: Wir nehmen einen impliziten 0.-Präfix an.
Mit anderen Worten, wenn der Benutzer den Wert
0.04
angeben will, so muß er
entweder -p04
als Parameter angeben,
oder PINHOLE=04
als Variable in seiner
Umgebung definieren. Falls der Benutzer
-p9999999
angibt, so wird dies als
0.9999999
interpretiert—zwar
immer noch sinnlos, aber zumindest sicher.
Zweitens werden viele Benutzer einfach die Konstanten
von Bender oder Connors benutzen wollen. Um es diesen
Benutzern einfacher zu machen, werden wir
-b
als -p04
,
und -c
als
-p037
interpretieren.
Wir müssen festlegen, was und in welchem Format unsere Anwendung Daten ausgeben soll.
Da wir als Eingabe beliebig viele Brennweiten
erlauben, macht es Sinn, die Ergebnisse in Form
einer traditionellen Datenbank–Ausgabe darzustellen,
bei der zeilenweise zu jeder Brennweite der
zugehörige berechnete Wert, getrennt durch ein
tab
-Zeichen, ausgegeben wird.
Optional sollten wir dem Benutzer die Möglichkeit
geben, die Ausgabe in dem schon beschriebenen
CSV-Format festzulegen. In diesem Fall
werden wir zu Beginn der Ausgabe eine Zeile einfügen,
in der die Beschreibungen der einzelnen Felder, durch
Kommas getrennt, aufgelistet werden, gefolgt von der Ausgabe
der Daten wie schon beschrieben, wobei das
tab
-Zeichen durch ein
Komma
ersetzt wird.
Wir brauchen eine Kommandozeilenoption für das
CSV-Format. Wir können nicht
-c
verwenden, da diese Option bereits
für verwende Connors Konstante
steht. Aus irgendeinem seltsamen Grund bezeichnen
viele Webseiten CSV-Dateien als
"Excel Kalkulationstabelle" (obwohl das
CSV-Format älter ist als Excel). Wir
werden daher -e
als Schalter für
die Ausgabe im CSV-Format
verwenden.
Jede Zeile der Ausgabe wird mit einer Brennweite beginnen. Dies mag auf den ersten Blick überflüssig erscheinen, besonders im interaktiven Modus: Der Benutzer gibt einen Wert für die Brennweite ein, und das Programm wiederholt diesen.
Der Benutzer kann jedoch auch mehrere Brennweiten in einer Zeile angeben. Die Eingabe kann auch aus einer Datei, oder aus der Ausgabe eines anderen Programmes, kommen. In diesen Fällen sieht der Benutzer die Eingabewerte überhaupt nicht.
Ebenso kann die Ausgabe in eine Datei umgelenkt werden, was wir später noch untersuchen werden, oder sie könnte an einen Drucker geschickt werden, oder auch als Eingabe für ein weiteres Programm dienen.
Es macht also wohl Sinn, jede Zeile mit einer durch den Benutzer eingegebenen Brennweite beginnen zu lassen.
Halt! Nicht, wie der Benutzer die Daten eingegeben hat. Was passiert, wenn der Benutzer etwas wie folgt eingibt:
00000000150
Offensichtlich müssen wir die führenden Nullen vorher abschneiden.
Wir müssen also die Eingabe des Benutzers sorgfältig prüfen, diese dann in der FPU in die binäre Form konvertieren, und dann von dort aus ausgeben.
Aber...
Was ist, wenn der Benutzer etwas wie folgt eingibt:
17459765723452353453534535353530530534563507309676764423
Ha! Das packed decimal-Format der FPU erlaubt uns die Eingabe einer 18–stelligen Zahl. Aber der Benutzer hat mehr als 18 Stellen eingegeben. Wie gehen wir damit um?
Wir könnten unser Programm
so modifizieren, daß es die ersten 18 Stellen liest,
der FPU übergibt, dann weitere
18 Stellen liest, den Inhalt des TOS
mit einem Vielfachen von 10, entsprechend der Anzahl der
zusätzlichen Stellen multipliziert, und dann beide
Werte mittels add
zusammen
addiert.
Ja, wir könnten das machen. Aber in diesem Programm wäre es unnötig (in einem anderen wäre es vielleicht der richtige Weg): Selbst der Erdumfang in Millimetern ergibt nur eine Zahl mit 11 Stellen. Offensichtlich können wir keine Kamera dieser Größe bauen (jedenfalls jetzt noch nicht).
Wenn der Benutzer also eine so große Zahl eingibt, ist er entweder gelangweilt, oder er testet uns, oder er versucht, in das System einzudringen, oder er spielt— indem er irgendetwas anderes macht als eine Lochkamera zu entwerfen.
Was werden wir tun?
Wir werden ihn ohrfeigen, gewissermaßen:
Um dies zu erreichen, werden wir einfach alle
führenden Nullen ignorieren. Sobald wir eine Ziffer
gefunden haben, die nicht Null ist, initialisieren wir
einen Zähler mit 0
und
beginnen mit drei Schritten:
Sende die Ziffer an die Ausgabe.
Füge die Ziffer einem Puffer hinzu, welchen wir später benutzen werden, um den packed decimal-Wert zu erzeugen, den wir an die FPU schicken können.
Erhöhe den Zähler um eins.
Während wir diese drei Schritte wiederholen, müssen wir auf zwei Bedingungen achten:
Wenn der Zähler den Wert 18 übersteigt, hören wir auf, Ziffern dem Puffer hinzuzufügen. Wir lesen weiterhin Ziffern und senden sie an die Ausgabe.
Wenn, bzw. falls, das nächste Eingabezeichen keine Zahl ist, sind wir mit der Bearbeitung der Eingabe erst einmal fertig.
Übrigends können wir einfach Zeichen, die
keine Ziffern sind, verwerfen, solange sie kein
#
-Zeichen sind, welches wir an den
Eingabestrom zurückgeben müssen. Dieses Zeichen
markiert den Beginn eines Kommentars. An dieser Stelle
muß die Erzeugung der Ausgabe fertig sein, und wir
müssen mit der Suche nach weiteren Eingabedaten
fortfahren.
Es bleibt immer noch eine Möglichkeit unberücksichtigt: Wenn der Benutzer eine Null (oder mehrere) eingibt, werden wir niemals eine von Null verschiedene Zahl vorfinden.
Wir können solch einen Fall immer anhand des
Zählerstandes feststellen, welcher dann
immer bei 0
bleibt. In diesem Fall
müssen wir einfach eine 0
an
die Ausgabe senden, und anschließend dem Benutzer
erneut eine "Ohrfeige" verpassen:
Sobald wir die Brennweite ausgegeben, und die
Gültigkeit dieser Eingabe verifiziert haben,
(größer als 0
und kleiner
als 18 Zahlen) können wir den Durchmesser der
Lochblende berechnen.
Es ist kein Zufall, daß Lochblende das Wort Loch enthält. In der Tat ist eine Lochblende buchstäblich eine Loch Blende, also eine Blende, in die mit einer Nadel vorsichtig ein kleines Loch gestochen wird.
Daher ist eine typische Lochblende sehr klein. Unsere
Formel liefert uns das Ergebnis in Millimetern. Wir werden
dieses mit 1000
multiplizieren, so
daß die Ausgabe in Mikrometern
erfolgt.
An dieser Stelle müssen wir auf eine weitere Falle achten: Zu hohe Genauigkeit.
Ja, die FPU wurde für mathematische Berechnungen mit hoher Genauigkeit entworfen. Unsere Berechnungen hier erfordern jedoch keine solche mathematische Genauigkeit. Wir haben es hier mit Physik zu tun (Optik, um genau zu sein).
Angenommen, wir wollten aus eine Lastkraftwagen eine
Lochkamera bauen (wir wären dabei nicht die
ersten, die das versuchen würden!). Angenommen, die
Länge des Laderaumes beträgt 12
Meter lang, so daß wir eine Brennweite von
12000
hätten. Verwenden wir
Benders Konstante, so erhalten wir durch Multiplizieren
von 0.04
mit der Quadratwurzel aus
12000
einen Wert von
4.381780460
Millimetern, oder
4381.780460
Micrometern.
So oder so ist das Rechenergebnis absurd präzise.
Unser Lastkraftwagen ist nicht genau
12000
Millimeter lang. Wir haben
diese Länge nicht mit einer so hohen Genauigkeit
gemessen, weswegen es falsch wäre zu behaupten,
unser Lochblendendurchmesser müsse exakt
4.381780460
Millimeter sein. Es
reicht vollkommen aus, wenn der Durchmesser
4.4
Millimeter beträgt.
Ich habe in obigem Beispiel das Rechenergebnis "nur" auf 10 Stellen genau angegeben. Stellen Sie sich vor, wie absurd es wäre, die vollen uns zur Verfügung stehenden, 18 Stellen anzugeben!
Wir müssen also die Anzahl der signifikanten Stellen
beschränken. Eine Möglichkeit wäre, die
Mikrometer durch eine ganze Zahl darzustellen. Unser
Lastkraftwaren würde dann eine Lochblende mit einem
Durchmesser von 4382
Mikrometern
benötigen. Betrachten wir diesen Wert, dann stellen wir
fest, das 4400
Mikrometer, oder
4.4
Millimeter, immer noch genau
genug ist.
Zusätzlich können wir noch, unabhängig von der Größe eines Rechenergebnisses, festlegen, daß wir nur vier signifikante Stellen anzeigen wollen (oder weniger). Leider bietet uns die FPU nicht die Möglichkeit, das Ergebnis automatisch bis auf eine bestimmte Stelle zu runden (sie sieht die Daten ja nicht als Zahlen, sondern als binäre Daten an).
Wir müssen also selber einen Algorithmus entwerfen, um die Anzahl der signifikanten Stellen zu reduzieren.
Hier ist meiner (ich denke er ist peinlich—wenn Ihnen ein besserer Algorithmus einfällt, verraten sie ihn mir bitte):
Initialisiere einen Zähler mit
0
.
Solange die Zahl größer oder gleich
10000
ist, dividiere die Zahl durch
10
, und erhöhe den Zähler
um eins.
Gebe das Ergebnis aus.
Solange der Zähler größer als
0
ist, gebe eine
0
aus, und reduziere den Zähler
um eins.
Der Wert 10000
ist nur für
den Fall, daß Sie vier
signifikante Stellen haben wollen. Für eine andere
Anzahl signifikanter Stellen müssen Sie den Wert
10000
mit 10
,
hoch der Anzahl der gewünschten signifikanten Stellen,
ersetzen.
Wir können so den Lochblendendurchmesser, auf vier signifikante Stellen gerundet, ausgeben.
An dieser Stellen kennen wir nun die Brennweite und den Lochblendendurchmesser. Wir haben also jetzt genug Informationen, um den f–Wert zu bestimmen.
Wir werden den f–Wert, auf vier signifikante Stellen gerundet, ausgeben. Es könnte passieren, daß diese vier Stellen recht wenig aussagen. Um die Aussagekraft des f–Wertes zu erhöhen, könnten wir den nächstliegenden, normalisierten f–Wert bestimmen, also z.B. das nächstliegende Vielfache der Quadratwurzel aus 2.
Wir erreichen dies, indem wir den aktuellen f–Wert
mit sich selbst multiplizieren, so daß wir dessen
Quadrat (square
) erhalten.
Anschließend berechnen wir den Logarithmus zur Basis 2
von dieser Zahl. Dies ist sehr viel einfacher, als direkt den
Logarithmus zur Basis der Quadratwurzel aus 2 zu berechnen!
Wir runden dann das Ergebnis auf die nächstliegende
ganze Zahl. Genau genommen können wir mit Hilfe der
FPU diese Berechnung beschleunigen: Wir
können den op-Code
fscale
verwenden, um eine
Zahl um 1 zu "skalieren", was dasselbe ist, wie eine Zahl
mittels shift
um eine
Stelle nach links zu verschieben. Am Ende berechnen wir noch
die Quadratwurzel aus allem, und erhalten dann den
nächstliegenden, normalisierten f–Wert.
Wenn das alles jetzt viel zu kompliziert wirkt—oder viel zu aufwendig—wird es vielleicht klarer, wenn man den Code selber betrachtet. Wir benötigen insgesamt 9 op-Codes:
Die erste Zeile,
fmul st0, st0
, quadriert
den Inhalt des TOS (Top Of Stack, was
dasselbe ist wie st
, von
nasm auch
st0
genannt). Die Funktion
fld1
fügt eine
1
dem TOS
hinzu.
Die nächste Zeile, fld
st1
, legt das Quadrat auf dem
TOS ab. An diesem Punkt befindet sich das
Quadrat sowohl in st
als
auch in st(2)
(es wird
sich gleich zeigen, warum wir eine zweite Kopie auf dem
Stack lassen.) st(1)
enthält die 1
.
Im nächsten Schritt, fyl2x
, wird der Logarithmus von
st
zur Basis 2 berechnet,
und anschließend mit st(1)
multipliziert. Deshalb haben
wir vorher die 1
in st(1)
abgelegt.
An dieser Stelle enthält
st
den gerade berechneten
Logarithmus, und st(1)
das Quadrat des aktuellen f–Wertes, den wir für
später gespeichert haben.
frndint
rundet den
TOS zur nächstliegenden ganzen Zahl.
fld1
legt eine
1
auf dem Stack ab.
fscale
shiftet die
1
auf dem TOS um
st(1)
Stellen, wodurch im
Endeffekt eine 2 in st(1)
steht.
Schließlich berechnet
fsqrt
die Quadratwurzel
des Rechenergebnisses, also des nächstliegenden,
normalisierten f–Wertes.
Wir haben nun den nächstliegenden, normalisierten
f–Wert auf dem TOS liegen, den auf
den Logarithmus zur Basis 2 gerundeten, nächstliegenden
ganzzahligen Wert in st(1)
, und das Quadrat des
aktuellen f–Wertes in st(2)
. Wir speichern den Wert
für eine spätere Verwendung in st(2)
.
Aber wir brauchen den Inhalt von
st(1)
gar nicht mehr. Die
letzte Zeile, fstp st1
,
platziert den Inhalt von st
in st(1)
, und erniedrigt
den Stackpointer um eins. Dadurch ist der Inhalt von
st(1)
jetzt
st
, der Inhalt von
st(2)
jetzt
st(1)
usw. Der neue
st
speichert jetzt den
normalisierten f–Wert. Der neue
st(1)
speichert das
Quadrat des aktuellen f–Wertes für die
Nachwelt.
Jetzt können wir den normalisierten f–Wert ausgeben. Da er normalisiert ist, werden wir ihn nicht auf vier signifikante Stellen runden, sondern stattdessen mit voller Genauigkeit ausgeben.
Der normalisierte f–Wert ist nützlich, solange er so klein ist, daß wir ihn auf einem Photometer wiederfinden können. Ansonsten brauchen wir eine andere Methode, um die benötigten Belichtungsdaten zu bestimmen.
Wir haben weiter oben eine Formel aufgestellt, über die wir einen f–Wert mit Hilfe eines anderen f–Wertes und den zugehörigen Belichtungsdaten bestimmen können.
Jedes Photometer, das ich jemals gesehen habe, konnte die benötigte Belichtungszeit für f5.6 berechnen. Wir werden daher einen "f5.6 Multiplizierer" berechnen, der uns den Faktor angibt, mit dem wir die bei f5.6 gemessene Belichtungszeit für unsere Lochkamera multiplizieren müssen.
Durch die Formel wissen wir, daß dieser Faktor
durch Dividieren unseres f–Wertes (der aktuelle Wert,
nicht der normalisierte) durch 5.6
und anschließendes Quadrieren, berechnen
können.
Mathematisch äquivalent dazu wäre, wenn wir
das Quadrat unseres f–Wertes durch das Quadrat von
5.6
dividieren würden.
Numerisch betrachtet wollen wir nicht zwei Zahlen quadrieren, wenn es möglich ist, nur eine Zahl zu quadrieren. Daher wirkt die erste Variante auf den ersten Blick besser.
Aber...
5.6
ist eine
Konstante. Wir müssen nicht
wertvolle Rechenzeit der FPU verschwenden.
Es reicht aus, daß wir die Quadrate der einzelnen
f–Werte durch den konstanten Wert
5.6²
dividieren. Oder wir
können den jeweiligen f–Wert durch
5.6
dividieren, und dann das Ergebnis
quadrieren. Zwei Möglichkeiten, die gleich
erscheinen.
Aber das sind sie nicht!
Erinnern wir uns an die Grundlagen der Photographie
weiter oben, dann wissen wir, daß sich die
Konstante 5.6
aus dem 5-fachen der
Quadratwurzel aus 2 ergibt. Eine
irrationale Zahl. Das Quadrat dieser
Zahl ist exakt
32
.
32
ist nicht nur eine ganze Zahl,
sondern auch ein Vielfaches von 2. Wir brauchen also
gar nicht das Quadrat eines f–Wertes durch
32
zu teilen. Wir müssen lediglich
mittels fscale
den
f–Wert um fünf Stellen nach rechts shiften.
Aus Sicht der FPU müssen wir also
fscale
mit
st(1)
, welcher gleich
-5
ist, auf den f–Wert anwenden.
Dies ist sehr viel schneller als die
Division.
Jetzt wird es auch klar, warum wir das Quadrat des f–Wertes ganz oben auf dem Stack der FPU gespeichert haben. Die Berechnung des f5.6 Multiplizierers ist die einfachste Berechnung des gesamten Programmes! Wir werden das Ergebnis auf vier signifikante Stellen gerundet ausgeben.
Es gibt noch eine weitere nützliche Zahl, die wir berechnen können: Die Anzahl der Stopps, die unser f–Wert von f5.6 entfernt ist. Dies könnte hilfreich sein, wenn unser f–Wert außerhalb des Meßbereiches unseres Photometers liegt, wir aber eine Blende haben, bei der wir unterschiedliche Geschwindigkeiten einstellen können, und diese Blende Stopps benutzt.
Angenommen, unser f–Wert ist 5 Stopps von f5.6 entfernt, und unser Photometer sagt uns, daß wir eine Belichtungszeit von 1/1000 Sek. einstellen sollen. Dann können wir unsere Blende auf die Geschwindigkeit 1/1000 einstellen, und unsere Skala um 5 Stopps verschieben.
Diese Rechnung ist ebenfalls sehr einfach. Alles, was wir tun müssen, ist, den Logarithmus des f5.6 Multiplizierers, den wir schon berechnet haben (wobei wir dessen Wert vor der Rundung nehmen müssen) zur Basis 2 zu nehmen. Wir runden dann das Ergebnis zur nächsten ganzen Zahl hin, und geben dies aus. Wir müssen uns nicht darum kümmern, ob wir mehr als vier signifikante Stellen haben: Das Ergebnis besteht höchstwahrscheinlich nur aus einer oder zwei Stellen.
In Assemblersprache können wir den Code für die FPU besser optimieren, als in einer der Hochsprachen, inklusive C.
Sobald eine C-Funktion die Berechnung einer Fließkommazahl durchführen will, lädt sie erst einmal alle benötigten Variablen und Konstanten in die Register der FPU. Dann werden die Berechnungen durchgeführt, um das korrekte Ergebnis zu erhalten. Gute C-Compiler können diesen Teil des Codes sehr gut optimieren.
Das Ergebnis wird "zurückgegeben", indem dieses auf dem TOS abgelegt wird. Vorher wird aufgeräumt. Sämtliche Variablen und Konstanten, die während der Berechnung verwendet wurden, werden dabei aus der FPU entfernt.
Was wir im vorherigen Abschnitt selber getan haben, kann so nicht durchgeführt werden: Wir haben das Quadrat des f–Wertes berechnet, und das Ergebnis für eine weitere Berechnung mit einer anderen Funktion auf dem Stack behalten.
Wir wußten, daß wir diesen Wert später noch einmal brauchen würden. Wir wußten auch, daß auf dem Stack genügend Platz war (welcher nur Platz für 8 Zahlen bietet), um den Wert dort zu speichern.
Ein C-Compiler kann nicht wissen, ob ein Wert auf dem Stack in naher Zukunft noch einmal gebraucht wird.
Natürlich könnte der C-Programmierer dies wissen. Aber die einzige Möglichkeit, die er hat, ist, den Wert im verfügbaren Speicher zu halten.
Das bedeutet zum einen, daß der Wert mit der FPU-internen, 80-stelligen Genauigkeit in einer normalen C-Variable vom Typ double (64 Bit) oder vom Typ single (32 Bit) gespeichert wird.
Dies bedeutet außerdem, daß der Wert aus dem TOS in den Speicher verschoben werden muß, und später wieder zurück. Von allen Operationen mit der FPU ist der Zugriff auf den Speicher die langsamste.
Wann immer also mit der FPU in einer Assemblersprache programmiert wird, sollte nach Möglichkeiten gesucht werden, Zwischenergebnisse auf dem Stack der FPU zu lassen.
Wir können mit dieser Idee noch einen Schritt weiter
gehen! In unserem Programm verwenden wir eine
Konstante (die wir PC
genannt haben).
Es ist unwichtig, wieviele Lochblendendurchmesser wir berechnen: 1, 10, 20, 1000, wir verwenden immer dieselbe Konstante. Daher können wir unser Programm so optimieren, daß diese Konstante immer auf dem Stack belassen wird.
Am Anfang unseres Programmes berechnen wir die oben
erwähnte Konstante. Wir müssen die Eingabe für
jede Dezimalstelle der Konstanten durch 10
dividieren.
Multiplizieren geht sehr viel schneller als Dividieren.
Wir teilen also zu Beginn unseres Programmes
1
durch 10
, um
0.1
zu erhalten, was wir auf dem Stack
speichern: Anstatt daß wir nun für jede einzelne
Dezimalstelle die Eingabe wieder durch 10
teilen, multiplizieren wir sie stattdessen mit
0.1
.
Auf diese Weise geben wir 0.1
nicht
direkt ein, obwohl wir dies könnten. Dies hat einen Grund:
Während 0.1
durch nur eine einzige
Dezimalstelle dargestellt werden kann, wissen wir nicht,
wieviele binäre Stellen benötigt
werden. Wir überlassen die Berechnung des binären
Wertes daher der FPU, mit dessen eigener,
hoher Genauigkeit.
Wir verwenden noch weitere Konstanten: Wir multiplizieren
den Lochblendendurchmesser mit 1000
, um
den Wert von Millimeter in Micrometer zu konvertieren. Wir
vergleichen Werte mit 10000
, wenn wir
diese auf vier signifikante Stellen runden wollen. Wir
behalten also beide Konstanten, 1000
und 10000
, auf dem Stack. Und
selbstverständlich verwenden wir erneut die gespeicherte
0.1
, um Werte auf vier signifikante
Stellen zu runden.
Zu guter letzt behalten wir -5
noch
auf dem Stack. Wir brauchen diesen Wert, um das Quadrat des
f–Wertes zu skalieren, anstatt diesen durch
32
zu teilen. Es ist kein Zufall, daß
wir diese Konstante als letztes laden. Dadurch wird diese
Zahl die oberste Konstante auf dem Stack. Wenn später
das Quadrat des f–Wertes skaliert werden muß,
befindet sich die -5
in
st(1)
, also genau da, wo
die Funktion fscale
diesen
Wert erwartet.
Es ist üblich, einige Konstanten per Hand zu erzeugen,
anstatt sie aus dem Speicher zu laden. Genau das machen wir
mit der -5
:
Wir können all diese Optimierungen in einer Regel zusammenfassen: Behalte wiederverwendbare Werte auf dem Stack!
PostScript® ist eine Stack-orientierte Programmiersprache. Es gibt weit mehr Bücher über PostScript®, als über die Assemblersprache der FPU: Werden Sie in PostScript® besser, dann werden Sie auch automatisch in der Programmierung der FPU besser.
Der Code folgt demselben Aufbau wie alle anderen Filter, die wir bisher gesehen haben, bis auf eine Kleinigkeit:
Wir nehmen nun nicht mehr an, daß das Ende der Eingabe auch das Ende der nötigen Arbeit bedeutet, etwas, das wir für zeichenbasierte Filter automatisch angenommen haben.
Dieser Filter verarbeitet keine Zeichen. Er verarbeitet eine Sprache (obgleich eine sehr einfache, die nur aus Zahlen besteht).
Wenn keine weiteren Eingaben vorliegen, kann das zwei Ursachen haben:
Wir sind fertig und können aufhören. Dies ist dasselbe wie vorher.
Das Zeichen, das wir eingelesen haben, war eine Zahl. Wir haben diese am Ende unseres ASCII –zu–float Kovertierungspuffers gespeichert. Wir müssen nun den gesamten Pufferinhalt in eine Zahl konvertieren, und die letzte Zeile unserer Ausgabe ausgeben.
Aus diesem Grund haben wir unsere
getchar
- undread
-Routinen so angepaßt, daß sie dascarry flag
clear immer dann zurückgeben, wenn wir ein weiteres Zeichen aus der Eingabe lesen, und dascarry flag
set immer dann zurückgeben, wenn es keine weiteren Eingabedaten gibt.Selbstverständlich verwenden wir auch hier die Magie der Assemblersprache! Schauen Sie sich
getchar
näher an. Dieses gibt immer dascarry flag
clear zurück.Dennoch basiert der Hauptteil unseres Programmes auf dem
carry flag
, um diesem eine Beendigung mitzuteilen—und es funktioniert.Die Magie passiert in
read
. Wann immer weitere Eingaben durch das System zur Verfügung stehen, ruft diese Funktiongetchar
auf, welche ein weiteres Zeichen aus dem Eingabepuffer einliest, und anschließend dascarry flag
cleart.Wenn aber
read
keine weiteren Eingaben von dem System bekommt, ruft dieses nichtgetchar
auf. Stattdessen addiert der op-Codeadd esp, byte 4
4
zuESP
hinzu, setzt dascarry flag
, und springt zurück.Wo springt diese Funktion hin? Wann immer ein Programm den op-Code
call
verwendet,push
t der Mikroprozessor die Rücksprungandresse, d.h. er speichert diese ganz oben auf dem Stack (nicht auf dem Stack der FPU, sondern auf dem Systemstack, der sich im Hauptspeicher befindet). Wenn ein Programm den op-Coderet
verwendet,pop
t der Mikroprozessor den Rückgabewert von dem Stack, und springt zu der Adresse, die dort gespeichert wurde.Da wir aber
4
zuESP
hinzuaddiert haben (welches das Register der Stackzeiger ist), haben wir effektiv dem Mikroprzessor eine kleine Amnesie verpaßt: Dieser erinnert sich nun nicht mehr daran, daßgetchar
durchread
aufgerufen wurde.Und da
getchar
nichts vor dem Aufruf vonread
auf dem Stack abgelegt hat, enthält der Anfang des Stacks nun die Rücksprungadresse von der Funktion, diegetchar
aufgerufen hat. Soweit es den Aufrufer betrifft, hat diesergetchar
gecall
t, welche mit einem gesetztencarry flag
ret
urned.
Des weiteren wird die Routine bcdload
bei einem klitzekleinen Problem zwischen der Big–Endian-
und Little–Endian-Codierung aufgerufen.
Diese konvertiert die Textrepräsentation einer Zahl in eine andere Textrepräsentation: Der Text wird in der Big–Endian-Codierung gespeichert, die packed decimal-Darstellung jedoch in der Little–Endian-Codierung.
Um dieses Problem zu lösen haben wir vorher den
op-Code std
verwendet. Wir machen diesen
Aufruf später mittels cld
wieder
rückgängig: Es ist sehr wichtig, daß wir keine
Funktion mittels call
aufrufen, die von
einer Standardeinstellung des
Richtungsflags abhängig ist,
während std
ausgeführt
wird.
Alles weitere in dem Programm sollte leicht zu verstehen sein, vorausgesetzt, daß Sie das gesamte vorherige Kapitel gelesen haben.
Es ist ein klassisches Beispiel für das Sprichwort, daß das Programmieren eine Menge Denkarbeit, und nur ein wenig Programmcode benötigt. Sobald wir uns über jedes Detail im klaren sind, steht der Code fast schon da.
Da wir uns bei dem Programm dafür entschieden haben, alle Eingaben, die keine Zahlen sind, zu ignorieren (selbst die in Kommentaren), können wir jegliche textbasierten Eingaben verarbeiten. Wir müssen dies nicht tun, wir könnten aber.
Meiner bescheidenen Meinung nach wird ein Programm durch die Möglichkeit, anstatt einer strikten Eingabesyntax textbasierte Anfragen stellen zu können, sehr viel benutzerfreundlicher.
Angenommen, wir wollten eine Lochkamera für einen 4x5 Zoll Film bauen. Die standardmäßige Brennweite für diesen Film ist ungefähr 150mm. Wir wollen diesen Wert optimieren, so daß der Lochblendendurchmesser eine möglichst runde Zahl ergibt. Lassen Sie uns weiter annehmen, daß wir zwar sehr gut mit Kameras umgehen können, dafür aber nicht so gut mit Computern. Anstatt das wir nun eine Reihe von Zahlen eingeben, wollen wir lieber ein paar Fragen stellen.
Unsere Sitzung könnte wie folgt aussehen:
%
pinhole
Computer,
Wie groß müßte meine Lochblende bei einer Brennweite
von 150 sein?
150 490 306 362 2930 12
Hmmm... Und bei 160?
160 506 316 362 3125 12
Laß uns bitte 155 nehmen.
155 498 311 362 3027 12
Ah, laß uns 157 probieren...
157 501 313 362 3066 12
156?
156 500 312 362 3047 12
Das ist es! Perfekt! Vielen Dank!
^D
Wir haben herausgefunden, daß der Lochblendendurchmesser bei einer Brennweite von 150 mm 490 Mikrometer, oder 0.49 mm ergeben würde. Bei einer fast identischen Brennweite von 156 mm würden wir einen Durchmesser von genau einem halben Millimeter bekommen.
Da wir uns dafür entschieden haben, das Zeichen
#
als den Anfang eines Kommentares zu
interpretieren, können wir unser
pinhole-Programm auch als
Skriptsprache verwenden.
Sie haben vielleicht schon einmal shell-Skripte gesehen, die mit folgenden Zeichen begonnen haben:
...oder...
... da das Leerzeichen hinter dem #!
optional ist.
Wann immer UNIX® eine Datei ausführen soll, die mit
einem #!
beginnt, wird angenommen, das
die Datei ein Skript ist. Es fügt den Befehl an das Ende
der ersten Zeile an, und versucht dann, dieses
auszuführen.
Angenommen, wir haben unser Programm pinhole unter /usr/local/bin/ installiert, dann können wir nun Skripte schreiben, um unterschiedliche Lochblendendurchmesser für mehrere Brennweiten zu berechnen, die normalerweise mit 120er Filmen verwendet werden.
Das Skript könnte wie folgt aussehen:
Da ein 120er Film ein Film mittlerer Größe ist, könnten wir die Datei medium nennen.
Wir können die Datei ausführbar machen und dann aufrufen, als wäre es ein Programm:
%
chmod 755 medium
%
./medium
UNIX® wird den letzten Befehl wie folgt interpretieren:
%
/usr/local/bin/pinhole -b -i ./medium
Es wird den Befehl ausführen und folgendes ausgeben:
Lassen Sie uns nun das folgende eingeben:
%
./medium -c
UNIX® wird dieses wie folgt behandeln:
%
/usr/local/bin/pinhole -b -i ./medium -c
Dadurch erhält das Programm zwei
widersprüchliche Optionen: -b
und
-c
(Verwende Benders Konstante und
verwende Connors Konstante). Wir haben unser Programm so
geschrieben, daß später eingelesene Optionen die
vorheringen überschreiben—unser Programm wird also
Connors Konstante für die Berechnungen verwenden:
Wir entscheiden uns am Ende doch für Benders Konstante. Wir wollen die Ergebnisse im CSV-Format in einer Datei speichern:
%
./medium -b -e > bender
%
cat bender
focal length in millimeters,pinhole diameter in microns,F-number,normalized F-number,F-5.6 multiplier,stops from F-5.6
80,358,224,256,1562,11
30,219,137,128,586,9
40,253,158,181,781,10
50,283,177,181,977,10
60,310,194,181,1172,10
70,335,209,181,1367,10
100,400,250,256,1953,11
120,438,274,256,2344,11
140,473,296,256,2734,11
%
Wenn Sie Fragen zu FreeBSD haben, schicken Sie eine E-Mail an
<de-bsd-questions@de.FreeBSD.org>.
Wenn Sie Fragen zu dieser Dokumentation haben, schicken Sie eine E-Mail an
<de-bsd-translators@de.FreeBSD.org>.