UniScript Manual. Release R2015. Uniplot Software GmbH

Transkript

1 UniScript Manual Release R2015 Uniplot Software GmbH

2

3 Inhaltsverzeichnis 1 Was ist UniScript 1 2 UniScript in Beispielen UniScript als Taschenrechner Matrizenrechnung Editieren im Kommandofenster Verwenden eines Editors Temperaturtabelle - 1. Version Temperaturtabelle - 2. Version Temperaturtabelle - 3. Version Temperaturtabelle - 4. Version Ausgabe der Temperaturtabelle als Grafik Elemente von UniScript Kommentare Fortsetzungszeilen Konstanten Numerische Konstanten Hexadezimale und oktale Konstanten Komplexe Konstanten String Konstanten Lange Zeichenketten Null-Zeichen in Strings Variablen Vektoren und Matrizen Index-Ausdrücke Operatoren Arithmetische Operatoren Vergleichsoperatoren Boolsche Operatoren Bitweise Operatoren Assoziativität und Priorität der Operatoren Kontroll-Anweisungen Die if-else-anweisung Die for-anweisung i

4 5.3 Die while-anweisung Die break- und die continue-anweisung Die try-except-anweisung Funktionen für Vektoren und Matrizen 39 7 Funktionen Syntax von Funktionen Parameter und Argumente Globale und lokale Variablen Die return-anweisung Funktionen die mehrere Werte zurückgeben Aufruf von Funktionen aus DLLs COM-Schnittstelle Der Debugger für Funktionen Noch ein paar Bemerkungen zu Funktionen UniScript-Objekte Einführung Objekt-Konstruktor-Schreibweise Standard-Methoden Methoden für Objekte Überladen von Operatoren Vererbung Funktionsaufrufe mit UniScript-Objekten Beispiel Stichwortverzeichnis 75 ii

5 KAPITEL 1 Was ist UniScript UniScript ist eine in UniPlot integrierte Programmiersprache. UniScript kann beispielsweise für folgende Aufgaben verwendet werden: Erweitern von UniPlot um zusätzliche Eigenschaften: Der Datenimport und die Erstellung von Legenden sind z. B. mit UniScript programmiert. Der Benutzer kann diese Funktionen an seine eigenen Anforderungen anpassen. UniPlot ist in Verbindung mit UniScript sehr flexibel. Automatisierung der Diagrammerstellung: Es können UniScript-Funktionen geschrieben werden, die z. B. die Schritte - Laden der Daten aus Dateien, Transformation der Daten, Erzeugung und Speichern der Diagramme - automatisch ausführen. Durchführung komplexer mathematischer Berechnungen mit Messdaten: UniScript ist besonders gut geeignet, um mit sehr wenigen Befehlen Umrechnungen von großen Datensätzen (Signalen) durchzuführen. Dazu stehen leistungsfähige Funktionen zur Verfügung (Suchfunktionen, Sortierfunktionen, FFT und vieles mehr). Für Aufgaben dieser Art ist UniScript besser geeignet als Programmiersprachen wie BASIC, FORTRAN oder C. UniScript ist ein Interpreter, so daß die zeitaufwendigen Übersetzungsvorgänge von Sprachen wie C oder FORTRAN entfallen. Ein Interpreter ist in der Ausführungsgeschwindigkeit langsamer als ein Compiler, dennoch kommt die Geschwindigkeit von UniScript bei einer Reihe von Aufgaben an die Geschwindigkeit von C heran. Der Grund ist, daß die Operatoren von UniScript auf Vektoren und Matrizen angewendet werden können. Diese und einige andere Eigenschaften wie z. B. die transparente Speicherverwaltung bewirken, daß UniScript-Programme viel kürzer sind als Programme in den anderen genannten Programmiersprachen, typischerweise kleiner als halb so groß. UniScript ist eine sehr einfache, kleine und kompakte Sprache. Sie kennt nur drei Datentypen (reelle Zahlen, komplexe Zahlen und Zeichenketten) und es stehen nur die wichtigsten Kontrollstrukturen zur Verfügung. UniScript hat eine C-ähnliche Syntax, so daß UniScript von Programmierern mit C-Kenntnissen nach kurzer Einarbeitungszeit verwendet werden kann. Sollten die Fähigkeiten von UniScript zur Lösung einer bestimmten Aufgabe nicht ausreichen, können C- oder FORTRAN-Funktionen aus sogenannten Dynamic Link Libraries (DLLs) in UniScript aufgerufen werden. 1

6 2 Kapitel 1. Was ist UniScript

7 KAPITEL 2 UniScript in Beispielen An einigen kleinen Beispielen soll Ihnen die Benutzung von UniScript gezeigt werden. Es ist empfehlenswert, wenn Sie dazu UniPlot starten und die Beispiele eingeben. Starten Sie also UniPlot und klicken Sie mit der Maus auf den Schalter mit dem Symbol eines Taschenrechners. Es erscheint das Kommandofenster von UniScript mit einer Copyright-Meldung. Vergrößern Sie das Kommandofenster auf Vollbilddarstellung. Der Stern * ist der sogenannte Prompt. Er zeigt Ihnen, daß UniScript für Ihre Eingaben bereit ist. 2.1 UniScript als Taschenrechner Geben Sie ein * * * 3* * 1/2 3

8 * (2 + 5)* * y = sin(0.5) * y * Sie können UniScript wie einen leistungsfähigen Taschenrechner verwenden. UniScript kann jedoch mehr, z. B. mit Matrizen rechnen. 2.2 Matrizenrechnung Die Gleichung ( ) ( x1 x 2 ) = ( ) 1 4 kann mit UniScript folgendermaßen gelöst werden: * a = [4,7;2,5] * a * b = [1;4] * b * x = a\b * x * a * x Matrizen werden in UniScript eingegeben, indem man die Spalten der Matrix durch ein Komma trennt und die Zeilen durch ein Semikolon. Die Zeile x = a\b löst das lineare Gleichungssystem. Das \- Zeichen ist der sogenannte Links-Divisions-Operator. Dieser Operator ist speziell für das Lösen von Gleichungssystemen mit reellen und komplexen Elementen gedacht. UniScript verwendet dazu die sehr leistungsfähigen Berechnungsverfahren der LAPACK-Library, so daß auch große Gleichungssysteme schnell und stabil gelöst werden können. UniScript kann noch einige andere Matrizenoperationen ausführen, z. B. die Determinate berechnen, die Inverse oder die Eigenwerte. * det(a) * a^ * eig(a) i i 4 Kapitel 2. UniScript in Beispielen

9 Die Eigenwerte wurden als komplexe Zahlen berechnet. Komplexe Zahlen werden eingegeben, indem man ein i hinter die Zahl schreibt. * (3 + 5i) * (2 + 7i) i Fast alle mathematischen UniScript-Funktionen können auch mit komplexen Zahlen rechnen, versuchen Sie z. B. sqrt(-1). 2.3 Editieren im Kommandofenster Sie können Ihre Kommandos mit den Pfeiltasten editieren. Die Einfg-Taste (Insert) schaltet zwischen Einfüge- und Überschreibmodus hin und her. Die BACKSPACE-Taste löscht das Zeichen vor dem Cursor, die Entf-Taste das Zeichen unter dem Cursor. Mit den Pfeiltasten nach oben und nach unten können Sie bereits abgeschickte Anweisungen zurückholen (sogenannte Command-History). Mit der F7-Taste erhalten Sie ein Listenfeld mit den 100 zuletzt eingegebenen Anweisungen. Mit der F8-Taste können Sie die Zeilen zurückholen, die mit den Buchstaben vor dem Cursor anfangen. Mit der Esc-Taste kann die Eingabezeile gelöscht werden. Außerdem kann mit der Esc-Taste eine laufende Funktion abgebrochen werden. Siehe auch ansichtkommando-fenster. Das Kommandofenster wird hauptsächlich dazu verwendet, um Befehle auszuprobieren und sich die Werte von Variablen anzuschauen. In allen anderen Fällen wird ein Editor verwendet. 2.4 Verwenden eines Editors Um einen Editor zu erzeugen, geben Sie im Kommandofenster den Befehl EdCreate ein und ordnen Sie die Fenster nebeneinander an. Geben Sie im Editor die folgenden Zeilen ein a = [4, 7; 2, 5] b = [1; 4] print "Die Determinante von", a print "ist", det(a) print "Die Lösung der Gleichung" print "a*x = b, mit a = ", a print "und b = ", b, "ist", a\b Speichern Sie Ihre Eingabe unter einem Namen, der mit.ic endet. Die Endung ".ic" steht für IsoCalc. UniScript hieß bis UniPlot 2.1 IsoCalc. Wählen Sie im Menü UniScript den Befehl Laden/Ausführen. UniScript führt Ihre im Editor eingegebenen Anweisungen aus. Die Ausgabe der print-anweisungen wird in das UniScript-Kommandofenster geschrieben. Gehen Sie mit dem Cursor auf einen Funktionsnamen und drücken Sie die F1-Taste. Wenn Sie den Cursor auf den det-funktionsaufruf positionieren, bekommen Sie die folgende Hilfe-Seite Editieren im Kommandofenster 5

10 Löschen Sie nun Ihre Editoreingaben (mit dem Befehl alles markieren im Menü Bearbeiten und anschließendem Drücken der DEL-Taste). 2.5 Temperaturtabelle - 1. Version Es soll nun ein Programm geschrieben werden, das eine Temperaturtabelle ausgibt. In der ersten Spalte sollen die Celsius-Grade stehen und in der zweiten Spalte die Temperatur in Fahrenheit. Für die Umrechnung gilt die Formel C = 5 / 9 * (F - 32) Das Beispiel ist einem Buch über die Programmiersprache C entnommen [Kernighan, Brian W., und Ritchie, Dennis M.: Programmieren in C, Hanser, München, 1983]. Es zeigt Ihnen nicht nur die Ähnlichkeit von UniScript und C, sondern führt auch in wichtige Aspekte der Programmierung ein, die für UniScript ebenso gelten wie für C. Das Programm, das die Tabelle ausgibt, sieht so aus: /* Umwandlung von Fahrenheit in Celsius fuer f = 0, 20,..., 300 */ def main() lower = 0; /* untere Grenze der Temp.-Tabelle */ upper = 300; /* obere Grenze */ step = 20; /* Schrittweite */ fahr = lower; while (fahr <= upper) 6 Kapitel 2. UniScript in Beispielen

11 celsius = (5.0 / 9.0) * (fahr ); printf("%4.0f %6.1f\n", fahr, celsius); fahr = fahr + step; Die ersten beiden Zeilen kommentieren das Programm /* Umwandlung von Fahrenheit in Celsius fuer f = 0, 20,..., 300 */ Alle Zeilen, die zwischen /* und */ stehen, werden von UniScript ignoriert. Mit def main()... wird ein Programm (eine Funktion) definiert. In C gibt es das Schlüsselwort def nicht; es entfällt dort. In UniScript muss jedoch vor den Namen von Funktionen das Schlüsselwort def stehen. main ist der Name der Funktion. In C steht der Name main für das Hauptprogramm. In UniScript ist main ein Name wie jeder andere. Hinter dem Funktionsnamen main stehen Klammern, die meist eine Liste von Parametern enthalten. In unserem Beispiel ist die Liste leer; die Klammern müssen aber dennoch hinter dem Funktionsnamen stehen, damit UniScript (und der Programmierer) besser erkennt, daß es sich bei main um einen Funktionsnamen handelt. Die geschweiften Klammern und umschließen die Anweisungen der Funktion main. Sie haben die Bedeutung von begin und end in anderen Programmiersprachen. In C folgen hinter der ersten geschweiften Klammer die Deklarationen der Variablen. In UniScript sind Deklarationen von Variablen nicht erforderlich. Die erste Anweisung ist lower = 0; Sie weist der Variablen lower den Wert 0 zu und zwar als doppelt genaue Gleitkommakonstante. Im C-Programm wurde lower als ganze Zahl deklariert. UniScript kennt diesen Datentyp nicht. UniScript kennt lediglich drei Datentypen: Doppelt genaue Gleitkommazahlen. Komplexe Zahlen, bestehend aus zwei doppelt genauen Gleitkommazahlen. Zeichenketten, bestehend aus beliebig vielen Zeichen. Von allen drei Datentypen können auch Vektoren und Matrizen gebildet werden, wie später gezeigt wird. Die Zeilen upper = 0; step = 20; fahr = lower; weisen den anderen in dieser Funktion verwendeten Variablen Anfangswerte zu. Es folgt eine sogenannte while-schleife: 2.5. Temperaturtabelle - 1. Version 7

