Dienstag, 16. April 2024, 17:38 UTC+2

Sie sind nicht angemeldet.

  • Anmelden
  • Registrieren

Wie wird eine Positionsbegrenzung bei Portfoliosystemen richtig realisiert?

Lieber Besucher, herzlich willkommen bei: INVESTOX-Forum. Falls dies Ihr erster Besuch auf dieser Seite ist, lesen Sie sich bitte die Hilfe durch. Dort wird Ihnen die Bedienung dieser Seite näher erläutert. Darüber hinaus sollten Sie sich registrieren, um alle Funktionen dieser Seite nutzen zu können. Benutzen Sie das Registrierungsformular, um sich zu registrieren oder informieren Sie sich ausführlich über den Registrierungsvorgang. Falls Sie sich bereits zu einem früheren Zeitpunkt registriert haben, können Sie sich hier anmelden.

Lupo

unregistriert

1

Donnerstag, 15. März 2018, 16:59

Wie wird eine Positionsbegrenzung bei Portfoliosystemen richtig realisiert?

Hallo Zusammen,

ich habe ein Master-Slave Aktien-Portfolio-Handelssystem mit täglicher Komprimierung basierend auf Marktbreitefiltern und feile derzeit an den Positionsbegrenzungsregeln,
um im Rahmen meines zu Verfügung stehenden Kapitals zu agieren. Das Zusatzmodul Kontoserver habe ich zu Verfügung und nutze es - die Positionsbegrenzung möchte ich vorzugsweise jedoch über Handelsregeln unter Nutzung der vom Kontoserver bereitgestellten Informationen zur Anzahl der aktuell gehaltener Positionen im Slave und zum freiem Kapital realisieren.
Das Kapital soll natürlich maximal genutzt werden.

Das Portfolio umfasst die DAX-Indizes (DAX, MDAX, SDAX und TECDAX). Maximal z.B. 20 Titel sollen im Slave gehalten bzw. deren Enter-Signale freigegeben werden. Demzufolge werden die Positionen mit 1/20 des zu Verfügung stehenden Kapitals ausgestattet.
Eine Mindestgrösse an Kapital je Position soll zusätzlich unterbinden, dass Kleinstpositionen eröffnet werden. Die Konstante „Kapitalreserve“ soll eine Absicherung bei Kurssprüngen bieten und das freie Kapital über 0 halten.

In diversen Tests hat sich bewährt, dass Entersignale im Slave erst ab einer Mindestanzahl von z.B. 9 Positionen im Master umgesetzt werden. Die bis zur Mindestanzahl aufgelaufenen Entersignale werden vorgemerkt durch ihr gültiges Enter-Signal und erst bei Erreichung der 9ten Position umgesetzt – wenn die Enter-Signale dann immer noch vorliegen. So sollen in Abschwungphasen Entersignale im Slave unterdrückt werden und erst bei einer mit der Mindestgrösse unterstellen einsetzenden Bodenbildung in den Indizes wieder Einstiege zugelassen werden.

Auch sollen ab unterschreiten der Mindestgrösse von 9 Positionen im Master alle bestehenden Positionen im Slave solange glattgestellt werden, bis die Mindestgrösse wieder erreicht ist – um wiederum bei einer unterstellen Abschwungphase nicht im Markt zu sein.

Derzeit sieht der Code zu den oben beschriebenen Positionsbegrenzung wie folgt aus – wobei aus Platzersparnis nur 10 Positionen abgebildet sind. Unter anderem soll mit dem Code ermittelt werden, ob und wie viele neue Positionen zur aktuellen Periode mit dem zu Verfügung stehenden Kapital eröffnet werden können.
Ggfs. sind mehr Positionen möglich, als das zu diesem Zeitpunkt vorliegende freie Kapital zulässt und deshalb abzufangen ist:

Quellcode

 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

//Entry-----------------------------------------------------

#_BewahreRauten#

