Hallo Taxus,



Für Zelle J9 ergibt die Kursabfrage im Chart 236,54. Gerundet 237. Sollte also stimmen.

Zelle L8 = 2227 ergibt sich meiner Ansicht nach aus dem Open von 2421 abzügl. 8%.
Sollte auch so stimmen.

Bei K6 = S weiß ich wie gesagt nicht, woher das kommt, da dafür ein Indikatorwert vorliegen müßte, der nicht da ist mangels Daten in den Spalten H bis J.

Ich würde mich freuen, wenn sich andere auch beteiligen würden und sich in die Sache reindenken.


Michael

Hallo Michael,

Du hast recht, L8 und L9 sind richtig.
Als 1. Trendwert dürfte K8 entstehen. Einen Shorttrend kann man auch nicht erkennen.
Die 8% passen zwar, aber ich würde tatsächlich beim 1. Open beginnen.

Siehst Du die weitere Berechnung auch so wie von mir beschrieben?
Herr Vogel schreibt zwar, daß er nur das Longsystem genutzt hat, der Indikator ermöglicht aber die Anwendung beider Systeme.

Die Kurve sieht doch richtig gut aus. Ich bin allerdings immer noch skeptisch solange wir sie nicht nachgebildet haben.

Schöne Grüße
Taxus

Hallo Taxus,
das sieht doch sehr gut aus - ist es schon die finale Lösung?

Jürgen

Hallo,

das würde ich eigentlich mit Euch gerne erledigen.
Es hat noch gar nichts zu bedeuten.
Ich taste mich nur ran, um zu sehen, ob das so auch korrekt ist.

Morgen werde ich noch den Shorttrend, einen Longtrend und noch einen Shorttrend zulegen. Wenn das klappt, dann haben wir´s.
Euere Diskussion brauche ich trotzdem, wie Ihr meine. Das denk ich mir halt so.


Schöne Grüße
Taxus

Hallo Taxus,

stell doch bitte mal die Formel hier rein.

Dann können Jürgen und ich uns die Sache direkt ansehen und von da aus weitermachen.


Michael

Hallo Taxus,
das schaut doch jetzt sehr gut aus! Gibt es irgendwelche Dinge die "wir Laien" noch voran bringen könnten?

Grüße Jürgen

Test
Programm-Werkstatt Tai-Pan-Formelsprache
Aufgabe: Trendfolgesystem nach Bernd Vogel

Wir binnen mit einer möglichst einfachen Beschreibung der Aufgabenstellung.
Eine 14-Seitige PDF ist hier nicht gefragt.
Text später gemeinsam oder jeder, der will. Es gibt keine Tabus.
Wir kochen alle nur mit Wasser. Ich benötige immer ein bissel mehr.

Wir benötigen ein Layout
Bild 0: Layout für DAX Wochen-Candlesticks-Chart

Wir erstellen eine Formel/Programm.
1. Allgemeiner Teil
erläuternder Text dazu vielleicht später

2. Wir legen die Namen für die Formel/Programm fest.
erläuternder Text dazu vielleicht später

3. Wir legen parallel zur Programmentwicklung die Parameterliste an.
erläuternder Text dazu vielleicht später

Bild 1: Fenster "Indikator anlegen" Register "Allgemein"

Der Parameter soll sich auf die 8% für den Auf- oder Abschlag bei Trendwechsel beziehen.
So könnte man diesen 8%-Satz auch auf persönlichem Wunsch ändern.

Wir öffnen den Formeleditor um unser Programm einzutragen.

{Formel Trendfolge Handelssystem}
// Entwicklung: Bernd Vogel veröffentlicht im Trader´s 05 2013
// Programmierung gewünscht von Jürgen Gerdes aus dem Tai-Pan-Forum
// Periodenart: auf Wochenbasis

debug // 1. debug

// Schritt 1: Variablenvereinbarungen

a0 := C;
a1 := Count(a0);
a2 := H;
a3 := L;
a4 := O;

debug // 2. debug

Result := a0;

Bild2: Formeleditor nach Eingabe des o.a. Textes

Erläuterungen:
Formelbezeichnung in {} setzen
- kürzestmöglich beschreiben, um später noch zu wissen worum es hierbei geht
Entwickler und Entwicklungsdatum angeben
- ggf. weitere einleitende Bemerkungen

- debug
Diese 1. "debug"-Anweisung wird nach Programmausführungsstart (i.d.R. einem Layoutaufruf) den
Tai-Pan-Formelsprachen-Editor öffnen.

Ihr könnt ein "debug" nahezu überall platzieren. Wo es sinnvoll ist werdet Ihr schnell selbst erkennen.