12 while (fahr <= upper)... fahr = fahr + step; In der while-schleife wird zunächst die Bedingung fahr <= upper ausgewertet. Trifft sie zu, d.h. fahr ist kleiner oder gleich upper, werden die Anweisungen innerhalb der while-schleife ausgeführt. Am Ende der while-schleife wird fahr um step (gleich 20) erhöht, was dazu führt, daß fahr irgendwann größer als upper wird, wodurch die while-schleife beendet wird. Ein paar Worte zur Formatierung von Funktionen: Man hätte alle Anweisungen der Funktion auch linksbündig schreiben können, das Programm ist jedoch besser lesbar, wenn die Anweisungen um eine Tabulatorposition nach rechts eingerückt werden. Anweisungen innerhalb von Schleifen oder if- Anweisungen werden um eine weitere Tabulatorposition eingerückt. Die Tabulatorweite wird im Editor am besten so eingestellt, daß ein Tabulator 4 Leerzeichen entspricht. Innerhalb der while-schleife befinden sich noch die beiden Anweisungen celsius = (5.0 / 9.0) * (fahr ); printf("%4.0f %6.1f\n", fahr, celsius); Die erste Anweisung führt die Umrechnung Fahrenheit in Celsius durch und die zweite Anweisung gibt die aktuellen Werte für fahr und celsius im UniScript-Kommandofenster aus. Für die Ausgabe wird die Funktion printf verwendet. Das Zeichen f am Ende des Funktionsnamens steht für formatiert. printf hat in diesem Beispiel drei Argumente. Das erste Argument ist "%4.0f %6.1f\n". Die Zeichenkette beschreibt, wie die anderen beiden Argumente fahr und celsius ausgegeben werden sollen. Die Zeichenkette enthält dazu die beiden Format-Elemente %4.0f und %6.1f. Format-Elemente beginnen mit einem Prozentzeichen. %4.0f bedeutet, daß der Parameter fahr mit insgesamt 4 Stellen ausgegeben wird und keine Nachkommastellen ausgegeben werden. Das %f bedeutet, daß die Zahl als Fließkommazahl ausgegeben wird. Entsprechend bewirkt %6.1f, daß celsius mit 6 Stellen ausgegeben wird, davon eine Stelle nach dem Komma. Die printf -Funktion verwendet als Dezimaltrennzeichen den Punkt. und kein Komma, wie im Deutschen üblich. Zeichen außerhalb von Format-Elementen werden direkt ausgegeben, wie das Leerzeichen zwischen den beiden Format-Elementen in der Beispiel- Funktion. Die beiden Zeichen \n bewirken, daß die nächsten Zeichen in einer neuen Zeile ausgegeben werden. In der Funktion main() werden 5 Variablen verwendet, nämlich: lower, upper, step, fahr und celsius. Diese Variablen werden erzeugt, wenn die Funktion aufgerufen wird und gelöscht, kurz bevor die Funktion beendet wird. Falls Sie es nicht bereits getan haben, geben Sie nun die Funktion in einem Editor ein; speichern Sie die Funktion z. B. unter dem Namen celsius.ic. Führen Sie im Editor im Menü UniScript den Befehl Speichern/Ausführen aus. Sie können die Funktion ausführen, indem Sie die Funktion im UniScript-Kommando-Fenster aufrufen: * main() Experimentieren Sie ein wenig mit der Funktion. Ändern Sie z. B. die Format-Zeichenkette der printf - Funktion. Führen Sie nach jeder Änderung im Editor den Menü-Befehl Laden/Ausführen aus, und rufen Sie die Funktion im UniScript-Kommando-Fenster auf. 8 Kapitel 2. UniScript in Beispielen

13 2.6 Temperaturtabelle - 2. Version Wir wollen nun eine neue Funktion schreiben, die die gleiche Ausgabe wie main() erzeugt. Wir nennen Sie main2(). Sie können Sie in die selbe Datei wie main() schreiben; in UniScript kann eine Datei beliebig viele Funktionen enthalten. /* Umwandlung von Fahrenheit in Celsius fuer f = 0, 20,..., Fassung -- */ def main2() for (fahr in 0:20:300) printf("%4d %6.1f\n", fahr, 5/9 * (fahr-32)); main2() verwendet anstatt der while-schleife eine for-schleife. Sie hat in UniScript die Form: for (var in vektor)... for und in sind Schlüsselwörter, var steht für einen beliebigen Variablennamen, vektor steht für den Namen eines Vektors oder für einen konstanten Vektor. Vektoren können in UniScript auf verschiedene Weise erzeugt werden. Eine Möglichkeit ist die Aufzählung der Elemente in eckigen Klammern wie weiter oben bereits gezeigt. vektor = [0,20,40,60,80] Eine andere Möglichkeit ist die Verwendung des Vektor-Erzeugungs-Operators : in der Form: vektor = start:step:end step kann auch weggelassen werden (vektor = start:end), dann wird für step 1.0 verwendet. 0:20:100 erzeugt beispielsweise den Vektor [0, 20, 40, 60, 80, 100]. Die for-schleife for (fahr in 0:20:300) printf("%4d %6.1f\n", fahr, (5/9)*(fahr-32.0)); erzeugt am Anfang der Schleife den Vektor 0:20:300 und weist fahr nacheinander die Werte 0, 20, 40 bis 300 zu. Wenn am Anfang einer Schleife bekannt ist, wie oft eine Schleife ausgeführt werden muss, ist die for- Schleife besser geeignet als die while-schleife, so daß main2() sicherlich eine bessere Lösung ist als main(). 2.7 Temperaturtabelle - 3. Version Es gibt in UniScript noch bessere Lösungen. Es kann bei diesem Problem ganz auf Schleifen verzichtet werden: 2.6. Temperaturtabelle - 2. Version 9

14 def main3() fahr = (0:20:300) ; printf("%4.0f %6.1f\n", fahr, (5/9)*(fahr-32)); In main() und main2() wurden skalare Werte an die Funktion printf übergeben, nämlich nacheinander die Werte 0, 20, 40 usw. In main3() wird mit der Anweisung fahr = (0:20:300) ; ein Spaltenvektor erzeugt. ist der Transponierungs-Operator, der aus dem Zeilenvektor 0:20:300 einen Spaltenvektor macht. Da fahr ein Spaltenvektor ist, ist auch (5/9)*(fahr-32) ein Spaltenvektor mit genau so vielen Zeilen wie fahr. printf arbeitet so oft die Format- Zeichenkette "%4.0f %6.1f\n" ab, wie Zeilen in den anderen Argumenten sind; printf hat sozusagen eine eingebaute for- Schleife. Es gibt in UniScript viele Funktionen mit eingebauten for-schleifen y = sin(0:2*pi/100:2*pi) erzeugt z. B. den Vektor y mit 100 Werten, ohne daß die Verwendung einer Schleife erforderlich ist. Dadurch können mit UniScript sehr kompakte Programme geschrieben werden. 2.8 Temperaturtabelle - 4. Version Es soll nun die Temperatur-Tabellen-Ausgabe nicht als Funktion, sondern in einer einzigen Anweisung geschrieben werden. Sie können den Funktionsaufruf entweder direkt ins UniScript-Kommandofenster schreiben oder in einen Editor. Bei jedem uniscriptspeichern/ausfuhren-befehl wird die Zeile direkt ausgeführt. printf("%4d %6.1f\n", fahr = (0:20:300), 5/9*(fahr-32)); Die Zeile zeigt eine weitere interessante Möglichkeit von UniScript, kompakte Programme zu schreiben. Eine Zuweisung ist nicht nur eine Anweisung wie bei den meisten Programmiersprachen, sondern wie in C auch ein Ausdruck. Dadurch sind Formulierungen wie a = 3 * (b = 5) möglich - a bekommt den Wert 15, und b den Wert 5 in einer Anweisung zugewiesen. In UniScript gibt es als vereinfachte Ausgabemöglichkeit die print-anweisung, bei der kein Format- String erforderlich ist. print ist kein Funktionsaufruf, sondern eine in die Sprache UniScript eingebaute Anweisung. Es werden deshalb keine Klammern um die Argumente geschrieben. Die Zeile print [fahr = (0:20:300), 5/9*(fahr-32)]; erzeugt zunächst aus den beiden Vektoren eine Matrix mit zwei Spalten, die anschließend in einem Standard-Format ausgegeben wird. Würde print in der Form print fahr = (0:20:300), 5/9*(fahr-32) geschrieben werden, so würden die beiden Vektoren nacheinander ausgegeben werden. Der Nachteil der print-anweisung ist, daß keine genaue Kontrolle über die Ausgabe vorhanden ist. (Schauen Sie sich die format-funktion im Hilfe-System an. Mit dieser Funktion kann das Standard- 10 Kapitel 2. UniScript in Beispielen

15 Format geändert werden.) Außerdem kann mit der print-anweisung nicht direkt in Dateien geschrieben werden, wie dies mit einer speziellen Version der printf -Funktion möglich ist (fprintf ). 2.9 Ausgabe der Temperaturtabelle als Grafik Als letztes Beispiel soll die Temperatur-Fahrenheit-Tabelle als Diagramm dargestellt werden. Ein Diagramm kann mit der Funktion plot erzeugt werden. h = plot(fahr = 0:20:300, 5/9 * (fahr - 32)) plot ist eine Funktion, die selber in UniScript geschrieben ist. Sie können sich den Quelltext von plot in der Datei script/plot.ic anschauen. plot hat den Zweck, XY-Diagramme aus Funktionen oder Vektoren zu erzeugen. In der Abbildung sehen Sie das Ergebnis des plot-aufrufs y-title x - Title Das Diagramm muss bei Ihnen nicht exakt genau so aussehen; plot verwendet die Standard- Einstellungen, die Sie mit dem Befehl Extras in UniPlot verändern können. Die plot-funktion hat ein neues Fenster erzeugt, in das Fenster ein Koordinatensystem gezeichnet, und die x- und die y-koordinaten als Kurvenzug im Koordinatensystem ausgegeben. Für diese drei Begriffe sollen im folgenden die Begriffe Dokument, Layer und Datensatz verwendet werden. Ein Fenster repräsentiert ein Dokument, ein Dokument ist der Inhalt des Fensters. In einem Dokument können ein oder mehrere Layer enthalten sein. Ein Layer hat ein Koordinatensystem, das nicht unbedingt sichtbar sein muss. Ein Layer kann neben Datensätzen auch Zeichenelemente enthalten. Ein Datensatz hat Datenpunkte mit Koordinaten. Er enthält aber auch Informationen über seine Darstellungsart. UniPlot ist in der objekt-orientierten Programmiersprache C++ programmiert worden. Dokumente, Layer und Datensätze sind dabei die Objekte, die mit UniPlot/UniScript erzeugt und verändert werden können. UniScript selber ist keine objekt-orientierte Programmiersprache. Um die Objekte dennoch zu verändern, werden in UniScript Zugriffsnummern (handle) auf die von UniPlot erzeugten Objekte verwendet. Der Aufruf h = plot(fahr = 0:20:300, 5/9 * (fahr - 32)) gibt einen Vektor von Zugriffsnummern zurück. h[1] ist dabei die Zugriffsnummer der Dokument-Seite, h[2] ist die Zugriffsnummer des Layers (Diagramms) und 2.9. Ausgabe der Temperaturtabelle als Grafik 11

16 h[3] die Zugriffsnummer des Datensatzes. Ordnen Sie das Kommandofenster und das Fenster mit dem Diagramm nebeneinander an und geben Sie im Kommandofenster PagePrint(h[1]) ein. Das Dokument wird gedruckt. Die Namen aller UniScript-Funktionen, die Dokumente verändern können, fangen mit den Buchstaben Doc an. Um eine Liste dieser Funktionen zu erhalten, geben Sie what("doc*") ein: * what ("Doc*") DocAddPage DocCopyPage DocCreate DocDestroy DocGetActivePage DocGetAllPages... DocSetProtectionFlags DocSetReadOnly DocSetSummaryInfo DocSetTitle DocShow 54 function(s) defined Die Funktion what gibt die Namen aller geladenen Funktionen aus, die ein bestimmtes Muster haben. Versuchen Sie what(), what("layer*") und what("xy*"). Schauen Sie sich die Beschreibungen der Funktionen im Hilfesystem an. Um die Beschreibung einer bestimmten Funktion zu erhalten, können Sie im Kommandofenster den Namen der Funktion schreiben, mit der Pfeiltaste nach links ein Zeichen zurückgehen und die F1-Taste drücken. Anschließend löschen Sie den Namen wieder mit der ESC-Taste. Zum Schluß sollen noch die Achsenbeschriftungen geändert werden LayerSetAxisTitle(h[2], "X", "Celsius") LayerSetAxisTitle(h[2], "Y", "Fahrenheit") PageReplot(h[1]) Normalerweise würde man die Achsenbeschriftungen mit UniPlot interaktiv ändern. Wenn die Achsenbeschriftungen aber automatisch erzeugt werden sollen, z. B. indem die Texte aus einer Datei gelesen werden, muss UniScript verwendet werden. 12 Kapitel 2. UniScript in Beispielen

17 KAPITEL 3 Elemente von UniScript 3.1 Kommentare Kommentare haben den Zweck, ein Programm besser lesbar zu machen. Die Sprache ignoriert alle Zeichen, die innerhalb von Kommentaren stehen. In UniScript gibt es Kommentare im C-Stil, die mit den Zeichen /* anfangen und mit den Zeichen */ enden, sowie Kommentare im C++-Stil, die mit den Zeichen // beginnen und bis zum Ende der Zeile reichen. Die Kommentare im C-Stil können über mehrere Zeilen gehen. Beispiele: /* */ Dies ist ein Kommentar im C-Stil. // Dies ist ein Kommentar // im C++-Stil Kommentare im C-Stil können überall dort stehen, wo auch ein Leerzeichen stehen kann, z. B.: rvsignal = [1.4, 1.45, /* Messfehler? */, 1.53]; Kommentare im C-Stil dürfen nicht geschachtelt werden. Die Zeichenfolge */ ist also innerhalb eines /* */-Kommentars verboten. Treffende Namen zu vergeben ist besser als ungünstige Namen zu kommentieren: ssfilename = GetOpenFileName(); ist auch ohne Kommentar besser zu lesen als die Zeilen // Dateinamen holen f = getname(); Auch Selbstverständlichkeiten zu kommentieren ist kein guter Stil // Minimum des Signals ermitteln rsmin = min(rvsignal); Kommentare werden häufig dazu verwendet, Quellcode-Zeilen auszublenden wie im folgenden Beispiel: // Berechnung einer n mal n Hilbert-Matrix def hilb(n) 13

