Backtesting Software

      Wenn Du mit GUI Automation sowas hier meinst ? Man kann sich also mit Mathematica ein Notebook erstellen, welches wiederum andere Notebooks automatisch erzeugt und natürlich kann das Notebook sich aktuelle Daten holen und diese verwerten.

      Die UsingFrontEnd-Doku ist nicht sonderlich aussagekräftig. Ich habe mich da durch viele andere Dokumente lesen müssen, um den Grundgedanken zu verstehen. Vieles davon von Wolfram Research, aber halt nicht da, wo ich es erwartet habe :D. Erwähnte ich nicht, dass Variante 3 die suchintensivste war ? ;)
      Du kannst COM und auch Excel direkt einbinden, wenn Du magst. Guckst Du hier Man kann auch Exceltabellen direkt in die Notebooks einbinden und darin weiterarbeiten.

      Danke für deine Mühen. Ich habe gestern noch den NET-Guide gelesen und bin etwas durch die Referenzen gebraust, und habe nichts Entsprechendes gefunden. Ich hätte eigentlich damit gerechnet, dass es sowas wie klassische GUI Automation gibt, wie zB bei Excel. Hasst du einen Link zu den Docs bzgl. UsingFrontEnd[] ?


      Ich habe erst die ersten Tutorials durch. Gibt es innerhalb von Mathematica eine Art Scripting Möglichkeit? Zum Beispiel, das Script holt sich die aktuellen Daten aus einem CSV-File, und spuckt dann die entsprechenden PDFs aus? Es muss ja nicht um jeden Preis von einer externen App passieren, wären halt ein paar Clicks mehr, aber das wäre auch keine Katastrophe.

      Textwand für Freaks

      Also... Neueste Informationen aus der Entwicklungsabteilung von Krümel Enterprises International besagen folgendes:


      Es gibt drei Möglichkeiten wie man die .NET API namens .NET/Link von Mathematica nutzen kann:

      Variante 1: Verwenden von eigenen oder Standard-.NET-Assemblies in Mathematica

      Man lädt sich das Link-Paket nach Mathematica, lädt anschließend die .NET Assemblies, aus denen man Funktionalitäten nutzen möchte, muss bei den Werteübergaben und Werteabfragen aber auf die passenden Typen achten bzw. deren Umwandlung. Wer auf was wie abbildet, ist aber gut von Wolfram beschrieben z.B. hier: CallingNETFromMathematica .

      Wenn man zwischendurch an der Assembly selbst noch was ändern will und neu kompilieren muss, muss man zuvor die Runtime "abschalten" und nachher wieder anschalten. Das ist nötig, weil das Entladen einer Assembly aus dem laufenden Betrieb so erstmal nicht von Microsoft vorgesehen war.
      Dafür gibts das Pärchen: InstallNET[] / ReinstallNET[].
      Damit umgehen sie bei Mathematica das Problem, was man mit R hat, wenn man sich auf normalen Weg eine .NET Assembly reinlädt: Man kriegt das Ding partout nicht mehr raus, darf die dll beim Neukompilieren nicht überschreiben und muss somit R neustarten, damit die Assembly entladen wird. Das ist megalästig, wenn man gleichzeitig in R und VS entwickelt.
      Man sollte also relativ problemlos gleichzeitig sowohl in Mathematica als auch VisualStudio (ich nehme mal an, dass die Mehrheit der .NET-Programmierer diese IDE verwenden) entwickeln können.

      Diese Variante bietet sich an, wenn man z.B. schon Berechnungsfunktionen in C# oder ähnlichen vorliegen hat und die nicht umschreiben möchte, darüber hinaus aber viel Wert auf die Mathematica-GUI und den WYSIWYG-Editor legt, der sich auch gut für Prototyping eignet.

      Kleines Beispiel:

      Quellcode

      1. (*Paket laden, welches die .NET Api zur Verfügung stellt *)
      2. Needs["NETLink`"]
      4. (*Runtime starten, das geht aber auch ohne diesen expliziten Call, denn die Runtime läuft anscheinend per default,
      5. man muss nur explizit abschalten, wenn man die Assembly neuladen will*)
      6. InstallNET[]
      8. (*Assembly laden mit Pfad*)
      9. LoadNETAssembly["wo liegt DLL - Path hier eintragen" <> "MathematicaTestAssembly.dll"]
      11. (*die Klasse laden, die man nutzen will, mit vollem Namen, also auch Namespace beachten*)
      12. testAssType = LoadNETType["MathematicaTestAssembly.TestAssembly"];
      14. (*Objekt erzeugen*)
      15. testAssObj = NETNew[testAssType];
      17. (*Ich rufe hier nur die Werte aus einem Attribut Data ab, welches lediglich ein Integer-Array int[] mit Randomwerten enthält, die
      18. bei der Objekterzeugung geniert werden *)
      19. randomIntegers = testAssObj@Data
      21. (*damit kann man jetzt in Mathematica weiterarbeiten. *)
      22. ListLinePlot[randomIntegers]
      24. (*Objekt explizit zerstören*)
      25. ReleaseNETObject[testAssObj]




      Variante 2: Verwenden von Mathematica-Kernel-Funktionen in einer eigenen .NET-Applikation:

      Man will z.B. die Mathematica-Grafiken (gibts ja auch in 3D zum Drehen ^^) in eine Form einbinden. Das geht sehr einfach: Wolfram's dll in das eigene Projekt einbinden, ein Kernel-Objekt erstellen, diese Referenz einer MathPictureBox (erbt von der .NET-Picturebox) in die Hand drücken und dann über das Feld MathCommand (String) die Mathematica-Plot-Befehle einspeisen. Zeichnen und aktualisieren bei geändertem Inhalt in MathCommand übernimmt diese Picturebox selbst.

      Bei der einzubindenden DLL Wolfram.NETLink.dll muss unbedingt die richtige eingebunden werden (es gibt mehrere mit demselben Namen, die funktionieren aber nicht alle gleich. ^^)
      Die, die funktioniert, findet man im Verzeichnis <Mathematica dir>\SystemFiles\Links\NETLink (das steht aber auch in dem Guide drin. Von daher muss man das eigentlich nur abarbeiten.


      Kleines Beispiel: in einer Form sind ein mehrzeiliges Textfeld und eine MathPictureBox-Instanz enthalten.
      Immer wenn der Text in dem Eingabefeld geändert wird, ändert sich automatisch die Grafik (vorausgesetzt, man gibt auch Grafikbefehle ein ;) ).
      Ich verkürze den Code mal aufs wesentliche und lasse das restliche Chichi-Zeug weg, was der VS-Code-Generator erzeugt. Fehlerbehandlung etc. muss man natürlich separat einbauen.

      Quellcode

      1. //Namespace einbinden mit den Funktionen
      2. using Wolfram.NETLink;
      4. partial class Form1
      5. {
      6. [...]
      7. public Wolfram.NETLink.UI.MathPictureBox pictureBox2;
      8. public System.Windows.Forms.TextBox textBox2;
      9. [...]
      12. public Form1(IKernelLink ml)
      13. {
      14. InitializeComponent();
      15. InitMathematicaComponents(ml);
      16. }
      18. private void InitMathematicaComponents(IKernelLink ml)
      19. {
      20. this.pictureBox2 = new Wolfram.NETLink.UI.MathPictureBox(ml);
      21. this.textBox2 = new System.Windows.Forms.TextBox();
      22. [...]
      24. //Bei Textänderung reagieren !
      25. this.textBox2.TextChanged += new System.EventHandler(this.textBox2_TextChanged);
      26. [...]
      27. }
      29. //wenn sich der Text in der Textbox ändert, soll auch der Mathematica-Plot in
      30. //der MathPictureBox aktualisiert werden
      31. private void textBox2_TextChanged(object sender, EventArgs e)
      32. {
      33. //Mathematica soll Plot aktualisieren !
      34. this.pictureBox2.MathCommand = this.textBox2.Text;
      35. }
      36. }
      38. //Verwendung
      40. static class Program
      41. {
      42. [STAThread]
      43. static void Main()
      44. {
      46. [...]
      47. // Mathematica Kernel wird gestartet, vorbildlicherweise wird sogar ein Designpattern verwendet ;)
      48. IKernelLink ml = MathLinkFactory.CreateKernelLink();
      50. // Zu Beginn wird ein "Hier bin ich" -Begrüßungspaket geschickt (InputNamePacket), damit man
      51. // weiß, dass der Kernel korrekt gestartet wurde, dieses muss man abwarten, wertet es aber an der Stelle hier nicht aus
      52. ml.WaitAndDiscardAnswer();
      55. //Nachfolgender Block erstellt eine Form mit einer Mathematica-Picturebox, welche mittels dem MathCommand
      56. //Feld den Inhalt zugewiesen bekommt. Wird das Feld neugesetzt, wird automatisch der PictureBox-Inhalt
      57. //aktualisiert.
      58. //Diese Picturebox muss mit einem Mathematica-Kernel verbunden sein (Variable ml).
      59. Form1 form = new Form1(ml);
      60. form.textBox2.Text = "ListPlot[Range[10]]";
      62. //über das MathCommand sind das Texteingabefeld und Mathematica verbunden.
      63. //Da das Texteingabefeld mit dem Plotbefehl initialisiert wird und auf die
      64. //Textänderung das MathCommand reagiert, kann man sich weitere Initialisierungen sparen.
      67. //Fertig zusammengebaute GUI starten
      68. Application.Run(form);
      71. //Am Programmende im Rahmen der Aufräumarbeiten den Kernel beenden,
      72. //sollte man immer machen, steht in der Doku
      73. ml.Close();
      75. }
      76. }


      Parallel dazu nutzt man den Kernel ebenfalls (oder einen zweiten, was ich präferieren würde, damit man sich mit den Rücksendungen nicht in die Quere kommt), um alle möglichen anderen Mathematica-Kernel-Funktionen zu nutzen. Einfach den Befehl als String rüberschicken, wenn man einen Returnwert erwartet auf das Ergebnis der Berechnung warten und dann den richtigen Rückgabewert abfragen und verwerten.
      Hierzu ist der Dokumentation schon für Wolfram-Verhältnisse erstaunlich dürftig (v.a. die .Net-Klassen *grummel* könnten echt Nachrüstung gebrauchen).

      Kleines Beispiel:

      Quellcode

      1. static class Program
      2. {
      3. [STAThread]
      4. static void Main()
      5. {
      7. [...]
      8. // Mathematica Kernel wird gestartet
      9. IKernelLink ml = MathLinkFactory.CreateKernelLink();
      11. // Zu Beginn wird ein "Hier bin ich" -Begrüßungspaket geschickt (InputNamePacket), damit man
      12. // weiß, dass der Kernel korrekt gestartet wurde, dieses muss man abwarten, wertet es aber an der Stelle hier nicht aus
      13. ml.WaitAndDiscardAnswer();
      16. // Ein einfaches Bild aus einem Plot erzeugen und speichern als JPEG
      17. ml.Evaluate("gr = Plot[ Sin[x], {x, 0, 2*Pi}];");
      18. ml.Evaluate("Export[\"test.jpg\",gr, \"JPEG\"]");
      20. //Und noch was mit Rückgabewert
      21. ml.Evaluate("2+2");
      22. ml.WaitForAnswer();
      23. int intResult = ml.GetInteger();
      24. Console.WriteLine("2 + 2 = " + intResult);
      26. //Am Programmende im Rahmen der Aufräumarbeiten den Kernel beenden
      27. ml.Close();
      29. }
      30. }



      Variante 3: Erstellen von automatischen Reports (Notebooks oder PDFs) aus .NET heraus:

      Das ist der bei weitem unangenehmste Teil von allen, denn hier sind einige Sachen noch nicht fertig oder noch gar nicht implementiert.

      Man kann auf jeden Fall schon aus .NET heraus (gilt auch immer alles für java , sollte ich vielleicht an der Stelle mal beiläufig erwähnen) eigene Notebooks erzeugen (lassen), indem man die Befehle ähnlich wie in Variante 2 an einen Mathematica-Kernel schickt. Doch anders als im obigen Beispiel ruft man dafür primär "Frontend"-Funktionen auf. Mathematica unterscheidet zwischen Kernel- und Frontendfunktionen. Frontend-Funktionen sind solche, die man auch von der Mathematica-Notebook-Gui aus verwendet, wenn man irgendwo draufklickt (also: Notebook aufmachen, was reinschreiben, speichern, ne Zelle selektieren und löschen usw.). Diese Funktionen sind auch recht gut dokumentiert. Problem ist aber: man hat ja in C# kein "Frontend" = keine GUI, sondern muss dem Standalone-Kernel nur suggerieren, dass da eines sei. Das macht man, indem man um die Mathematica-Funktionen einfach noch ein UsingFrontEnd[] drumherumhäkelt, bevor man den Befehl wie auch in Variante 2 schon an den Kernel schickt.

      Kleines Beispiel:

      Brainfuck-Quellcode

      1. static class Program
      2. {
      3. [STAThread]
      4. static void Main()
      5. {
      7. [...]
      8. // Mathematica Kernel wird gestartet
      9. IKernelLink ml = MathLinkFactory.CreateKernelLink();
      11. // Zu Beginn wird ein "Hier bin ich" -Begrüßungspaket geschickt (InputNamePacket), damit man
      12. // weiß, dass der Kernel korrekt gestartet wurde, dieses muss man abwarten, wertet es aber an der Stelle hier nicht aus
      13. ml.WaitAndDiscardAnswer();
      16. //------------------------Notebook erstellen, was reinschreiben und speichern---------------------------------------
      19. //Notebook erzeugen lassen
      20. String expr = "UsingFrontEnd[nb =NotebookPut[ Notebook[ {Cell[BoxData[RowBox[{\"2\", \"+\", \"1\"}]], \"Code\"]} ]]] ";
      21. ml.EvaluateToOutputForm(expr, 0);
      23. //Noch ne Zelle hinten anfügen, man kann auch Zellen remote löschen oder mittendrin einfügen. Dazu Doku lesen !! ;)
      24. expr = "UsingFrontEnd[NotebookWrite[nb, Cell["New content", "Subsection"]]]";
      25. ml.EvaluateToOutputForm(expr, 0);
      27. //speichern
      28. expr = "UsingFrontEnd[file = ToFileName[\"C:/Users/Ich/Mathematica_Notebooks/test/\", \"Test28.nb\"];]";
      29. ml.EvaluateToOutputForm(expr, 0);
      31. expr = " UsingFrontEnd[NotebookSave[nb, file]; NotebookClose[nb];]";
      32. ml.EvaluateToOutputForm(expr, 0);
      35. //Und das klappt derzeit noch nicht: Evaluieren des Inhalts und Ersetzen der Zellen. Was auch bedeutet, dass noch
      36. //keine Plots erzeugt und eingefügt werden.
      37. expr = "UsingFrontEnd[NotebookEvaluate[file,InsertResults -> True]];";
      38. ml.EvaluateToOutputForm(expr, 0);
      41. //Am Programmende im Rahmen der Aufräumarbeiten den Kernel beenden
      42. ml.Close();
      43. }
      44. }


      Derzeit (also in 8.0.4) geht NotebookEvaluate bzw. sämtliche Varianten ein Notebook ohne ECHTES Frontend zu evaluieren noch nicht (also z.B. auch "Alles auswählen und evaluieren" mittels

      Quellcode

      1. //nb enthält das Notebook
      2. UsingFrontEnd[SelectionMove[nb, All, Notebook]];
      3. UsingFrontEnd[SelectionEvaluate[nb]];


      ). Von der Mathematica-GUI aus ja, ohne GUI nein. :( Die einzige mehr oder mehr oder weniger offizielle Antwort dazu habe ich in der MathGroup gefunden. Inhalt in etwa: Nun ja, "wir bauen es ein, wenn Interesse besteht"." Hmpf. Suuuper. :(

      Ich habe vieles ausprobiert, denn so richtig wollte ich es nicht glauben, dass es nicht geht. Ich habe es aber nicht hinbekommen. Wenn jemand nen Trick findet, wäre ich sehr dankbar. Mein Workaround wäre: Man erstellt sich remote das Notebook mit sämtlichen Inhalt, macht es dann mit Mathematica kurz auf, drückt auf den Menüpunkt "Evaluate Notebook" und speichert das Ergebnis dann in dem Format, welches man haben will (also z.B. PDF). Dieser Evaluierungsschritt geht nämlich remote aktuell nicht, und man muss es quasi manuell "nachbauen". Hirnrissig, aber nicht zu ändern. Auch in der Mathematica-Doku strahlen einen stellenweise noch grüngelbe Warnbalken an, dass das Thema noch in Bearbeitung ist. NotebookEvaluate wurde erst in Version 8 eingefügt, ist also noch recht frisch.

      Variante 2 und 3 sind hier in CallingMathematicaFromNET beschrieben.
      Zur Verwendung von Frontend-Funktionen gibts aber noch viel mehr (z.B. hier, denn das sind ja auch Funktionen, die man von Mathematica direkt für eigene Zwecke nutzen kann und nicht nur für die Fernsteuerung aus .NET heraus.


      Zusammenfassung

      Variante 1 ist gefällig und gut nutzbar. Variante 2 ist zwar weniger gut dokumentiert, aber das Prinzip versteht man schnell, somit fällt das Doku-Manko nicht so auf. Variante 3 hat Potential, aber mich bislang die meisten Nerven und Sucherei gekostet und das will was heißen. Eigentlich geht es aber auch recht einfach, leider hat Mathematica da aber noch eine offene Baustelle, so dass man derzeit mit Einschränkungen arbeiten muss. Man muss sich aber mMn am tiefsten in den Notebook-Aufbau einarbeiten und mit den aktuell noch offenen Baustellen leben bzw. Kompromisse eingehen beim Ergebnis. Es besteht jedoch noch Hoffnung, dass es in zukünftigen Versionen von Mathematica eingebaut wird.

      Purri schrieb:

      Krümel: hasst du schon mal die Mathematica .NET api verwendet? Ist das einigermaßen schmerzfrei zu benutzen?

      Kann ich nicht beurteilen, ich schleppe mich schon den ganzen Tag mit Ibuprofen durch. Bei mir ist alles schmerzfrei :D. Und ja, ich hab's heute zum ersten Mal das Interface verwendet, bislang hatte ich noch nie das Bedürfnis.


      Purri schrieb:


      Im Prinzip mache ich Auswertungen in C#, und will dann halbwegs ansprechende Reports erstellen, vorzugsweise in PDF oder Html. Nachdem du heute ein paar Bilder gepostet hasst, habe ich mir gedacht dass es evtl. die Mathematica Plot-Funktionen dafür geeignet sind. Zur Zeit habe ich nur rein Text-basierte Ausgaben. Ich will also vorhandene Daten plotten bzw in tabellarischer Form ausgeben, etwas Layout und dann das Ganze als PDF oder Html ausgeben. Und möglichst wenig Aufwand. Ist da Mathematica brauchbar?

      Es gibt eine sehr gute Anleitung (allerdings auf Englisch) und auch einige Beispiele. Alles bei Mathematica in der Hilfe mit dabei oder bei Wolfram auf der Webseite.
      Z.B. .Net User Guide als PDF

      Ich hab Dir hier mal ein kleines Beispiel programmiert
      test.zip
      , das funktioniert bei mir, lädt meine Dotnet-Assembly, welche lediglich eine Liste mit Integer-Randoms generiert und diese ruft man von Mathematica aus ab. Die plotte ich dann.
      Man muss bei den Typen nur aufpassen, was man in was umwandelt bzw. was Mathematica automatisch schon macht. Ist aber alles recht gut beschrieben. Die Doku von Wolfram ist echt vorbildlich. Da kommt man auch ohne irgendwelche Userforen aus.

      Reports erstellen geht einfach. Mathematica-Notebook einfach mit Save-As in folgende Formate exportieren:



      In die andere Richtung gehts natürlich auch, das habe ich allerdings jetzt nicht ausprobiert, hab nur gesehen, dass die Doku auch voll mit Infos dazu war.

      Bei IronPython wird mW noch immer kein MatPlotLib unterstützt. Sho hätte limitierte Plot-Funktionalität, genauso wie DataVisualization.Charting im .Net Framework. Damt kann man zwar plotten, aber kein Layout für die Reports machen, oder PDFs machen. Ich hab sowas noch nie gemacht. Aber wahrscheinlich ist Mathematica dafür eh auch nicht das Richtige.

      Krümel: hasst du schon mal die Mathematica .NET api verwendet? Ist das einigermaßen schmerzfrei zu benutzen?

      Im Prinzip mache ich Auswertungen in C#, und will dann halbwegs ansprechende Reports erstellen, vorzugsweise in PDF oder Html. Nachdem du heute ein paar Bilder gepostet hasst, habe ich mir gedacht dass es evtl. die Mathematica Plot-Funktionen dafür geeignet sind. Zur Zeit habe ich nur rein Text-basierte Ausgaben. Ich will also vorhandene Daten plotten bzw in tabellarischer Form ausgeben, etwas Layout und dann das Ganze als PDF oder Html ausgeben. Und möglichst wenig Aufwand. Ist da Mathematica brauchbar?

      Danke PT,

      wenn ich nicht meine Matlab Studentenlizenz bis ins Rentenalter ausdehnen will, bleibt mir nur der Umstieg auf eine Alternativsoftware.
      Denn Matlab ist für Privatpersonen definitiv unbezahlbar. Was Du über die Zusatzpakete von Mathematica schreibst, wundert mich etwas
      und hatte ich eigentlich so bei Matlab gesehen. Wird hier also am Ende von beiden Firmen dieselbe Preispolitik betrieben?
      Ich dachte, mit Mathematica + TimeSeries-Package hätte man 99% der notwendigen Funktionen.

      Hallo!
      Habe den Thread mit großem Interesse gelesen. Leider kenne ich bisher nur Matlab.
      Daher meine Frage an diejenigen, die bereits mit Mathematica und Matlab gearbeitet haben:
      Für die Verarbeitung von Kursdaten sollte eigentlich ein Programm für numerische Mathematik geeigneter
      sein als eines für symbolische Mathematik. Haben euch in Mathematica schon Funktionen für die
      Analyse von Zeitreihen gefehlt, die in Matlab vorhanden sind? Wie sind die Programme im Vergleich
      bezüglich Stabilität, Qualität der Hilfedateien, Unterstützung durch den Hersteller/Internetforen?
      Danke!

      Perfect Trader schrieb:

      Danke Purri, das hat mich aus sehr interessiert und darum habe ich gleich mal einen neuen Thread Python für Trading- und Backtest-Aufgaben dazu eröffnet - und hoffe nun, daß die wahren Python- und Backtest-Experten da auch von angelockt werden.

      Hi,

      ich bin sicher kein Python Experte, ich habe mir auf die Schnelle ein Tutorial reingezogen, um mit Sho ein bischen herumspielen zu können, das wars.

      Ich habe das wohl im falschen Thread gepostet, das ist ja eigentlich keine Backtesting-Software - wenn man richtiggehend ein Tradingsystem simulieren will, stelle ich mir das relativ anstrengend vor, und mit spezialisierter Software kommt man wohl viel schneller ans Ziel. Ich hab noch nicht einmal ein Timeseries Paket für IronPython gefunden.

      Ich sehe das eher als Daten-Anyalyse und Visualisierungs-Software. Nichts was man mit R oder Mathematica nicht auch oder wahrscheinlich besser machen kann, aber auf Grund der Integration in VisualStudio finde ich das sehr interessant. Wenn man vorwiegend in C# unterwegs ist, ergeben sich da sicher sehr interessante Einsatzmöglichkeinten, vor allem mit der interaktiven Konsole. Man kann einfach sehr schnell mit ein paar Code-Zeilen Sachen ausprobieren und Ergebnisse visualisieren. Man kann sogar ein Programm zur Laufzeit verändern. So eine Konsole gab es bisher in VS nicht. Ausser F# Interactive - aber funktionale Programmierung ist für mich schwarze Magie.

      syntaktische Whitespaces .... nee, danke.
      Für einen Zehn-Zeiler finde ich das gar nicht so schlecht, für was Längers würde ich die Curlys auch nicht missen wollen..

      Perfect Trader schrieb:

      Gleichzeitig zeigt eine Reihe angefangener Threads, wie der zum Trade-Statistik-Sheet oder der zu R daß wir noch nicht das richtige "Common Format" gefunden haben.

      .... und ich ergänze mal: "und auch nicht werden".

      Das ist nicht pessimistisch, sondern Menschenkenntnis. ;) Die Leute hier im Forum sind viel zu unterschiedlich (neudeutsch: heterogen) als dass man sie für lediglich eine oder 2 Programmiersprachen/ Plattformen gewinnen könnte. Ich mache z.B. fast gar nichts in Excel, weil ich da das Gefühl habe, man hätte mir beide Hände amputiert. Wobei es für kleinere Sachen ein gutes Tool ist, unbestritten. Ich will aber immer zu schnell noch mehr und irgendwann kommt man aber nicht mehr weiter. Und die Grenze ist bei Excel gefühlt zu schnell erreicht und dann muss ich doch wieder wechseln.

      R war lange Zeit (davor Matlab) ne feine Sache, ich hab mir auch nen richtig geiles Interface geschrieben, um Dot-Net-Assemblies in R sinnvoll benutzen zu können (z.B. auch mal wieder entladen, ohne R zu beenden und statconn fand ich richtig doof - Linzenzpolitik, Splashscreen, nicht im laufenden Programm entladbar), aber mittlerweile arbeite ich fast nur noch mit Mathematica. Das erfüllt alle meine Bedürfnisse bis auf das nachmittägliche Eis-am-Kiosk-holen. Ich lege mittlerweile auch extrem viel Wert auf Dokumentation, weil ich schon viel aufgrund mangelhafter Doku wegwerfen musste, da ich meine eigenen wirren Gedankengänge nicht mehr entschlüsseln konnte. Vielen anderen ist die Doku (was bei mir heißt: Code-Doku plus hauptsächlich wissenschaftlich angehauchte Beschreibung meiner Untersuchungen) völlig wurscht, wie man schon in vielen Metatrader-Indikatoren-Sources sehen kann. Die Leute werden Mathematica nicht zu schätzen wissen und umgekehrt will ich nicht mehr so wie sie arbeiten. Schon hast Du 2 disjunkte Mengen.

      Die Komplementärmenge zu mir (also die Leute, die nicht ich sind ?( ) kann man nochmal nach diversen Kriterien aufteilen: Programmierkenntnisse, Grad der Professionalität, Lernbereitschaft/ Wechelbereitschaft, Bereitschaft Geld auszugeben für Software, Schwerpunktthemen bei der Programmierung (macht man z.B. viel Statistik ist eine Software sinnvoll, die das schon unterstützt), persönliche Vorlieben (es gibt ja z.B. immernoch Microsoft-Hasser, mir völlig unverständlich) ,...

      Da sich insgesamt nur sehr wenige User hier im Forum mit Programmierung beschäftigen, verbleiben hinterher genauso viele Mengen wie Benutzer. Behaupte ich mal ;). Nix Schnittmenge und so. Da sich auch die Bereitschaft, Kompromisse einzugehen, bei den meisten in Grenzen hält (bei mir z.B. Dank unschöner Forenerfahrung, you know, ich hab Dir da schließlich lange genug ein Ohr abgekaut ;), ändert aber nichts am Ergebnis: verbrannte Erde, ich mach keine Kompromisse mehr zu meinen Ungunsten) ... nun, es sind hier zu wenige und die wenigen sind zu unterschiedlich und zu *hust* "individuell" bzw. speziell aufgestellt.

      Python finde ich persönlich total grätzig, denn syntaktische Whitespaces .... nee, danke. Wenn ich mich unbedingt geißeln will, telefoniere ich lieber mal ne Runde mit der ungeliebten Verwandtschaft. Ich kann die Intention der Python-Entwickler bei diesem Feature verstehen, aber arbeiten mag ich freiwillig nicht damit. Wenn es keine andere Programmiersprache auf der Welt gäbe oder der Kunde partout drauf pocht - ok :wacko: Saurer Apfel und so...
      Aber wenn es nicht sein muss, verzichte ich instant und nehme eine der 1000 für mich angenehmeren Alternativen oder lerne lieber noch ne weitere Programmiersprache.

      Darüber hinaus versuche ich, da effizienter, möglichst wenig parallel zwischen verschiedenen Programmiersprachen/-plattform hin- und herzuspringen. Das ist zwar vielleicht uncool, aber die Switching Costs sind meist zu hoch und unnötig. Meist beschränkt man sich dann nämlich auf den kleinsten gemeinsamen Nenner bei den Programmiersprachen-Features und reizt die Vorteile nicht voll aus. Bsp. FOR-Schleifen in R benutzen :thumbdown: statt sich mal die Apply-Familie anzusehen. Und dann rummaulen, dass R so langsam sei... :rolleyes:

      Sho

      research.microsoft.com/en-us/projects/sho/

      Ich habs heute nur kurz angesehen, ich finde das sieht auf den ersten Blick recht interessant aus. Microsoft verwendet das Tool intern schon lange, und hat es vor einem Monat veröffentlicht.

      Sho ist im Prinzip ein IronPython (= Python + .Net) Paket mit eigenen Matrix Klassen, Datenvisualisierung, Mathe/Analyse-Funktionen und einiges mehr. Man kann entweder die Sho-Konsole eigenständig verwenden, oder das Ganze in VisualStudio integrieren.

      Das Nette ist, man kann zB eine Klasse in C# schreiben, und dann über die interaktive Python-Konsole die Klasse laden, sie mit Daten füttern, das Ergebniss plotten, Introspektieren, usw. usf. - anstatt umständlich in C# Testfälle zu programmieren. Man kann auch einzelne C# Files (Source oder dll) direkt in die Konsole laden, sich damit herumspielen und schaun, wie es funktioniert.