Am Programmende folgt dann unbedingt noch eine 2. "debug"-Anweisung.

Damit Euch die Anzeige der letzten Variablen noch ermöglicht wird.
Das werdet Ihr auch selbst schnell erkennen können.

Damit könnt Ihr alle weiteren Programmschritte einzeln oder abschnittsweise verfolgen und die Variablen und deren Änderungen detailliert verfolgen.

Das ist das ganze Geheimnis an Tai Pan.

Im Formeleditor werdet Ihr alles finden können, um Euer oder ein anderes Programm verstehen und vor allem eigene Entwicklungen vornehmen zu können.

P a u s e

Aufgabe 1:
- Layout anlegen
- Formel anlegen
- Parameter anlegen
- Formeltext eingeben (Achtung: Die 3 Formelnamen dürfen natürlich in Euerer Sammlung noch nicht vorkommen, sonst würdet Ihr diese überschreiben).
- Schaut Euch im Debugger die Variablen a0 bis a4 in aller Ruhe an.
- Layout mit Formel abspeichern

Stellt ggf. Fragen.
Wir kauen das hier einmal richtig durch.
Ihr könnt dann immer wieder nachschaun.

Für die unbgeduldigen Profi´s gibt es bald richtig und vor allem viel Arbeit.

Ruft nun Euer Layout auf und fügt ein Zweites hinzu.
Das geht so:
- Layout aufrufen
- Geht im Chartfenster oben im Menü auf Chart und dann auf "Titel hinzufügen".
Ihr nehmt natürlich den DAX.
- Verwendet für dieses Layout als Periodenart "Tageskurse".
- Wendet nun unsere bisherige Formel an und schaut in die Arrays. Es werden ganz automatisch Tageskurse verwendet. Das macht Tai Pan dann schon.
- Ändert das hinzugenommene Layout nun auch auf Wochenkurse ab.
- Speichert das komplette Layout unter Euerem bisherigen Namen.

Warum?
Nun, bei der Entwicklung eines Programmes kommt manchmal eines zum anderen und ganz schnell hat man sein Programm so verändert, daß man das Alte nicht mehr erkennt.
Ist das Neue dann noch falsch, braucht man mehr oder weniger Zeit um alles wieder auf den alten Zustand zurückzuführen.
Dazu benötigt man dann auch von seiner Formel eine Kopie. Ich nenne sie meist Test am Ende.
Außerdem kann man sich die beiden Programmergebnisse nebeneinander anzeigen lassen und so schneller
die Veränderungen auf Korrektheit überprüfen. Das ist nur ein Vorschlag.
Warum noch?
Ich teste alle Programme i.d.R. auch gleich noch für Monate und Jahre.
Also schaffe ich mir meist am Ende ein Layout mit 4 Charts für Tage/Wochen/Monate/Jahre..
Ist alles ok, läßt sich prima ein Katalog durchblättern.
Oder, ich verwende eine Formel in dem einen Layout und dem anderen die gleiche Formel aber nur bis zum vorausgehenden Börsentag.
Welchen Sinn macht das?
Nun bei manchen Programmen ist es interessant den Vortageschart zu sehen, wenn der sich total geändert hat zum aktuellen Chart. Wem das z.Z. noch nichts sagt, der wird sich vielleicht irgendwann
daran erinnern.

Weiter im Programm
Zunächst etwas Text.
Das Handelsystem arbeitet mit Candlecharts.
Es braucht die Open-, High-, Low und Close-Kurse.
Und wir müssen die Kursanzahl mal zählen. Das macht die Funktion "Count".

Rechenzeit
Um die Rechenzeit möglichst kurz zu halten stellen wir diese Kurse in Variablen bereit.
Die Kurse werden dann nur einmal aus der Datenbank gelesen und stehen immer wieder zur Verfügung.
Bei kleinen Programm merkt man das nicht. Bei größeren wird es extrem schneller.
Um die Variablen beim Test nicht in der ganzen Liste laufend scrollen zu müssen, nehme ich meist den Anfangsbuchstaben a und dann den Rest zur Unterscheidung dazu.

Jetzt werden wir ein paar erforderliche Berechnungen durchführen, um weitere Variablen bereitzustellen.

Wir benötigen:

- alle 7-Wochen-Hoch und -Tiefs

Das müßt Ihr Euch gleich mal anschaun.

a2H := HHV(a2, 7); // So werden die 7-Wochen-Hochs berechnet.
a3L := LLV(a3, 7); // So werden die 7-Wochen-Tiefs berechnet.

Schreibt die beiden Anweisungen in unserer bisherigen Formel vor dem 2. debug hinzu.