18 /* */ h = zeros(n, n); for (i in 1:n) for (j in 1:n) h[i;j] = 1/(i+j-1); return h; // so geht es schneller als // mit zwei geschachtelten for-schleifen x = 1:n; x = x[ones(1,n); /* alle Spalten */ ]; return 1./(x+x. -1); 3.2 Fortsetzungszeilen In UniScript dürfen Anweisungen nicht über mehrere Zeilen gehen. Wird eine Anweisung zu lang, kann man mit zwei Punkten eine Fortsetzungszeile einleiten. UniScript ignoriert alle Zeichen hinter den beiden Punkten bis zum Ende der Zeile: return (ones(1,m).* 10).^.. [s1+(0:m-2) * (S2-s1)./ (m-1), S2]; Fortsetzungszeilen können nur dort beginnen, wo auch ein Leerzeichen erlaubt ist, also nicht innerhalb von Namen oder Konstanten. Eine Zeichenkette kann folgendermaßen in mehreren Zeilen geschrieben werden: "Dies ist eine lange konstante Zeichenkette," +.. " die über zwei Zeilen geschrieben wird" Ab UniPlot R brauchen hinter einem Komma, einem Semikolon und binären Operatoren keine.. mehr angegeben werden. D. h. die.. in den beiden Beipielen oben sind redundant. 3.3 Konstanten Die einfachste Form eines Ausdrucks ist eine Konstante. In UniScript gibt es drei konstante Typen: Reelle Konstanten, komplexe Konstanten (diese beiden Typen bezeichnet man als numerische Konstanten) und Zeichenketten-Konstanten oder String-Konstanten. 3.4 Numerische Konstanten Eine numerische Konstante steht für eine Zahl. In UniScript werden Zahlen als doppelt genaue Fließkomma-Zahlen gespeichert. Beispiele für gültige Zahlen sind: 14 Kapitel 3. Elemente von UniScript

19 e-3 12E3 Nicht zulässig sind folgende Darstellungen.03 // Punkt am Anfang nicht erlaubt 12. // Punkt am Ende nicht erlaubt 13.9D8 // Buchstabe D als Exponentkennzeichen // nicht erlaubt 3,82 // Dezimaltrennzeichen ist der Punkt, // nicht das Komma Es gelten genau die gleichen Regeln wie bei der Programmiersprache C. Normalerweise wird man Konstanten einen Namen geben. Dazu wird wie in C die #define- Anweisung verwendet. Die #define-anweisung hat folgende Form: #define konstanten-name ersatztext Anmerkung für C-Programmierer: Die define-anweisung ist die einzige Präprozessor-Anweisung, die UniScript kennt. Parameter sind nicht zulässig. Immer dort, wo der UniScript-Interpreter auf konstanten-name trifft (außer in Zeichenketten und Kommentaren), wird er durch den Ersatztext ausgetauscht. Der Konstanten-Name muss den Regeln für UniScript-Namen gehorchen, der Ersatztext kann eine beliebige Zeichenfolge sein. Wird beispielsweise die Konstante PI wie folgt definiert: #define PI kann der Name PI in Ausdrücken wie u = 2 * PI * r verwendet werden. Die Namen von Konstanten werden üblicherweise in Großbuchstaben geschrieben, um sie leichter von Variablennamen zu unterscheiden. Nach der Definition des Namens PI ist der Name in allen Dateien bekannt, nicht nur in der Datei, in der er definiert wurde wie in der Programmiersprache C. 3.5 Hexadezimale und oktale Konstanten Ganzzahlige Konstanten können wie in C auch in hexadezimaler oder oktaler Schreibweise geschrieben werden. Besteht eine Zeichenkette aus den Zahlen und a... f (oder A... F) und beginnt sie mit den Zeichen 0x oder 0X, wird sie als hexadezimale Zahl (Basis 16) interpretiert. Beispiel: 0x10 ist 16 0xFF ist 255 0x0d ist 13 0x5 ist 5 Besteht eine Zeichenkette nur aus den Ziffern , und sie beginnt mit der Ziffer 0 (null) wird sie als oktal, also zur Basis 8, interpretiert. 034 ist ist Hexadezimale und oktale Konstanten 15

20 3.6 Komplexe Konstanten Komplexe Konstanten werden eingegeben, indem man den Kleinbuchstaben i direkt hinter die Zahl schreibt, z. B. 3i, 1.23e-8i, 0xFFi. 3.7 String Konstanten String-Konstanten sind in Anführungszeichen stehende Zeichenketten: "Dies ist eine String-Konstante" Ein String kann Steuerzeichen (Escape Sequenzen) für die Ausgabe enthalten. Will man z. B. bei der Ausgabe das Wort "String-Konstante" in eine neue Zeile schreiben, muss man vor das Wort den String \n einfügen: "Dies ist eine\nstring-konstante" UniScript kennt folgende Escape-Sequenzen: Code Bedeutung \ Repräsentiert ein einzelnes \-Zeichen (den Backslash) \n Repräsentiert einen Zeilenwechsel (newline) \r Repräsentiert einen Wagen-Rücklauf (carriage return) \b Repräsentiert ein backspace \f Repräsentiert ein formfeed \t Repräsentiert ein Tabulator-Zeichen \a Repräsentiert einen Warn-Ton (allert) \" Repräsentiert das Zeichen \" \zzz zzz steht für eine ganze Zahl in hexadezimaler, oktaler oder dezimaler Schreibweise (siehe Anmerkung). \uxxxx XXXX steht für eine hexadezimale Zahl mit genau 4 Ziffern, die den Code eines Unicode-Zeichens enthalten (ab UniPlot 5.0). Anmerkung: Die Zahl zzz kann in dezimaler, hexadezimaler oder oktaler Schreibweise im Bereich (dezimal) sein. Es wird der ASCII-Code für die entsprechende Zahl ausgegeben. Beispielsweise sind die Zeichenketten "Hallo\n", "Hallo\10" (dezimal), "Hallo\012" (oktal) und "Hallo\x0a" oder "Hallo\0x0a" identisch. Bei der hexadezimalen Schreibweise, müssen den Zeichen \x oder \0x exakt zwei hexadezimale Zeichen (0.. f) folgen. Bei der dezimalen oder oktalen Schreibweise werden alle dezimalen (0.. 9) oder oktalen (0.. 7) Ziffern gelesen. Falls die Zahl größer als 255 (dezimal) ist, wird sie durch Abschneiden auf ein Byte gekürzt. Beispielsweise ist "\300a" nicht das selbe wie "\30" + "0a". Die hexadezimale Schreibweise ist der dezimalen und oktalen Schreibweise vorzuziehen, da sie nicht zu solchen Missverständnissen führen kann. Falls eine Zeichenkette den Präfix r hat, z. B. r"hallo\10" werden alle Backslashe in der Zeichenkette belassen, r"hallo\10" liefert die selbe Zeichenkette wie "Hallo\\10". Innerhalb einer einfachen Zeichenkette mit r-präfix kann kein "-Zeichen definiert werden. 16 Kapitel 3. Elemente von UniScript

21 3.8 Lange Zeichenketten Ab UniScript 4.0 gibt es sogenannte lange Zeichenketten. Diese Zeichenketten beginnen mit der Zeichenfolge "[[ und enden mit der Zeichenfolge ]]". Beispiel: a = "[[ Dies ist eine String-Konstante ]]" ist die selbe Zeichenkette wie: a = "\ndies ist eine\nstring-konstante\n" In langen Zeichenketten können -Zeichen mit oder ohne führendem Backslash verwendet werden. Der r-präfix ist möglich. 3.9 Null-Zeichen in Strings Ab UniScript können Zeichenketten Null-Zeichen enthalten (eight-bit clean Strings). Dadurch können UniScript-Strings beliebige binäre Daten enthalten. Der +-Operator kann auch für Zeichenketten mit 0-Zeichen verwendet werden. Die Vergleichsoperatoren verwenden nur den String bis zum ersten 0-Zeichen. "Hello\x00Hello" == "Hello" liefert TRUE (1). Um die Zeichenketten komplett zu vergleichen, kann die Funktion mem_compare verwendet werden. Viele String-Funktionen verwenden nur den Teil des Strings bis zum ersten 0-Zeichen. Beispiel: strlen("hello\x00hello") liefert 5, d. h. die Anzahl an Zeichen bis zum ersten Null-Zeichen. Der Funktionsaufruf mem_len("hello\x00hello") liefert in UniPlot 4.x den Wert 11 in UniPlot 5.x oder höher den Wert 22, da UniPlot 5 Unicode verwendet und ein Unicode-Zeichen 2 Bytes enthält Variablen Eine Variable ist eine benannte Speicheradresse. In UniScript braucht eine Variable nicht deklariert werden, man kann sie einfach bei Bedarf definieren: a = 1 Falls a bisher noch nicht existierte, wird sie durch diese Anweisung erzeugt, das heißt, es wird Speicherplatz für die 1 bereitgestellt und die 1 wird in den Speicher kopiert. Falls die Variable a bereits vorher existierte, wird zunächst der alte Wert der Variablen gelöscht. Der alte Wert kann z. B. ein "String" gewesen sein, die Variable kann also ihren Typ ändern. Der Name einer Variablen kann aus Buchstaben, Ziffern und Unterstrichen bestehen. Er muss aber mit einem Buchstaben oder einem Unterstrich anfangen. Länderspezifische Buchstaben (z. B. Umlaute) sind 3.8. Lange Zeichenketten 17

22 nicht erlaubt. Namen können beliebig lang sein. Es werden jedoch nur die ersten 80 Zeichen unterschieden. Groß- und Kleinbuchstaben werden unterschieden: var und Var sind also zwei unterschiedliche Namen. Namen dürfen nicht identisch mit den UniScript Schlüsselwörtern sein. In UniScript sind folgende Wörter reservierte Namen: break continue def else except for global if in print return try while Variablennamen dürfen auch nicht mit Funktionsnamen identisch sein: sin = sin(1) ist nicht zulässig, wohl aber Sin = sin(1). Gültige Variablennamen sind _test var1 Dies_Ist_Ein_Langer_Name a1 Return während die Namen 1a Dies ist kein Name a?3 ungültig sind. Bei größeren Programmen ist es empfehlenswert, die Namen so zu wählen, daß die Bedeutung und der Typ der Variablen erkennbar sind. Bei den Funktionen, die mit UniScript mitgeliefert werden, bestehen die meisten Namen deshalb aus einem Typpräfix und dem eigentlichen Namen, der mit einem Großbuchstaben anfängt. Beispiele: Name ssfilename svfilename smsorted rsxvalue rvmin rmsize Bedeutung ss steht für skalarer String. ssfilename wird also einen einzelnen Dateinamen enthalten. sv steht für String-Vektor. svfilename wird also vermutlich mehrere Dateinamen enthalten. sm steht für String-Matrix. rs steht für reeller Skalar. rv steht für reeller Vektor. rm steht für reelle Matrix. 18 Kapitel 3. Elemente von UniScript

23 bvisible b steht für Bool. Eine solche Variable sollte den Wert wahr oder falsch (TRUE (1) oder FALSE (0)) haben. hlayer h steht für Zugriffsnummer (handle). hvlayer hv steht für einen Vektor von Zugriffsnummern. nlayer n steht für Anzahl und sollte eine ganze Zahl sein, z. B Vektoren und Matrizen Die folgende Anweisung erzeugt einen Zeilenvektor mit den Elementen 6, 4 und 13 und weist ihn der Variablen a zu: a = [6, 4, 13] Falls die Variable a vorher bereits einen Wert hatte, wird dieser Wert durch diese Anweisung überschrieben. a ist nun ein reeller Vektor mit drei Elementen. Man kann die Variable a in Ausdrücken verwenden. Die Anweisung: b = a + 5 addiert den Wert 5 zu allen Elementen von a und weist das Ergebnis der Variablen b zu. b hat dann den Wert [11, 9, 18]. Es werden häufig Vektoren der Form [1, 2, 3, 4, 5,..., n] oder [1.0, 1.5, 2.0,...] benötigt. Zur Erzeugung solcher Vektoren steht der :-Operator zur Verfügung. Es gibt zwei Formen: start:end und start:step:end Die erste Form entspricht start:1.0:end. step wird zu start addiert, solange der Wert kleiner oder gleich end ist. Beispiel: 1:5 ist [1, 2, 3, 4, 5] 1.3:4 ist [1.3, 2.3, 3.3] 1:0.5:2 ist [1, 1.5, 2.0] start kann größer als end sein 5:1 ist [5, 4, 3, 2, 1] Ein Vektor ist in UniScript der Spezialfall einer Matrix; [6, 4, 13] ist eine 1 * 3 Matrix, d.h. sie besteht aus einer Zeile und drei Spalten. Matrizen, die nur Elemente in einer Zeile enthalten, bezeichnet man auch als Zeilenvektoren. Spaltenvektoren werden ähnlich eingegeben wie Zeilenvektoren, die Elemente werden jedoch durch ein Semikolon getrennt: Vektoren und Matrizen 19

24 a = [1;2;3] Spaltenvektoren können mit dem Transponierungsoperator in Zeilenvektoren umgewandelt werden (und umgekehrt). b = a Die Matrix kann man sich als Kombination der Zeilenvektoren [1,2,3], [4,5,6] und [7,8,9] vorstellen. Sie kann in UniScript folgendermaßen eingegeben werden: m = [1,2,3; 4,5,6; 7,8,9] Eine Matrix kann auch aus vorhandenen Vektoren und Matrizen aufgebaut werden, z. B m1 = [1,2,3; 4,5,6; 7,8,9] m2 = [10,11; 12,13] v1 = [14,15] v2 = [16;17;18] m = [m1, [m2;v1], v2] 3.12 Index-Ausdrücke Auf einzelne Elemente eines Vektors kann über seine Indizes zugegriffen werden. Hat die Variable a den Wert [1.5, 3.8, 6.3], dann hat a[1] den Wert 1.5, a[2] den Wert 3.8 und a[3] den Wert 6.3. Indizes sind ganzzahlige Werte und beginnen bei 1. Statt eines einzelnen Index kann auch ein Index- Vektor angegeben werden. So hat a[1, 3] den Wert [1.5, 6.3] und a[1, 3, 1] den Wert [1.5, 6.3, 1.5]. Einzelne Indizes können also mehr als einmal angegeben werden. Eine Vektor-Variable mit einem Index-Vektor kann auch auf der linken Seite des Zuweisungs-Operators stehen. a = [1, 2, 3, 4, 5] a[1, 4] = [-1, 66] a[1] wird der Wert -1 zugewiesen und a[4] der Wert 66. Der Index-Vektor muss in diesem Fall genauso viele Elemente haben wie der Vektor auf der rechten Seite des Zuweisungs-Operators. Um zwei Werte auf Gleichheit zu testen, wird in UniScript der ==-Operator verwendet. Die Variable a hat nun den Wert [-1, 2, 3, 66, 5]. Die Anweisung a[1, 4] = a[4, 1] 20 Kapitel 3. Elemente von UniScript

