Hallo an alle Forenmitglieder,
zunächst möchte ich mich entschuldigen, dass ich erst jetzt auf eure
E-Mails antworte.
Mein Problem war ja, dass ich das folgende Beispiel aus:
https://www.wolfram.com/mathematica/new-in-8/integrated-c-workflow/create-standalone-executables-using-compiled-funct.html
nicht ausführen konnte.
Doch es gibt links oben auf dieser Seite einen kleinen Schalter: "show
complete Mathematica input". Drückt man ihn, erhält man die sonst
fehlende Struktur von "lopassmainSrc". Hier hat Udo schon einen
richtigen Hinweis gegeben, wenn er schreibt:
"die Datei lopassmainSrcFile existiert nicht in diesem Beispiel:
Copy/Paste - Fehler bei der Erstellung des Manual. Im Fall muss diese
Funktion selbst geschrieben werden und im erzeugten Verzeichnis abgelegt
werden."
Voraussetzung dafür ist jetzt aber eben nur die tatsächlich, wenn aber
auch zunächst nur versteckt vorhandene Funktion lopassmainSrc. Und die
selbst zu schreiben..., jedenfalls das hätte ich nicht hingekriegt.
Ich möchte das so nun auch einwandfrei funktionierende Notebook jetzt
unten vollständig wiedergeben. Dann kann jeder Interessierte selbst
mitttels CreateExecutable eine Mathematica-erzeugte exe-Datei daraus
erstellen. Dadurch ergeben sich interessante Möglichkeiten, allerdings
benötige ich aber nun weitere Hilfe aus dem Forum, um eine Windows-App
daraus zu machen, denn ich habe keinerlei Erfahrungen mit dem dafür
sicherlich gut geeigneten Visual Studio. Aber das dürfte für einige
Forummitglieder vielleicht doch eine interessante oder doch auch
leichte(?) Herausforderung sein. Und interessant ist dies auch deshalb,
weil dieses lowpass-Beispiel, weiterverarbeitet zur Windows-App, m.E.
eine grundlegende Anleitung dafür bietet, selbst erstellte
Mathematica-Programme in kleine oder auch umfangreichere Gadgets
umzuwandeln. Ich hoffe, ich habe euer Interesse geweckt. Für die weitere
Umsetzung bietet sich das kostenlose Visual Studio 2022 an. Dazu gibt es
eine gute herunterladbare deutsche pdf-Anleitung für die Vorgehensweise
innerhalb des Studios:
cpp-get-started-msvc-170.pdf.
Man findet sie unter:
https://learn.microsoft.com/de-de/cpp/build/vscpp-step-0-installation?view=msvc-170
und kann diese Seite dann auch als pdf-Datei (auf der Seite links unten)
herunterladen.
Und in dieser pdf-Datei befindet sich auch ein schlichtes Beispiel für
die Erstellung eines simplen Taschenrechners in Visual Studio. Einen
solchen Taschenrechner nun aber auch direkt in Mathematica zu
programmieren, sollte einfach sein und dann könnte man sich vielleicht
die ganzen umständlichen Projektprozeduren in Visual Studio schenken, um
daraus gleich eine Windows-App zu machen...?
Aber eine Anbindung der in Mathematica erstellten lowpass.exe mittels
Visual Studio dürfte durch die pdf-Anleitung dann vermutlich auch
einfacher werden.
(Übrigens hat man mit dem kostenlos herunterladbaren
WolframPlayer_13.3.0_WIN_EXP.exe einen guten Viewer, die eigenen
Mathematica-Programmierungen und deren Ergebnisse, also Notebooks etc.
für andere sichtbar darzustellen.)
Auch möchte ich mich noch für den Beitrag von Peter bedanken. Vielleicht
gibt es ja jetzt mit dem Einsatz von Visual Studio doch eine
Möglichkeit, das lowpass schneller zu machen. Die Funktion lopass ist ja
ohnehin schon in compilierter Form angegeben und würde mittels C++ -
Verbindung doch wohl noch deutlich schneller werden (denn die
Langsamkeit von Mathematica wurde ja von Anfang an beklagt und gerade
aufwendige numerische Berechnungen sollten durch eine C-Anbindung schon
damals deutlich beschleunigt werden). Interessant ist dazu dann ja auch
der Hinweis auf das Buch "Mathematica und C in der modernen
Theoretischen Physik mit Schwerpunkt Quantenmechanik" (1997) von
Jens-Peer Kuska. Dem Buch liegt eine CD bei und ist mit Sicherheit immer
noch von großem Wert. Wie es der Zufall so will, hatte ich das Buch
(schon vor ca. 20 Jahren erworben). Und darin beschreibt der Verfasser
tatsächlich auch die Möglichkeit einer Anbindung von Mathematica an C
(damals mittels Mathematica Version 4). Mir war das damals aber alles
viel zu kompliziert und gerade deshalb fand ich die Möglichkeit (nun
mittels Mathematica 12) jetzt so prima, mit CreateExecutable eine
einfache Anbindung an das Visual Studio herzustellen.
Also für alle Beiträge herzlichen Dank.
Und nun, vielleicht findet jemand eine Lösung, den lowpass mittels
Visual Studio in eine Windows-App umzuwandeln. Die Programmierung des
Notebooks ist m.E. teilweise ziemlich raffiniert, aber der Nachvollzug
gerade deswegen lohnenswert und auch recht interessant. Dazu hier nun
das jetzt vollständige Notebook:
Software Development
Create Standalone Executables Using Compiled Functions
You can generate and distribute standalone executables.
lopassmainSrc = "
#include \"stdio.h\"
#include \"stdlib.h\"
#include \"lopass.h\"
#include \"WolframRTL.h\"
static WolframLibraryData libData = 0;
int main()
{
int err = 0;
mint i, type, rank, nelems, *dims;
double *data;
MTensor x, y;
double dt;
double RC;
libData = WolframLibraryData_new(WolframLibraryVersion);
/* read x */
type = MType_Real;
rank = 1;
dims = (mint*)malloc(rank * sizeof(mint));
scanf(\" %d\", &nelems);
dims[0] = nelems;
err = (*(libData->MTensor_new))(type, rank, dims, &x);
if (err) return 1;
free(dims);
data = (*(libData->MTensor_getRealData))(x);
for(i = 0; i < nelems; i++) {
scanf(\" %lf\", &(data[i]));
}
/* read dt */
scanf(\" %lf\", &dt);
/* read RC */
scanf(\" %lf\", &RC);
err = Initialize_lopass(libData);
y = 0;
err = lopass(libData, x, dt, RC, &y);
printf(\"%d\\n\", err);
if(0 == err){
dims = libData->MTensor_getDimensions(y);
nelems = dims[0];
data = (*(libData->MTensor_getRealData))(y);
printf(\"%d\\n\", nelems);
for(i = 0; i < nelems; i++)
printf(\"%f\\n\", data[i]);
}
Uninitialize_lopass(libData);
return 0;
}
";
Start by defining a function or functions of interest.
lopass = Compile[{{x, _Real, 1}, dt, RC},
Module[{a = dt/(RC + dt), yprev = First[x], yi},
Table[yi = a*x[[i]] + (1 - a)*yprev;
yprev = yi;
yi, {i, 1, Length[x]}]]];
Generate C code and a header.
targetDir = CreateDirectory[]
fnSource = FileNameJoin[{targetDir, "lopass.c"}];
Export[fnSource, lopass];
Write a C main function to call the generated code.
lopassmainSrcFile = FileNameJoin[{targetDir, "lopassMain.c"}];
Export[lopassmainSrcFile, lopassmainSrc, "Text"]
Compile it into an executable using the Wolfram Runtime Library.
Needs["CCompilerDriver`"];
lopassExe =
CreateExecutable[{fnSource, lopassmainSrcFile}, "lowpass",
"TargetDirectory" -> targetDir,
"Libraries" -> "WolframRTL_Static_Minimal"]
Now you can distribute the program and run it outside of
/Mathematica/. You can also run it inside /Mathematica/ to test
and demonstrate it. Set up an input signal with several
frequency components.
input = Table[Sin[x] + Sin[x*10] + Sin[x*50], {x, 0, 10, 0.01}];
ListPlot[input, Joined -> True]
Convert the input signal to the file format that the executable
expects.
inputText =
StringJoin[ToString[Length[input]], "\n",
Riffle[ToString /@ input, "\n"],(* dt*)"0.01",(*RC *)"0.3"];
inputFile = FileNameJoin[{targetDir, "input.txt"}];
Export[inputFile, inputText, "Text"]
Run the executable, parse the output, and plot the original
signal (blue) with the low-pass filtered signal (red).
SetDirectory[targetDir]; outputLines =
Import["!" <> lopassExe <> " < " <> inputFile, "Lines"];
ResetDirectory[];
output = ToExpression /@ outputLines;
output = If[
Length[output] > 1 && First[output] === 0 &&
output[[2]] === Length[output] - 2,
Drop[output, 2],
$Failed
];
ListPlot[{input, output}, Joined -> True]
Also, die obige Aufforderung
Now you can distribute the program and run it outside of
/Mathematica/.
spricht ja nun Bände.
Deshalb, ich bin dankbar für jeden Beitrag, dies nun auch zu realisieren!
Beste Grüße
Axel
--
Diese E-Mail wurde von Avast-Antivirussoftware auf Viren geprüft.
www.avast.com
_______________________________________________
DMUG Deutschsprachiges Mathematica-Forum demug@XXXXXXX.ch
http://www.mathematica.ch/mailman/listinfo/demug
Archiv: http://www.mathematica.ch/archiv.html
DMUG-Archiv, http://www.mathematica.ch/archiv.html