Speichert die Formel und schaut Euch das Ergebnis im Debugger an.
Überprüft vor allem, ob das so korrekt ist.
Beginnt bei den Arrays am allerersten Kurstag.

P a u s e

- die einfache Schwankungsbreite
- und die erweiterte Schwankungsbreite

a5 := a2H - a3L; // Schwankungsbreite
a51 := a5 * 1.5; // Schwankungsbreite * 1.5

Fügt diese beiden Zeilen wieder vor dem 2. debug hinzu.

Ich schlüssle die Formeln meist ganz und gar auf, um sie leichter nachvollziehn und natürlich prüfen zu können. Meist lasse ich es auch dabei. Man könnte das Programm aber auch sehr verkürzen, wenn man die Zwischenschritte wegläßt und alles sehr effektiv zusammenfaßt.

Prüft die Ergebnisse einfach einmal nach.

P a u s e

Wir benötigen noch den SMA 3.

a7 := SMA(C, 3); // SMA über 3 Perioden, hier Wochen
a71 := Count(a7); // Wir zählen die Anzahl der SMA-Kurse.

Fügt die beiden Zeilen noch vor dem 2. debug ein.

Schaut Euch bitte den SMA im Debugger vom 1. Kurs aus an.

Wir zählen mal die Anzahl der "Kurse" und schaun uns das Array mal vom 1. Kurs her an.
Bei der Gelegenheit sehen wir überhaupt mal nach welches Array wie viele Kurse hat.

P a u s e

Jetzt wieder etwas nachdenken.
Wir wollen das unser Indikator, der ja eine Stop-Loss-Linie für Long- und Shorttrends ist, vom allerersten Kurs an funktioniert.
Deshalb ziehen wir von Open und zwar von allen Openkursen die 8% ab.

Das bedeutet doch:
Der 1. Kurs überhaupt ist der Openkurs.
Damit wir unsere Verluste bei unmittelbar fallenden Kursen begrenzen setzen wir bei 8% Minus ein Stop.
Steigen die Kurse von Woche zu Woche, dann ziehen wir den Stop-Kurs nach und zwar immer vom neuen höheren Open 8%.
Solange wir danach verfahren kann die Stop-Loss-Linie steigen.
Sie darf aber nie fallen.
Bei immer weiter fallenden Kursen würde irgendwann der Stop ausgelöst, da die Linie ja nie fallen darf.

Was bedeutet das für unser Programm?
Wir beginnen grundsätzlich mit einem angenommenem Longtrend.
Das ist nur logisch.
Über die 8% diskutieren wir an dieser Stelle nicht, denn die verlieren wir, wenn es so kommen, sollte mindestens.

P a u s e

Unser Formeleditor hat nun folgenden Text:

Wir öffnen den Formeleditor um unser Programm einzutragen.

{Formel Trendfolge Handelssystem}
// Entwicklung: Bernd Vogel veröffentlicht im Trader´s 05 2013
// Programmierung gewünscht von Jürgen Gerdes aus dem Tai-Pan-Forum
// Periodenart: auf Wochenbasis

debug // 1. debug

// Schritt 1: Variablenvereinbarung

a0 := C;
a1 := Count(a0);
a2 := H;
a3 := L;
a4 := O;

a2H := HHV(a2, 7); // So werden die 7-Wochen-Hochs berechnet.
a3L := LLV(a3, 7); // So werden die 7-Wochen-Tiefs berechnet.

a5 := a2H - a3L; // Schwankungsbreite
a51 := a5 * 1.5; // Schwankungsbreite * 1.5

a7 := SMA(C, 3); // SMA über 3 Perioden, hier Wochen
a71 := Count(a7); // Wir zählen die Anzahl der SMA-Kurse.

debug // 2. debug

Result := a0;

In der z.Z. letzten Programmzeile haben wir den Ausgabewert notiert.
Der Formeleditor fordert eine Result-Anweisung grundsätzlich.
Damit er Ruhe gibt trage ich immer einen annehmbaren Wert, meist die Closelinie, ein.

Wir wollen den Ausgabewert nun auch im Formeleditor Register "Ausgabewerte" eintragen.

Wir tragen folgendes ein:
- Bezeichnung: a0
- Ausgabetyp: Linie
- Farbe: Grün

Später werden wir hier Änderungen vornehmen.

Weiter geht´s.

Wir berechnen nun die Arrays mit den 8%-Ab- bzw. Aufschlägen.

a9 := a4 - a4 * Para1 /100; // a4 = Open, Anfangsstop 8% unter Openkurs (=Abschlag) für den Beginn

