This is documentation for Mathematica 4, which was
based on an earlier version of the Wolfram Language.
View current documentation (Version 11.1)

 Documentation /  Mathematica /  Das Mathematica Buch /  Die Prinzipien von Mathematica /  MathLink und externe Programm-Kommunikation /

Installieren vorhandener MathLink-kompatibler ProgrammeBehandlung von Listen, Arrays und anderen Ausdrü{ck}en

2.12.3 Anpassung externer, in Mathematica aufrufbarer Funktionen

Wenn eine Funktion, die in einem externen Programm definiert ist, aus Mathematica aufrufbar werden soll, dann muß nur noch geeigneter MathLink-Code hinzugefügt werden, der die Argumente an die Funktion übergibt und die produzierten Ergebnisse zurückgibt.

In einfachen Fällen läßt sich der erforderliche Code erzeugen, indem für jede externe Funktion eine geeignete MathLink-Schablone erzeugt wird.

:Begin:

:Function: f

:Pattern: f[x_Integer, y_Integer]

:Arguments: {x, y}

:ArgumentTypes: {Integer, Integer}

:ReturnType: Integer

:End:

Eine Datei f.tm, die eine MathLink-Schablone für eine externe Funktion f enthält.

Die Elemente einer MathLink-Schablone

Sobald eine MathLink-Schablone für eine bestimmte externe Funktion konstruiert worden ist, muß diese Schablone mit dem eigentlichen Quellcode der Funktion kombiniert werden. Unter der Annahme, daß der Quellcode in der Programmiersprache C geschrieben ist, läßt sich dies dadurch erreichen, daß eine Zeile hinzugefügt wird, durch die die MathLink-Standard-Header-Datei einbezogen wird, und dann ein kleines main-Programm eingefügt wird.

Einbeziehen der MathLink-Standard-Header-Datei.

#include "mathlink.h"

Hier ist der eigentliche Quellcode der Funktion f.

int f(int x, int y)

return x+y;

Dies richtet die externe Funktion ein, damit sie Aufrufe von Mathematica annehmen kann.

int main(int argc, char *argv[])

return MLMain(argc, argv);

Eine Datei f.c, die C-Quellcode enthält.

Beachten Sie, daß die erforderliche Form von main auf verschiedenen Systemen etwas unterschiedlich sein kann. Die Release Notes, die für Ihr spezielles Computersystem im MathLink Developer's Kit enthalten sind, sollten die geeignete Form liefern.

Typische externe Programme zur Verarbeitung von MathLink-Quelldateien

MathLink-Schablonen sind üblicherweise in Dateien mit Namen der Form datei.tm abgelegt. In derartige Dateien kann zwischen den Schablonen für unterschiedliche Funktionen auch C-Quellcode eingefügt werden.

Sobald die entsprechenden Dateien eingerichtet worden sind, müssen anschließend die MathLink-Schablonen-Information verarbeitet und der gesamte Quellcode kompiliert werden. Dies wird in der Regel durch Ausführen diverser externer Programme erledigt. Die genauen Einzelheiten werden dabei aber vom jeweiligen Computersystem abhängig sein.

Unter Unix enthält zum Beispiel das MathLink Developer's Kit ein Programm mit Namen mcc, das die MathLink-Schablonen in Dateien, deren Name mit .tm endet, vorverarbeitet und anschließend cc aufruft, um es auf den resultierenden C-Quellcode anzuwenden. mcc reicht Anweisungszeilen-Optionen und auch andere Dateien direkt an cc weiter.

Dies führt eine Vorverarbeitung mit f.tm durch und kompiliert dann die resultierende C-Quelldatei zusammen mit der Datei f.c.

mcc -o f.exe f.tm f.c

Dies installiert das Binärprogramm in die aktuelle Mathematica-Session.

In[1]:= Install["f.exe"]

Out[1]=

Nun ruft f[x, y] die externe Funktion f(int x, int y) auf und addiert zwei ganze Zahlen.

In[2]:= f[6, 9]

Out[2]=

Das externe Programm verarbeitet nur ganze Zahlen in Maschinengröße, so daß dies ein seltsames Ergebnis liefert.

In[3]:= f[2^31-1, 5]

Out[3]=

Auf anderen Systemen als Unix enthält das MathLink Developer's Kit in der Regel ein Programm mit Namen mprep, das Sie direkt aufrufen müssen, um alle .tm-Dateien, die Sie vorverarbeiten wollen, anzugeben. mprep erzeugt als Ausgabe C-Quellcode, den Sie anschließend einem C-Compiler zuführen können.

Behandlung von Links zu externen Programmen

Dies ermittelt den Link zum f.exe-Programm.

In[4]:= Links["f.exe"]

Out[4]=

Dies zeigt die Mathematica-Muster, die mit dem Link evaluiert werden können.

In[5]:= LinkPatterns[%[[1]]]

Out[5]=

Install richtet die eigentliche Funktion f so ein, daß eine geeignete ExternalCall-Funktion ausgeführt wird.

In[6]:= ?f

Wenn eine MathLink-Schablonendatei verarbeitet wird, werden zwei grundlegende Dinge getan. Zuerst wird mit den :Pattern:- und :Arguments:-Spezifikationen eine Mathematica-Definition erzeugt, die eine externe Funktion via MathLink aufruft. Und zweitens wird mit den :Function:-, :ArgumentTypes:- und :ReturnType:-Spezifikationen C-Quellcode erzeugt, der Ihre Funktion innerhalb des externen Programms aufruft.

:Begin:

Dies gibt den Namen der eigentlichen C-Funktion, die im externen Programm aufzurufen ist.

:Function: prog_add

Dies gibt das Mathematica-Muster, für das eine Definition festgelegt werden soll.