25 vertauscht das erste Element mit dem vierten Element des Vektors, ohne die anderen Elemente zu verändern. Die Anweisung a[6] = 100 führt zu einem Laufzeitfehler, da der Vektor a nur 5 Elemente hat. Um an den Vektor ein sechstes Element anzuhängen, muss geschrieben werden a = [a, 100] Auf eine Matrix kann mit zwei Indexvektoren die durch ein Semikolon getrennt sind zugegriffen werden. Der erste Indexvektor ist der Zeilen-Index-Vektor und der zweite der Spalten-Index-Vektor. Ist die Matrix a gleich [5,6;7,8] dann ist z. B. a[1;1] gleich 5 und a[1;2] gleich 6. Entsprechend ist a[1,2;1] gleich [5,6] die erste Zeile der Matrix a. Falls ein Zeilen- oder Spalten-Index-Vektor vollständig ist, kann er auch weggelassen werden. Anstatt a[1,2;1] kann man also schreiben a[;1], um auf die erste Zeile der Matrix a zuzugreifen. Eine Matrix wird in UniScript intern als eindimensionaler Vektor spaltenweise gespeichert. Die Elemente der Matrix werden also in UniScript intern in der Reihenfolge [1, 4, 7, 2, 5, 8, 3, 6, 9] gespeichert. Auf diese interne Darstellung kann zugegriffen werden, indem bei Matrizen ein eindimensionaler Indexvektor angegeben wird. Anstatt a[2;3] (zweite Zeile, dritte Spalte) kann auch a[8] geschrieben werden. Um auf alle Elemente der Matrix als Vektor zuzugreifen, kann a[1:9] geschrieben werden, dies entspricht der Schreibweise a[:]. Zusammenfassung var = start:step:end erzeugt einen Zeilenvektor. var = start:end erzeugt einen Zeilenvektor mit der Schrittweite 1.0. var = [e1, e2, e3] erzeugt einen Zeilenvektor. var = [e1; e2; e3] erzeugt einen Spaltenvektor. var = [e1, e2; e3, e4] erzeugt eine Matrix. var[index-vektor] greift auf Elemente eines Vektors zu. var[zeilen-index-vektor; spalten-index-vektor] greift auf Elemente einer Matrix zu. var[zeilen-index-vektor ; ] greift auf die Zeilenvektoren einer Matrix zu. var[ ; spalten-index-vektor] greift auf die Spaltenvektoren einer Matrix zu. var[:] wandelt eine Matrix in einen Zeilenvektor um Index-Ausdrücke 21

26 22 Kapitel 3. Elemente von UniScript

27 KAPITEL 4 Operatoren Operatoren wie der Additionsoperator + können in UniScript auf skalare Größen, Vektoren und Matrizen angewendet werden. Folgende Matrizen haben einen speziellen Namen: Zeile * Spalte Name 1 * 1 Skalar 1 * m Zeilenvektor n * 1 Spaltenvektor n * m Matrix n * n quadratische Matrix 4.1 Arithmetische Operatoren Die meisten Operatoren wirken elementweise, z. B. ( ) ( ) = ( 6 ) In diesem Fall müssen beide Operanden das gleiche Format haben, d. h. die gleiche Anzahl an Zeilen und Spalten. Jedoch kann einer der beiden Operanden ein Skalar sein: ( ) ( ) = oder 5 + ( ) 1 2 = 3 4 ( ) Andere Ausnahmen gibt es nicht, insbesondere kann kein Zeilenvektor zu einem Spaltenvektor addiert werden. Bei Zeichenketten wirkt der +-Operator wie eine Verkettung. ( ) ( alph bet alpha + a = gamm delt gamma ) beta delta Man beachte den Unterschied: ["a", "b"] ist ein Zeilenvektor mit zwei Elementen aus jeweils einem Zeichen. 23

28 "a" + "b" ist der Skalar "ab", der aus zwei Zeichen besteht. In UniScript gibt es zwei verschiedene Multiplikationsoperatoren: Den Matrizen-Multiplikations- Operator * und den elementweisen Multiplikations-Operator.*, der aus den beiden Zeichen. und * besteht, die unmittelbar hintereinander stehen müssen. Der.*-Operator wirkt wie der +-Operator elementweise: ( ) ( ) ( ) * = während der *-Operator eine echte Matrizenmultiplikation durchführt: ( ) ( ) ( ) * = Wenn einer der beiden Operanden ein Skalar ist, liefern beide Multiplikationsarten das gleiche Ergebnis. Bei Matrix-Multiplikationsoperatoren gilt nicht, daß die Zeilenanzahl gleich der Spaltenanzahl sein muss, sondern die Spaltenanzahl der ersten Matrix muss gleich der Zeilenanzahl der zweiten Matrix sein, was man gut erkennt, wenn man die Matrizen nach dem Falkschen Schema aufschreibt: 2 3 * Eine n * m-matrix multipliziert mit einer m * q-matrix liefert eine n * q-matrix. Es gibt drei verschiedene Divisionsoperatoren. Die elementweise Division./ arbeitet wieder ähnlich wie die Addition: ( ) ( ) ( ) / = während die Matrix-Division x/y (Rechts-Division) der Operation x / y = x * y^-1 = (y \ x ) = ((y )^-1 * x ) entspricht. Falls das System nicht quadratisch ist, wird eine Minimum- Norm-Lösung berechnet. Die Matrix-Links-Division x\y entspricht der Operation x \ y = x^-1 * y, ohne daß jedoch intern die Inverse berechnet wird. Auch bei diesem Operator gilt, daß falls das System nicht quadratisch ist, eine Minimum-Norm-Lösung berechnet wird. Beispiel: * a = [4,7;2,5] * a * b = [1;4] * b * x = a\b * x * a * x Kapitel 4. Operatoren

29 * a = [1,2;3,4;5,6] * a * b = [7,8,9] * b * x = a\b * a * x // Probe Der %-Operator (der wie der +-Operator elementweise wirkt) bestimmt den ganzzahligen Rest einer Division. Zunächst werden beide Zahlen durch Abschneiden der Nachkommastellen in ganze Zahlen umgewandelt wird dadurch in die Zahl 5 umgewandelt. Beispiel: * 5 % * % Bei der Potenzierung x^y muss x ein Skalar oder eine quadratische Matrix sein und y ein Skalar sein. Falls y eine ganze Zahl ist, wird die Operation durch Multiplikationen durchgeführt, sonst über die Eigenwerte und Eigenvektoren von x (x * omega^y * x^-1) mit der Matrix der Eigenvektoren x und der Diagonalmatrix der Eigenwerte omega). * a = [1,2;3,4] * a * a^ * a*a^ * a^ i i i i Der elementweise Potenz-Operator.^ wirkt wie der +-Operator, d.h. entweder haben beide Operanden das gleiche Format, oder einer der beiden Operanden ist ein Skalar. Die beiden Transponierungs-Operatoren (Transponierung) und. haben bei reellen Matrizen die gleiche Wirkung. Bei Matrizen mit komplexen Elementen werden die Elemente beim -Operator jedoch zunächst konjugiert. * a = [1,2;3,4] * a * a Arithmetische Operatoren 25

30 * a * a = a + 3i * a i i i i * a i i i i * a i i i i Zusammenfassung Operator Bedeutung x + y Addition von reellen und komplexen Zahlen sowie Verkettung von Strings. x - y Subtraktion von reellen und komplexen Zahlen. x * y Matrizen-Multiplikation von reellen und komplexen Zahlen. x.* y Elementweise Multiplikation von reellen und komplexen Zahlen. x / y Bei Skalaren gewöhnliche Division. Bei Matrizen entspricht die Division x/y der Operation x \* y^-1. Falls x ein Skalar ist, wird x elementweise durch y geteilt. x./ y Elementweise Division von reellen und komplexen Zahlen. x \ y Links-Division. Löst die Gleichung x^-1 \* y. x % y (Modulus) Ganzzahligen Rest einer Division bestimmen. Der Operator kann nur auf reelle Zahlen angewendet werden. x ^ y Potenzierung von reellen und komplexen Zahlen. x.^ y Elementweise Potenzierung von reellen und komplexen Zahlen. x Transponierung. Bei komplexen Matrizen werden die Elemente konjugiert. x. Elementweise Transponierung. 4.2 Vergleichsoperatoren Alle Vergleichsoperatoren wirken elementweise. Sie liefern 1, wenn der Vergleich wahr ist und 0, wenn der Vergleich falsch ist. ( ) ( ) < 2.5 = Bei Zeichenketten wird ein lexikographischer Vergleich durchgeführt: "a" < "b" ist 1 Achtung: Zeichenketten mit Umlauten werden nicht nach deutschen lexikalischen Regeln verglichen. 26 Kapitel 4. Operatoren

31 Die Zeichenketten werden exakt und Zeichen für Zeichen verglichen. Z. B. ist: "a " == "a" ist 0 "Hallo" == "hallo" ist 0 Im ersten Beispiel werden die Leerzeichen berücksichtigt und im zweiten Beispiel die Groß/Klein- Schreibweise. Ist das Verhalten nicht erwünscht, können die Funktionen strtrim und strlower (oder strupper) auf die Operanden angewendet werden. strtrim("a ") == strtrim("a") ist 1 strlower("hallo") == strlower("hallo") ist 1 Auf komplexe Zahlen können nur die beiden Operatoren == und!= angewendet werden. Zusammenfassung: Operator x < y x <= y x == y x!= y x > y x >= y Bedeutung x kleiner y x kleiner oder gleich y x gleich y x ungleich y x größer y x größer oder gleich y 4.3 Boolsche Operatoren Die boolschen (logischen) Operatoren werden meist in Verbindung mit den Vergleichsoperatoren angewendet. Z. B. ist der Ausdruck (a < 5) && (a > 8) wahr, d.h. gleich 1, wenn a kleiner als 5 und größer als 8 ist. Der Und-Operator hat eine niedrigere Priorität als alle Vergleichsoperatoren, so daß der Ausdruck eigentlich nicht geklammert werden müßte: a < 5 && a > 8 ist dasselbe wie (a < 5) && (a > 8). Zusammenfassung: Operator Bedeutung x && y Logische Und-Verknüpfung. x y Logische Oder-Verknüpfung.!x Logische Negation (Nicht x). 4.4 Bitweise Operatoren UniScript verfügt über die gleichen Operatoren für Bit-Manipulationen über die auch die Programmiersprache C verfügt. Die Operanden werden zunächst durch Abschneiden in vorzeichenbehaftete ganze Zahlen mit 32 Bits umgewandelt. Beispiel: 9.56 & wird bewertet als 9 & 10. Schreibt man die beiden Zahlen 4.4. Bitweise Operatoren 27

32 als Bitmuster (binär) auf, erhält man = 9 & = = 8 Die Bits im Ergebnis sind 1, wenn die entsprechenden Bits der Operanden 1 sind und sonst 0. Die bitweisen Operatoren können wie der arithmetische +-Operator auf Matrizen und Vektoren angewendet werden. Der Und - Operator wird dabei häufig dazu verwendet, einzelne Bits auf 0 zu setzen. Beispiel: rvsignal enthält ein mit einem 12Bit-AD-Wandler aufgenommenes Signal. Es sollen alle Bits von rvsignal bis auf die unteren 12 Bits auf 0 gesetzt werden. Dies wird mit erreicht indem man rvsignal mit 0x0FFF Und verknüpft rvsignal & 0x0FFF. Der Oder - Operator setzt die Bits auf 1, die in einem der Operanden 1 sind = = = 11 Der Exklusiv-Oder - Operator setzt die Bits auf 1, die in genau einem der Operanden 1 sind = = = 3 Die Schiebe-Operatoren schieben die Bits des linken Operanden nach rechts oder links. Beispielsweise ergibt (binär) << 1 das Ergebnis (binär) (dies entspricht einer Multiplikation mit 2). Die binäre Schreibweise ist in UniScript nicht möglich. Sie dient hier nur zur Verdeutlichung. Der Komplementoperator (ein Vorzeichen-Operator) vertauscht alle Bits seines Operanden (~01001 (binär) ist (binär)). Zusammenfassung: Operator Bedeutung x & y Bitweise Und-Verknüpfung. x y Bitweise Oder-Verknüpfung. y Exklusiv-Oder-Verknüpfung. x << y Bitweises Links-Schieben. x >> y Bitweises Rechts-Schieben. ~x Bitweises Komplement. 4.5 Assoziativität und Priorität der Operatoren In der Tabelle auf der nächsten Seite ist die Assoziativität (Zusammenfassung, Reihenfolge) und die Priorität (Vorrang) der Operatoren in aufsteigender Reihenfolge angegeben. Operatoren in einer Zeile haben den gleichen Vorrang. Durch Verwendung von Klammern bzw. durch Zuweisung an temporäre Variablen kann die Reihenfolge der Bewertung geändert werden. Mit Klammern sind nicht unbedingt die runden Klammern () gemeint. Beispiel: 28 Kapitel 4. Operatoren