a91 := a4[1] - a4[1] * Para1/100; // Zwischenprüfung, ob die 8% Abschlag korrekt berechnet wurden

a92 := a4 + a4 * Para1 /100; // a4 = Open-Kurse, Anfangsstop 8% über Openkurs (=Aufschlag) nach Trendwechsel von Long auf Short

Die 3 Zeilen fügen wir wieder vor dem 2. debug ein.

Schaut Euch am besten die beiden Arrays "a91" und "a92" sowie die Variable "091" für den ersten Openkurs im Debugger an.

Wir sind immer noch bei den Vorbereitungen zur Erstellung des "Indikators" besser der Trailing-Stop-Loss-Linie.

Diese Trailing-Stop-Loss-Linie wird ein Array werden. Das ist schon mal sicher.
Sie wird von Börsentag zu Börsentag vom 1. beginnend bis zum letzten berechnet.
Im Programm werden wir auf die O-, H-, L-Kurse zugreifen.
Dazu müssen wir immer über die Anzahl der Kurse informiert sein.
Das haben wir oben bereits berechnet.

Wir benötigen für jedes Array im Prinzip einen Zähler, weil wir definieren müssen, welche Werte wir z.B. vergleichen. Eigentlich erschließt sich diese Tatsache erst später. Wenn man genügend Erfahrung hat weiß man das natürlich vorab.


aindi := a4; // Unsere Trailing-Stop-Loss-Linie nennen wir "aindi". "a", weil wir das Array bei allen unseren Variablen aufführen wollen
// und "indi", damit wir schnell wissen um was es sich handelt.
// mit aindi := a4; legen wir fest, daß aindi ein Array mit der Länge und den
// Kursen des Open-Arrays wird.
aindi := leer; // Danach setzen wir alle Openkurse auf "leer".
// Das ist auch anders realisierbar, würde jetzt aber zu weit führen.
aindiz := 1; // Unser Indikator/ Trailing-Stop-Loss-Array "aindi" braucht einen Zähler,
// mit dem Startwert = 1, weil wir mit dem 1. Kurswert zum Index =1
// beginnen wollen.

Bitte übernehmt die 3 Zeilen samt den Kommentaren in Eueren Formeleditor vor dem 2. debug.

Schaut Euch nun wieder im Debugger die 3 beiden Werte mit ihren Veränderungen an.

P a u s e


Wir benötigen nun noch einen Zähler für a9. Das waren die Opernkurse mit dem 8%-Abschlag.
Genaugenommen benötigten wir 2 Zähler, einen für den Abschlag und einen für den Aufschlag.
Da beide Arrays gleich lang sein werden wird ein Zähler reichen.
Ich schreibe das hier so einfach hin. Das ergibt sich aber immer erst im Programm.
Dann muß man eben immer mal wieder vorn rein und die erforderlichen Werte vereinbaren und bereitstellen. Das ist normal wenn es ein bissel aufwendiger wird.

a9z := 2; // a9 braucht einen Zähler, Startwert = 2, weil der 2. Open-8%-Wert mit
// den 1. Open-8%-Wert verglichen werden soll.

Result 1 := aindi;

Die obige Result-Anweisung habe ich durch "Result1 := aindi;" ersetzt, weil wir demnächst den Indikator "aindi" berechnen werden.
Result und Result1 bezeichnet die selbe Result-Anweisung.

In den Ausgabe werten ändern wir den Namen "a0" einfach in "aindi".
Dann ist das auch erledigt.

Die beiden Zeilen fügen wir wieder vor dem 2. debug ein.

Wir vergleichen nun unsere Formeltexte.
So sollte es bei Euch auch aussehen. Sorry, ich mußte erst einmal alles auf Gleichstand bringen. Jetzt sollte es gut sein. Im Formeleditor kann man alles schön schreiben. Hier müßte man erst eine andere Schriftart wählen. Das würde aber auch nicht reichen, weil nicht mehrere Leerzeichen hintereinander übernommen werden. Daher der Aufwand.

Bild 3: Aktueller Stand Formeleditor Register "Formeltext"

Versucht nun bitte erst einmal den Formeltext so wie im Bild hinzubekommen.
Schaut Euch danach alles im Debugger noch einmal in Ruhe an.

Im Formeltext habe ich ein 3. debug am Ende nachgetragen.
Das hatte gefehlt, obwohl ich es ja immer empfehle.
Seht es mir bitte nach.

Dann wird´s schwieriger werden.

P a u s e

Heute werden wir mit der Berechnung des Indikators/ der Trailing-Stop-Loss-Linie beginnen.

Die Arbeit wird sich in 2 Schritte unterteilen:

Die Berechnungsmöglichkeit des Indikators ist anfangs von 2 Faktoren abhängig.
Das wären:
- Die Berechnung des SMA über 3 Wochen. Der 1. SMA-Wert liegt also erst mit der 3. Woche vor.
Wenn der SMA den Indikator kreuzt soll ein Handelssignal Kauf/Verkauf für den Open der Folgewoche entstehen.
- Die Berechnung der 7-Wochen-High und -Lows kann erstmals in der 7. Woche erfolgen.

Mit dem allerersten Open wollen wir den Indikator aber schon verwenden.

Deshalb 2 Schritte:
1. Berechnung des Indikators bis einschließlich der 6. Woche auf der Grundlage: Open - 8%.
2. Berechnung auf der Grundlage der Vorgaben von Herrn Vogel:
Also 8% Ab- oder Aufschlag in der Folgewoche je nach Trendwechsel, der SMA scheidet den Indikator von unten nach oben oder von oben nach unten.
Bei Beibehaltung des eingeschlagenen Trends wird ab der Folgewoche, das ist die 2. Woche nach dem Trendwechsel, ein Ab- oder Aufschlag in der o.g. Schwankungsbreite vorgenommen.
So werden Kurs für Kurs die Kurswerte des Indikators berechnet.
Ist doch eigentlich ganz einfach. Na das werden wir noch sehen.

P a u s e

Zunächst ein paar Überlegungen:
Eigentlich ist alles in einer Schleife abzuarbeiten.
Es ist zu prüfen ob der SMA den Indikator schneidet oder nicht.
Am Beginn kann der SMA den Indikator aber nicht schneiden, weil es ihn ja erst ab der 7. Woche geben wird.
In der 1. Kurswoche kann der Wochenkurs aber den 1. 8%-Abschlag vom 1. Openkurs schneiden.
Da Herr Vogel aber von einer wöchentlichen, also einer Kontrolle jeweils am Wochenschluß ausgeht,
würde unser Stop gar nicht wirken. Denn er sagt, daß erst am Beginn der Folgewoche mit dem Open die Position glattgestellt wird.
Das müssen wir wissen, denn es kann schon hart ins Geld gehen.
Persönlich würde ich gerade am Beginn, zumindest nach diesem Handelssystem, nach 8% Verlust sofort die Reißleine ziehen.
Wir aber müssen uns hier erst mal einigen und werden nach dem Original verfahren.

Wir müssen für den 1. Kurs den Indikator außerhalb der angesprochenen Schleife einfach fest vorgeben:

aindi[1] := a9[aindiz]; // 1. Indikator-Wert: aindi := Open - 8% (O-8% = a9) = Stop-Loss

Danach wird der Zähler für das Array einfach vom 1. auf den 2. Kurs eins höher gestellt.
Das sieht dann so aus.

aindiz := aindiz +1;

Diese beiden Zeilen fügen wir wieder vor dem 2. debug ein.

Bild 4: aktueller Formeltext


Jetzt werden wir den 2. Wert des Indikators "aindi" berechnen.

Dazu einige Vorüberlegungen:
- Der Zähler von "aindi" steht auf dem 1. Kurs (Index = 1).
- Am Ende der 2. Woche wollen wir prüfen, ob der vorläufige Indikatar auf Openbasis minus 8% den alten Indikatorwert, also den 1., unterschritten hat.
- Ist er unterschritten, dann soll der alte Indikator erhalten bleiben, wegen der Verlustbegrenzung.
- In der Folgewoche würde in diesem Fall zum Open die Position glattgestellt werden.
- Ist es nicht der Fall, dann wird vergibt sich der Wert von "aindi" aus dem neuen Open minus 8%.

Das ergibt dann folgende Anweisung:
Wir verwenden dabei den "IF-Befehl".
Der besagt vereinfacht folgendes: Ist die Bedingung erfüllt, dann wird der erste und sonst der zweite Wert verwendet.

aindi[aindiz] := if(a9[a9z] < aindi[aindiz], aindi[aindiz], a9[a9z]); // 2. Indikator-Wert: Wenn O-8% < ist als O-8% in der Vorwoche, dann bleibt der alte und sonst wird der neue übernommen.

Da wir nun den 2. Indikatorwert ermittelt haben, müssen wir den Zähler vom 1. auf den 2. Indikatorwert 1 hochstellen.

aindiz := aindiz +1; // aindi = 3

// Dann führen wir gleich noch einen Schalter ein und stellen ihn auf "L" für Longtrend.

aTrendw := "L";

Bild 4: aktueller Formeltext

Nun folgt die Schleife zur weiteren Berechnung aller folgenden Indikatorkurse.
Achtung