global calc SumEntry: KatSumme(#>>0.1 < Open(#_BT Marktbreite#)<<#, #BT_DatSim#);

global calc Position: #_PFPosition Marktbreite_AktienMaxPos=30; NurEntries=Ja; Sortierung=Ab; Synchbasis=Allianz vNA;#;

//Money-Management-------------------------------

global const KapReserve: 1.02;
global const MaximumPositionen: 20;
global const Mindestgroesse: 2000;
global calc KontoKK: KontoKennzahlHist(#KontoReg#, Gesamtkapital, C);
global calc FreiesKapital: KontoKennzahlHist(#KontoReg#, FreiesKapital, C);
global calc Positionen: KontoKennzahlHist(#KontoReg#, Positionen, C);

global calc PosFrei: If((MaximumPositionen - Positionen) <= 0, 1, MaximumPositionen - Positionen);
global calc PosFrei1: If((MaximumPositionen - Positionen -1) <= 0, 1, MaximumPositionen - Positionen -1);
global calc PosFrei2: If((MaximumPositionen - Positionen -2) <= 0, 1, MaximumPositionen - Positionen -2);
global calc PosFrei3: If((MaximumPositionen - Positionen -3) <= 0, 1, MaximumPositionen - Positionen -3);
global calc PosFrei4: If((MaximumPositionen - Positionen -4) <= 0, 1, MaximumPositionen - Positionen -4);
global calc PosFrei5: If((MaximumPositionen - Positionen -5) <= 0, 1, MaximumPositionen - Positionen -5);
global calc PosFrei6: If((MaximumPositionen - Positionen -6) <= 0, 1, MaximumPositionen - Positionen -6);
global calc PosFrei7: If((MaximumPositionen - Positionen -7) <= 0, 1, MaximumPositionen - Positionen -7);
global calc PosFrei8: If((MaximumPositionen - Positionen -8) <= 0, 1, MaximumPositionen - Positionen -8);
global calc PosFrei9: If((MaximumPositionen - Positionen -9) <= 0, 1, MaximumPositionen - Positionen -9);
global calc PosFrei10: If((MaximumPositionen - Positionen -10) <= 0, 1, MaximumPositionen - Positionen -10);

global calc PosKapital:
If(Mindestgroesse * PosFrei < FreiesKapital * KapRes, FreiesKapital / PosFrei,
If(Mindestgroesse * PosFrei1 < FreiesKapital * KapRes, FreiesKapital / PosFrei1,
If(Mindestgroesse * PosFrei2 < FreiesKapital * KapRes, FreiesKapital / PosFrei2,
If(Mindestgroesse * PosFrei3 < FreiesKapital * KapRes, FreiesKapital / PosFrei3,
If(Mindestgroesse * PosFrei4 < FreiesKapital * KapRes, FreiesKapital / PosFrei4,
If(Mindestgroesse * PosFrei5 < FreiesKapital * KapRes, FreiesKapital / PosFrei5,
If(Mindestgroesse * PosFrei6 < FreiesKapital * KapRes, FreiesKapital / PosFrei6,
If(Mindestgroesse * PosFrei7 < FreiesKapital * KapRes, FreiesKapital / PosFrei7,
If(Mindestgroesse * PosFrei8 < FreiesKapital * KapRes, FreiesKapital / PosFrei8,
If(Mindestgroesse * PosFrei9 < FreiesKapital * KapRes, FreiesKapital / PosFrei9,
If(Mindestgroesse * PosFrei10 < FreiesKapital * KapRes, FreiesKapital / PosFrei10,
1
)))))))))));

global calc Stückzahl: FLOOR(ABS(PosKapital / Close));

//Entry-----------------------------------------------------
global calc SchalterE: Schalter(0, 0.8 < Position And 0 < Stückzahl And 9
<= SumEntry, 1, Position < 0.8 And SumEntry <= 9 , -1);

//EnterLong----------------------------------------------
global calc EnterLong: Ref(//0
0.8 < Cross(SchalterE, 0, 1)
, -1);

//ExitLong-----------------------------------------------
global calc ExitLong: Ref(//0
Cross(SchalterE, 0, 1) < 0
, -1);


Zum einem kann man das gewiss eleganter lösen und ich nehme jeden Tipp für Verbesserungen gerne auf – davon abgesehen habe ich einen groben Bug eingebaut, denn es tritt u.a. folgender Fehler in der Simulation auf, zu dessen Abstellung ich um eure Hilfe bitte:

Es werden zeitweise mehr als die maximal 20 zulässigen Positionen im Slave eröffnet. Und zwar i.d.R. dann, wenn an einem Tag mehr Entersignale als freie Positionen vorliegen. Das freie Kapital wird dabei negativ. Auch werden u.a. dabei manche Entersignale mit der folgenden Fehlermeldung nicht umgesetzt:

>>>>Handelssystem-Fehler<<<<
Zeit: 04.03.2018 09:20:31
Info: Fehler im Programmablauf (siehe Details)
Modul/Vorgang: Projekt
Funktion: Aktuelle Position bestimmen

Fehlermeldung: Überlauf aufgetreten. Die Werte
einer Berechnung liegen außerhalb des gültigen Bereiches oder es fand
eine Division durch 0 statt (Fehler Nr. 6).

Ab diesem Zeitpunkt ist der betroffene Titel durch den o.g. Fehler „verriegelt“ und liefert keine Ergebnisse mehr.

Wie macht man so eine Positionsbegrenzung grundsätzlich richtig (bevorzugt per Handelsregeln...)? Stehe momentan auf'm Schlauch...

Danke,

Lupo

Bernd

Experte

Registrierungsdatum: 5. Juni 2005

Beiträge: 4 070

Wohnort: Iringsweg

2

Montag, 19. März 2018, 12:38

Für den Backtest müsstest Du eigentlich nur #_PFPosition# im Slave System der Enter-Bedingung zufügen, um abzuschätzen, was von der Performance übrig bleiben könnte. Im Realhandel wird man eine Begrenzung dann mit dem Kontoserver umsetzen wollen.
Gruss
Bernd

Ähnliche Themen