33 * m1 = [1, 2] * m2 = [3, 4] * m3 = [5; 6] * m = [m1;m2,m3] >>> (E ) Format der Operanden inkompatibel * m = [[m1;m2],m3] * m Hier musste [m1;m2] geklammert werden, da der,-operator eine höhere Priorität hat als der ;- Operator. Operatoren Assoziativität = (Zuweisung) von rechts ; (spaltenweise Verkettung) von links, (zeilenweise Verkettung) von links (logisches Oder) von links && (logisches Und) von links (bitweises Oder) von (bitweises Exklusiv-Oder) von links & (bitweises Und) von links ==!= (Vergleich) von links <= < > >= (Vergleich) von links << >> (Links- und Rechtsschieben) von links + - (Addition und Subtraktion) von links *.* / %./ \ (multiplikative Operatoren) von links : (Vektorerzeugung) von links! ~ - + (Vorzeichenoperatoren) von links ^.^. (Potenz, Transponierung) von rechts 4.5. Assoziativität und Priorität der Operatoren 29

34 30 Kapitel 4. Operatoren

35 KAPITEL 5 Kontroll-Anweisungen Kontrollanweisungen bestimmen die Reihenfolge, in der Aktionen durchgeführt werden. Vorbild für die Kontrollstrukturen von UniScript war die Programmiersprache C; die for-anweisung von UniScript weicht jedoch von der C-Version ab. Die try-except-anweisung ist nur bei wenigen C-Compilern vorhanden; eine Variante existiert jedoch bei den moderneren C++-Compilern. Die switch-anweisung und die do-while-anweisung fehlen in UniScript. Diese Anweisungen sind jedoch einfach durch ifelse-if-ketten bzw. die while-anweisung zu ersetzen. Die goto-anweisung fehlt ebenfalls, weil es für sie nur sehr wenige vernünftige Verwendungen gibt. 5.1 Die if-else-anweisung Die if-else-anweisung wird für Entscheidungen verwendet. Sie hat die Form if (bedingung) if-anweisungen else else-anweisungen Der Ausdruck bedingung muss reell sein. Die if-anweisungen werden ausgeführt, wenn die Bedingung wahr ist (d.h. wenn der skalare Ausdruck ungleich 0 ist) und die else-anweisungen werden ausgeführt, wenn die Bedingung falsch, d.h. 0 ist. Der else-teil kann entfallen if (bedingung) if-anweisungen Gehört zu den if- und else-teilen nur jeweils eine Anweisung, kann auf die geschweiften Klammern verzichtet werden a = 1; if (a == 1) print "a ist 1" else print "a ist nicht 1" Übersichtlicher ist es jedoch, wenn die Anweisungen geklammert werden und eine Anweisung pro Zeile geschrieben wird. a = 1 if (a == 1) print "a ist 1" else print "a ist nicht 1" 31

36 Die folgende Schreibweise ist in UniScript nicht erlaubt, weil UniScript die zweite geschweifte Klammer als Ende der if-else-anweisung interpretiert und beim Wort else einen Syntaxfehler produziert. a = 1; if (a == 1) print "a ist 1"; else print "a ist nicht 1"; Wer die Anweisungen unbedingt in dieser Form schreiben will, kann sich mit Fortsetzungszeilen behelfen: a = 1; if (a == 1).. print "a ist 1"; else.. print "a ist nicht 1"; Die Bedingung muss, wie bereits bemerkt, ein reeller Skalar sein. Der Ausdruck string == "Hallo" liefert dann einen reellen Skalar, wenn string ein Skalar ist, nämlich 1, wenn in string "Hallo" steht und sonst 0. Falls string jedoch einen Vektor oder eine Matrix von Strings enthält, liefert der Vergleichsausdruck einen reellen Vektor oder eine reelle Matrix. Enthält string z. B. den aus drei Elementen bestehenden Vektor ["Hallo", "HALLO", "hallo"] liefert der Vergleichsausdruck string == "Hallo" den reellen Vektor [1, 0, 0]. Um diesen reellen Vektor in einen reellen Skalar umzuwandeln, existieren die beiden UniScript Funktionen all und any. Falls all mit einem reellen Vektor aufgerufen wird, liefert all den Skalar 1, wenn alle Elemente den Wert 1 haben und 0, wenn das nicht der Fall ist. Entsprechend liefert any den Wert 1, wenn irgend ein Wert des Eingabevektors den Wert 1 hat. Falls das Argument von all oder any eine reelle Matrix ist, wird die Matrix spaltenweise ausgewertet. Die Funktionen liefern dann einen Zeilen-Vektor. Durch doppeltes Anwenden der Funktionen kann daraus ein Skalar gemacht werden. Das folgende Beispiel führt also Aktion-1 nur aus, wenn alle Elemente von string den Wert "Hallo" haben, unabhängig davon, ob string ein Skalar, ein Vektor oder eine Matrix ist. if (all(all(string == "Hallo"))) // Aktion-1 else // Aktion-2 Häufig werden if-else-anweisungen verwendet, um eine Entscheidung aus einer Reihe von Alternativen zu treffen. In diesem Fall werden sogenannte else-if-ketten verwendet: if (bedingung-1) anweisung-1 32 Kapitel 5. Kontroll-Anweisungen

37 else if (bedingung-2) anweisung-2 else if (bedingung-3) anweisung-3 else if (bedingung-4) anweisung-4 else anweisung-n Die Bedingungen werden nacheinander geprüft, bis eine Bedingung zutrifft. Die entsprechenden Anweisungen werden ausgeführt und die else-if-kette wird beendet. Falls keine Bedingung zutrifft, wird der letzte else-fall ausgeführt. 5.2 Die for-anweisung Die for-anweisung wird dazu verwendet, über alle Elemente eines Vektors zu iterieren. for (i in vektor) for-anweisungen Hat vektor den Wert [1,3,6,4] nimmt i nacheinander die Werte 1, 3, 6, 4 an. vektor kann auch ein String-Vektor oder ein komplexer Vektor sein. Der Vektor wird nur einmal am Anfang der for-schleife ausgewertet. Das folgende Beispiel a = [1,2,3] for (i in a) a = 0; printf("a = %d, i = %d\n", a, i); erzeugt die Ausgabe a = 0, i = 1 a = 0, i = 2 a = 0, i = 3 Das folgende Beispiel verwendet die DocCreate-Funktion um drei UniPlot-Dateien zu öffnen: svfilename = ["be_ia.ipw", "fit.ipw", "no_x.ipw"]; svfilename = GetRootDirectory() + "examples/" +.. svfilename; for (ssname in svfilename) DocCreate(ssName); 5.3 Die while-anweisung Die while-anweisung wird verwendet, um eine Anweisung oder eine Folge von Anweisungen mehrfach auszuführen. Man bezeichnet dies als Schleife Die for-anweisung 33

38 while (bedingung) while-anweisungen bedingung muss wie bei der if-anweisung ein reeller skalarer Ausdruck sein. Die Anweisungen werden wiederholt ausgeführt solange die Bedingung wahr, also ungleich 0 ist. while (1) print "Hallo" würde also ununterbrochen ausgeführt, da die Bedingung nie den Wert 0 annimmt. Sie kann nur von außen abgebrochen werden, indem man die ESCAPE-Taste (ESC-Taste) betätigt. Man sieht solche while(1)-schleifen dennoch häufiger. Sie werden dann jedoch durch eine break- oder return- Anweisung abgebrochen. Diese while-schleife gibt genau 10 mal das Wort "Hallo" aus und druckt am Ende die Zahl 11. i = 1; while (i <= 10) print "Hallo"; i = i + 1; print i; 5.4 Die break- und die continue-anweisung Die break-anweisung wird in Verbindung mit der if-anweisung dazu verwendet, eine while- oder for-anweisung vorzeitig abzubrechen. Einige Sprachen haben eine Schleife, die am Ende prüft, ob die Anweisungen der Schleife nochmal ausgeführt werden sollen (bei Pascal ist dies die repeat-schleife, bei C die do-schleife). Mit der break-anweisung kann dieses Verhalten in UniScript simuliert werden. Das folgende Beispiel druckt 10 mal "Hallo" und am Ende die Zahl 10. i = 1; while (1) print "Hallo"; if (i == 10) break; i = i + 1; print i; Mit der continue-anweisung können Anweisungen innerhalb einer for- oder while-schleife übersprungen werden. Hier ein Beispiel, das alle Dateien aus einem Verzeichnis öffnet, die die Endung.ipw haben. sspath = "c:/uniplot/samples/"; svfiles = FindFiles(ssPath + "*.*"); for (ssname in sspath + svfiles[;1]) if (strupper(splitpath(ssname)[4])!= ".IPW") continue; if (DocCreate(ssName) == 0) break; 34 Kapitel 5. Kontroll-Anweisungen

39 FindFiles(ssPath + "*.*") liefert eine Stringmatrix mit den Dateien des Verzeichnisses sspath. In der ersten Spalte der Matrix befinden sich die Dateinamen. In der zweiten Spalte befindet sich die Größe der Dateien und in der dritten Spalte die Dateiattribute. Diese beiden Angaben interessieren hier nicht, weshalb sie mit dem Ausdruck svfiles[;1] herausgefiltert werden. Die Funktion SplitPath teilt einen vollständigen Dateinamen in seine Bestandteile Laufwerk, Pfad, Name und Erweiterung auf. Der Aufruf SplitPath(ssName)[4] liefert dabei die Dateinamenserweiterung. strupper wandelt sein Argument in Großbuchstaben um, so daß die Bedingung auch zutrifft, wenn SplitPath eine Dateinamenserweiterung in Kleinbuchstaben liefert. Wenn die Bedingung nicht zutrifft, wird die continue-anweisung ausgeführt. Dies bewirkt, daß ganz ans Ende, also unmittelbar vor die schließende geschweifte Klammer, gesprungen wird. Falls die Funktion DocCreate die Zahl 0 zurückliefert, konnte das Dokument nicht erzeugt werden. Es wird dann die break-anweisung ausgeführt, wodurch unmittelbar hinter die for-schleife gesprungen wird. Man hätte bei dem Beispiel übrigens auf die continue-anweisung verzichten können, indem man in FindFiles als Suchmuster "*.ipw" angegeben hätte, also FindFiles(ssPath + "*.ipw"). 5.5 Die try-except-anweisung Die try-except-anweisung dient hauptsächlich dazu, Programmierfehler abzufangen und die Fehlerbehandlung zu vereinfachen. Sie hat die Form try try-anweisungen except (bedingung) except-anweisungen Im Gegensatz zur if-else-anweisung ist der zweite Block nicht optional. Zu jedem try-block gehört genau ein except-block. try-except-blöcke können geschachtelt werden. Normalerweise werden nur die try-anweisungen ausgeführt, d. h. im Normalfall wird weder bedingung ausgewertet, noch die except-anweisungen ausgeführt. Es gibt jedoch eine Reihe von Gründen, die dazu führen, daß während der Ausführung der try-anweisungen ein Problem auftritt. Beispiele: Es ist nicht genug Speicher vorhanden, um eine der Anweisungen auszuführen. Der Benutzer hat die ESC-Taste gedrückt, während eine der try-anweisungen ausgeführt wurde. Es wurde auf ein Element eines Vektors zugegriffen, das nicht existiert. Falls die try-anweisungen Funktionsaufrufe enthalten, kann ein Fehler innerhalb der Funktion aufgetreten sein. Innerhalb einer Funktion kann die error-funktion aufgerufen worden sein. Der 1. und der 2. Fall sind Probleme, die vom Programmierer nicht vorhersehbar sind. Der 3. und 4. Fall sind im allgemeinen Programmierfehler. Man bezeichnet die Fälle als Ausnahmen und die Lösung der Probleme als Ausnahme-Behandlung (exception handling). Im 5. Fall (Aufruf der error-funktion) wird bewußt eine Ausnahme erzeugt. Beispiel: 5.5. Die try-except-anweisung 35

40 def GetTextFile(ssFileName) fp = fopen(ssfilename, "rt"); sstext = fread(fp, "char"); fclose(fp); return sstext; fopen öffnet eine Datei zum Lesen, fread liest aus der Datei (bei dieser Form des Aufrufs die gesamte Datei) und fclose schließt die Datei. Es ist wichtig, daß eine Datei nach ihrer Verwendung wieder geschlossen wird, da (je nach Betriebssystem) nur eine kleine Anzahl Dateien gleichzeitig geöffnet werden dürfen. Ruft man die Funktion mit GetTextFile("d:\\test.txt") auf, dann gibt die Funktion den Inhalt der Datei "d:\\test.txt" als Zeichenkette an den Aufrufer zurück. Voraussetzung ist, daß die Datei existiert, genug Speicher vorhanden ist, um die Datei zu lesen, in den Funktionen (z. B. fopen) kein Fehler ist und der Benutzer nicht während der Funktionsaufrufe die ESC-Taste gedrückt hat. Falls eine dieser Ausnahmen auftritt, wird das Programm mit einer Fehlermeldung abgebrochen. Das Problem ist, daß dieser Fehler auftreten kann, bevor die fclose-funktion aufgerufen wird. Es gibt einen sogenannten Ressourcen-Verlust. Das Problem kann gelöst werden, indem man die problematischen Anweisungen in einem tryexcept-block schützt. def GetTextFile(ssFileName) fp = 0; try fp = fopen(ssfilename, "rt"); sstext = fread(fp, "char"); if (isreal(sstext)) error(); fclose(fp); return sstext; except (1) if (fp!= 0) fclose(fp); MessageBox("Datei kann nicht geladen werden!"); return ""; Falls irgend eine Ausnahme innerhalb des try-blocks auftritt, wird in den except-block verzweigt, in dem die Ausnahme behandelt werden kann. In diesem Beispiel wird die Datei geschlossen (falls sie von fopen erfolgreich geöffnet wurde) und eine Fehlermeldung in einem Meldungsfenster ausgegeben. Hinter dem Schlüsselwort except steht eine in Klammern eingeschlossene Bedingung. Ist die Bedingung 0, wird die Ausnahme nicht im folgenden except-block behandelt. Ist die Bedingung ungleich 0 (im Beispiel wurde die Konstante 1 verwendet), wird der except-block beim Auftreten einer Ausnahme ausgeführt. Innerhalb der Bedingung kann mit der Funktion GetExceptionCode festgestellt werden, welche Ausnahme aufgetreten ist. Beispiel: def TestException(a, b) try for (i in 1:10000) 36 Kapitel 5. Kontroll-Anweisungen