Wie im Thema bereits geschrieben habe ich eine zufällige Zwischenlösung beim Testen meines Programmes erstellt. Um diese geht es in der Schleife.
Außerdem habt Ihr so gleich für diese Variante die Lösung.
Aber es ist noch nicht die Lösung unserer Aufgabe.

Die Schleife muß ich ganz reinstellen, sonst muß ich zuviel schreiben.
Bitte versucht die Schleife abzuarbeiten.
Das wird schwierig und mühseelig genug werden.
Bitte versucht auch daraus die Lösung herzuleiten.

Ich stelle nun die Schleife rein, dann den Formeltext und Ihr versucht dann alles im Debugger nachzuvollziehn. Da gebe ich Euch aber das Debuggerbild noch zuletzt vor.

Ich weiß, daß das jetzt sehr viel verlangt ist.
Bitte versucht es.

Nun die Schleife.

While aindiz <= a1 Do
Begin
If a7[aindiz] > aindi[aindiz-1] Then
Begin
aindi[aindiz] := if(a9[a9z] < aindi[aindiz-1], aindi[aindiz-1], a9[a9z]);
aindiz := aindiz +1;
a9z := a9z + 1;
End
Else
Begin
If aTrendw = "S" Then
Begin
aindi[aindiz] := a4[aindiz] + a4[aindiz] * Para1/100; // Anfangs muß die Anweisung übersprungen werden
aindiz := aindiz + 1;
aTrendw := "S";
End
Else
Begin
aindi[aindiz] := if(a92[aindiz] > aindi[aindiz-1], aindi[aindiz-1], a92[aindiz]);
aindiz := aindiz +1;
a9z := a9z + 1;
End
End
End

Das ist der Text.
Die Struktur nach dem Schreiben des Textes wird von der Forumsoftware nicht unterstützt.
Das ist gerade meine Kritik. Damit kann man nicht allzuviel anfangen. Es ist für Blabla geignet und nicht mehr, und auf jeden Fall nicht für anspruchsvolle Aufgaben.

Bitte tippt jetzt nichts ein, sondern übernehmt alles was fehlt aus dem folgenden Bild 5.

Bild 5: aktueller gesamter Formeltext

Ich habe lieber den ganzen Text noch einmal gestrafft, damit Ihr auch ja den ganzen Formeltext
in einem Bild sehen könnt.

Darin enthalten ist die Schleife und die folgende Anweisung.

Color1:=if(aindi < a0,green,red);
// Mit dieser Anweisung wird die Farbe des Indikators "aindi" festgelegt.
// Liegt aindi unter dem Close, wird aindi in Grün und darüber in Rot angezeigt.
// Will man das nicht, dann läßt man die Anweisung einfach weg.

P a u s e

Bevor wir nun alles austesten, solltet Ihr ganz genau prüfen, ob Euer Formeltext korrekt ist.
Da muß alles stimmen.

So nun bekommt Ihr ein Debuggerbild. Das müßt Ihr auch erst mal verdauen.
Ihr laßt den Debugger bis zur Anweisung "aTrendw := "L";" mit F8 laufen und arbeitet die Anweisung auch mit ab.
Dann steht die Markierung so wie im Bild 7.
Das Bild hat bei mir ein 24" Format. Es kann sein, daß es für Euch zu groß ist.
Alles andere macht es aber noch schwieriger.

Danach soll folgendes Layout mit der Indikatorlinie/Trailing-Stop-Loss-Linie entstehen:

Bild 6: Layout mit Indikator aus der Zwischenvariante

Bild 7: Debuggeransicht

Erläuterung der Debuggeransicht aus Bild 7:

1. Fenster links oben "Formeltext"
Das Programm wurde bis zur blauen Markierung abgearbeitet.
Es wurde gerade die Anweisung "a9 := 2;" abgearbeitet.
2. Fenster rechts oben "Variablenliste"
Markiert habe ich, weil wir das leisten und nicht das Programm, die Variable "a9z".
Sie steht bei 2, wie in der Anweisung links im Formeltext vorgegeben.
3. Fenster rechts unten "Code".
Das Fenster wird kaum benutzt. Wenn man die Markierung im Formeltext-Fenster verliert, dann klickt man im Code-Fenster einfach auf die Markierung und die Markierung im Formeltext-Fenster erscheint wieder. Das sollte man wissen.
4. Fenster links unten:
Alle Fenster habe ich hier verkürzt eingestellt, damit sie in der Dropbox zu sehen sind.
Ihr könnt sie je nach Bildschirmgröße weiter in der vertikalen aufzoomen.
- Array: aindi Das ist unser Indikator-Array. Wir scrollen alle Fenster auf den 1. Kurs mit Index 1 und markieren den Wert. Ohne Markierung springt Tai Pan sonst immer auf den letzten Kurs.
- Array: A7 Das ist der SMA über 3 Wochen.
- Array: A9 Das sind alle Kurse Open minus 8%.
- Array: a92 Das sind alle Openkurse plus 8%.
- Array: a4 Das sind alle Openkurse.
Je nach dem welche Anweisungen wir gerade im Debugger testen wollen, müssen wir bei Bedarf die in diesem Bereich verwendeten Variablen in ihrer Entwicklung beobachten und auf Korrektheit prüfen. Das ist recht aufwendig. Die vergebenen Variablennamen, von mir alle mit a beginnend vergeben sind jetzt nicht förderlich. Aber sie vermeiden ein Scrollen in der Variablenliste.
Denn für unsere Schleife müssen wir auch den Stand der Zähler
- aindiz für Array aindi
- a9z für Array a9
beobachten. Bei ein bißchen Übung kommt man schnell dahinter.
Sagt Euch immer nur eins, wenn es mal hakt:
Es handelt sich nur um eine Linie, deren Entwicklung ich Kurs für Kurs prüfen muß bis sich alles wiederholt.

P a u s e

Jetzt wollen wir die Schleife testen:
Das werde ich schwer beschreiben können, weil es sehr viel zu schreiben gibt und die Übersicht dabei verloren gehen wird.
Deshalb werde ich es nur grob erklären.

Wenn Ihr alles so einghestellt hat, die Fenster und die Markierungen, dann geht es mit der Funktionstatse "F8" in Einzelschritten weiter.

Wir schauen uns kurz das linke untere Fenster an Kurs 1 an. Es ist leer.

Wir drücken einmal F8.
Die Markierung im Formeltextfenster
- hat die Anweisung aindiz[1] := a9[aindiz]; ausgeführt
und springt zur nächsten Anweisung.
Wir kontrollieren im linken unteren Fenster den 1. Eintrag. Dort steht jetzt der Wert für das 1. Open minus 8% = 527.4912.
Der Wert wurde aus Array a9 vom 2. Index dorthin übertragen.
Jetzt muß der Zähler für das Array aindi wiedwer eins rauf gesetzt werden, weil der 2. Wert berechnet werden muß.
Wir drücken F8 und der Index aindiz wurde von 1 auf 2 gestellt.
Manchmal empfiehlt es sich die Taste F8 blind zu drücken und die Zähleränderung direkt zu beobachten. Wenn man etwas geübt ist und sich alles laufend wiederholt, schaue ich meist nur noch auf den Zähler bis zum nächsten Knackpunkt.
Also im Variablenfenster steht jetzt als Wert aindiz eine 2. Alles ist ok.
Wir drücken wieder F8 und so weiter.

Die Schleife While Bedingung DO sagt uns, führe die folgenden Anweisungen solange aus bis der letzte, der aktuellste Kurs erreicht ist. Das ist sehr vereinfacht.
Deshalb prüft man hier nur solange bis alle Varianten ok sind oder alle Fehler beseitigt wurden.
Das ganze Array mit 1955 Kursen aktuell wäre schon zu viel verlangt.
Man kann dann das Ganze mit F5 abkürzen. Dann läuft der Debugger alle Anweisungen bis zum nächsten debug durch. Dieses debug muß dann nach der Schleife platziert werden.
Ich weiß, daß das viel verlangt ist. Ihr sollt es wenigstens wissen. Bei einfachen Aufgaben schaffen das alle, die sich rantrauen und wollen.

Nach der Schleife kommt noch der Befehl mit Color1.
Sucht bitte in der Variablenliste Color 1 und schaut Euch das Array an.
Dann noch ein F5 und der Indikator wird in Euer Layout eingetragen.

Fertig.
Ich wünsche Euch vor allem etwas Spaß dabei.

An alle Profi´s:
Hier könnt Ihr jetzt weiterarbeiten. Viel Erfolg. Ich mach erst mal Pause.

Schöne Grüße
Taxus

Hallo Zusammen,
ich habe mich scheinbar beim mit (ab)schreiben vertan, wo liegt mein Fehler? Es wird nichts geplotet....

=====
{Formel Trendfolge Handelssystem}
// Entwicklung: Bernd Vogel veröffentlicht im Trader´s 05 2013
// Programmierung gewünscht von Jürgen Gerdes aus dem Tai-Pan-Forum
// Periodenart: auf Wochenbasis

debug

// Schritt 1: Variablenvereinbarung

a0 := C;
a1 := Count(a0);
a2 := H;
a3 := L;
a4 := O;