:Pattern: SkewAdd[x_Integer, y_Integer:1]

Die Werte der zwei Listenelemente sind die eigentlichen Argumente, die zur externen Funktion weitergereicht werden.

:Arguments: x, If[x > 1, y, y + x - 2]

Dies spezifiziert, daß die Argumente als ganze Zahlen zur C-Funktion weitergereicht werden sollen.

:ArgumentTypes: Integer, Integer

Dies spezifiziert, daß der Rückgabewert der C-Funktion eine ganze Zahl sein soll.

:ReturnType: Integer

:End:

Sowohl die :Pattern:- als auch die :Arguments:-Spezifikationen in einer MathLink-Schablone können beliebige Mathematica-Ausdrücke sein. Was immer Sie als :Arguments:-Spezifikation angeben, wird jedesmal, wenn Sie die externe Funktion aufrufen, evaluiert werden. Das Ergebnis der Evaluierung wird als Argumentenliste an die Funktion weitergereicht.

Manchmal wollen Sie vielleicht Mathematica-Ausdrücke erstellen, die nicht evaluiert werden sollen, falls eine externe Funktion aufgerufen wird, sondern stattdessen nur, wenn die externe Funktion installiert wird.

Dies erreichen Sie durch Einfügen von :Evaluate:-Spezifikationen in Ihrer MathLink-Schablone. Der Ausdruck, den Sie nach :Evaluate: angeben, kann über mehrere Zeilen fortgesetzt werden. Es wird dabei angenommen, daß das Ende dann erreicht ist, wenn eine leere Zeile oder eine Zeile auftaucht, die nicht mit Leerzeichen oder Tabulatoren beginnt.

Dies spezifiziert, daß eine Meldung für die Verwendung von SkewAdd eingerichtet werden soll, wenn ein externes Programm installiert wird.

:Evaluate: SkewAdd::usage = "SkewAdd[x, y] performs

a skew addition in an external program."

Wenn ein externes Programm installiert wird, werden die Spezifikationen in seiner MathLink-Schablonen-Datei in der Reihenfolge verwendet, in der sie angegeben wurden. Dies bedeutet, daß jeder in den :Evaluate:-Spezifikationen angegebene Ausdruck, der vor :Begin: plaziert ist, evaluiert werden wird, bevor die Definitionen für die externe Funktion eingerichtet werden.

Hier sind Mathematica-Ausdrücke, die evaluiert werden, bevor die Definitionen für externe Programme festgelegt sind.

:Evaluate: BeginPackage["XPack`"]

:Evaluate: XF1::usage = "XF1[x, y] is one external function."

:Evaluate: XF2::usage = "XF2[x] is another external function."

:Evaluate: Begin["`Private`"]

Dies spezifiziert, daß die Funktion XF1 in Mathematica eingerichtet werden soll, um die Funktion f im externen C-Programm aufzurufen.

:Begin:

:Function: f

:Pattern: XF1[x_Integer, y_Integer]

:Arguments: x, y

:ArgumentTypes: Integer, Integer

:ReturnType: Integer

:End:

Dies spezifiziert, daß XF2 in Mathematica die Funktion g aufrufen soll. Ihr Argument und ihr Rückgabewert werden als Gleitpunktzahlen angenommen.

:Begin:

:Function: g

:Pattern: XF2[x_?NumberQ]

:Arguments: x

:ArgumentTypes: Real

:ReturnType: Real

:End:

Diese Mathematica-Ausdrücke werden nach den Definitionen für die externen Funktionen evaluiert. Sie beenden den speziellen Kontext, der für die Definitionen verwendet wird.

:Evaluate: End[ ]

:Evaluate: EndPackage[ ]

Hier ist der eigentliche Quellcode für die Funktion f. Es ist nicht notwendig, daß die Argumente dieser Funktion die gleichen Namen haben wie ihre Mathematica-Gegenstücke.

int f(int i, int j)

return i + j;



Hier ist der eigentliche Quellcode für g. Zahlen, die Sie in Mathematica angeben, werden automatisch in den C-Typ double konvertiert, bevor sie zu g weitergereicht werden.

double g(double x)

return x*x;

Mittels :Evaluate:-Spezifikationen können Mathematica-Ausdrücke bei der ersten Installierung des externen Programmes evaluiert werden. Man kann auch erreichen, daß zu diesem Zeitpunkt Code innerhalb des externen Programms ausgeführt wird; dazu fügt man den entsprechenden Code in main() vor dem Aufruf von MLMain() ein. Dies ist manchmal nützlich, wenn man das externe Programm initialisieren muß, bevor Funktionen darin verwendet werden.

Ausführen einer Anweisung in Mathematica von einem externen Programm aus

int diff(int i, int j) {

Dies evaluiert eine Mathematica-Funktion mit Namen Print, falls i < j.

if (i < j) MLEvaluateString(stdlink, "Print[\"negative\"]");

return i - j;

}

Dies installiert ein externes Programm, das die oben definierte Funktion diff enthält.

In[7]:= Install["diffprog"]

Out[7]=

Der Aufruf von diff bewirkt, daß Print ausgeführt wird.

In[8]:= diff[4, 7]

Out[8]=

Beachten Sie: Alle Ergebnisse, die bei der durch MLEvaluateString() angeforderten Evaluierung erzeugt werden, werden ignoriert. Derartige Ergebnisse lassen sich nutzen, wenn eine vollständige Zweiweg-Kommunikation zwischen Mathematica und externen Programmen, wie sie im Abschnitt 2.12.9 erläutert wird, eingesetzt wird.

Installieren vorhandener MathLink-kompatibler ProgrammeBehandlung von Listen, Arrays und anderen Ausdrü{ck}en