41 x = a + b; except (GetExceptionCode() == ICERR_INTERRUPT) MessageBox("Benutzer-Abbruch"); Wird die Funktion z. B. mit den Argumenten "a" und 1.6 aufgerufen, TestException("a", 1.6), tritt eine Ausnahme auf. Dadurch wird der Ausdruck GetExceptionCode() == ICERR_INTERRUPT ausgewertet. GetExceptionCode liefert eine Fehlernummer - in diesem Fall die Fehlernummer mit dem Namen ICERR_OPERATOR_TYPE. Da die Fehlernummer nicht ICERR_INTERRUPT ist, wird der except-block nicht ausgeführt; die Ausnahme wird in diesem Fall nicht in der Funktion behandelt. Die Ausnahme wird nur behandelt, wenn der Benutzer in der for-schleife die ESC-Taste betätigt und dadurch die Ausnahme ICERR_INTERRUPT auslöst. Die Definitionen für die UniScript-Fehlernummern befinden sich in der Datei alias.ic Die try-except-anweisung 37

42 38 Kapitel 5. Kontroll-Anweisungen

43 KAPITEL 6 Funktionen für Vektoren und Matrizen In diesem Kapitel soll die Verwendung einiger wichtiger Funktionen zur Bearbeitung von Vektoren und Matrizen gezeigt werden. Die genaue Beschreibung der einzelnen Funktionen entnehmen Sie bitte den Hilfeseiten des Hilfesystems. Um Matrizen oder Vektoren zu erzeugen, bei denen alle Elemente 0 oder 1 sind, werden die beiden Funktionen zeros und ones verwendet. zeros(nr, nc) liefert eine Null-Matrix mit nr Zeilen und nc Spalten. zeros(1, 10) entspricht dem Aufruf ones(1, 10). Die Funktion rand(nr,nc) liefert Zufallszahlen zwischen 0 und 1. Die Funktion size(x) liefert die Größe der Variablen x. Sie gibt einen 1 * 2 Vektor zurück, der die Anzahl der Zeilen und Spalten seines Arguments enthält. Beispiel: * m = rand(3, 4) * size(m) 3 4 Die Funktion nr liefert die Anzahl der Zeilen einer Matrix oder eines Vektors, die Funktion nc liefert die Anzahl der Spalten und die Funktion len die Anzahl der Elemente. Somit ist len(x) gleich nr(x) * nc(x). Dazu einige Beispiele: v[len(v):1] = v[1:len(v)] tauscht die Reihenfolge der Elemente eines Vektors. Entsprechend tauscht: m[1:nr(m):1;] = m[nr(m):1;] die Zeilen einer Matrix, und m[;1:nc(m)] = m[;nc(m):1] die Spalten einer Matrix. Der Aufruf m = m[; 2:nc(m), 1] rotiert die Spalten einer Matrix, d.h. packt die erste Spalte der Matrix m hinter die letzte Spalte. v = v[1:3-1, 3+1:len(v)] entfernt das 3. Element aus einem Vektor. Um das erste Element zu entfernen, schreibt man 39

44 v = v[2:len(v)] und um das letzte zu entfernen v = v[1:len(v)-1] Die Typen von Matrizen können mit der Funktion type erfragt werden. Sie gibt einen der Strings "real", "complex", "string", "undef", oder "function" zurück. Der kleinste oder größte Zahlenwert in einem Vektor wird mit der Funktion min bzw. max gesucht. Falls das Argument eine Matrix ist, liefern die Funktionen einen Zeilenvektor mit den Minima/Maxima der Spalten des Vektors: * m = rand(3,3) * m * min(m) * max(m) Doppeltes Anwenden der Funktion liefert den kleinsten/größten Wert aller Elemente der Matrix: min(min(m)) oder max(max(m)). Mit der Funktion sort können die Elemente eines Vektors oder einer Matrix sortiert werden. Falls das Argument eine Matrix ist, werden die Zeilen der Matrix nach der ersten Spalte sortiert, d.h. die erste Spalte wird sortiert und die Zeilen der Matrix werden komplett ausgetauscht. * srand() // Random-Generator auf Startwert setzen * m = rand(3,4) * m * sort(m) Die Funktion find liefert die Indizes aller Werte seines Arguments die ungleich 0 sind. find wird hauptsächlich in Verbindung mit Vergleichsoperatoren verwendet. * a = [1,7,5,22] * a <= * find(a <= 5) Die beiden folgenden Zeilen setzen alle Elemente im Vektor a, die kleiner als 5 sind, auf 9. i = find(a < 5); a[i] = zeros(1, len(i)) Kapitel 6. Funktionen für Vektoren und Matrizen

45 KAPITEL 7 Funktionen Funktionen sind ein Mittel, die Übersicht bei größeren Programmen nicht zu verlieren. Eine Funktion ist eine Folge von Anweisungen, denen ein Name gegeben wird. Sie kann als Black-Box verwendet werden, ohne ihre Funktionsweise genau zu kennen. Um die Sinus-Funktion anzuwenden, benötigen Sie nicht das Wissen über ihre interne Arbeitsweise, Sie brauchen nur ihren Namen und ihre Schnittstelle zu kennen: Sie brauchen nur zu wissen, was die Funktion macht und nicht wie sie es macht. 7.1 Syntax von Funktionen In UniScript kann eine Funktion sehr einfach definiert werden def db(rvsignal) return 20.0.* log10(rvsignal); Hinter dem Schlüsselwort def steht der Name der Funktion, gefolgt von einer in Klammern eingeschlossenen Parameterliste, die hier nur einem Parameter enthält. Es folgt der sogenannte Funktionsrumpf mit den Anweisungen. Die letzte Anweisung gibt das Resultat der Funktion an den Aufrufer zurück. Die Funktion kann mit dem Aufruf rvdb = db(1:100); ausgeführt werden, wodurch die Zahlen 1 bis 100 in db umgerechnet werden. Formal sieht eine Funktionsdefinition folgendermaßen aus: def name (parameter-liste) anweisungen Für die Namen von Funktionen gelten die gleichen Regeln wie für Variablen-Namen. Er muss mit einem Buchstaben oder Unterstrich anfangen, gefolgt von beliebig vielen Buchstaben, Unterstrichen und Ziffern. Der Name darf nicht identisch mit einem reservierten Namen sein. Der Name darf außerdem nicht identisch mit einer eingebauten Funktion sein. Eine eingebaute Funktion (built-in-function) ist eine in C, C++ oder FORTRAN geschriebene Funktion, die beim Start von UniScript mit der Funktion loadlib geladen wird. Diese Funktionen befinden sich in sogenannten Dynamic Link Libraries (DLLs). Eine Liste der Funktionen können Sie mit dem Aufruf symbols(sym_builtin) erhalten. 41

46 Hinter dem Namen steht eine in Klammern eingeschlossene Parameterliste, die zwischen 0 und 32 durch Komma getrennte Parameter haben kann. Die kürzeste in UniScript mögliche Funktion ist def f() Die Klammern für die Parameterliste und die Klammern für den Funktionsrumpf sind syntaktisch erforderlich. Wird diese Funktion aufgerufen, gibt sie eine 0 zurück. 7.2 Parameter und Argumente Als Argumente bezeichnet man die Werte, mit denen eine Funktion aufgerufen wird. Parameter sind die Namen, die in der aufgerufenen Funktion für die Argumente stehen. Eine Funktion kann bis zu 32 Parameter haben. Beispiel: def db(rvsignal) return 20.0.* log10(rvsignal); db(1:100) Der Wert 1:100 ist das Argument, rvsignal ist der Parameter der Funktion. Eine Funktion kann mit weniger Argumenten aufgerufen werden als die Funktion Parameter hat. Beispiel: def Test(a, b, c) return 1; Test(); Test(1); Test(1,2); Test(1,2,3); Test(1,2,3,4); Alle Aufrufe sind zulässig bis auf den letzten. Eine Funktion darf nicht mit mehr Argumenten aufgerufen werden, als Parameter in der Parameterliste stehen. Die Anzahl der Argumente kann innerhalb einer Funktion mit der Funktion nargsin festgestellt werden. def Test(a, b, c, d, e, f, g) nargs = nargsin(); printf("die Funktion wurde mit %d von 7 " +.. "möglichen Argumenten aufgerufen\n", nargs); Es darf nicht auf Parameter zugegriffen werden, für die keine Argumente existieren. Wurde Test() mit Test(1, 2, 3) aufgerufen, dürfen die Parameter d - e in der Funktion nicht verwendet werden. 42 Kapitel 7. Funktionen

47 7.3 Globale und lokale Variablen Normalerweise sind alle innerhalb einer Funktion definierten Variablen lokal zur Funktion. Sie sind außerhalb der Funktion nicht bekannt. Wenn die Funktion aufgerufen (aktiviert) wird, werden die Variablen erzeugt und wenn die Funktion beendet wird, werden die Variablen aus dem Speicher entfernt. Mit der global-deklaration können Variablen definiert werden, die die Funktion überdauern. Außerdem können andere Funktionen oder Anweisungen außerhalb von Funktionen diese Variablen ändern. Beispiel: def Test() global Glob1, Glob2; Glob1 = 1; Glob2 = 2; Lokal1 = 3; Lokal2 = 4; print Glob1, Glob2, Lokal1, Lokal2; Glob1 = 5; Glob2 = 6; Lokal1 = 7; Lokal2 = 8; print Global1, Global2, Lokal1, Lokal2; Test(); print Global1, Global2, Lokal1, Lokal2; Führt man dieses Programm aus, druckt es zunächst die Zahlen 5, 6, 7, 8. In der Funktion Test() gibt es die Zahlen 1, 2, 3, 4 aus und in der letzten print-anweisung die Zahlen 1, 2, 7, 8. Die Funktion Test() hat die Variablen Glob1 und Glob2 verändert, nicht aber die außerhalb der Funktion definierten Variablen Lokal1 und Lokal2. Globale Variablen sollten sparsam verwendet werden, da es leicht vorkommen kann, daß eine solche Variable außerhalb einer Funktion versehentlich verändert wird. Außerdem schränken globale Variablen in Funktionen die Allgemeinverwendbarkeit der Funktionen ein. 7.4 Die return-anweisung Die return-anweisung hat den Zweck, Werte an den Aufrufer zurück zu geben und die Funktion zu beenden. Sie hat die Form return ausdruck; Wird ausdruck weggelassen, gibt die Funktion den Wert 0.0 zurück. Falls eine Funktion keine return-anweisung enthält, wird am Ende der Funktion eine Default-return-Anweisung ausgeführt, die ebenfalls den Wert 0.0 zurückgibt. Beispiel: def Test(x) if ((x % 2) == 0) return "x ist ohne Rest durch 2 teilbar"; 7.3. Globale und lokale Variablen 43

48 return "x ist NICHT ohne Rest durch 2 teilbar"; Test(4) Test(5) Falls das Argument von Test() durch 2 teilbar ist, wird die erste return-anweisung ausgeführt und die Funktion beendet, ansonsten wird die zweite return-anweisung ausgeführt. 7.5 Funktionen die mehrere Werte zurückgeben Funktionen, die Sie bisher kennen gelernt haben, wie z. B. die Funktion sin geben einen Wert an den Aufrufer zurück. Es ist jedoch manchmal erforderlich oder praktisch, daß eine Funktion mehrere Werte an den Aufrufer zurückgibt. Beispiel Ruft man die Funktion eig in der Form * m = [4,7;2,5] * eig(m) i i liefert sie die Eigenwerte der Matrix m. Ruft man die Funktion in der Form * <e, v> = eig(m) auf, schreibt sie die Eigenwerte in die Variable e und die Eigenvektoren in die Variable v. Definiert werden Funktionen dieser Art in der Form def <o1, o2> = name(i1, i2) o1 =...; o2 =...; Die beiden Ausgabeparameter (hier o1 und o2) werden nicht über die return-anweisung zurückgegeben, sondern in der Funktion werden die Werte direkt in die Parameter geschrieben. Wie für die Eingabeparameter gilt auch hier, daß nicht auf die Parameter zugegriffen werden darf, wenn die Funktion nicht mit der entsprechenden Anzahl an Parametern aufgerufen wurde. Die Anzahl kann innerhalb der Funktion mit nargsout ermittelt werden. def <a,b,c,d> = Test(e,f,g,h,i) nargsin = nargsin(); nargsout = nargsout(); printf("die Funktion wurde mit %d von 5 " +.. "möglichen Argumenten aufgerufen\n", nargsin); printf("die Funktion wurde mit %d von 4 " +.. "möglichen Ausgabe-Variablen aufgerufen\n",.. nargsout); Bei der Definition muss darauf geachtet werden, daß die Namen der Ausgabeparameter in den Winkeln <> nicht noch einmal in der Liste der Eingabeparameter verwendet werden dürfen. 44 Kapitel 7. Funktionen