a2H := HHV(a2, 7); // So werden die 7-Wochen-Hochs berechnet.
a3L := LLV(a3, 7); // So werden die 7-Wochen-Tiefs berechnet.

a5 := a2H - a3L; // Schwankungsbreite
a51 := a5 * 1.5; // Schwankungsbreite * 1.5

a7 := SMA(C, 3); // SMA über 3 Perioden, hier Wochen.
a71 := Count(a7); // Anzahl von SMA 3 Kursen.

a9 := a4 - a4 * Para1 /100; // a4 = Open, Anfangsstop 8% unter Openkurs (=Abschlag) für die ersten 6 oder 7 Wochen
a91 := a4[1] - a4[1] * Para1/100; // Zwischenprüfung, ob die 8% Abschlag korrekt berechnet wurden
a92 := a4 + a4 * Para1 /100; // Anfangsstop 8% über Openkurs (= Aufschlag) nach Trendwechsel auf Short

aindi := a4; // Unsere Trailing-Stop-Loss-Linie nennen wir aindi. a, weil wir das Array bei
// allen unseren Variablen aufführen wollen und indi, damit wir schnell wissen
// um was es sich handelt.
// mit aindi := a4; legen wir fest, daß aindi ein Array mit der Länge und den
// Kursen des Open-Arrays wird.
aindi := leer; // danach setzen wir alle Openkurse auf "leer".
// Das ist auch anders realisierbar, würde jetzt aber zu weit führen.
aindiz := 1; // Unser Indikator>>/ tariling-Stop-Loss-Array "aindi" braucht einen Zähler,
// mit dem Startwert = 1, weil wir mit dem !. Kurswert zum Index = 1
// beginnen wollen.
a9z := 2; // a9 braucht einen Zähler, Startwert = 2, weil der 2. Open-8%-Wert mit
// den 1.OPpen-8%-Wert verglichen werden soll.
debug // 2. debug

Result1:= aindi;
Result:= a0;

debug // 3. Debug am Ende und ganz wichtig damit man sich das Result 1 ansehen kann

=====
Im Gegensatz zu Taxus habe ich zwei Ergebnisse (shit), ich bin mir nicht im klaren, wann das result := a0 weggefallen ist.

Kann ich hier eigentlich kein Bild posten?


Grüße

Jürgen
===

Bin total daneben, hab ganz die Möglichkeit übersehen Dateien hochzuladen, sorry! Anbei die debug_14062013 Datei - alsoi ich werde daraus nicht schlau, bei mir tut sich nichts im chart.

Dateianhänge:
debug_14062013.pdf (32kb) downloaded 48 time(s).

Hallo Taxus,

erstmal großen Respekt vor deiner Leistung .

Habe den Programmcode abgetippt und erhalte die Indikatorlinie in rot bzw. grün.
(Hätte ich nie im Leben hingekriegt).

Was mir dabei auffällt, ist daß die Übergänge von Long nach Short und umgekehrt "nahtlos" verlaufen.
Es fehlt der Sprung um 8% nach unten bzw. nach oben.
Bug oder Feature?

Da es einige Zeit dauern wird, bis ich das Programm bis ins Detail verstanden habe, kann ich mir diese Frage im Moment selbst noch nicht beantworten .

@ Jürgen:

Dein Debugger-Auszug stimmt nicht mit dem vorher geposteten Programm überein.
Da hast du in der Zwischenzeit im Formeleditor noch einiges aktualisiert.
Es stehen im Debugger einige Codezeilen (etwa ab Zeile 95), die in meinem Debuggerauszug zum gleichen Stand des Programms nicht enthalten sind.


Michael

Hallo Jürgen,

der Befehl "debug" in einer Formel/Programm von Tai-Pan-eod veranlaßt die Formel/Programm:
- den Debugger mit allen einstellbaren Anzeigemöglichkeiten zu öffnen und
- genau in der Zeile mit dem "debug" das Programm anzuhalten.
Das Wort "debug" wird von Tai Pan farbig markiert. Bei mir ist es Blau.
Danach kann man entscheiden, wie man das Programm fortsetzen will.
In aller Regel wird man mit der Funktionstaste "F8" für eine schrittweise Bearbeitung fortfahren.
Will man dann ein paar Zeilen ohne Anzeige überspringen kann man "F5" nehmen.
Das Programm wird dann bis zum nächsten "debug" fortgesetzt und läuft durch.
"F5" verwendet man auch zur Abarbeitung von Schleifen, die ein ganzes Array durchackern, wenn man die Schleifenfunktion bereits geprüft hat oder das nicht notwendig war.

Schöne Grüße
Taxus