49 Die Rückgabe mehrerer Return-Werte wird selten verwendet, weil die Verwendung von Objekten (siehe UniScript-Objekte) praktischer ist. Beispiel: def Test(p1, p2) o = [.]; // Objekt erzeugen o.a = 123; o.b = "Hello"; return o; 7.6 Aufruf von Funktionen aus DLLs DLL ist die Abkürzung für Dynamic Link Library. In DLLs befinden sich Funktionen, die mit einem Compiler erzeugt worden sind. Mit UniScript können solche Funktionen direkt aufgerufen werden. Es wird also kein C oder FORTRAN Compiler mehr benötigt, wie in den älteren Versionen der Skript- Sprache. Es gibt jedoch zwei Einschränkungen. Funktionen denen Strukturen oder Zeiger auf Funktionen übergeben werden, können nicht direkt aufgerufen werden. Für Funktionen dieser Art muss weiterhin eine Schnittstelle in C oder FORTRAN geschrieben werden. Wir wollen die Verwendung dieser neuen Schnittstelle an einigen Beispielen zeigen. FindWindow Das erste Beispiel ist die Funktion FindWindow(). Die Funktion befindet sich in einer DLL die zum Windows-Betriebssystem gehört. Die Funktion kann dafür verwendet werden, zu prüfen, ob ein bestimmtes Programm bereits gestartet wurde. Bevor die Funktion aufgerufen werden kann, muss die Funktion aus der DLL bei UniScript registriert werden. UniScript muss wissen, in welcher DLL sich die Funktion befindet, muss den Namen der Funktion kennen und muss die Typen der Parameter und den Typ des Returnwertes kennen. Die Datentypen der Parameter und des Returnwertes werden benötigt, damit UniScript beim Aufruf der Funktion entsprechende Konvertierungen durchführen kann. Zur Registrierung bei UniScript dient die Funktion RegisterFunction. Sie können den Funktionsaufruf zum Beispiel in die Startup-Datei startup.ic schreiben, damit die registrierte Funktion UniScript bei jedem Start bekannt ist. RegisterFunction ("user32","findwindowa",.. "uint", "FindWindow", ["char*", "char*"]); Die Parameter haben folgende Bedeutung: Der erste Parameter ist der Name der Dynamic Link Library (DLL). Die Funktion FindWindow() befindet sich in der DLL user32.dll in einem der Windows-Verzeichnisse. In welcher DLL sich die Funktion befindet, kann man der Dokumentation des Windows Software Development Kits (SDK) entnehmen, die bei den Windows-Compilern mitgeliefert wird. Der zweite Parameter ist der interne Name der Funktion. Die Funktion FindWindow() hat den internen Namen FindWindowA. Dies wird ebenfalls der SDK-Dokumentation entnommen Aufruf von Funktionen aus DLLs 45

50 Der dritte Parameter ist ein String, der den Typ des Returnwerts beschreibt. Aus der SDK- Dokumentation kann man entnehmen, daß der Returnwert von FindWindow() ein HWND ist (ein Handle auf ein Fenster). Da RegisterFunction den Typ HWND nicht kennt, kann statt dessen ein "uint" verwendet werden. Ein "uint" ist eine vorzeichenlose ganze Zahl mit 32 Bits. Die möglichen Typen, die bei RegisterFunction angegeben werden können, entnehmen Sie bitte der UniScript-Referenz. Der vierte Parameter ist der UniScript-Name, d. h. der Name mit dem die Funktion in UniScript aufgerufen werden soll. Sie können hier einen beliebigen Namen angeben, der den Regeln für Funktionsnamen entspricht. Der fünfte Parameter ist ein Vektor mit Strings, der die Parameter der Funktion beschreibt. Die Funktion FindWindow hat zwei Parameter. Der erste ist ein Zeiger auf einen String, der den internen Fensternamen angibt, und der zweite Parameter ist ein Zeiger auf einen String, der die Fenster- Titel-Beschriftung angibt. Der interne Fenstername ist bei dem Programm MS-Excel z. B. "XLMAIN", bei MS-Word " OpusApp" und bei UniPlot ":UniPlot:". Nachdem die Funktion registriert wurde, kann die Funktion aufgerufen werden. Die Funktion gibt einen Wert ungleich 0 zurück, wenn Excel gestartet wurde und sonst eine 0. // Finde des Fenster von Excel. Für den zweiten // Parameter kann eine 0 angegeben werden (siehe // SDK Dokumentation) h = FindWindow("XLMAIN", 0); if (h == 0) // Fenster nicht gefunden, d.h. Excel ist // noch nicht gestartet. Dann starte Excel system("excel", SW_SHOW, TRUE); // an dieser Stelle ist Excel gestartet DGEMM Das nächste Beispiel ist ein komplizierter Aufruf einer mathematischen Funktion, die sich in der mit UniScript mitgelieferten DLL rs_math.dll befindet. Sie wertet die folgende Anweisung aus: C = alpha * A * B + beta * C alpha und beta sind skalare Größen, A, B und C sind zueinander passende Vektoren oder Matrizen. Die Funktion dient hier nur als Beispiel, wie FORTRAN-Funktionen von UniScript aufgerufen werden, denn die Anweisung C = alpha * A * B + beta * C kann direkt so in UniScript ausgeführt werden. Ein Funktionsaufruf ist also eigentlich gar nicht erforderlich. Das Beispiel hat den Zweck zu zeigen, wie Funktionsaufrufe dieser Art durchgeführt werden. Die FORTRAN SUBROUTINE-Anweisung hat die Form: SUBROUTINE DGEMM (TRANSA, TRANSB, M, N, K, ALPHA, A, LDA, B,LDB, BETA, C, LDC) Die Funktion gehört zu einer großen Funktions-Bibliothek, der sogenannten BLAS (Basic Linear Algebra System). Funktionen in DLLs müssen eine sogenannte C-Schnittstelle haben, die bei dieser Funktion so aussieht: 46 Kapitel 7. Funktionen

51 int dgemm_(char *transa, char *transb, int *m, int *n, int *k, double *alpha, double *a, int *lda, double *b, int *ldb, double *beta, double *c, int *ldc); Die entsprechende UniScript Registrierung hat dann den folgenden Aufruf: RegisterFunction("rs_math.dll", "dgemm_", "int",.. "_dgemm",.. ["char*", "char*", "int*", "int*",.. "int*", "double*", "double*",.. "int*", "double*",.. "int*", "double*", "double*", "int*"]); Wir rufen die Funktion nicht direkt auf, sondern schreiben eine Verpackung. UniScript kann beim Aufruf von externen DLL-Funktionen nur ganz wenige Fehlerüberprüfungen machen. Ein fehlerhafter Aufruf kann zum Absturz von UniPlot führen (zu einer sogenannten Speicherzugriffsverletzung). Damit ein solches Problem nicht auftreten kann, wird eine sichere Hülle für _dgemm() geschrieben. Um das Beispiel zu vereinfachen, setzen wir in der Formel: C = alpha * A * B + beta * C alpha auf 1 und beta auf 0. // C = A * B def Multiply(a, b) if (nargsin()!= 2) error("number of args"); if (type(a)!= "real" type(b)!= "real") error("type error"); nra = nr(a); nrb = nr(b); nca = nc(a); ncb = nc(b); if (nra!= ncb) error("dimensions must match"); c = zeros(nra, ncb); _dgemm("n", "N", nra, ncb, nca, 1.0,.. a, nra, b, nrb, 0.0, c, nra); return c; Die folgenden Zeilen testen die Schnittstelle und vergleichen das Ergebnis mit dem in UniScript eingebauten Multiplikationsoperator. a = rand(2, 3); b = rand(3, 2); x1 = Multiply(a, b) x2 = a * b; print x1-x2; GetCurrentDirectory, SetCurrentDirectory 7.6. Aufruf von Funktionen aus DLLs 47

52 Wir wollen nun noch zwei Funktionen schreiben, mit denen man Verzeichnisse wechseln kann, bzw. die das aktuell gesetzte Arbeitsverzeichnis anzeigen: gwd() (get working directory) soll den Namen des aktuell gesetzten Verzeichnisses zurückgeben. cd() (change directory) soll in ein anderes Verzeichnis wechseln. Die entsprechenden Windows-Betriebssystem-Aufrufe sind GetCurrentDirectoryA() und SetCurrentDirectoryA(). GetCurrentDirectoryA() hat zwei Parameter: Der erste ist die Größe des Puffers, in den die Funktion den aktuellen Verzeichnisnamen schreibt, der zweite Parameter ist ein Zeiger auf den Puffer. Die Funktion schreibt nicht mehr Zeichen in den Puffer, als im ersten Parameter angegeben wurde. Sie gibt die Anzahl der Zeichen zurück, die in den Puffer tatsächlich geschrieben wurden. Die Registrierung der Funktion sieht folgendermaßen aus: RegisterFunction("KERNEL32", "GetCurrentDirectoryA",.. "uint", "GetCurDir", ["uint", "char*"]); Entsprechend die Registrierung für SetCurrentDirectoryA() RegisterFunction("KERNEL32", "SetCurrentDirectoryA",.. "uint", "SetCurDir", "char*"); Wir schreiben nun eine Verpackung für die beiden Funktionen: def gwd() ss = " "; ssbuffer = ""; for (i in 1:10) ssbuffer = ssbuffer + ss; GetCurDir(strlen(ssBuffer), ssbuffer) return ssbuffer; Die ersten drei Zeilen im Rumpf der Funktion gwd() erzeugen einen Puffer mit 300 Zeichen, der dann von der Funktion GetCurrentDirectoryA() gefüllt bzw. überschrieben wird. Der Puffer wird dann an den Aufrufer der Funktion gwd() zurückgegeben. Die Funktion SetCurrentDirectoryA() soll ebenfalls eine Verpackung erhalten. Die beiden if- Abfragen stellen sicher, dass SetCurrentDirectoryA() nicht mit fehlerhaften Parametern aufgerufen werden kann. def cd(ssdir) if (nargsin()!= 1) error("usage: cd (ssdir)") if (type(ssdir)!= "string") error("usage: cd (ssdir)") return SetCurDir(ssDir); Zum Schluss können die beiden Funktionen durch einige Aufrufe getestet werden: * cd ("c:/") * cd () 48 Kapitel 7. Funktionen

53 >>> cd : usage: cd (ssdir) * gwd() c:\ * cd("d:/uiplot/script") * gwd() c:\ * cd("d:/uniplot/script") * gwd() d:\uniplot\script 7.7 COM-Schnittstelle Ab Version 3.0 kann UniScript auf Objekte zugreifen, die ein sogenanntes Dispatch-Interface haben Zugriff auf Excel Wir wollen die Verwendung dieser neuen Schnittstelle an einigen Beispielen zeigen. Wir verwenden dazu als Beispiel das Tabellenkalkulationsprogramm Excel von Microsoft. Es soll eine Tabelle mit Daten gefüllt werden. Zunächst muss Excel gestartet werden. Dazu wird die Funktion CreateObject verwendet, die einen Zeiger(eine Referenz) auf Excel zurückgibt. Die Funktion erwartet als Argument den Servernamen des Programms das gestartet werden soll. Bei Excel lautet der Servername "Excel.Application". xls = CreateObject("Excel.Application") xls.visible = 1 Die zweite Anweisung (xls.visible = 1) macht das Fenster der Applikation sichtbar. Es wird die Punktschreibweise verwendet um auf eine Eigenschaft (property) des Objekts zuzugreifen. Die Punktschreibweise wird auch verwendet um auf Methoden (Funktionen) eines Objekts zuzugreifen. Die beiden folgenden Anweisungen fügen Excel eine Arbeitsmappe hinzu. wb = xls.workbooks wb.add(); Die beiden Anweisungen können auch in einer einzelnen Anweisung geschrieben werden. xls.workbooks.add() Mit den folgenden Zeilen wird die Tabelle gefüllt. xls.activesheet.range("a1").value = "x" xls.activesheet.range("b1").value = "sin(x)" x = linspace(0, 2*PI) y = sin(x) xls.activesheet.range("a2:a101").value = x xls.activesheet.range("b2:b101").value = y 7.7. COM-Schnittstelle 49

54 7.7.2 Zugriff auf Datenbanken Das folgende Beispiel verwendet die ADO (ActiveX Data Objects) um auf eine Excel-Tabelle wie auf eine Datenbanke mit SQL zuzugreifen. // create an Excel 2007 file with the following content and // name the sheet Sheet1: /* a b c 1 2 test1 4 5 test2 3 1 test3 */ def ado_excel_test() //Must be an XLSX file, slash or double backslash ssexcelfile = "c:\\excelfile.xlsx"; sssheetname = "Sheet1"; // HDR=Yes : First row are the column names of the table strcnn = "Provider=Microsoft.ACE.OLEDB.12.0;Data " +... "Source=%s;" +.. "Extended Properties=\"Excel 12.0 Xml;HDR=Yes;IMEX=1\";" strcnn = sprintf(strcnn, ssexcelfile); db = db_create("ado"); if (db.connect(strcnn) == 0) MessageBoxError("Cannot connect: %s", strcnn); return "" // $-sign is neccessary for the table name // return all data sssql = sprintf("select * FROM [%s$];", sssheetname); smdata = db.exec(sssql); // return all columns and all records where a > 1 sssql = sprintf("select * FROM [%s$] Where a > 1;", sssheetname); smdata = db.exec(sssql); // return column b and c where column a > 1 sssql = sprintf("select b,c FROM [%s$] Where a > 1;", sssheetname); smdata = db.exec(sssql); return smdata; Das folgende Beispiel verwendet die DAO DataBase-Engine um eine Excel-Tabelle zu lesen. Dabei kann mit der Punktschreibweise auf die Objekte der DataBase-Engine zugegriffen werden. dao = CreateObject("Dao.DBEngine.36"); if (dao == 0) error("dao.dbengine.3.6 kann nicht erzeugt werden"); ws = dao.createworkspace("", "Admin", "", 2); ssfile = GetRootDirectory() + "samples\ole\test.xls" dbs = ws.opendatabase(ssfile, 0, 0, "Excel 8.0;HDR=No;"); m = dbs.openrecordset("test$").getrows(1000); print m 50 Kapitel 7. Funktionen

55 7.7.3 Variantmatrizen In einer Excel-Tabelle können sich unterschiedliche Datentypen befinden. In dem Beispiel oben wurde in die Zelle A1 die Zeichenkette x geschrieben und in die Zellen A2 bis A101 wurden Gleitkommazahlen geschrieben. Bei Datenbanken kann jede Spalte einen anderen Datentyp haben. In der ersten Spalte könnte sich beispielsweise ein Datum befinden, in der zweiten Spalten ganze Zahlen und in der 3. Spalte Zeichenketten mit 80 Zeichen Länge. Um diese Art von Daten mit UniScript einfach bearbeiten zu können, wurden in UniScript 3.0 Variant- Matrizen eingeführt. Variant-Matrizen können Elemente der folgenden 4 Datentypen enthalten: Typ real complex Bedeutung Doppelt genaue Gleitkommazahlen. Jede Zahl verwendet 8 Bytes. Komplexe Zahlen. Das sind Pärchen von doppelt genauen Gleitkommazahlen. Jede komplexe Zahl verwendet also 16 Bytes. string Zeichenketten bis zur Länge 2 hoch 31. object Referenzen auf COM-Objekte. Das folgende Beispiel erzeugt einen Spalten-Vektor mit 3 Gleitkommazahlen, einer komplexen Zahl, einem String und einem Objekt. * xls = CreateObject("Excel.Application"); * v = [ConvertToVariant([1,2,3]), 4+5i, "Hello", xls] * v i Hello (0x001B6FC4) Auf Variantmatrizen kann in der gleichen Art zugegriffen werden wie auf andere UniScript-Matrizen. Mit Variantmatrizen kann jedoch weder gerechnet werden, noch können Vergleichsoperatoren auf Variant-Matrizen angewendet werden. Die folgenden Anweisungen führen also zu einem Laufzeitfehler: a = [1, "Hallo"] b = a if (a == b) MessageBox("a gleich b") Auch die folgenden Anweisungen sind nicht zulässig, da beim Zugriff auf eine Variantmatrix keine Typumwandlungen durchgeführt werden. a = [1, "Hallo"] b = a print a[1] + b[1] a[1] bzw. b[1] sind Variant-Matrizen mit jeweils einem Element des Typs "real" COM-Schnittstelle 51

56 Um mit Variant-Matrizen rechnen zu können müssen sie zunächst mit der Funktion VariantConvert in Real-Matrizen umgewandelt werden. a = [1, "Hallo"] b = a print VariantConvert(a[1]) + VariantConvert(b[1]) Die inverse Funktion zu VariantConvert ist ConvertToVariant. Mit VariantGetType kann die Typ-Matrix einer Variant-Matrix erfragt werden. Die UniScript-Variant-Matrizen sind nicht mit dem Datentyp Variant von Visual-Basic bzw. der COM- Schnittstelle zu verwechseln. Der Variant-Datentyp der COM-Schnittstelle hat folgende Datentypen: Typ-Nr. Name Bedeutung 0 VT_EMPTY Leer. 1 VT_NULL Null. 2 VT_I2 2-byte signed int. 3 VT_I4 4-byte signed int. 4 VT_R4 4-byte real. 5 VT_R8 8-byte real. 6 VT_CY Currency. 7 VT_DATE Datum/Zeit. 8 VT_BSTR Binary string. 10 VT_ERROR SCODE. 11 VT_BOOL Boolean. 17 VT_UI1 Unsigned char. Wenn UniScript eine Eigenschaft oder Methode der COM-Schnittstelle verwendet muss UniScript Datentyp-Umwandlungen zwischen den UniScript-Datentypen und den Datentypen der COM- Schnittstelle durchführen. UniScript geht dabei folgendermaßen vor. Die Typen VT_I2, VT_I4, VT_R4, VT_R8, VT_ERROR, VT_UI1 werden in den UniScript-real (doppelt genaue Gleitkommazahl) Datentyp umgewandelt. Typ Nummer VT_BSTR wird in einen UniScript-String umgewandelt. Die Typen VT_EMPTY, VT_NULL, VT_CY, VT_DATE werden in komplexe Zahlen umgewandelt. Der Real-Teil ist dabei der eigentliche Wert und der Imaginärteil die Typ-Nummer. Beispiel: Enthält die Spalte A einer Excel-Tabelle die folgenden Daten, A x 1, #DIV/0! FALSCH dann liefert UniScript den folgenden Vektor: * v = xls.activesheet.range("a1:a6").value * print v x i i 52 Kapitel 7. Funktionen

57 -2.147e i Das Feld A3 ist leer, dafür liefert UniScript die komplexe Zahl 0+0i. Das Feld A4 enthält ein Datum, dafür liefert UniScript die komplexe Zahl i. Mit DT_Format(real(v[4])) kann man diesen Datumswert in eine Zeichenkette umwandeln. Die Zelle A5 (-2.147e i) enthält einen Error-Code, in diesem Fall den Error-Code für die Excel-Formel =1/ UniPlot als Server UniPlot kann auch als Server verwendet werden. Sie können also Funktionen von UniPlot/UniScript in anderen Anwendungen verwenden. UniPlot hat dabei eine duale Schnittstelle, d.h., es kann sowohl von Sprachen wie VBScript, JavaScript, Visual Basic für Applikationen als auch von Sprachen wie C, C++, Visual Basic verwendet werden. Dies soll an einigen Beispielen mit Excel gezeigt werden. Um die Beispiele auszuprobieren, benötigen Sie Excel 97 oder Excel Vorbereitung Damit Sie die Beispiele ausprobieren können, müssen Sie zunächst folgende Schritte durchführen: Falls UniPlot gestartet ist, beenden Sie UniPlot. Öffnen Sie ein DOS-Kommandofenster. Die Beispiele finden Sie im Verzeichnis UniPlot\samples\ole. Kopieren Sie die UniScript- Dateien deren Namen mit AX- anfangen in das UniPlot Autoload-Verzeichnis. Sie können den folgenden Befehl im DOS-Kommandofenster eingeben: copy c:\uniplot\samples\ole\ax-*.ic c:\uniplot\autoload Wechseln Sie in das Verzeichnis \uniplot\program. Starten Sie UniPlot mit der folgenden Kommandozeile: uniplot /regserver Damit ist UniPlot in der Registrierdatenbank als OLE-Server angemeldet. Wenn Sie die Beispiele ausprobiert haben, löschen Sie die ax-*.ic-dateien aus dem uniplot/autoload-verzeichnis. Beispiel 1 (AX-Data) Das folgende Beispiel zeigt, wie UniScript-Funktionen von Excel aufgerufen werden können und wie Daten an diese Funktionen übergeben werden können. Um das Beispiel auszuführen, gehen Sie wie folgt vor: Starten Sie UniPlot. Öffnen Sie das UniScript Kommando- Fenster (ansichtkommando-fenster). Starten Sie Excel. Öffnen Sie die Datei uniplot\samples\ole\ax-data.xls. Excel zeigt evtl. ein Dialogfeld mit der Meldung, dass die Datei Makros enthält. Wählen Sie die Schaltfläche Makros aktivieren. Ordnen Sie das UniPlot- und das Excel-Fenster nebeneinander an. Selektieren Sie nun einige Felder der Excel-Tabelle. Sie sehen das im UniScript-Fenster Werte ausgegeben werden, wenn Sie die Selektion ändern COM-Schnittstelle 53

58 Wie funktioniert dieser Datenaustausch zwischen Excel und UniPlot/UniScript? Es wurden dazu zwei Programme geschrieben. Das Excel-Programm (in Visual-Basic für Applikationen) befindet sich in der Excel-Datei uniplot\samples\ole\ax-data.xls. Das UniScript- Programm befindet sich in der Datei uniplot\autoload\ax-data.ic. Betrachten wir zunächst das Excel-Programm. Sie können es sich ausschauen, wenn Sie in Excel den Befehl Extras=>Makro=>Visual Basic-Editor (Alt+F11) ausführen. Dim app As Object Private Sub Worksheet_SelectionChange(ByVal Target As Excel.Range) On Error GoTo Error Set app = CreateObject("UniPlot.Application") app.visible = 1 n = app.call("ax_datatest", Target) Error: End Sub Mit Dim app As Object wird eine globale Variable erzeugt. Die Variable wird nicht innerhalb der Funktion erzeugt, damit die Variable nicht zerstört wird, wenn die Funktion beendet wird. Die Funktion Worksheet_SelectionChange wird von Excel aufgerufen, wenn sich die Selektion der Tabelle ändert. Als Parameter wird der Funktion ein Bereichs-Objekt übergeben, hier mit dem Namen Target. Mit Set app = CreateObject("UniPlot.Application") wird eine Referenz auf eine laufende UniPlot-Instanz erzeugt. Die Funktion entspricht der CreateObject-Funktion von UniScript. Mit app.visible = 1 wird das UniPlot-Fenster angezeigt, falls es nicht bereits sichtbar ist. Mit n = app.call("ax_datatest", Target) wird eine UniScript-Funktion aufgerufen. Der erste Parameter ist der Name der UniScript-Funktion, hier AX_DataTest, danach folgen die Parameter für die Funktion. Hier wurde nur ein Parameter übergeben, da die Funktion AX_DataTest nur einen Parameter erwartet. Es können aber bis zu 16 Parametern über die Call-Methode an UniScript- Funktionen übergeben werden. Schauen wir uns nun die UniScript-Funktion AX_DataTest an, die von Excel aufgerufen wird. Die Funktion bekommt eine Range-Objekt von Ecxel übergeben. In der Funktion werden die Rows- Eigenschaft und die Value-Eigenschaft des Range-Objekts verwendet. Schauen Sie sich im Excel- Hilfesystem die Bedeutung dieser Eigenschaften an. def AX_DataTest(t) if (t.rows.count > 100) print "Rows > 100" else print t.value Beispiel 2 (AX-Curv) Um das zweite Beispiel auszuführen, gehen Sie wie folgt vor: Falls UniPlot gestartet ist, beenden Sie UniPlot. Starten Sie Excel. Öffnen Sie die Datei uniplot\samples\ole\ax-curv.xls. Excel 54 Kapitel 7. Funktionen

59 zeigt evtl. ein Dialogfeld mit der Meldung, dass die Datei Makros enthält. Wählen Sie die Schaltfläche Makros aktivieren. In der Excel-Tabelle befinden sich zwei UniPlot-Objekte mit jeweils einem Diagramm. Um Daten zum linken Diagramm zu schicken, markieren Sie die Zahlen 1, 4, 2, 2, etc. Zum rechten Diagramm werden die Zahlen geschickt, wenn die erste Zelle einen Wert ungleich 1 enthält. Private Sub Worksheet_SelectionChange(ByVal Target As Excel.Range) Dim arr(100) As Double On Error GoTo Error Worksheets("Sheet 1").OLEObjects(1).Enabled = True Worksheets("Sheet 1").OLEObjects(1).AutoLoad = True Worksheets("Sheet 1").OLEObjects(2).Enabled = True Worksheets("Sheet 1").OLEObjects(2).AutoLoad = True hdocleft = Worksheets(1).OLEObjects(1).Object.Handle hdocright = Worksheets(1).OLEObjects(2).Object.Handle t1$ = Cells(22, 2).Value t2$ = Cells(23, 2).Value i = 0 For Each Cell In Target.Cells arr(i) = CDbl(Cell.Value) i = i + 1 Next Set app = Worksheets("Sheet 1").OLEObjects(1).Object.Application n = app.call("ax_curvetest", hdocleft, hdocright, arr, i, t1$, t2$) Error: 7.7. COM-Schnittstelle 55

60 End Sub def AX_CurveTest(hDoc1, hdoc2, y, n, t1, t2) if (y[1] == 1.0) hpage = DocGetActivePage(hDoc1); else hpage = DocGetActivePage(hDoc2); if (hpage == 0) return 0; hlayer = PageGetAllDataLayers(hPage) hdata = LayerGetAllDatasets(hLayer); if (hdata == 0) hdata = XYCreate("test", 1, 1); LayerAddDataset(hLayer, hdata); if (n > 1) x = 1:n; ret = XYSetData(hData, x, y[x]); LayerAutoScale(hLayer) LayerSetAxisTitle(hLayer, "x", t1) LayerSetAxisTitle(hLayer, "y", t2) FF_FieldUpdate(0, hpage, 0, 0, 0); PageReplot(hPage); return n; 7.8 Der Debugger für Funktionen Mit dem Debugger können Sie UniScript-Funktionen im Einzelschritt durchlaufen, Haltepunkte setzen sowie sich die Werte von lokalen und globalen Variablen anschauen. 56 Kapitel 7. Funktionen

61 Die Anwendung des Debuggers soll an einem Beispiel gezeigt werden: Öffnen Sie die Datei uniplot\script\do_new.ic. Setzen Sie den Cursor auf die Zeile 62 (def _DoFileNew()). Drücken Sie die Funktionstaste F9 (Toggle-Breakpoint) um einen Haltepunkt auf diese Zeile zu setzen. Am linken Rand des Editors sehen Sie das Breakpoint-Symbol (rote Kreisfläche). Führen Sie den Befehl dateineu aus. Am Breakpoint (Haltepunkt) erscheint ein gelber Pfeil. UniPlot hält die Ausführung des Programms am Breakpoint an. Mit der Funktionstaste F10 können Sie die Funktion im Einzelschritt durchlaufen. Mit F5 können Sie bis zum nächsten Breakpoint bzw. zum Ende des Programms laufen. Bewegen Sie dazu den Mauszeiger über einen Variablennamen innerhalb der Funktion und halten Sie den Mauszeiger an. Der Wert der Variablen wird in einem kleinen gelben Fenster (Tooltip) angezeigt. Folgende Funktionen stehen beim Debugger zur Verfügung: F5 Laufe bis zum nächsten Haltepunkt (BreakPoint). Falls sich der Haltepunkt in einer Datei befindet die nicht geöffnet ist, wird die Datei vorher geöffnet. F9 Setze/Entferne Haltepunkt in der Zeile, in der sich der Cursor befindet. Strg+F9 Löscht alle Haltepunkte. F10 Aufruf als ein Schritt (Step) Der Debugger für Funktionen 57