Tőzsdecápák - avagy FOREX automatikusan

A trend ellenünk megy

2014-08-11T09:06:00.003+02:00

A legutóbbi posztban arról volt szó, hogyan használjuk ki azt, amikor az indikátorok trend fordulót jeleznek, de valamilyen oknál fogva mégis tovább halad az árfolyam nekünk nem jó irányba.
Ilyenkor persze feltételeznünk kell azt is, hogy az indikátorok által jelzett feltételes trendfordulóra be is kötöttünk egy pozíciót! Mivel azonban a trend ellenünk megy, így természetesen veszteségbe fordul a nyitott pozíció, és elkezdünk aggódni! De nem kell túlságosan!

Ugyanis kétféleképpen is lehet védekezni az ilyen szituációk ellen.
Az egyik megoldás az, hogyha a kezdő pozíció nyitás méretét vesszük alapkötésnek és ezzel az alapkötéssel nyitjuk meg a további dupla méretű pozíciókat, vagyis hogyha a legelső pozíció méretünk 0,01 lot, a következő pozíció méretének 0,02, aztán 0,04, majd 0,08 stb. méretűeknek kell lennie, de az alap kötési egységünk 0,01 lot (ez ugye a legelső kötés méret), és ezzel nyitjuk a további pozíciókat valahogy így :

1. kötés : 0,01 lot
2. kötés : 0,02 lot --> 2 x 0,01 lot
3. kötés : 0,04 lot --> 4 x 0,01 lot
4. kötés : 0,08 lot --> 8 x 0,01 lot
...

Természetesen ez még önmagában nem adja a megoldást, mert a megoldás lényegében az, hogy amikor a szabad margin elkezd drasztikus mértékben csökkenni, akkor elkezdjük bezárni a legnagyobb veszteséggel rendelkező pozíciókat! Ez felszabadít némi margint és hogyha közben az árfolyam megfordul, akkor persze már nincs baj. Ha nem, akkor tovább folytathatjuk a számla megóvását veszteségek árán, de sajnos tudomásul kell venni, hogy a piac nem a mi kívánságaink teljesítésére mozgatja az árfolyamot, hanem a "befektetői hangulat" hatására. Tehát előfordulhat így is, hogy a számlánknak annyi.

Amikor az ember éles piacra lép, könnyen elkapja a félelem, ha ellenünk meg az árfolyam, de ami sokkal rosszabb, hogyha sorozatos nyereségek után történik mindez, akkor a veszteségbe forduló pozíciót nem kezdjük időben menedzselni! Ez a mohóság tipikus esete, ami természetesen jelenség a kereskedések során.

Ha azonban le tudjuk küzdeni a kezdeti mohóságunkat, akkor jöhet a második megoldás! Ennek lényege az, hogy nem nyitunk pozíciót a forduló trend megfelelő irányába, hanem a pillanatnyi árfolyamtól bizonyos távolságba elhelyezünk egy stop megbízást!

(Gyorstalpaló : stop megbízások és a limit megbízások olyan függőben lévő pozíció nyitások, amelyek bizonyos feltételek esetén nyílnak meg automatikusan. A stop megbízás esetében trend irányú nyitásról beszélünk, ha stop vételi megbízást helyezünk el, akkor azt a pillanatnyi ár fölé tesszük, amikor az árfolyam eléri a szintet, akkor megnyílik a vételi pozíció annak reményében, hogy az árfolyam tovább mozog felfelé. A vételi limit megbízás ennek a fordítottja, a pillanatnyi ár alá helyezhetjük annak reményében, hogyha az ár lemegy a limit megbízás szintjére, ott megfordul és elindul felfelé. Az eladási függő megbízások ugyanezek, csak fordítva.)

Ez miért jó nekünk? Egyszerű! Tételezzük fel, hogy az árfolyam felfelé mozog és az RSI is és az ADX is azt mutatja, hogy bizony a trend kimerült és meg fog fordulni, hiszen az RSI a felső extrém tartományban van, az ADX pedig már rég túllépte a 40-es extrém szintet. Ilyenkor a felfelé mozgó trend megtörésére játszva a pillanatnyi ár alá elhelyezünk egy sell (short , kinek mi tetszik) stop megbízást. Ha az árfolyam tovább mozog a nekünk nem kívánatos irányba (azaz tovább emelkedik az árfolyam), akkor nincs semmi baj, hiszen nincs élő nyitott pozíciónk, ha viszont valóban megfordul az árfolyam, akkor megnyílik a pozíciónk, ráadásul akkor, amikor tutira lefelé mozog az ár!

Nézzük továbbra is azt az esetet, amikor az árfolyam mégis felfelé megy tovább. Építhetünk piramist? Hát persze! Mi az hogy! Mivel egyre nagyobb stop megbízásokat helyezünk el, ha nagyon elszáll az árfolyam, akkor akár nyolc megbízás is lehet ott, és amikor végre megfordul az árfolyam, akkor éppen a legnagyobb stop megbízásunk élesedik, ami azonnal nyereséges lesz!

SELL Stop piramis - A sárga függőleges vonalnál indul a "rally". elhelyezünk egy sell stop megbízást az árfolyam alá, mert fordulóra készülünk. De nem fordul, ezért amikor az árfolyam tovább emelkedik, 250 PIP-re az előzőtől elhelyezünk egy újabb sell stop-ot az árfolyam alá, de már az első pozíció méretének duplájával. Újabb 250 PIP után már a legelső négyszerese, és így tovább! Itt csak 6 sell stop van, de ez lehet akát 10 is! A kockázati tőként mondja meg, mennyit szabad.

Eddig pozíciókat nyitottunk, megkerestük a nekünk megfelelő stratégiát, piramisokat építettünk a pozíciókból, de van egy rossz hírem! A pozíció nyitás még nem elegendő a sikerhez! Le is kell zárni a pozíciókat, méghozzá nyereséggel, a lehető legjobb időben! Láttuk, hogy ez nem mindig lehetséges, de bízunk a stratégiánkban és úgy gondoljuk, hogy nyerünk!

Hogy mit is kezdjünk ezzel a - jó esetben sok-sok - nyitott pozícióval, erről lesz szó a következő posztban!

Mi van ha ...

2014-08-08T09:27:00.000+02:00

A legutóbbi posztban megvitattuk a pozíció nyitásának stratégiáját. Ez ugyebár két indikátor alapján történik, a feltételezett trend irányába, röviden összefoglalva amikor az RSI azt alsó extrém tartományban tartózkodik, akkor long irányú, amikor pedig a felső extrém tartományban van, akkor short irányú pozíciót nyitunk.
Mindezt az ADX indikát ADX vonala erősíti meg számunkra, amely ha az extrém érték fölött jár, akkor érvényes az RSI jelzése.

Sok példát tehetnék ide, hogyan is működik ez, és hogy milyen jól. De nincs ez mindig így!

Mi van ha a trend erős, RSI valamelyik extrém tartományban van, mégsem fordul meg a trend, hanem ballag tovább. Az RSI hol visszatér az extrém tartományból, hol nem, de a középvonalat nem éri el, az ADX is folyamatosan 40 fölött van...

RSI extrém tartományban, az ADX folyamatosan extrém szint fölött - ilyenkor mi van?

Az ábrán mutatott esetben ugye short-ot kellene nyitnunk, de sajnos hiába nyitunk short-ot, az árfolyam tovább megy felfelé! Ráadásul úgy néz ki, hogy elszállt az árfolyam, azaz nem valószínű, hogy visszatér az eredeti árakhoz...

Na ilyenkor mi van?

Többféle megoldás létezik. A legáltalánosabban elterjedt megoldás a rulett asztalok mellől kitiltott Martingale módszer, esetleg az anti-Matringale módszer. Mi ez és hogy jön ide.

Röviden a Martingale módszer : fogadási stratégia, amely nem foglalkozik azzal, hogy milyenek az esélyek egyik vagy másik irány megnyerésére, a fontos az, hogy 50-50% esély legyen mindkét oldal megnyerésére, vagy elvesztésére. A lényeg az, hogyha megtesszük a tétjeinket, akkor vagy nyerünk, vagy vesztünk. Ha nyerünk, akkor zsebre tesszük a nyereményt, ha vesztünk akkor újra megtesszük a tétjeinket, de immáron az elveszített korábbi tét kétszeresét. Ezt egészen addig folytatjuk, amíg egyszer csak nyerünk. Ebben az esetben visszanyerünk mindent, amit kockáztattunk, plusz nyereményként pedig a kezdő tétünket. Így máris pluszban vagyunk.

Hogyan működik ez a tőzsdén? A már említett esetünkben ez úgy működik, hogy amikor az RSI a felső extrém tartományban van, az ADX pedig megerősíti, hogy a trend kifulladóban van, akkor nyitunk egy short pozíciót. Ha azonban az árfolyam tovább emelkedik, akkor bizonyos árfolyam távolság után újabb short pozíciót nyitunk, de már kétszeresét a korábbi pozíciónak!

Természetesen ez nem veszélytelen stratégia. Gondoljuk csak el! Ha minden alkalommal az előző pozíció dupláját nyitjuk meg, akkor exponenciálisan növekszik a nyitott pozíciók mérete, ezzel együtt pedig a bekötött összeg :

1. kötés : 0,01 lot
2. kötés : 0,02 lot
3. kötés : 0,04 lot
4. kötés : 0,08 lot
5. kötés : 0,16 lot
6. kötés : 0,32 lot
7. kötés : 0,64 lot
8. kötés : 1,28 lot

Ugye látszik a piramis? Nyolc kötés után a megnyitott pozíció mérete már 1,28 lot, az összes bekötött pozíció mennyiség pedig 2,55 lot! Ha nyolc kötés után nem áll meg az árfolyam, akkor ez a 2,55 lot olyan gyorsan égeti el a számlánkat, mint egy rakétahajtómű a papír zsebkendőt.

A kérdések a következők :

Mekkora lépésközönként nyissunk új pozíciót? Magyarán a kérdés az, hogy milyen árfolyam emelkedés után nyitunk újabb pozíciót, amely mérete természetesen az előtte lévő duplája.
Az előbb meghatározott lépésközökkel nyitott pozíciók kezdő mérete mennyi lehet, hogy ne égesse el a számlát? Vagyis ha 0,01 lot-tal kezünk az lesz a jó, vagy kezdhetünk már 0,1 lot-tal is?
Vajon a fenti két kérdés megválaszolása után hány darab trend ellenes (emelkedő árfolyam esetén short pozíció nyitása, vagy fordítva, csökkenő trend esetén long pozíció nyitása) lehetséges? Ne felejtsük el, hogy minden egyes újabb pozícióval a nyitott pozíciók mérete duplázódik, illetve a be nem kötött tőkénk ennek megfelelően csökken! (Hiszen az árfolyam ellenünk dolgozik)

Ezekre a kérdésekre nem könnyű válaszolni, általában egy teljes évet visszatesztelve lehet jó közelítésű statisztikát kinyerni, amellyel általában a következő egy évet is végig lehet kereskedni. Erre jó a stratégia backtest-je. Erre később ki is térünk részletesen, mert nem ez az egyetlen paraméter, amelyet tesztelnünk kell, lesz más is! De erről egy későbbi posztban lesz szó.

A poszt címéhez méltóan folytatom a kérdésfeltevést : Mi van, ha az elmúlt egy év tesztelései alapján beállított paraméterek működnek ugyan, de az árfolyam mégis elszáll?

Ez történt 2012 őszén a japán yen árfolyamával. A korábbi néhány PIP-es hullámvasút után hirtelen az egekbe szökött az árfolyam (gyengült a yen) és szinte megállíthatatlanul ment feljebb és feljebb. Sok trend ellenes kereskedő bukott ezen...

Kétféle megoldást választhatunk! A kényelmes megoldás az, hogyha hagyjuk az egészet az enyészetnek és elveszítjük a számlán lévő kockázati (!!!!!) tőkénket, hiszen úgyis csak annyit kockáztattunk, amennyit el merünk veszíteni!

A másik megoldás az, ha védekezünk ez ellen is, amelyre szintén kétféle megoldás létezik!

A védekezésről viszont - mert van védekezési lehetőség - a következő posztban lesz szó!

Pozíció nyitási stratégia

2014-08-06T09:25:00.002+02:00

A múltkori bejegyzésben a pénzkezelésről ejtettünk szót. A mostani poszt már inkább a pozíció nyitásról szól, hiszen ez az egyik leglényegesebb része egy stratégiának (a pozíció zárás mellett természetesen).
Egyfajta trend irányú kereskedésről lesz szó, azonban tudjuk, hogy a tőzsdén bármi megtörténhet, ezért fel kell készülnünk a trend ellen "ható erőkre" is.

Két indikátort fogunk használni a pozícióba lépéshez, az egyik az RSI lesz, a mások pedig az ADX. Nézzük röviden, melyik mire való indikátor.

RSI (Relative Strength Index) - Momentum indikátor, amely az árak alakulását mutatja 0 és 100 között. Általában 14-es periódussal használják, két jelentős szintet - 30 és 70 - figyelembe véve. 30 alatt az eladások miatt túlságosan leárazott instrumentumról beszélhetünk - azaz az adott instrumentum túladott -, míg 70 felett többnyire a vásárlások miatt túlértékelt, túlárazott - azaz túlvett - instrumentumról van szó.
Tulajdonképpen a papír árának "hangulatáról" van szó. Ha megfigyelünk egy chart-to, többnyire ezekről a szintekről az árfolyam visszafordul, vele együtt az RSI is. Tehát kiválóan alkalmas lehet a trendek váltásának jelzésére. Természetesen óvatosan kell ezt kezelni, de erre majd később kitérünk.

RSI - a függőleges vonal mentén látható, hogy az instrumentum túladott lett, így meg is fordult a trend

ADX (Average Directional Index) - Ez egy trend követő indikátor, amely leginkább a trend erősségét mutatja. Az alsó határ ismert csak, amely 0, és természetesen itt is van egy jelentős szint, ez pedig a 40-es érték. Szintén 14-es periódussal használják. Jelentését nem nehéz megérteni, amikor az indikátor a 40-es szint fölé emelkedik, a trend erőssége már jelentős, ami egyben azt is jelentheti, hogy a trend kimerül és visszafordul.
Fontos megemlíteni a +DI és a -DI nevű komponenseit az indikátornak, amelyek fontos szerepet játszanak, ezek egymáshoz viszonyított helyzete mutatja a trend irányát, miután maga az ADX vonal csak az erősséget, akár esik a trend, akár emelkedik. Amikor a +DI és a -DI keresztezi egymást, akkor többnyire trendváltás figyelhető meg.

ADX - a piros függőleges vonalnál jól látható a trend csökkenőbe fordulása, a sárga függőleges vonalnál pedig már jelentős a trend.

A két indikátor együttes használatával meglehetősen jól megbecsülhető a trendek megfordulása, amelyekre a megfelelő irányba kötött pozíciókkal trendirányban kereskedhetünk.
Mivel azonban za RSI indikátor jelzéseire támaszkodunk, ezért nem fogjuk kihasználni az ADX indikikátor +DI és -DI komponenseit, csakis kizárólag a fő ADX vonalat fogjuk figyelni.
Íme a chart setup :

RSI, ADX együtt - a függőleges vonalnál jól látszik, hogy az árfolyam túladott szinten van (RSI 30 alatt), a trend erőssége jelentős (ADX 40 fölött), amely a trend kimerülését vetíti előre, az árfolyam ezt követően meg is fordul és az árfolyam emelkedni kezd

Természetesen azért ez nem mindig ilyen szabályszerű, mint ahogyan a tőzsdén szabályszerűséget igen nehéz találni. Gondoljunk csak bele, hogyha ez így lenne, akkor mennyire egyszerű dolga lenne az egyszeri kereskedőnek, benyitja a pozíciót és mindig nyer!

Tényleg így van?

Derítsd ki! Nézd meg, hogy 10 esetből hány olyan eset van, amikor a fent leírt és bemutatott szabályosság működik és megfordul az árfolyam, és hány olyan eset van, amikor az indikátorok ellenére az árfolyam mégis tovább esik, vagy tovább emelkedik.

Vigyázz!!! Minden időtávon más és más eredményt kapsz!

A következőkben arról lesz szó, hogyan fordíthatjuk a magunk javára az árfolyam szabálytalanságait!
Amit pedig mindig tarts szem előtt : a veszteségek szükségesek a nyereségekhez!

Pénzkezelés

2014-05-19T10:03:00.001+02:00

Azért tartom fontosnak a pénzkezelést, mert sokan járnak úgy, hogy a megtakarított pénzüket pillanatok alatt elégetik egy FOREX számlán, valamilyen robottal, esetleg egy stratégiával, amit valahol vásároltak.

A pénzkezelés legalább olyan fontos, mint maga a stratégia, és nem kell hozzá doktori diploma, hogy bárki józan ésszel végig gondolva kitalálja, mennyit mer veszíteni. Ha a pénzkezelési stratégiánk jó, akkor nem fogunk abba a 90%-ba tartozni, akik már az első évben lenullázzák a pénzüket!
Nem győzöm persze hangsúlyozni, hogy a pénzkezelés szorosan összefügg a Money Management-tel is, hiszen ez utóbbit a stratégiánkban fogjuk alkalmazni, annak a része, de a pénzkezelési stratégia az alapja.

Nézzük csak, miért is kell foglalkoznunk a témával. Azért, mert az elsődleges célunk természetesen az, hogy pénzt keressünk a FOREX-ezéssel, bármilyen stratégiát is választunk. Pénzt keresni pedig úgy lehet, hogyha készítünk egy stratégiát, amellyel rendesen be tudjuk osztani a megtakarításainkat, és megóvjuk attól, hogy elillanjon.

Ha a megtakarításainkat 100%-nak tekintjük, akkor ennek az összegnek mindössze a 40%-át érdemes tőzsdei, vagy devizapiaci kockázatnak kitenni. A "maradék" 60%-ot másféle - kisebb kockázatú - befektetési formákba kell tenni, mint például az alapok. Nem hoznak sok profitot, de a banki kamatoknál valamivel többet és legalább a kockázata kicsi annak, hogy eltűnik. Lássuk be, örök igazság az, hogy alacsony kockázat, alacsony hozam és fordítva. Természetes tehát, hogy a magasabb kockázatú befektetési formát csak alacsony összeggel vállaljuk, mert ha elveszítjük, akkor talán fáj, de nem annyira, mint amikor a teljes megtakarításunkat veszítjük el.

A maradék 40% tőzsdei/devizapiaci befektetést viszont okosan kell elosztani. Nyilván a 40% mindössze 10%-át kezdd el FOREX-en forgatni, mert ez a 40% 10%-a a teljes 100%-nak "csak" a 4%-a lesz. Ezzel a kockázatunkat is 4%-nál tartjuk! Legalábbis a teljes megtakarításunkra nézve!

Ezzel szemben viszont a megfelelő stratégiával (amire természetesen ki forgunk térni) ezt a 4%-ot meg lehet pörgetni úgy, hogy a 4%-ot megduplázod és a 100%-os megtakarításodból hirtelen 104% lesz...

Ennek szellemében kell a pénzedet kezelned, ha okosan, befektetőként szeretnéd azt kezelni!

A fő szabályok a következők :

Csak annyi pénzt tegyél egy kereskedési számlára, amit nem fáj elveszíteni! Vagyis NE a teljes befektetni kívánt összeget kockáztasd, hanem csak azt, amit nem félsz elveszteni! A kereskedési számládon ne a befektetési tőkéd legyen, hanem CSAK a kockázati! Így ha azt elveszíted, akkor tudod mit veszítettél, a tőzsdepszichológia nem ül a nyakadba és tudod kezdeni elölről!
Ha devizával foglalkozol, akkor egy devizapár kereskedésével foglalkozz egy számlán és ne többel. Saját bőrömön tapasztaltam meg, hogy milyen az, amikor három devizapárral kereskedtem egy számlán, remekül teljesített, egyik többet hozott, a másik kevesebbet. Aztán az egyik devizapár elszállt és vitt mindent. Ha a három devizapárral három rész számlán kereskedtem volna a tökét három felé osztva, ma is létezne a számlák közül legalább kettő.
Ha csak a kockázati összeget utalod a számlára, válassz olyan brókert, ahol adnak kedvezményeket. Nem a nulla spread-re gondolok, meg ilyesmikre, hanem az átutalt pénzedhez hozzátett bónuszokra gondolok. Van, ahol "csak" 30%-ot adnak, de van, ahol 100%-ot! Természetesen ezt majd vissza kell adnod, amikor a nyereségedet hazautalod, viszont ha elveszíted, akkor senki sem kéri rajtad számon, elveszíthető a bónusz büntetlenül! NAGYON FONTOS, hogy olyan brókert válassz, ahol ezt a bónuszt akkor adják, amikor odautalod a pénzedet. Nem akkor amikor X lot-ot kereskedtél egy hónapban... Az nem jó. De a bróker választását úgyis kivesézzük.

Ezekkel a fő szabályokkal a pénzkezelésed rendben lesz, nem kell attól félned, hogy többet veszítesz, mint amennyit megengedhetsz magadnak!

Figyelj oda rá, hogy kiszámold pontosan, mekkora a takaród, ne nyújtózkodj túl rajta! Ezt hideg fejjel, mielőtt egyáltalán kereskedni kezdesz, akkor tedd meg! Ha nincs elég pénzed a FOREX-ezésre, mert a megtakarításod 4%-a nem éri el a számla nyitási minimumot, akkor NE FOREX-ezz! Tényleg!

Ez nem az a sport, amit nulla kezdőpénzzel elkezdhetsz, bárki is állítja ennek az ellenkezőjét!

Remek marketing fogás az, amikor azt hirdetik, hogy légy a megtakarításod brókere és ezt már pár tízezer forinttal el lehet kezdeni! Ezek a szövegek arra valók, hogy mindenkit becsábítsanak a tanterembe! Nem szabad bedőlni az ilyesmiknek!

És végül még egy jó tanács! Két könyvet szeretnék ajánlani, amit mindenképpen érdemes elolvasni, mielőtt FOREX-ezni kezdesz és kiszámolod a 4%-odat! Mindekettőt Robert Kiyosaki írta az első egy klasszikus és talán már hallottál róla! Ez pedig a Gazdag papa szegény papa c. alkotása, amely több kiadást is megért! Ez beállítja a gondolkodás módodat, segyt átgondolni azt, hogy mihez kezdj, ha ki akarsz törni a mindennapokból. Természetesen nem minden gondolatát kell befogadnod, mert nagyon sok mindent az amerikai viszonyokra talált ki, mi pedig Magyarországon élünk! Tehát ami működik amerikában, az nem feltétlenül működik itthon!

De a gondolkodás mód nagyon fontos, ezért olvasd el!

A másik, amit szintén el kell olvasnod, az pedig a Cashflow négyszög c. könyve, ami pedig tovább fejleszti ezt a gondolkodás módot, megtanít befektetőként gondolkodni, hogy egy kicsit kívülről is lásd a mátrixot!

Ha ezeket elolvastad, kiszámoltad mennyi pénzre van szükséged, és felkészültél, akkor tovább léphetsz!

Egy teljesen új kezdet

2014-05-02T10:37:00.000+02:00

Kedves Olvasóim!

Öt éve tanultam meg a tőzsdézés alapjait, fél évvel később már programozni kezdtem Metatrader-ben.
Sok buktatót megéltem, sok dolgot leírtam - többek között ide is - amit ma már másképpen gondolok. Nem azért, mert határozatlan vagyok, hanem azért, mert ez a szakma - egész nyugodtan mondhatom, hogy az - egy folyamatos tanulás.

Bármennyire is furán hangzik és sokan ellenzik is, ez a szakma a közösség ereje nélkül nem megy. Sajnálatos módon ma Magyarországon ezekért a közösségekért fizetni kell. Mégpedig azért, mert Magyarországon szeretnek az emberek nagy pénzeket keresni és azt is úgy, hogy kevés kockázatot vállaljanak. Annak idején én is egy ilyen csapat tagja voltam, nagyon nem kevés pénzért.

Ezek a közösségek az úgynevezett tőzsdetanfolyamok. Akkoriban (2009-et írtunk) nem sok volt ráadásul azt sem tudtam mit keressek, így hát rengeteg pénzért szombatonként 10 héten keresztül tanutam meg a tőzsdézés alapjait. Ma már szinte mindenki tanítja ezt a szakmát, de nagyon kevesen művelik. Elenyésző mennyiségben vannak olyan társaságok, akik főállásban (!!!) kereskednek, és miután már van kiforrott technikájuk, tanítják, nem kevés pénzért. Persze ezt okosan csinálják, mindenre megtanítanak, hogy olyan sikeres légy, mint ők, de a titoktartási nyilatkozattal megvédik a szellemi tulajdonukat, méghozzá elég hatékonyan.

Két alkalommal is voltam egy ilyen csapat oktatásán, és azt kell mondjam zseniálisak! Olyan technikát tanítanak, amivel BÁRKI képes pénzt keresni a FOREX piacon, odafigyelnek a tanítványokra, a tanfolyam után is követik a fejlődésüket, segítenek! Nem sok ilyet ismerek! Aki engem tanított legelső alkalommal sok-sok pénzért, ma bíróságra jár, mert stratégiát nem tanított, titokban tartotta, viszont 400 ezerért tanított automatizált technikát, és aki akart beszállhatott hozzá. Persze nagy bukta lett, most perelik. Nevesíteni nem szeretnék!

Amiért majdnem egy teljes év után mégis billentyűzetet ragadtam, az azért történt, mert sok dolog összeállt a fejemben. Nem adhatom tovább Nektek azt, amit tanultam az elmúlt hónapokban, de azok az elméleti elemek, amelyek kulcsfontosságúak egy robot megalkotásánál, azokat tovább merem adni, hiszen ezek olyan közkincsek, amelyeket BÁRKI megtalálhat az interneten, legfeljebb egy kis angol nyelv ismeret szükséges hozzá.

Legutóbbi bejegyzésem a Money Managementről szól. El is készült a második poszt is, de ezt már nem publikáltam, mert mire a végére értem, addigra rá kellett jöjjek, amiről írtam két részre osztható, Money Management-re és pozíció management-re. Át kellene írnom az egészet, hogy értelme legyen.

Közben a háttérben egy automatizált rendszer is kialakult, egy teljes évig remekül működött, aztán hirtelen megváltozott a piac és a megduplázott számlát elégette rendszer. Hosszan önvizsgálat következett, hogy miért, és azt kell mondjam, két hibája is volt, ami a buktát eredményezte. Az egyik, hogy nem ismertem fel a piac változásait. A másikról egy következő bejegyzésben részletesen írni fogok.

Aztán jött a tanfolyam - nem is egy - és ráébredtem, hogy az eltelt 5 éve alatt gyökeresen megváltozott az elképzelésem az automatikus kereskedésről. Úgy döntöttem, hogy teljesen újragondolom azt a robotot, amellyel sikeresen megdupláztam korábbi számlámat és végül elúszott az egész a saját ostobaságom miatt.

Több olyan tudás is van a fejemben, amivel ma már egészen másképp építeném fel ezt a robotot, de miután már ebbe a blogba is igen sok időt fektettem, úgy döntöttem, megosztom Veletek, hogy mit és hogyan csinálnék, sőt mi több, együtt Veletek fogom kialakítani ezt az automatikusan kereskedő FOREX robotot.

Ezt a bejegyzést nem mézes madzagnak szántam, de úgy gondolom, hogy egy rendesen kivitelezett robot elkészítése előtt azt meg kell tervezni rendesen. A folyamatnak néhány elég jól elkülöníthető része van :

Pénzkezelés - avagy mennyit és hogyan tegyünk a robot zsebébe
Brókerválasztás - mert nem minden ECN ami fénylik
A robot stratégiája - amit meg kell írnunk

Hogyan nyitunk pozíciót, milyen jelre
Mekkora pozíciót nyitunk (Money Management)
Hogyan kezeljük a pozíciókat (Pozíció Management)
Hogyan zárjuk a pozíciókat

Optimalizálás, backtest-elés
Élesbe állítás
A robotunk üzemeltetése, azaz mire figyeljünk a piacon

Ezek nem tűnnek nagy durrantásnak, de nagyon fontos dolgok - a robot megírásán túl.

Még egy dolog, mielőtt nekivágunk! Amióta automatikus rendszerekkel foglalkozom, rá kellett jönnöm, hogy egy FOREX robot megírásában maga a programozás elenyészően fontos csak. Ha olyan programozó vagy, aki nem iskolában tanulta a programozást, hanem autodidakta módon, akkor se ijedj meg ettől! Néhány fontos szabály ismeretében BÁRKI képes robotot írni és pénzt keresni vele.

A következő bejegyzésben összeszedem a pénzkezeléssel kapcsolatos tudnivalókat, amelyeket az utóbbi években megtanultam, részben a saját káromon, részben a tanfolyamokon.

Money Management I. rész - Stop-loss kezelés

2013-07-08T20:08:00.002+02:00

Többször is említettem, hogy elengedhetetlenül fontos a Money Management (továbbiakban MM).
Miért is?

Azért, mert az MM-nek kettős feladata van egy forex robot esetében.
Az egyik feladat a kockázatkezelés, a másik pedig a nyereség maximalizálása. Ez utóbbi gondoskodik egyébként a gyengén teljesítő robot nyereségességéről, míg a kockázatkezelés a veszteségek minimalizálásáról.

A kockázatkezelés helytelen altgoritmizálása lehet ugyanolyan káros, mint az, ha rossz a robotunk pozíció nyitása. A kockázatkezelés legegyszerűbb módszeréül robot készítők többnyire az egyszerű stop-loss-t szokták választani, ami nem rossz döntés, de két hátránya van :

ha túl közel van, akkor a visszateszteknél kiüti és ezzel megakadályozza a hosszabb trendekben való részvételt, jól lehet a veszteség is alacsony marad, de a nyereség is
ha túl messze van, akkor ugyan benne tudunk maradni a hosszú trendekben, de hosszú távon sajnos - a nagy távolság miatt - komoly veszteségeket termel. Ne felejtsük el, hogy a piac 30%-ban trendel csak, a többi részében oldalazik.

Mi lehet a megoldás?

Kockázatot kezelni úgy lehet, ha tudja az ember, miféle kockázatra kell felkészülnie. A fenti két hátrány az, ami a legkomolyabb kockázat, ha stop-loss-t használunk, ha nem használunk, akkor viszont fel kell készülni a teljes számla elvesztésére!

Tehát, hogyan védekezhetünk a fenti két esetben? A válasz egyszerűnek tűnik, de persze nem az. Az egyik megoldás az, ha követő stopot használunk.

Követő stop esetében a legkomolyabb kérdés természetesen az, hogy milyen távolságban legyen a stop vonal az árhoz viszonyítva, illetve az is fontos szempont, hogy mikor kezdjük el húzni a stopot az ár után.

A távolság persze szubjektív, tehát egy adott devizapár esetén ki kell kísérletezni backtest-tel, esetleg meg lehet próbálni optimalizálni is. Nyilván két fontos tényező befolyásolja:

az egyik a spread,
a másik pedig az, hogy mit enged meg a bróker legkisebb stop távolságnak (stoplevel paraméter).

Ha meg van a távolság, akkor már csak azt kell eldönteni, hogy mikor kezdjük el húzni a stop vonalat. Erre három lehetőségünk adódik :

Az árfolyam pozitív elmozdulása esetén azonnal - itt ugyebár el tudjuk érni azt, hogy a veszteségünket a lehető legkisebbre csökkentsük, de ezzel persze csak ámítjuk magunkat, mert ezt a módszert akkor választjuk, ha túl messze van a stop az ártól. Nagyjából mindig lesz veszteség, kisebb-nagyobb, mert a stoplevel túlságosan magas, vagy az időtáv kicsi.
Amikor az árfolyam pozitív irányba elmegy legalább egy spread-nyit, akkor nullába húzzuk (breakeven stop, azaz fedezeti stop) és innentől indulhat a stop húzás - ami jó módszer arra, hogy legrosszabb esetben veszteség és nyereség nélkül jöjjünk ki a pozícióból. Igen ám, de a legtöbb brókernél a stoplevel, azaz a minimális stop távolság jóval nagyobb, mint a spread, tehát ez nem minden esetben járható. Ráadásul a kezdeti stop távolság itt is fontos tényező.
Amikor az árfolyam pozitív irányba mozdul el, több, mint egy spread-nyit, és már valamekkora nyereség is realizálható lenne (1:1 Risk reward esetén természetesen ez a nyereség meg kell egyezzen a stop-loss veszteségével és ez az ideális), akkor a stop vonalunkat behúzzuk a spread határára és onnan húzzuk az ár után, ahogy megy felfelé - ez szintén jó módszer lehetne, ha a 2-es pontban említett akadály nem állna fenn a bróker oldaláról. Ekkor ugyanis vagy nyereséges, vagy stop-loss-nyi veszteséges pozíciókat zárnánk, és ha jól választjuk meg a minimális nyereség mértékét, és a stratégiánk találati aránya 50%-nál jobb, akkor máris nyereséges stratégiát alkotottunk.

A fentiekből látható, hogy kulcs kérdés a jó bróker megválasztása, amikor is a spread-ek alacsonyak és természetesen a stoplevel is alacsony, vagy esetleg nincs.

Persze azonnal rávágja mindenki, hogy ezek bizony az ECN brókerek, ahol persze magas összeggel lehet csak tőkét nyitni. Pedig bármilyen hihetetlen, vannak nem ECN brókerek, aki stoplevel nélkül (akár tized PIP-pel az ár alatt) engednek stop-loss vonalat húzni, alacsony a belépési tőke és a spread-ek sem eget verőek!

Ilyen bróker az LMAX Exchange is. Bátran ajánlom, jó feltételekkel lehet náluk számlát nyitni!

Van azonban a fenti három módszernél egy sokkal jobb módszer is, ha már sikerült jó brókernél számlát nyitni! A módszert az szülte, hogy nyilvánvalóan nehéz jó teszteket futtatni, hogy eltaláljuk az optimális stop távolságot, ami minden piaci helyzetben megállja a helyzetét.

Egy jó forex robot képes alkalmazkodni a piaci helyzethez és képesnek kell lennie olyan stop távolságokat számítani, ami minden esetben jó. Na jó, de hogyan?

Ha fix stop távolságot használ a robot, akkor ha túl kicsi, gyorsan kiüti az árfolyam. Ha túl nagy, akkor a veszteséges pozíció zárások lesznek többségben és elúszik a pénzünk. Ha teszteket futtatunk, akkor láthatóvá válik ez a probléma. Ezen egy rendkívül egyszerű módszerrel lehet úrrá lenni. Ha a piac trendel, akkor lehet nagy stop távolságokat hagyni, ha pedig oldalazik, akkor ajánlatos minél kisebbeket választani, és inkább stoppolódjunk ki, ha nem megy semerre sem a piac.

Erre tökéletes megoldás a piac volatilitásának figyelése, amikor is az ATR indikátor siet a segítségünkre. Van persze, aki a Parabolic SAR-t használja, de saját tapasztalatom az, hogy a Parabolic későn reagál és sokszor nehéz jól paraméterezni, hogy megbízható stop-okat adjon. Ehelyett ha long pozíciót nyitunk, akkor az előzőleg bezárt gyertya kanóc aljára ráteszünk egy ATR értéket és annyival lejjebb húzzuk meg a stop-loss vonalunkat (mínusz a spread természetesen), short esetén természetesen a kanóc tetejére számolunk rá ATR-nyit (és még egy spread-nyit). Finomításképpen be lehet iktatni egy szorzót, amely tovább növelheti a stop távolságot, de többnyire ez felesleges, mert az ATR stop húzás kellőképpen igazodik a piachoz.

Ha trendel a piac, akkor kellő stop távolságot tart, hogy a visszatesztek és a counter trendek esetében ne csapja ki az árfolyam a stopot, de amikor oldalazásba kezd a piac, akkor a volatilitás is csökken, közelebb kerül a stop-loss és ha esetleg megfordul a trend, a lehető legkisebb veszteséggel tudjuk realizálni a profitot.

Ez talán a lehető legjobb stratégia a kockázatkezelésre. Nyilván ez nem minden devizapárnál jön be, de a legtöbbnél igen. A legjobban fluktuáló piacok azok, ahol ezt kamatoztatni lehet, tehát a major párokra kell koncentrálnunk, és persze a lehető legkisebb spread-del rendelkező párokra.

Az MM másik aspektusa - a kockázatkezelés mellett - a nyereségek maximalizálása. A nyereségek maximalizálásának is többféle módja létezik, bár a közös bennük mindig az úgynevezett pozíció építés nevű technika.

Erről azonban a következő post-ban lesz szó, hamarosan!

Addig is gondolkodtatónak íme egy indikátor, amely a lehetséges ATR stop-okat mutatja a gyertyák felett és alatt.

 //+------------------------------------------------------------------+  
 //|                           ATRStop.mq4 |  
 //|                  Copyright © 2010, János Antal |  
 //|                 http://tozsdecapak.blogspot.com |  
 //+------------------------------------------------------------------+  
 #property copyright "Copyright © 2010, János Antal"  
 #property link   "http://tozsdecapak.blogspot.com"  
   
 #property indicator_chart_window  
 #property indicator_buffers 2  
 #property indicator_color1 DodgerBlue  
 #property indicator_color2 Red  
   
 extern  int  ATR=50;  
 extern  int  Multiplier=1;  
 extern  bool Body=0;  
   
 double UP[], DN[];  
   
 int init()  
 {  
   SetIndexStyle(0,DRAW_LINE,0,2);  
   SetIndexBuffer(0,UP);  
   SetIndexLabel(0,"UP");  
   
   SetIndexStyle(1,DRAW_LINE,0,2);  
   SetIndexBuffer(1,DN);  
   SetIndexLabel(1,"DN");  
 }  
   
 int start()  
 {  
   int  counted_bars=IndicatorCounted();  
   double _ATR;  
     
   int limit = Bars-counted_bars;  
     
   for(int i=0;i<=limit;i++)  
   {  
    _ATR=iATR(Symbol(),Period(),ATR,i);  
    if (!Body)  
    {  
      UP[i]=iHigh(Symbol(),Period(),i)+_ATR*Multiplier;  
      DN[i]=iLow(Symbol(),Period(),i)-_ATR*Multiplier;  
    }else  
    {  
      if (iOpen(Symbol(),Period(),i) > iClose(Symbol(),Period(),i))    // Piros gyertya  
      {  
       UP[i]=iOpen(Symbol(),Period(),i)+_ATR*Multiplier;  
       DN[i]=iClose(Symbol(),Period(),i)-_ATR*Multiplier;  
      }else if (iOpen(Symbol(),Period(),i) < iClose(Symbol(),Period(),i)) // Zöld gyertya  
      {  
       UP[i]=iClose(Symbol(),Period(),i)+_ATR*Multiplier;  
       DN[i]=iOpen(Symbol(),Period(),i)-_ATR*Multiplier;  
      }else if (iOpen(Symbol(),Period(),i) == iClose(Symbol(),Period(),i)) // Doji gyertya  
      {  
       UP[i]=iOpen(Symbol(),Period(),i)+_ATR*Multiplier;  
       DN[i]=iClose(Symbol(),Period(),i)-_ATR*Multiplier;  
      }  
    }  
   }  
 }

És némi magyarázat a kódhoz :

ATR : ez természetesen az ATR indikátor periódus paramétere
Multiplier : ez az a bizonyos szorzó, egész szám! Ennyiszeresére szorozza fel a normál ATR értéket
Body : ha 0 értékre állítjuk, akkor a gyertya kanócokra számítja rá az ATR értéket, ha bármi másra, akkor gyertya testre számol rá ATR-nyit

A kék vonal a short pozíciók lehetséges stop-loss pontjait köti össze, a piros pedig a long-okét. Természetesen minden esetben az előző gyertyára számított értéket van értelme figyelembe venni, hiszen az aktuális gyertya még nem zárult be, vagyis folyamatosan változ(hat)nak az értékek.

Jó nézelődést!

Backtest - avagy a puding próbája

2013-04-23T18:41:00.000+02:00

Egyik korábbi bejegyzésemben arról írtam, hogy a tesztelés egy igen fontos fázis, ha robotot készítünk.
A tesztelés nem túl egyszerű dolog, ugyanis ehhez teszt adatok kellenek. Korábban a NinjaTrader-rel próbálkoztam, de olyan nagyon megbízhatatlan adatokat szolgáltatott a teszteléshez, ami miatt a sokkal megbízhatóbb - és talán éppen ezért népszerűbb - MetaTrader-re nyergeltem át.

A FOREX robot tesztelésének egyik legfontosabb lépése a backtest. Nem kell megijedni ettől a szótól, csupán annyit jelent, hogy a múlt adatait alapul véve tesztelünk. A MetaTrader ebben is profibb társainál (habár biztosan lesz aki talál ettől is jobbat), ugyanis a múltbéli adatokat nem gyertyákként raktározza el, hanem tick-ekként, vagyis a múlt történései reprodukálhatók tick-ről tick-re.

Természetesen ez a rendszer sem hibátlan, de legalább korrigálhatók a hibák és egy olyan adatbázison tudunk tesztelni, ami a valósághoz a legközelebb áll.

Hozzátenném azonban, hogy a múlt béli adatokon végzett tesztek eredményei nem azt jelentik, hogy a jövőben is így fog teljesíteni a robot! Olyannyira nem, hogy előfordulhat az, hogy a backtest alkalmával fantasztikus eredményeket hoz a robot, de amikor az éles FOREX adatokon teszteljük, akkor sorra köti és zárja a vesztes pozíciókat. Természetesen a backtest statisztikailag bizonyítja FOREX robotunk működésének helyességét, de ez minden. A fontos az, hogy nem szabad nagyobb jelentőséget tulajdonítani a backtest-nek, mint ami valójában! Csak statisztikai teszt.

Viszont ez a statisztikai tesz igen sok hasznos információval szolgál arról, hogy az általunk kitalált stratégia életképes-e, egyáltalán vannak-e sikeres kötései, illetve ha veszteséges kötései vannak, akkor azok miért vannak, mennyi ilyen veszteséges kötés van egymás után, illetve milyen körülmények között történik.

Miért érdekesek ezek számunkra? Nagyon egyszerű a válasz. Azért, mert rájöhetünk a stratégiánk gyenge pontjára, amit a stratégia módosításával megszüntethetünk, de akár azt is láthatjuk belőle, hogy egy jó Money Management stratégiával hogyan lehet még több nyereségre szert tenni, esetleg a veszteséges stratégiát nyereségesbe átfordítani.

Nézzük hogyan is megy ez és mit láthatunk egy ilyen tesztből.
A tesztet a Stratégia Teszter menüpontban találjuk, a Nézet menüben (CTRL-R gyorsbillentyű). A grafikon alján meg is nyílik egy kis ablak, amiben néhány mezőt találunk.
Nézzük őket sorjában :

Expert Advisor - ez a mi kis programunk lesz, itt a legördülő menüből lehet kiválasztani a tesztelni kívánt robotot.
Szimbólum - Nos, itt pedig azt a devizapárt fogjuk tudni kiválasztani, amin a tesztet végre akarjuk hajtani.
Model - itt a szimuláció modelljét tudjuk kiválasztani, erről mindjárt kicsit bővebben beszélünk
Használat dátuma - itt mondhatjuk meg, hogy mely dátumtól mely dátumig történjen a teszt, illetve azt, hogy egyáltalán foglalkozzon-e a dátumokkal a teszter.
Visual mode - ha kipipáljuk, akkor látni fogjuk a szimulációt tick-ről tick-re és követhetjük mit művel a programunk. Itt van pár érdekesség, erről is beszélünk mindjárt.
Időszak - itt tulajdonképpen az időtávot választhatjuk meg, hogy 15 percesen, vagy 1 óráson, vagy valamelyik másik időtávon szeretnénk a tesztet végrehajtani.
Optimalizáció - ha optimalizálni szeretnénk, akkor ezt kell bepipálni. Ezt ne tegyük, ugyanis most backtest-telni fogunk.
Van egy-két nyomógomb is a jobb szélen, ezek közül a legfontosabb az Expert tulajdonságok, ahol a robotunk paramétereit adhatjuk meg úgy, mintha éppen most indítanánk éles rendszerben, de a rendelkezésre álló tőkét is beállíthatjuk, az optimalizálás paramétereit is, stb. (Az optimalizálás egy külön témakör, ezért erről most nem ejtünk szót)
Szimbólumok tulajdonságai - itt az adott devizapár chart-jára vonatkozó információkat láthatjuk - sajnos nem módosíthatjuk. Ez a bróker által meghatározott spread, swap, margin, stb. információk, tájékoztatásul.
Nyitott chart - ezzel a gombbal megnyithatjuk a chart-ot, ha nem visuális módban futattuk a tesztünket és megnézhetjük mi történt a teszt ideje alatt.
Expert módosítás - egyértelmű, ez az átjáró a MetaEditor-ba.

A tesztet azután tudjuk elindítani, ha már mindent beállítottunk. Vizuális tesztelés során, látni fogjuk, hogyan mozog az árfolyam, illetve mikor milyen pozíciókat nyit az Expert-ünk.

A tesztelés sebességét a kis csúszkával állíthatjuk, illetve dönthetünk úgy is, hogy kihagyjuk a vizuális megjelenítést, fusson végig a meghatározott időszakon a program és mutassa a tesztelés eredményeit.

A tesztelések eredménye azonban már más kérdés.

Nyilvánvalóan érdekes látni azt, hogy az általunk fabrikált Expert követi az utasításainkat - és miért is ne tenné - tehát a pozíció nyitások akkor lép-e pozícióba, amikor a megfelelő jelet kapja, akkor zárja-e a pozíciót, amikor kell, stb.

A backtest természetesen erre is választ ad.

Feltételezzük azonban, hogy az Expert írója képes úgy megírni a programot, ahogy a robot kívánja, és a stratégia szerint nyit és zár pozíciót. Az igazi kérdés ilyenkor az, hogy maga a stratégia életképes-e!

Ez nyilván nem csak attól függ, hogy a pozícióba lépés és a pozíció zárás sikeres volt-e, de sokat nyom a latba.

Nézzük csak miről is van szó...

Robotunk stratégiáját ugye úgy találtuk ki, hogy bizonyos piaci körülményekre számítva nyitunk és zárunk pozíciót. A valódi kérdés az, hogy ezeket a piaci körülményeket sikerült-e úgy meghatározni, hogy nyertes pozíciót zárjunk a lehető legtöbb alkalommal. Mondok egy példát.

Tegyük fel, hogy olyan forex robotot készítünk, amely semmi mást nem figyel, csak azt, hogy az aktuális gyertyatrend végén (mondjuk 5 gyertyából álló lokális gyertyatrendeket figyelünk) van-e kulcsforduló gyertya. Ha van, akkor a lokális gyertyatrend megfordulására számítunk és a feltételezett fordulás irányba nyitunk pozíciót. Tehát trend irányba.

(valljuk be őszintén, hogy ez nem is egy rossz stratégia, sokan kereskednek ilyen egyszerű szabályok alapján, ráadásul minden tőzsdeiskolában tanítják ennek az egyedülálló gyertya alakzatnak az erősségét, jelentőségét)

Azt, hogy mennyire sikeres a robotunk sok tényező befolyásolja, a legbeszédesebb mérőszáma a számlaegyenleg változása. De ne csak ezt figyeljük.

Egy forex robot esetében igen fontos információ a találati arány. Nézzük meg, mit is olvashatunk ki egy teszt eredményeiből!

Amikor a backtest lefutott, a Stratégia teszter alsó ablakában öt fület látunk.

Az első fülön a robot beállításait látjuk (Beállítások fül), a második fülön ar Eredmények-et, azaz a kötéslistát részletesen, a harmadig fül a Grafikon nevet kapta és tulajdonképpen a számla egyenlegünk változásait jeleníti meg a rendszer, negyedik fül a Jelentés-é, az ötödik pedig a Napló, ahol az Expert Advisor hibaüzeneteit találhatjuk meg.

Számunkra a Jelentés fülön található információk a lényegesek most!

A legfontosabb információk közé tartozik a Modelling quality a jobb felső sarokban. Ez azt mondja meg, hogy a tesztelés során használt adatok milyen pontossággal felelnek meg a historikus adatoknak. Ez a mérőszám igen fontos, hiszen, ha ez nem elég magas szám, akkor a teszt komolysága kerül veszélybe.

Alap esetben ez 25%, ami sajnos elégtelen! 50%-nál jobb értékre van szükség egy hihető teszthez, minél közelebb esik a 100%-hoz, annál megbízhatóbbak a jelentés eredményei. Azt, hogy hogyan lehet ezt a %-os arányt javítani, igen sok útmutatót találunk az interneten, erre most nem térnék ki, de meg kell említenem, hogy viszonylag egyszerű és ingyenes megoldásokkal fel lehet tornászni ezt a számot 90%-ra. 70% körüli értékkel már nyugodtan tesztelhetünk és hihetünk is a teszteknek.

A következő fontos információ a középen lévő Short pozíciók (won %) nevű adat, amely mellett rögtön ott van jobbra a Long pozíciók (won %) adat is és ne feledkezzünk meg a középső oszlopban lévő Nyereséges kereskedések (összes %-a) adatról sem! Ezek fogják megmondani, hogy valójában mennyire sikeres a stratégiánk, mekkora a találati arány! A short és long pozíciók találati arányát láthatjuk itt, illetve az összes (short és long) kötés találati arányát, ami a két előbbi átlaga.

Ha ez az érték 50%, vagy e körüli, akkor egy átlagos stratégiát sikerült összeraknunk.

(és szeretném megjegyezni itt gyorsan, hogy például a gyárilag készített MACD Sample nevű Expert Advisor találati aránya az összes kötésre 90%!!! Érdekes, hogy maga a robot nem hoz komoly eredményeket ennek ellenére)

Ez a szám igazából azért fontos, hogy tudjuk, hogy a kitalált stratégiánk - azaz milyen jelre kötünk és zárunk pozíciót - hányszor "jön be" az aktuális piaci helyzetben. Minél magasabb ez a szám, annál inkább alkalmas a stratégia automatikus kereskedésre, forex robot készítésére. Ha ezek a számok 50%-nál alacsonyabbak, akkor inkább fél automatikus (semi-automatic) stratégiát építhetünk belőle!

Tehát ha ez a szám alacsony, az még nem jelenti azt, hogy használhatatlan kereskedésre, csupán azt, hogy olyan feltételeket állítottunk fel, amely az esetek kevesebb, mint 50%-ban jön csak be, mint nyerő stratégia. Tehát tanuljuk meg helyén kezelni ezt az adatot.

Az előbbi információk beszédességét nagyban befolyásolja, hogy a teszt milyen időszakot ölel át. Minél nagyobbat, annál jobb. Ha tudunk egyben tesztelni mondjuk egy évet, akkor az a legjobb, hiszen egy év alatt igen sokféle gazdasági esemény fordul elő, amelyekre reagálnia kell a robotunknak!

Fontos és meghatározó információ az is, hogy összesen hány kötés szerepelt a tesztben, hiszen nem mindegy, hogy 3 kötésből lett a robot 60%-os találati arányú, vagy 300 kötésből. Minél nagyobb az össz kötések száma, annál jobb és megbízhatóbb a teszt.

Ezt egyébként a jelentés bal oldalán az Összes kereskedés mellett látjuk majd!

Érdekes adat még az egymást követő sikeres ügyletek (a profit pénzben) és az egymást követő veszteséges ügyletek (a veszteség pénzben) adatok is. Ezek tulajdonképpen a sorozatban nyert és vesztett ügyletek számát mutatja, ahol igen fontos lehet adott stratégia esetében, hogy milyen arányban van e két szám. Természetesen minél nagyobb a sorozatban megnyert kötések száma a sorozatban elvesztett kötésekhez képest, annál jobb.

A fenti adatok sokat mondhatnak egy Expert Advisor teljesítményéről, ha nem csak a számla egyenleg értékét nézzük. Ugyanis ezek abban segítenek, hogy mit tegyünk még a robotunkhoz annak érdekében, hogy nyerhessünk vele. Esetleg mit változtassunk a stratégiánkon.

A stratégia megváltoztatásához annyit fűznék hozzá, hogy ez nem feltétlenül okos ötlet. Ugyanis, ha a legnagyobb veszteségeket kielemzi az ember a chart-on, akkor azt fogjuk a stratégiában kiküszöbölni és ezzel még több bonyodalmat okozunk robotunknak, az egyébként nyereséges szituációkra.

Tehát a stratégiához csak a legvégső esetben nyúljuk.

Sokkal okosabb ötlet a Money Management-hez nyúlni. Létezik olyan stratégia, amely 30%-os találati aránnyal rendelkezik, ennek ellenére nyereséges, nem is kicsit. Ezt természetesen a Money Management-nek köszönheti. Igen, egy alapvetően veszteséges stratégiát is nyereségessé lehet tenni egy jó Money Management-tel, a kérdés mindössze annyi, hogy érdemes-e azért a nyereségért bonyolult MM-et hozzá fejleszteni.

Fogok írni a MM különféle elgondolásairól,mert nagyon érdekes, ha az ember végig gondolja, mihez mit érdemes párosítani. Nem mindegy, hogy trend irányába kereskedünk, vagy trend ellen, és az sem mindegy, hogy mekkora a találati aránya a robotnak! Egy jó forex robot jó MM-el kell rendelkezzen!

Egy különleges - támasz ellenállás - indikátor forex robotokhoz

2013-04-16T18:02:00.000+02:00

Ahogyan kifejlődött

Amikor tőzsdézni tanultam, sokat kellett küzdenem azzal, hogy mi számít völgynek és mi számít csúcsnak. Éppen ezért sokat gondolkodtam később egy olyan indikátoron, ami megjelöli nekem a csúcsokat és a völgyeket! Mindjárt rávilágítok arra is, hogy miért!

Sokat kísérleteztem, keresgéltem a neten, de sehogyan sem találtam olyan indikátort, amivel elégedett lettem volna, mert sokszor oda is rajzol egy indikátor völgyet és csúcsot, ahová én nem tenném. Viszont, ahová völgy és csúcs megjelölést tennék, oda meg nem tesz jelet!

Na de miért is probléma ez?
Rengeteg stratégiát néztem át az elmúlt évek során, különösen azért, hogy FOREX robotot készítsek belőle. A legtöbb stratégia indikátor betegségben szenved, mert több, mint 6 indikátort használnak, amelyek különféle kombinációi esetén nyitnak pozíciót, amit aztán még többféle kombináció esetében zár le.
A legtöbb stratégia az emberi megérzésre, intuícióra, vagy valami olyasmire hajaz, amiből aztán lehetetlen egy jól működő expert advisor-t összehozni!

Ezzel szemben, a leges-legegyszerűbb stratégiák, amelyekkel kézzel kereskedni is lehet, a támasz-ellenállás átlépésekre alapszik, és ezeket viszont nem nehéz leprogramozni, ha az ember kellő gyakorlatra tesz szert!
És itt jön a csúcs-völgy megállapítás problémája.

Az alapötlet rém egyszerű, ebből sikerült azután építkezni.
Hogyan állapítsunk meg völgyet és csúcsot, ez itt a kérdés. Amikor tanultam a tőzsdézés fortélyait, volt egy érdekes megállapítási "algoritmus", ami segített megtanulni a völgy és csúcs meghatározását. Ha ez nem megy, akkor felejtsük is el, hogy kézzel kereskedni fogunk valaha is!
Erre a "feladatra" az volt a "mankó", hogy feltettem a chart-ra egy 2-es és egy 6-os mozgóátlagot (Moving Average). Ezekkel kezdtem operálni. Ha a gyorsabb MA alulról felfelé keresztezi a lassabbat, akkor ott a közelben kell lennie egy völgynek, míg ha felülről lefelé keresztezi, akkor ott meg egy csúcsnak kell lennie valamerre a keresztezés előtt!

Amint ezt felfedeztem, már sokkal könnyebb volt a völgyeket és csúcsokat szubjektíven meghatározni. Igen ám, de ez kézi módszer, segít a kézi kereskedésben, de nem segít automatizáltan.
Egy olyan indikátorban kezdtem gondolkodni, amely megjelöli a csúcsokat és völgyeket, de jól is használható.

Végül sikerült összerakni! Nem sima vagy exponenciális mozgóátlagot használtam, hanem súlyozottat, és mellé tettem egy logikát, az indikátor kereszteződése után visszamenőleg a Highest() és a Lowest() függvénnyel megkeresi a legalacsonyabb pontot és a legmagasabb pontot (highest high és lowest low logika). Ott lesznek a csúcsok és völgyek!

De hogy még jobban hangolható legyen a dolog, a Highest() és a Lowest() függvények vizsgálódási paraméterét - tehát, hogy hány gyertyára visszamenőleg keressék meg a csúcsot és völgyet - változtathatóra állítottam be, sőt, a mozgóátlagok paraméterét is!

Addig, amíg az indikátor nyilakkal bejelölte a csúcsot és völgyet, kézi kereskedéshez kiváló, de forex robot számára nem túl használható megoldás született. Sok a baj ezekkel a nyilakkal.
Robot számára valami egyszerűbb kell. Kitaláltam hát, hogy a Donchian channel mintájára elkészítem az indikátor "csatornásított" változatát, amelyben ugyanúgy három paraméterrel lehet meghatározni a tulajdonságát (MA-k és a Highest és Lowest függvények paraméterét).

Ez nagyon bejött! A csatornából kitörő gyertya azonnal jelzi a trend megindulását, a csatorna érintése viszont tökéletes megoldás oldalazás végig kereskedésére! A robotok is szeretik, mert egy határozott vonal átlépést sokkal könnyebb ellenőrizni programból, mint nyilakat keresgélni visszamenőleg X gyertyára!

Az indikátor neve : TopBottomChannel.
Paraméterei :

sens : alapérték 20, azt a gyertyaszámot adja meg, amelyen belül meg kell keresni a legmagasabb, vagy a legalacsonyabb pontját a gyertyatrendnek.
slowMA : alapérték 6, lassú mozgóátlag periódus ideje.
fastMA : alapérték 2, gyors mozgóátlag periódus ideje.

Lehet játszani a beállításokkal, de az alapértékek általában jók. M1-től fölfelé kereskedésre is lehet hazsnálni, mindjárt leírom hogyan.

Az indikátor :

 //+------------------------------------------------------------------+  
 //|                       TopBottomChannel.mq4 |  
 //|                  Copyright © 2009, Janos Antal |  
 //|                                 |  
 //+------------------------------------------------------------------+  
 #property copyright "Copyright © 2013, Janos Antal"  
 #property link   "http://tozsdecapak.blogspot.hu"  
   
 #property indicator_chart_window  
 #property indicator_buffers 2  
 #property indicator_color1 DodgerBlue  
 #property indicator_color2 Red  
   
 #include <stderror.mqh>  
 #include <stdlib.mqh>  
   
 #include <WinUser32.mqh>  
   
 #import "user32.dll"  
   int RegisterWindowMessageA(string lpstring);  
 #import  
   
 #define CHART_CMD_UPDATE_DATA  33324  
   
 extern int sens = 20;  
 extern int slowMA = 6;  
 extern int fastMA = 2;  
   
 double top[], bottom[];  
 int bar;  
 int hwnd = 0;  
 //+------------------------------------------------------------------+  
 //| Custom indicator initialization function             |  
 //+------------------------------------------------------------------+  
   
 int UpdateChartWindow()  
 {    
   if(hwnd == 0) {  
    //Megkeressük a chart window-t az update-eléshez  
    hwnd = WindowHandle(Symbol(), Period());  
   }  
   if(hwnd!= 0) {  
    if (IsDllsAllowed() == false) {  
      //DLL calls engedélyezve kell legyen  
      Print("Dll calls must be allowed");  
      return (-1);  
    }  
    if (PostMessageA(hwnd,WM_COMMAND,CHART_CMD_UPDATE_DATA,0) == 0) {  
      //Nem sikerült, bezárult az ablak  
      hwnd = 0;  
    } else {  
      //Sikerült  
      int MT4InternalMsg = RegisterWindowMessageA("MetaTrader4_Internal_Message");  
      PostMessageA(hwnd,MT4InternalMsg,2,1);       
      return (0);  
    }  
   }  
   return (-1);  
 }  
   
 int init()  
  {  
   SetIndexStyle(0,DRAW_LINE,0,2);  
   SetIndexBuffer(0,top);  
   SetIndexLabel(0,"Top");  
   SetIndexArrow(0,241);  
   
   SetIndexStyle(1,DRAW_LINE,0,2);  
   SetIndexBuffer(1,bottom);  
   SetIndexLabel(1,"Bottom");  
   SetIndexArrow(1,242);  
   return(0);  
   bar=0;  
  }  
 //+------------------------------------------------------------------+  
 //| Custom indicator deinitialization function            |  
 //+------------------------------------------------------------------+  
 int deinit()  
  {  
 //----  
     
 //----  
   return(0);  
  }  
 //+------------------------------------------------------------------+  
 //| Custom indicator iteration function               |  
 //+------------------------------------------------------------------+  
 int start()  
 {  
   int  counted_bars=IndicatorCounted();  
   int bi;  
   int ti;  
   int index,i,j;  
   double FMWA1, FMWA2, SMWA1, SMWA2, t,b;  
       
   if(counted_bars<0) return(-1);   
   if(counted_bars>0) counted_bars--;   
     
   int limit = Bars-counted_bars;  
     
   if (bar == Bars)  
   {  
    return;  
   }else  
   {  
    bar=Bars;  
   }  
     
   if (limit < 1500)  
    limit=1500;  
   
   for(i=limit;i>0;i--)  
   {  
    FMWA1=iMA(NULL,0,slowMA,0,MODE_LWMA,PRICE_CLOSE,i);  
    FMWA2=iMA(NULL,0,slowMA,0,MODE_LWMA,PRICE_CLOSE,i-1);  
    SMWA1=iMA(NULL,0,fastMA,0,MODE_LWMA,PRICE_CLOSE,i);  
    SMWA2=iMA(NULL,0,fastMA,0,MODE_LWMA,PRICE_CLOSE,i-1);  
      
    top[i]=GlobalVariableGet("Top"+Symbol()+Period());  
    bottom[i]=GlobalVariableGet("Bottom"+Symbol()+Period());      
              
    if (SMWA1 > FMWA1 && SMWA2 < FMWA2)            
    {  
      bi=iLowest(Symbol(),Period(),MODE_LOW,sens,i);  
      b=Low[bi];  
      for(j=0;j<=bi;j++)  
      {  
       bottom[j]=b;  
      }  
      GlobalVariableSet("Bottom"+Symbol()+Period(),b);  
    }  
      
    if (SMWA1 < FMWA1 && SMWA2 > FMWA2)            
    {  
      ti=iHighest(Symbol(),Period(),MODE_HIGH,sens,i);  
      t=High[ti];  
      for(j=0;j<=ti;j++)  
      {  
       top[j]=t;  
      }  
      GlobalVariableSet("Top"+Symbol()+Period(),t);      
    }   
   }  
     
   UpdateChartWindow();  
 }

Kereskedés

Az időtáv gyakorlatilag bármi lehet, M1-től D1-ig, bár azt meg kell mondjam, hogy magasabb időtávon biztosabb a jel, de aki tőzsdézik, jól tudja ezt.

Trendben

Pozíció nyitás : amikor az alsó vonal alatt zár egy gyertya, short pozíció nyitása, illetve ha a felső vonal fölött zár a gyertya, akkor long. Stop-loss lehet az átlépés helye, vagy a korábbi völgy, azaz a csatorna alja.

Pozíció zárás: több megoldás működhet, nekem ami eddig legjobban bejött, az az, ha mondjuk a felső vonal fölött zár a gyertya, megnyitom a long-ot, majd az árfolyam elkezd felfelé mozogni. Amikor visszateszt, vagy counter trend kezdődik, létrejön egy újabb mozgóátlag keresztezés, és a TopBottomChannel felső vonala felugrik. Na ekkor zárom a a long-ot. Short-nál ugyanígy, csak ellentétes irányban természetesen.

Másik megoldás egy követő stop, ami lehet ATR alapú (ha a bróker enged közeli stopokat), vagy lehet fix. Lehet nullába húzós (break even stop) is, majd ezután indul a követő stop húzás.

Oldalazásban

Pozíció nyitás : amikor a csatorna vonala "ugrik", akkor detektálja a mozgóátlagok kereszteződését. Ekkor általában "megérinti" a csatorna tetjét, vagy az alját egy gyertya, de nem lépi át (oldalaz). Ekkor érdemes trend irányú pozíciót nyitni! Tehát ha a felső vonal "ugrott", akkor short, mert már lefelé megy az árfolyam, ha a pedig az alsó vonalat érinti, akkor long. Stop-loss lehet a csatorna vonal maga, célárnak pedig meg lehet jelölni a másik csatorna vonalát.

Pozíció zárás : amikor eléri az ár az alsó csatornát, akkor céláron, vagy kézzel ott. Esetleg követő stop, de ez rosszabb hatásfokkal működik.

Sok sikert a kereskedéshez!

A TrendMagic indikátor

2012-04-05T11:13:00.001+02:00

Miután legutóbb feltettem a TVI indikátort, akkor vettem észre, hogy tulajdonképpen már csak a TrendMagic indikátor hiányzik hozzá. Nem szeretném, ha lemaradna, ezért most ezt is közzé teszem.

Korábban már volt róla szó, hogy ez egy CCI és ATR alapú indikátor, elég jól használható, amikor a trend irányára vagyunk kíváncsiak. Ez is színváltoztatós indikátor, de nem függ semmilyen másik indikátortól...

Nos, íme a kódja :

//+------------------------------------------------------------------+
//|                                                   TrendMagic.mq4 |
//|                                    Copyright © 2010, János Antal |
//|                                  http://tozsdecapak.blogspot.com |
//+------------------------------------------------------------------+
#property copyright "Copyright © 2010, János Antal"
#property link      "http://tozsdecapak.blogspot.com"
#include <stderror.mqh>
#include <stdlib.mqh>

#property indicator_chart_window
#property indicator_buffers 2
#property indicator_color1 Lime
#property indicator_width1 2
#property indicator_color2 Red
#property indicator_width2 2

extern int CCI = 50;
extern int ATR = 5;

double bufferUp[];
double bufferDn[];

int init()
{
   SetIndexStyle(0, DRAW_LINE, STYLE_SOLID, 2);
   SetIndexBuffer(0, bufferUp);
   SetIndexLabel(0,"TrendMagic Up");

   SetIndexStyle(1, DRAW_LINE, STYLE_SOLID, 2);
   SetIndexBuffer(1, bufferDn);
   SetIndexLabel(1,"TrendMagic Down");
}

int start()
{
   double thisCCI;
   double lastCCI;

   for (int shift = Bars; shift >= 0; shift--)
   {
      thisCCI = iCCI(NULL, 0, CCI, PRICE_TYPICAL, shift);
      lastCCI = iCCI(NULL, 0, CCI, PRICE_TYPICAL, shift + 1);

      if (thisCCI >= 0 && lastCCI < 0) bufferUp[shift + 1] = bufferDn[shift + 1];
      if (thisCCI <= 0 && lastCCI > 0) bufferDn[shift + 1] = bufferUp[shift + 1];

      if (thisCCI >= 0)
      {
         bufferUp[shift] = Low[shift] - iATR(NULL, 0, ATR, shift);
         if (bufferUp[shift] < bufferUp[shift + 1])
            bufferUp[shift] = bufferUp[shift + 1];
      }
      else
      {
         if (thisCCI <= 0)
         {
            bufferDn[shift] = High[shift] + iATR(NULL, 0, ATR, shift);
            if (bufferDn[shift] > bufferDn[shift + 1])
               bufferDn[shift] = bufferDn[shift + 1];
         }
      }
   }
}

Ez egy igen egyszerű, ám igen jól használható indikátor, amely leginkább napon belüli kereskedés fő trendirányának a meghatározására való. Ez igen jó támpont lehet, ha egy másik momentum indikátor jelei alapján szeretnénk pozícióba lépni! Ez az indikátor a mi kis robotunk alapja.

Hamarosan backtest következik.
A backtest fogja megmondani nekünk, hogy a kereskedési elv, amelyet leprogramoztunk.

Addig is azt javaslom, hogy a három indikátort, melyet nem is régen közzétettem (most a TrendMagic, korábban a TVI és a TVI_2color, melyek közül ugyan csak az utóbbit használjuk, mégis az előbbivel együtt képes csak működni), valamint a teljes robotot másoljátok le, fordítsátok le a MetaEditor segítségével és próbálgassátok különféle devizapárokon.

Aki már végzett backtest-et, annak is javaslom, hogy mindenféle devizapáron tesztelje le, nézegesse, aki még sosem tesztelt, annak csak azt javaslom, hogy tegye fel a robotot egy demó számlára tetszőleges devizapárra és nézze meg, mikor köt, jókor köt-e, stb.
FIGYELEM! Jelenleg a profit lényegtelen, csak az a fontos, hogy jól működik-e a program!

Ha bárkinek bármilyen kérdése lenne, írjon bátran, válaszolok szívesen!

Jó szórakozást mindenkinek!

A TVI indikátor

2012-02-16T16:59:00.000+01:00

Ismételten eltelt sok-sok idő, már nem is szabadkozom. A lényeg az, hogy ugyan a robotot a kezeitek közé adtam, de éppen az az indikátor, amely ehhez nélkülözhetetlen, az hiányzik.
Éppen ezért most közre adom azt, illetve azokat, amelyekkel én is dolgozom!

Azért a többes szám, mert itt két indikátorról van szó. Az egyik maga a TVI indikátor, a másik pedig egy színes változata, amely azonban az "ős" TVI-t használja!
Tehát a robotunkban lévő indikátor nem működik az eredeti TVI indikátor nélkül.

Lássuk hát! Az első tehát a TVI önmaga.

//+------------------------------------------------------------------+
//|                                           Ticks Volume Indicator |
//|                                        Copyright Â© William Blau |
//|                                    Coded/Verified by Profitrader |
//+------------------------------------------------------------------+
#property copyright "Copyright Â© 2006, Profitrader."
#property link      "profitrader@inbox.ru"
//-----
#property indicator_separate_window
#property indicator_buffers 1
#property indicator_color1 Blue
//---- input parameters
extern int r=12;
extern int s=12;
extern int u=5;
//---- buffers
double TVI[];
double UpTicks[];
double DownTicks[];
double EMA_UpTicks[];
double EMA_DownTicks[];
double DEMA_UpTicks[];
double DEMA_DownTicks[];
double TVI_calculate[];

double MyPoint;
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int init()
{
   IndicatorShortName("TVI("+r+","+s+","+u+")");
   IndicatorBuffers(8);
   SetIndexBuffer(0,TVI);
   SetIndexBuffer(1,UpTicks);
   SetIndexBuffer(2,DownTicks);
   SetIndexBuffer(3,EMA_UpTicks);
   SetIndexBuffer(4,EMA_DownTicks);
   SetIndexBuffer(5,DEMA_UpTicks);
   SetIndexBuffer(6,DEMA_DownTicks);
   SetIndexBuffer(7,TVI_calculate);
   SetIndexStyle(0,DRAW_LINE);
   SetIndexLabel(0,"TVI");

    if (Digits == 5 || (Digits == 3 && StringFind(Symbol(), "JPY") != -1))
    {
      MyPoint = Point*10;
    }
    else
    if (Digits == 6 || (Digits == 4 && StringFind(Symbol(), "JPY") != -1))
    {
      MyPoint = Point*100;
    }
    else
    {MyPoint = Point;}

   return(0);
}
//+------------------------------------------------------------------+
//| Custom indicator deinitialization function                       |
//+------------------------------------------------------------------+
int deinit()
{
   return(0);
}
//+------------------------------------------------------------------+
//| Ticks Volume Indicator                                           |
//+------------------------------------------------------------------+
int start()
{
   int i,counted_bars=IndicatorCounted();
//---- check for possible errors
   if(counted_bars<0) return(-1);
//---- last counted bar will be recounted
   if(counted_bars>0) counted_bars--;
   int limit=Bars-counted_bars;
//----
   for(i=0; i<limit; i++)     {
      UpTicks[i]=(Volume[i]+(Close[i]-Open[i])/MyPoint)/2;
      DownTicks[i]=Volume[i]-UpTicks[i];
     }
   for(i=limit-1; i>=0; i--)
     {
      EMA_UpTicks[i]=iMAOnArray(UpTicks,0,r,0,MODE_EMA,i);
      EMA_DownTicks[i]=iMAOnArray(DownTicks,0,r,0,MODE_EMA,i);
     }
   for(i=limit-1; i>=0; i--)
     {
      DEMA_UpTicks[i]=iMAOnArray(EMA_UpTicks,0,s,0,MODE_EMA,i);
      DEMA_DownTicks[i]=iMAOnArray(EMA_DownTicks,0,s,0,MODE_EMA,i);
     }
   for(i=0; i<limit; i++)      TVI_calculate[i]=100.0*(DEMA_UpTicks[i]-DEMA_DownTicks[i])/(DEMA_UpTicks[i]+DEMA_DownTicks[i]);
   for(i=limit-1; i>=0; i--)
      TVI[i]=iMAOnArray(TVI_calculate,0,u,0,MODE_EMA,i);
//----
   return(0);
}
//+------------------------------------------------------------------+

Ezt egyszerűen bemásolod a MetaEditor egyik új indikátor fájljába és lefordítod.
Ez egyébként a TVI indikátor megvalósítása, amelyet egy korábbi bejegyzésben taglaltam.
A színes változat ezt hívja meg, és kétféle színnel jelöli az emelkedő és a csökkenő trendet.

Íme :

//+------------------------------------------------------------------+
//|   TVI_2color.mq4
//+------------------------------------------------------------------+
#property indicator_separate_window
#include <stdlib.mqh>
#property indicator_buffers 2
#property indicator_color1 Green
#property indicator_color2 Red
#property indicator_level1 0.00
#property indicator_levelcolor Black

extern int r=12;
extern int s=12;
extern int u=5;
extern int tf=15;

double ev=EMPTY_VALUE;

double Up[];
double Dn[];

double TVI[];
double Trend[];

int init()
{
   IndicatorBuffers(2);

   SetIndexStyle(0,DRAW_LINE,0,2);
   SetIndexBuffer(0,Up);
   SetIndexLabel(0,"Up");

   SetIndexStyle(1,DRAW_LINE,0,2);
   SetIndexBuffer(1,Dn);
   SetIndexLabel(1,"Dn");

   ArraySetAsSeries(TVI,true);
   ArraySetAsSeries(Trend,true);

   return(0);
}

int deinit()
{
   return(0);
}

int start()
{
   int counted_bars=IndicatorCounted();
   if(counted_bars<0) return(-1); //---- check for possible errors
   if(counted_bars>0) counted_bars--; //---- last counted bar will be recounted
   int limit = Bars-counted_bars;

   for (int i=limit;i>=0;i--)
   {
      ArrayResize(TVI,Bars);
      ArrayResize(Trend,Bars);

      Trend[i] = Trend[i+1];

      TVI[i] = iCustom(NULL,tf,"TVI",r,s,u,0,i);

      if (TVI[i] > TVI[i+1])
      {Trend[i] = 1;}
      else
      if (TVI[i] < TVI[i+1])
      {Trend[i] = -1;}

      if (Trend[i] > 0)
      {
         Up[i] = TVI[i];

         if (Trend[i+1] < 0)
         {
            Up[i+1] = TVI[i+1];
         }
         Dn[i] = ev;
      }
      else
      if (Trend[i] < 0)
      {
         Dn[i] = TVI[i];

         if (Trend[i+1] > 0)
         {
            Dn[i+1] = TVI[i+1];
         }
         Up[i] = ev;
      }
   }
}
//+------------------------------------------------------------------+

Tulajdonképpen ennyi! A robot ez utóbbi indikátor színváltozásait figyeli és köt.

Hamarosan folyt.köv., ugyanis az elmúlt jó néhány hónapban sok érdekes dolgot tanultam!
Amit tanultam mindannyiótok hasznára fog válni!
Addig is jó kísérletezést a robival...

A robotunk egyben, az utolsó csavarig

2011-05-20T21:33:00.002+02:00

Ismét jó sok idő telt el, volt, aki kommentben sürgetett meg.
Nos, tehát a teljes kódot közzé teszem, hiszen ez az értelme a blognak.

Azonban szeretnék leszögezni ismételten valamit, méghozzá nyomatékosan!

Ez az Expert Advisor nem alkalmas éles kereskedésre, kizárólag oktatási céllal készült. Aki éles számlán üzemelteti, a veszteségeiért eme blog írója semmilyen felelőséget sem válallal! A kód egésze, illetve egyes elemei szabadon felhasználhatóak, kivéve a kereskedelmi célú felhasználást! Kereskedelmi célra felhasználni a szerző beleegyezése nélkül tilos!

Remélem mindenki számára érthető, ugyanis nem szeretnék senkivel sem vitatkozni, különösen nem jogi kereteken belül! Tehát ez itt egy oktató program! Semmi más! A célja az egyes programozási fogások, ötletek bemutatása.

A FOREX robotunk megírása koránt sem fejeződött be, most jön ugyanis a tesztelése, egész konkrétan a backtest, ami egy jó támpont arra, hogy mennyire jó az ötlet maga. Illetve fogjuk látni a hibákat is, no meg azt is, hogy mikor köt rosszul. Sokat számít, hogy jól ki tudjuk értékelni a backtest-et.

Ha megtörtént a backtest, akkor jöhet egy tisztességes Money Management is hozzá, végül pedig egy demo számlán fogjuk tesztelni, és a teszt eredményét fogjuk kiértékelni. Hozzátenném, hogy egy egyébként elvben jól működő, de mégis veszteséget termelő programből nyereségeset lehet varázsolni egy kitűnő Money Management-tel...Ehhez persze az kell, hogy az elv működjön, vagyis lehetőleg több nyerő kötése legyen, mint vesztő és lehetőleg ez ne a véletlenen múljon, vagyis jókor kell pozíciót nyitnia. A jó pozíció nyitás azt jelenti, hogy a várható nyereség nagyobb, mint a veszteség (haladóknak : RR nagyobb, mint 1!).

Tehát minden egyéb magyarázat nélkül, következzék a robot kódja. Annyit tennék még hozzá, hogy aki esetleg nem érti minden egyes részét, bátran olvasson vissza a korábbi bejegyzéskbe, ugyanis az utolsó sorig megmagyaráztam a robot kódját.
A kód tehát :

//+------------------------------------------------------------------+
//| TrendMagic-TVI.mq4 |
//| Copyright © 2011, János Antal |
//| http://tozsdecapak.blogspot.com |
//+------------------------------------------------------------------+
#property copyright "Copyright © 2011, János Antal"
#property link "http://tozsdecapak.blogspot.com"
#property show_inputs
#include <stderror.mqh>
#include <stdlib.mqh>

extern double maxlots=0.01;
extern int slippage=5;
extern int TrendMagicCCI=50;
extern int TrendMagicATR=5;
extern int TVI_rs=50;
extern int TVI_TF=0;

int currentbar;
string TMTrend, TVITrend;
int orders;
bool nyitott;

int init()
{
}
int deinit()
{
}
int start()
{
int err, ticket;
double stoploss, ParUp, ParDn;

// Csak akkor fusson le, ha a gyertya már befejeződött

if (currentbar < Bars)
currentbar = Bars;
else
return;

nyitott = false;
orders = OrdersTotal();

for(int pos=0;pos<orders;pos++)
{
if(OrderSelect(pos,SELECT_BY_POS)==false)
continue;
else
if (OrderSymbol() == Symbol())
nyitott=true;
}

// TrendMagic alapján nyitunk pozíciót

if (iCustom(NULL,0,"TrendMagic",TrendMagicCCI,TrendMagicATR,0,1) != EMPTY_VALUE && iCustom(NULL,0,"TrendMagic",TrendMagicCCI,TrendMagicATR,1,1) == EMPTY_VALUE) // Long
{
TMTrend="Long";
}

if (iCustom(NULL,0,"TrendMagic",TrendMagicCCI,TrendMagicATR,0,1) == EMPTY_VALUE && iCustom(NULL,0,"TrendMagic",TrendMagicCCI,TrendMagicATR,1,1) != EMPTY_VALUE) // Short
{
TMTrend="Short";
}

if (iCustom(NULL,0,"TVI_2color",TVI_rs,TVI_rs,5,TVI_TF,0,1) != EMPTY_VALUE && iCustom(NULL,0,"TVI_2color",TVI_rs,TVI_rs,5,TVI_TF,1,1) == EMPTY_VALUE)
{
TVITrend="Long";
}

if (iCustom(NULL,0,"TVI_2color",TVI_rs,TVI_rs,5,TVI_TF,0,1) == EMPTY_VALUE && iCustom(NULL,0,"TVI_2color",TVI_rs,TVI_rs,5,TVI_TF,1,1) != EMPTY_VALUE)
{
TVITrend="Short";
}

//Pozíció nyitások

if (TMTrend == "Long" && TVITrend == "Long" && !nyitott)
{
ticket=OrderSend(Symbol(),OP_BUY,maxlots,Ask,slippage,0,0,"TrendMagic-TVI - Long",MathRand(),0,Green);
err = GetLastError();
if (err != 0 && ticket < 0)
{
Print("Error # ", err, " ", ErrorDescription(err));
}
}

if (TMTrend == "Short" && TVITrend == "Short" && !nyitott)
{
ticket=OrderSend(Symbol(),OP_SELL,maxlots,Bid,slippage,0,0,"TrendMagic-TVI - Short",MathRand(),0,Green);
err = GetLastError();
if (err != 0 && ticket < 0)
{
Print("Error # ", err, " ", ErrorDescription(err));
}
}

//Stop-loss húzás
orders=OrdersTotal();

if (orders != 0)
{
for(pos=0;pos<orders;pos++)
{
if(OrderSelect(pos, SELECT_BY_POS,MODE_TRADES))
{
ParUp=iCustom(NULL,0,"Parabolic trendchaser", false, 0.06,0.1,7,0,0,1);
ParDn=iCustom(NULL,0,"Parabolic trendchaser", false, 0.06,0.1,7,0,1,1);

if (OrderType() == OP_BUY && OrderSymbol() == Symbol() && ParDn != 0)
{
stoploss = ParDn;

if (OrderModify(OrderTicket(),OrderOpenPrice(), stoploss, OrderTakeProfit(),0,Blue))
Print("Stop-loss módosítva!");
else
{
Print("Stop-loss nem módosult! ", DoubleToStr(stoploss,5));
Print("Hibaüzenet : ",ErrorDescription(GetLastError()));
}
}else if (OrderType() == OP_SELL && OrderSymbol() == Symbol() && ParUp != 0)
{
stoploss = ParUp;

if (OrderModify(OrderTicket(),OrderOpenPrice(), stoploss, OrderTakeProfit(),0,Blue))
Print("Stop-loss módosítva!");
else
{
Print("Stop-loss nem módosult! ", DoubleToStr(stoploss,5));
Print("Hibaüzenet : ",ErrorDescription(GetLastError()));
}
}
}else
Print("Nem sikerült húzni a Stop-Loss-t, nem találom a pozíciót!");
}
}
}

A kódot a MetaEditor szerkesztő mezőjébe kell bemásolni, de előtte egy "üres" Expert Advisor-t kell készíteni. Ez a következőképpen megy, ha már a MetaEditor-ban vagyunk :

File menü
New menüpont
A megjelenő ablakban az Expert Advisor-t kell bejelölni
A tovább gomb után pedig olyan nevet adunk neki, amilyet akarunk, de célszerű a forráskód fejlécében lévő nevet adni neki (TrendMagic-TVI).
Célszerű az ablak tartalmátteljesen kitörölni és bemásolni a fenti kódot.

Ha ezzel meg vagyunk,akkor már csak annyi a dolgunk, hogy lefordítjuk a kódot, amit vagy az F5 billentyűvel tehetünk meg, vagy pedig a menü alatti ikon sorban található Compile gombbal.
A fordítás után a chart-ra visszatérve a navigátor ablakban az Expert Advisor mappában találjuk azon a néven, amilyen nevet adtunk neki létrehozáskor.

Aki kedvet érez hozzá, nyugodtan kísérletezzen vele, de szigorúan csak demo számlán!!!
Ez a program még nem elég érett az éles számlán történő használatra, de folyamatosan érlelni fogjuk. Most még elég nyers ez a kód.

Aki esetleg fordítási hibával találkozik (előfordulhat, hogy a HTML-be illesztés során homokszem kerül a gépezetbe), nyugodtan írja meg nekem, bár leteszteltem, és le kellene fordulnia simán.
Egyébként elég beszéldessek a hibaüzenetek.

Kellemes babrálást!

Készre csiszolás

2011-03-23T21:15:00.001+01:00

Megint kicsit elmaradtam, de majd most megpróbálom bepótolni a várva várt készre csiszolással...

Tehát FOREX robotunk már készen van nagyjából, bár igazából még csak a pozíció nyitásokat beszéltük meg. Arról volt szó, hogy pozíció zárás nem is lesz benne, hiszen stop-loss-t fogunk beállítani, ez fogja zárni a pozíciónkat, méghozzá úgy, hogy az árhoz minél közelebb húzzuk.
A folyamatos ár után húzott - követő - stopunkat addig húzogatjuk, amíg a stop-loss a kötési ár fölé/alá (függően attól, hogy long, vagy short pozíciónk van) kerül, lehetőleg minél jobban.
Ekkor, ha az ár visszaesik, akkor a stop-loss ugyan bezárja a pozíciót, de ekkor már nyereséges lesz.
Na, jó, de hogyan lehet ezt csinálni?

A dolog rém egyszerű, a Parabolic trendchaser egyéni indikátort fogjuk ügyesen felparaméterezni, és az ő jelzéseire állítjuk be a stop-loss-t. Sajnos ez nem lesz mindig lehetséges, de erről majd picit később.

Mindenek előtt, a programunk elején, közvetlenül a start() függvény elejére illesszünk be egy új sort, ahol három új változót fogunk felvenni.
Tehát a start() függvényünknek így kell kezdődnie :

int start()
{
int err, ticket;
double stoploss, ParUp, ParDn;

A három double változó feladat lesz a stop-loss kiszámítása és húzása. Az első két int változó feladata a pozíció nyitások lebonyolítása, a ticket számát tartalmazza és az esetleges hibakódot.

No, de nézzük csak hogyan kell a stopot húzni.A teljes kód a következőképpen néz ki, a jelentését mindjárt meg is beszéljük :

orders=OrdersTotal();

if (orders != 0)
      {
         for(pos=0;pos
         {
            if(OrderSelect(pos, SELECT_BY_POS,MODE_TRADES))
            {
               ParUp=iCustom(NULL,0,"Parabolic trendchaser", false, 0.06,0.1,7,0,0,1);
               ParDn=iCustom(NULL,0,"Parabolic trendchaser", false, 0.06,0.1,7,0,1,1);

               if (OrderType() == OP_BUY && OrderSymbol() == Symbol() && ParDn != 0)
               {
                  stoploss = ParDn;

                  if (OrderModify(OrderTicket(),OrderOpenPrice(), stoploss, OrderTakeProfit(),0,Blue))
                     Print("Stop-loss módosítva!");
                  else
                  {
                     Print("Stop-loss nem módosult! ", DoubleToStr(stoploss,5));
                     Print("Hibaüzenet : ",ErrorDescription(GetLastError()));
                  }
               }else if (OrderType() == OP_SELL && OrderSymbol() == Symbol() && ParUp != 0)
               {
                  stoploss = ParUp;

                  if (OrderModify(OrderTicket(),OrderOpenPrice(), stoploss, OrderTakeProfit(),0,Blue))
                     Print("Stop-loss módosítva!");
                  else
                  {
                     Print("Stop-loss nem módosult! ", DoubleToStr(stoploss,5));
                     Print("Hibaüzenet : ",ErrorDescription(GetLastError()));
                  }
               }
            }else
               Print("Nem sikerült húzni a Stop-Loss-t, nem találom a pozíciót!");
         }
      }

Az OrdersTotal() függvény elárulja nekünk, hogy mennyi nyitott pozíció van ezen a számlán, minden devizapáron.
A legelső if utasítás arról gondoskodik, hogy csakis kizárólag akkor foglalkozzunk a stop húzással, ha van nyitott pozíciónk.
Ezután egyesével végig szaladunk egy for ciklus segítségével a pozíciókon. A ParUp és a ParDn értékek kiszámításával kezdjük, hiszen nemsokára szükségünk lesz rá. Ezek adják majd a stop szinteket.

A következő if utasítással azt vizsgáljuk, hogy :

Long pozíció-e az éppen vizsgált soron következő pozíció
Az aktuális chart-nak megfelelő devizapáron köttetett-e (képzeljük csak el, ha egy EURUSD-n futó programunk lezárná az EURHUF long pozíciónkat... Kellemetlen lenne...)
És azt is vizsgáljuk, hogy van-e kiszámított érték egyáltalán, mert ha nincs, akkor minek túráztatjuk magunkat

Ha a feltételek teljesülnek, akkor az OrderModify() függvénnyel beállítjuk a stopot. A top értéke a Parabolic trendchaser indikátor alsó pöttyének az értéke lesz, ezért a stoploss változónkba is ezt írjuk be és ezt is állítjuk be stopnak.
Figyeljük meg, hogy az aktuális adatokat kikérjük a pozícióról és azokat vissza is írjuk az OrderModify() függvénybe, tehát csak a stopot módosítjuk. (tehát az OrderTicket() függvény megmondja az aktuálisan kiválasztott pozíciónk ticket számát, az OrderOpenPrice() elárulja milyen áron nyitottuk a pozíciót, ha van take profit beállítva, akkor az OrderTakeProfit() ezt is elárulja. Mindezeket visszaírjuk a módosításba eredeti formájukban, tehát nem bántjuk őket, így tudjuk csak stop-loss-t módosítani)

Természetesen vizsgáljuk a visszatérési értékét a függvénynek, tehát ha igaz értékkel tér vissza, akkor közöljük a program felhasználójával, hogy sikerült, ha pedig nem sikerült, azt is közöljük, de a hiba okát is kiírjuk, erre való az ErrorDescription(GetLastError()) összefüggés.
Az igazsághoz persze az is hozzátartozik, hogy a programunk elejére be kell szúrnunk még két sort, ahhoz, hogy a hibakiírás működhessen, mégpedig ezt a két sort :

#include <stderror.mqh>
#include <stdlib.mqh>

Ezekkel biztosíthatjuk, hogy az előbb említett hibakezelő függvények működhessenek.
Érdemes a többi include utasítás alá beilleszteni, ha van. De mindenképpen a többi #-kal kezdődő sorokhoz.

A short pozíciónál ugyanez az eljárás, de ott a Parabolic trendchaser indikátor felső pöttyének az értékét fogjuk beállítani.

A FOREX robotunk még nem az igazi, összeraktuk, készre csiszoltuk, de még nem políroztuk fel, ugyanis vannak még szépség hibái.
Például az, hogyha a Parabolic trendchaser indikátor éppen nem mutat alul pöttyöt, csak felül (mert ugye ez is egy Parabolic SAR rokon és vagy fönt, vagy lent vannak pöttyei), akkor nem húz stopot a program.
Akkor sem fog stopot húzni, hogyha túlságosan közel vagyunk pillanatnyi árhoz.

Ezeket az eseményeket le kell kezelnünk, különben stop nélkül maradunk és nem, vagy túl későn lesz lezárva a pozíciónk, amiből komoly veszteségek származhatnak.
Mindenesetre ez a kis program jól szemlélteti, hogy hogyan érdemes nekifeszülni egy ilyen program megírásának és mire érdemes gondolni közben.

A következő post-ban a legutóbbi két esemény kezelésével foglalkozunk, megoldást keresünk rá, szemléltetve a MetaTrader további lehetőségeit.

Ezután a teljes programkódot közzéteszem, hogyha valakinek nincs kedve az egészet begépelni, vagy ha esetleg lemaradt, akkor egyben láthatja a kódot.
Telis-tele lesz megjegyzésekkel, hogy mi miért van, így talán azok is követni tudnak majd, akik eddig nem olvasták el az összes post-ot.

Ha pedig mindenki a kezébe kaparintotta a működő robotot, jöhet a tesztelés, melynek fázisait szintén végignézzük, illetve a fejlesztés további szakaszai jönnek, a veszteségek kiküszöbölése és egy jó kis money management kerül bele.

Építkezés - folytatás II. ...

2011-02-25T21:36:00.023+01:00

Szép jó estét mindenkinek! Gondolom már vártátok a folytatást, hát itt van.

Eddig ugye szó esett a FOREX robot és a MetaTrader kapcsolatáról, szó esett a robot felépítéséről is.
Sőt, mi több, el is kezdtük építeni a kis okos robotunkat MetaTrader-ben, a saját C# programozási nyelvén.

Eddig ott tartunk, hogy az indikátorok alapján eldöntöttük, hogy merre az arra, vagyis azt, hogy a mi kis okos FOREX robotunk long - azaz vételi -, vagy short - azaz eladási - pozíciót nyisson.
Most azt fogjuk megbeszélni, hogy na, akkor hogyan is nyissunk pozíciót!

Csapjunk is a közepébe, íme a kód és már meg is beszéljük hogyan működik :

      if (TMTrend == "Long" && TVITrend == "Long" && !nyitott)
      {
         ticket=OrderSend(Symbol(),OP_BUY,maxlots,Ask,slippage,0,0,"TrendMagic-TVI - Long",MathRand(),0,Green);
         err = GetLastError();
         if (err != 0 && ticket < 0)
         {
            Print("Error # ", err, " ", ErrorDescription(err));
         }
      }

Első ránézésre talán bonyolultnak tűnik, de nem az.
Minden ahhoz az alapvető feltételhez van kötve, hogy az indikátorok mit mutatnak.
Tehát három feltétel meglétét vizsgáljuk. Az első kettő a két indikátor együttállása, a harmadik pedig a start() függvény elején vizsgált feltétel szerint beállított nyitott nevű változónk. Ez ugye igaz értéket vesz fel, ha az aktuális devizapáron van már nyitott pozíciónk.
Tehát a feltétel vizsgálja, hogy long nyitási lehetőség van-e és azt, hogy NINCS nyitott pozíciónk. Mert ha már van, akkor nem nyitunk rá. (ez majd a rákötésnél lesz érdekes, de ott még nem tartunk)
Tehát a '!' jel az, amely a tagadás (szakmaibban szólva negálás) ebben a nyelvben, ha egy változó hamis értéket tartalmaz, akkor ez igazzá változtatja és fordítva. Tehát, ha van nyitott pozíciónk, akkor ezzel a jellel hamis értéket kapunk és nem teljesül az if utasításunk, ha pedig nincs nyitott pozíciónk, akkor igaz értéket kapunk és ha mindkét indikátor long-ot mutat, akkor már folytatjuk is a végrehajtást a következő utasítás soron.

Nem gatyázunk, ez már maga a pozíció nyitás. Sajnos ez is kétesélyes, vagy sikerül, vagy nem. Éppen ezért ha nem sikerül, akkor arról tudnunk kell.
De ne szaladjunk ennyire előre.
Az OrderSend() függvény gondoskodik arról, hogy a pozíció megnyíljon, bármilyen irányba. Nyilván az első paramétere az instrumentum neve - vagyis a devizapár neve - lesz, ahol a pozíciót nyitni szeretnénk, a második a már sokkal érdekesebb, mert itt mondjuk meg miféle pozíciót nyitunk.
Nézzük csak, miket lehet nyitni :

OP_BUY : ez egyszerűen egy long, azaz vásárlási (buy) pozíció nyitást jelent, semmi extra
OP_SELL : a long párja, vagyis a short, eladási (sell) pozíció
OP_BUYLIMIT : na, ez már érdekes, ha az ár elér egy bizonyos szintet, akkor nyit egy long-ot
OP_SELLLIMIT : ez az előző short testvére
OP_BUYSTOP : ez nagyon hasonló a buy limit-hez, de kicsit másképp működik, mindjárt kitérünk rá
OP_SELLLIMIT : ez pedig az előző párja

Mi a különbség a LIMIT és a STOP pozíció nyitás között? Sok!
A LIMIT mindig egy felső határt, a STOP pedig egy alsó határt jelöl. Vagyis, például egy buy limit esetén amikor a limitet meghaladja az ár, akkor nyit pozíciót, minimálisan a megadott limit áron és nem kevesebbért.
A buy stop pedig akkor fog pozíciót nyitni, amikor az ár leesik arra a bizonyos árszintre, amit megadunk és legfeljebb azon az áron nyit pozíciót, amit megadunk. Tehát a limit ár általában magasabb, mint a pillanatnyi ár, a stop pedig alacsonyabb, de ez a stratégiától függ természetesen. Mindenesetre így tervezték ezeket a pozíció nyitási lehetőségeket.

Két következtetést lehet levonni ebből. Az egyik, hogy a limit egy felső határ fölött, de legalább annyiért, ha a beérkező tick magasabb, akkor magasabban fog pozíciót nyitni, a stop pedig egy alsó határ alatt nyit pozíciót, maximum annyiért, de ha a tick alacsonyabb, akkor alacsonyabban fog pozíciót nyitni.
A másik következtetés, hogy ezek nem azonnali pozíció nyitások, hanem feltételesek, tehát amíg a pozíció meg nem nyílik, törölni is lehet őket mindenféle következmények nélkül.

Az első kettőt fogjuk használni, ugyanis ezek az azonnali pozíció nyitások. A többit nem is fogjuk használni, ezek általában kézi kötésnél játszanak szerepet, automatikus kereskedésben még sosem láttam ilyen kötést...

Nos, visszatérve a pozíció nyitó OrderSend() függvényünkre, a harmadik paraméterünk azt mondja meg, hogy mekkora méretű pozíciót nyitunk. Erről a nap végére tartogatok egy kis magyarázatot.
A következő paraméter az ár, amin szeretnénk pozíciót nyitni.Ezt megadhatjuk közvetlenül is, de ennek nem sok értelme van, ugyanis a program végrehajtása során ez az ár változhat. Tehát érdemes a pillanatnyi áron vásárolni.

No és akkor itt most álljunk meg egy szóra, mert itt jön az a rész, amit néha a kereskedők elfelejtenek. Aki nem felejti el ezeket, nyugodtan átlépheti ezt a bekezdést, de szerintem érdemes elolvasni. Fél perc...
A devizapárokkal történő kereskedés két áron zajlik. A vételi és az eladási áron. A MetaTrader a vételi árat Ask-nak hívja, az eladási árat pedig Bid-nek. A kettő közötti árrést nevezzük spread-nek.
Mivel a brókereknek az eladási ár a legfontosabb, így az eladási árat követhetjük nyomon a grafikonokon. Tehát venni az Ask áron tudunk, eladni viszont a Bid áron.

Éppen azért, ha pillanatnyi áron szeretnénk long pozíciót nyitni, akkor az az Ask ár lesz.

A következő három paraméter a slippage, amit már a múltkori post-ban megbeszéltünk, majd a stop-loss és a take-profit következik, melyeket hogyha 0-ra állítunk, akkor nem létezők lesznek, most ezt használjuk.
A következő paraméter egy egyszerű szöveges komment, amit úgy fogalmazunk meg, ahogy akarunk.

Az ezt követő paraméter a magic number, amit senki sem tud pontosan mi célt szolgál, ami biztos, hogy a felhasználó saját döntése alapján azt ír ide, amit akar, mint egyedi azonosítót.
Egyetlen dolgot fedeztem fel ezzel kapcsolatban, hogy a MetaTrader nem szereti, ha két különböző devizapáron azonos magic number-rel jelzett pozíció van nyitva. Egyszerűen megkavarodik és hülyeséget csinál.
Éppen ezért ide mindig kivétel nélkül valamilyen véletlen számot szoktam tenni. Lehet egy jól meghatározott konstans érték is, de akkor mindenképpen gondoskodjunk arról, hogy a különböző devizapárokon különböző magic number-eket használjunk!
Ezt követően a pozíció nyitás lejárati idejét lehet megadni, ami persze csak akkor értelmes, ha limit, vagy stop pozíciókat nyitunk és akkor is csak addig, amíg meg nem nyílik a pozíció. Ezért ez nekünk mindig 0.

Megnyitott pozíciót csak lezárni lehet, törölni nem!
Ezt azért húztam alá, mert nagyon fontos! Törölni csakis azokat a megbízásokat lehet, amelyek még nem teljesültek, amelyek már teljesültek, azok nyitott pozíciók és csak lezárni lehet őket, ez persze már pénzbe kerül (ára a spread-től és a pozíció méretétől függ), míg a nem teljesült megbízásokat büntetlenül törölhetjük bármikor, ingyenesen.

A legutolsó paraméter pedig a chart-on a nyitást ábrázoló nyilacska színe, ami szintén szabadon választott.

A függvény visszatérési értéke a pozíció nyitási jegy száma, ha sikerült a nyitás. (emlékszünk ugye a múltkori leírásra, miért kezeli így a program ezeket).
Ha ticket nem valami értelmes értéket tartalmaz, akkor nem sikerült a pozíció nyitás és akkor a hibát a felhasználó tudtára kell adni. Erre valók a következő sorok.

Először is pozíció nyitás után kiolvassuk a hiba számát a GetLastError() függvénnyel. Ha ez nem nulla és a ticket változónk is valamilyen nullánál kisebb értéket tartalmaz (tipikusan -1), akkor nem sikerült a pozíció nyitás és a hibár egy Print() függvénnyel a Naplóba írjuk.
A Napló tartalma a MetaTrader kereskedési felületén megtekinthető bármikor a program futásakor, tehát ide mindig üzenhetünk, hogyha a felhasználót szeretnénk tájékoztatni valamiről, ami nem a chart-on kell, hogy legyen.

Tehát ennyit a long pozíció nyitásáról.
A short pozíció nyitása is ugyanilyen egyszerű, csak ott a Bid árat kell megadnunk, és már nyílik is a pozíció.
Tehát így néz ki a short nyitás :

if (TMTrend == "Short" && TVITrend == "Short" && !nyitott)
      {
         ticket=OrderSend(Symbol(),OP_SELL,maxlots,Bid,slippage,0,0,"TrendMagic-TVI - Short",MathRand(),0,Green);
         err = GetLastError();
         if (err != 0 && ticket < 0)
         {
            Print("Error # ", err, " ", ErrorDescription(err));
         }
      }

Látható milyen egyszerű.

A következő post-ban a stop húzást fogjuk megvalósítani, ezáltal lesz egy stratégiánk, ami jelek alapján pozíciót nyit és zár, indulhat a back test. A back test-ek végrehajtásához a legjobb a hétvége, akkor lehet nyugodtan tesztelgetni.
Tehát igyekszünk holnap minden finomra csiszolni a programunkon, hogy vasárnap békésen tesztelhessen mindenki!

A pozíció méretről ígértem egy kis elmélkedést.
A FOREX esetében - amikor is nem részvényeket vásárlunk, hanem devizapárokat - nem darabonként vesszük, adjuk, hanem kötegekben, csomagokban. Ezt a FOREX úgy nevezi, hogy Lot. Egy ilyen kereskedési egység 100.000 alapdevizát jelent, ha azt a tizedespont után 5 számjegy követi.
Ehhez a tőkeáttétel szerinti fedezet szükséges, ha a tőkeáttételünk 1:100, akkor ennek az egy század részét kell a számlán tartanunk, ha vásárolni akarunk. Ez 1000 USD. Tehát ez nagyon sok. Éppen ezért, mivel a pénzünknek csak maximum 3%-át kockáztatjuk, a maximális kötési mennyiséget be kell lőnünk.

Ha 0.01 lot-ot kötünk, akkor "csak" 10 USD-t kockáztatunk, tehát az óvatosság nem csakhogy nem árt, hanem inkább még használ is.

Építkezés - folytatás...

2011-02-24T22:27:00.000+01:00

Tegnap elkezdtük a FOREX robotunk építését, ma pedig folytatjuk.
Beszéltünk tegnap a stratégiáról egész részletesen, sőt, el is kezdtük a kódolást a felhasználótól bekért kezdő adatokkal és az első lépést is megtettük a robot építésében.

Ma egy újabb lényeges résszel folytatjuk, mégpedig a start() függvényünket csiszolgatjuk még tovább.
Egész konkrétan azt fogjuk lekódolni, amikor a program megvizsgálja van-e nyitott pozíciónk.
Nem is nagyon szaporítom a szót fölöslegesen, íme a kód, aztán pedig megbeszéljük :

   nyitott = false;
   orders = OrdersTotal();

   for(int pos=0;pos
   {
      if(OrderSelect(pos,SELECT_BY_POS)==false)
         continue;
      else
            if (OrderSymbol() == Symbol())
               nyitott=true;
   }

Gondolom emlékeztek rá, hogy tegnap felvettünk egy globális változót, amely bool típusú. Ha ez igaz (azaz true) értéket tartalmaz, akkor van nyitott pozíciónk, ha pedig hamis (false), akkor nincs.

Felmerülhet a kérdés, hogy mi a fenének ez rögtön az elejére. A magyarázat rém egyszerű. Azért, mert ha nem ezzel kezdenénk a műveleteket, akkor a programunk minden alkalommal, amikor pozíció nyitási jeleket lát a chart-on, minden alkalommal nyitna egy pozíciót. Minden egyes gyertyánál, amíg csak jel van.
Ez oda vezetne, hogyha mondjuk egy 100 gyertyából álló trend indulna el, akkor nyitna 100 pozíciót. Ha megfelelően nagy pozíció méretet állítunk be, akkor egyszer csak nem tudnánk már nyitni, mert a teljes tőkénket befektettük a sok pozíció nyitással és gyakorlatilag elfogyna a pénzünk. A baj nem itt van, hanem ott, amikor lezárjuk őket. Ugyanis a java része veszteséges lenne, és csak kis hányada - egész konkrétan a legelőször nyitottak - lennének nyereségesek.

Ez azt jelenti, hogy viszonylag gyorsan el is fogyna a pénzünk...

Itt azért meg kell jegyeznem a teljesség kedvéért, hogy vannak olyan technikák, amikor nyitunk egy pozíciót, majd amikor jónak látjuk, nyitunk egy másikat is ugyanabba az irányba, azután még egyet, de ezek száma korlátos és egyszerre zárjuk le őket. de ezeket jól átgondoltan akkor nyitjuk, amikor megbizonyosodtunk arról, hogy a trend merre megy és amikor mindet egyszerre bezárjuk, akkor legfeljebb az utolsó veszteséges, a többi viszont óriási nyereséggel zárul. Ezt hívják piramis építési technikának, beszélünk is majd róla később, de most egyenlőre maradunk az egy nyitott pozíciónál.

Nézzük a kódot! Mivel minden új gyertya "keletkezésekor" lefut a robot lelke, vagyis a start() függvényünk, ezért minden új gyertya indulásakor meg is vizsgáljuk van-e nyitott pozíciónk.
Ehhez legelőször is azt feltételezzük, hogy nincs nyitott pozíciónk és beállítjuk hamis értékre a nyitott nevű változónkat.
Ezután használjuk az orders változót, amely egész típusú és egy egyszerű függvénnyel megadjuk neki azt, hogy hány nyitott pozíciónk van. Erre való az OrdersTotal() beépített MetaTrader függvény.
Ez a függvény visszaad egy egész számot, amely a nyitott pozíciók méretének számát tartalmazza.

Ezzel itt vége is, gondolhatnánk, hiszen ez a függvény megmondja mennyi nyitott pozíciónk van, minek a további kód? Aki ezt gondolja, teljesen igaza is van. Egyetlen egy dolgot azonban nem szabad elfelejtenünk!
A MetaTrader több devizapáron is megjeleníti a chart-ot és mindegyiken köthetünk üzletet, viszont ha pozíció nyitási jelet látunk mondjuk az EURUSD-n, de az USDCHF-en már van nyitott pozíciónk, akkor EURUSD-n nem fog nyitni, mert az OrdersTotal() függvény beleszámolja az ÖSSZES nyitott pozíciót!

Ezért hát a kód többi része. Egy egyszerű for ciklust indítunk el, amely csak akkor fut le, ha a változó értéke nagyobb nullánál, tehát ha legalább egy nyitott pozíciónk van.
Az OrderSelect() függvény lépeget végig a nyitott pozíciókon, méghozzá a paramétereiben megadott módon.
Kétféle módon tudja ezt megtenni, vagy a pozíció nyitási jegy száma alapján (erről mindjárt beszélünk kicsit), vagy pedig pozíció szám alapján, amely pozíció nem más, mint a pozíció nyitásának sorszáma időrendben, függetlenül az instrumentumtól, vagy bármi mástól.
Mivel a nyitási jegy számát nem tudjuk, ezért pozíciónként megyünk végig a nyitott üzleteken.

A pozíció nyitási jegyekről pár szóban.
Annak idején, amikor még a kereskedést a tőzsdén a placcon nyomták, akkor a brókerek egy cetlire írták fel, hogy miből mennyit akarnak vásárolni, vagy eladni. Aztán amikor jött az ajánlati könyv vezetője, beordított egy árat, hogy akkor most venne ennyiért ezt és ezt. A brókerek meg üvöltve tették meg az ajánlataikat, amelyet, ha elfogadott az ajánlati könyvbe a kereskedő, akkor az volt a hivatalos tranzakció, új alapokra helyezve a következő tranzakciót (nő, vagy csökken az ár mindegyik után, hiszen ha sok az eladó, akkor az lenyomja az árat, ha pedig a vevő sok, akkor az meg felveri az árat).
Ezeknek a cetliknek, mint kötési jegyeknek, egyedi sorszáma van, melyet az ajánlati könyvbe bejegyeznek.

A dolog az intelligens számítógépek korában is pontosan így működik, azzal a különbséggel, hogy nem brókerek üvöltenek a placcon, hanem számítógépek zúdítják a biteket a brókercéghez, ahol az ajánlati könyvet kezelik. Vannak olyan bróker cégek, ahol az ajánlati könyv legfelső néhány tételét látni is lehet a weboldalon, így lehet tudni nagyjából, hogy eladói, vagy vevői nyomás van a piacon.

Mivel a MetaTrader nem csak devizapárok, hanem részvények (pontosabban származtatott részvény termékek, EFT-k) kereskedésére is alkalmas, ezért a deviza kereskedelemben is megtartották a szisztémát és ugyanígy kezelik az ajánlatokat.

Tehát ott tartottunk, hogy a nyitott pozíciónak van egy egyedi azonosító száma, amely megkülönbözteti az összes többitől, legyen az bármelyik chart-on.
Az OrderSelect() függvénynek két paramétere van. Az egyik a pozíció száma, vagy pedig a kötési jegy száma, a második paramétere pedig azt mondja meg, hogy az első paraméter egy kötési jegy szám, vagy sorszám.
Ezen adatok alapján megkeresi a pozíciót és kiválasztja (mintha csak egy listában sárga kijelölő filctollal kisárgítaná nekünk). Ezek után az összes pozícióra vonatkozó függvény ezzel az egy pozícióval foglalkozik.
Van jó pár, akit érdekel és otthon van alapszinten az angol nyelvben, végig nézegetheti a Help-ben. Csak párat megemlítek közülük, le lehet kérdezni a kötés idejét, méretét, az árat, az aktuális profit/loss-t, a stop-ot hová húztuk, a take profit hol van, stb.
De megtudhatjuk belőle azt is, hogy melyik instrumentumra kötöttük azt a bizonyos pozíciót.

Éppen ez kell nekünk. Tehát a for ciklusunk végig megy a nyitott pozíciókon sorszám szerint, és megnézegeti, hogy a pozíció milyen instrumentumon köttetett. Az OrderSymbol() függvény visszaadja a nyitott pozíció instrumentumát, a Symbol() függvény pedig azt mondja meg, hogy az aktuális chart éppen milyen instrumentumon van.
Az OrderSelect() függvény visszatérő értékként azt adja vissza, hogy sikeres volt-e a pozíció kiválasztása. Tehát a kód egyszerűen végig sétál a nyitott pozíciókon, ha van egyáltalán, és megnézi, hogy bármelyik nyitott pozíció instrumentuma megegyezik-e a chart-on lévővel.

FOREX robotunk újabb alkatrésze jön, mégpedig a pozíció nyitásokhoz szükséges vizsgálat.
Itt is gyorsan mutatom a kódot, azután megbeszéljük :

if (iCustom(NULL,0,"TrendMagic",TrendMagicCCI,TrendMagicATR,0,1) != EMPTY_VALUE && iCustom(NULL,0,"TrendMagic",TrendMagicCCI,TrendMagicATR,1,1) == EMPTY_VALUE) // Long
      {
         TMTrend="Long";
      }

Ez itt egy egyszerű vizsgálat, if utasítással. A trükk azonban a részletekben rejlik.
Gyors magyarázat az egyszerűség kedvéért. Az iCustom függvénnyel lehet az egyéni indikátorokat lekérdezni. Az összes beépített indikátornak van saját beépített függvénye (pl. a MACD-nek az iMACD függvény).
Az indikátorok lekérdezését végző függvények paraméter listája mindig két érték megadásával kezdődnek.
Az első a megfelelő instrumentum megadása, a második pedig az időtáv, amin dolgoznia kell.

Ha egészen precízek szeretnénk lenni, akkor az instrumentumnak megadhatnánk a Symbol() függvényt, amiről fentebb már volt szó, az időtávnak pedig a Period() függvényt. Ez az aktuális chart éppen használatos időtávját adja meg.

Ehelyett azonban az alapértékeket adjuk meg, az instrumentumnak a NULL értéket, az időtávnak pedig a 0-t.
Ha megnézzük a help-ben a iCustom() függvényt, akkor látjuk, hogy az instrumentum paraméterként megadott NULL érték az aktuális instrumentumot jelenti, a 0 időtáv pedig szintén az aktuálisat.

Persze megadhatunk fix értékeket is, de akkor csak azon az instrumentumon és csak azon az időtávon fog működni a FOREX robotunk.
Folytatva az iCustom() függvény magyarázatát, a következő paraméter az egyéni indikátor neve string-ként megadva. Ez a név pontosan az kell, hogy legyen, amit az egyéni indikátorok listában látunk a Navigation ablakban. Különben nem fogja megtalálni. A mi esetünkben ez a TrendMagic egyéni indikátor lesz.
Ezután következnek a TrendMagic paraméterlistája, majd két fontos információ.
Az első azt adja meg, hogy a TrendMagic indikátor melyik paraméterét kérdezzük le, a második pedig azt, hogy a pillanatnyi gyertyához képest visszafelé hányadik gyertyánál lévő értékre vagyunk kíváncsiak.

Az egyéni indikátorok lekérdezhető paraméterei függenek az egyéni indikátortól. Egy mozgóátlagnak (iMA) egyetlen paramétere van, de egy ADX-nek rögtön három. A paraméter számozás 0-val kezdődik, tehát a legelső paraméter a 0-ás, a második az 1-es és így tovább.

Honnan lehet tudni, hogy melyik a 0-ás paraméter? Onnan, hogyha feltesszük a chart-ra, fentről lefelé ez jelenik meg legelőször, általában az indikátor neve mellett.

A mi esetünkben a TrendMagic-nek két paramétere van, jól lehet egyetlen vonalat látunk a képernyőn, ami hol piros, hol kék. A kék és piros értékeket külön kezeli, ezért ez két különféle paraméter.
A 0-ás érték az a kék vonal esetén él, az 1-es érték pedig a piros vonal esetén él. Tehát ha a 0-ás paraméter nem üres, akkor tudjuk, hogy a TrendMagic vonala kék, azaz emelkedő trendet mutat, ha az 1-es paramétere nem üres, akkor piros a vonal és csökkenő trendet mutat.

Az iCustom() függvény legutolsó paramétere, amit már megbeszéltünk, az pedig a pillanatnyi gyertyát megelőző gyertya sorszámára utal, az ott lévő indikátor értéket vizsgáljuk. Itt a pillanatnyi gyertya előtti, tehát a legutolsó bezárt gyertyánál lévő indikátor értékre vagyunk kíváncsiak, mivel a pillanatnyi gyertya mindig változik, tehát a hozzá tartozó indikátor érték is. Egy folyamatosan változó értékre alapozni egy pozíció nyitást, öngyilkosság, de minimum hazárdjáték. A tőzsdézés viszont nem hazárdjáték.

Az említett if utasítás tehát egész egyszerűen azt az esetet vizsgálja, hogy a TrendMagic paramétere nem üres, de az 1-es paramétere üres (vagyis a vonal kék ÉS nem piros), akkor a TrendMagic emelkedő trendet mutat, vagyis long pozíció nyitására van lehetőség eszerint az indikátor szerint.

Ugyanez fordítva a short trend nyitásának feltétele :

if (iCustom(NULL,0,"TrendMagic",TrendMagicCCI,TrendMagicATR,0,1) == EMPTY_VALUE && iCustom(NULL,0,"TrendMagic",TrendMagicCCI,TrendMagicATR,1,1) != EMPTY_VALUE) // Short
      {
         TMTrend="Short";
      }

Tehát itt pedig az előző feltétel ellentétét vizsgáljuk.
Felhívnám a figyelmet az egyenlőség és a nem egyenlőség vizsgálatát végző operátorokra. A dupla '=' jel a megfelelőséget, a '!=' pedig a nem megfelelőséget vizsgálja. Azért említem meg, mert tipikus programozói hiba szokott lenni, hogy a dupla '=' jel helyett csak szimplát használnak, ami ugye értékadást jelent. Tehát a feltétel MINDIG igaz lesz, de ha egy változó van a bal oldalon, akkor az felveszi azt az értéket, ami a jobb oldalon van. Ez nem egészséges.

A másik tipikus hiba, hogyha valaki más nyelvben is programozik, mondjuk például Visual Basic-ben, akkor a nem megfelelőség jeleként a kacsacsőrt használja, vagyis a '<>' jelet. Ez azonnali fordítási hibát dob, tehát ezt nem nehéz kivédeni, de sok kezdő nem érti a hiba üzenetet, hogy miért nem tetszik a fordítónak ez a megszokott jel... Hát mert csak. Ez egy C-szerű nyelv, márpedig ennek a nyelvnek a szintaktikája nem szereti a más nyelvben megszokott jelet. Ennyi az egész.

Tehát túl is vagyunk a TrendMagic indikátorunk által mutatott jelek értelmezésén, amit el is tettünk egy string változóba. Azért string-be, mert ez így mindenkinek olvashatóbb, jobban is lehet értelmezni.

Következzék hát a TVI jeleinek vizsgálata.
Mivel ez pont ugyanúgy működik, mint a TrendMagic így nincs meglepetés, csak a paraméterek száma különbözik, mert itt három paraméter van, nem kettő. De ettől eltekintve ugyanígy kell vizsgálni a zöld és piros értékeket. Sőt, mi több, még a paraméterek lekérdezése is ugyanígy működik :

if (iCustom(NULL,0,"TVI_2color",TVI_rs,TVI_rs,5,TVI_TF,0,1) != EMPTY_VALUE && iCustom(NULL,0,"TVI_2color",TVI_rs,TVI_rs,5,TVI_TF,1,1) == EMPTY_VALUE)
      {
         TVITrend="Long";
      }

      if (iCustom(NULL,0,"TVI_2color",TVI_rs,TVI_rs,5,TVI_TF,0,1) == EMPTY_VALUE && iCustom(NULL,0,"TVI_2color",TVI_rs,TVI_rs,5,TVI_TF,1,1) != EMPTY_VALUE)
      {
         TVITrend="Short";
      }

Tehát szinte ugyanazt a kódot kapjuk, csak egy paraméterrel több van és másképp hívják az indikátort (és persze más paramétert kapnak az indikátorok is).

Ezzel szinte készen is vagyunk, már ami az indikátorok vizsgálatát illeti, a következő post-ban már a pozíció nyitásokkal leszünk elfoglalva, azután pedig stop-loss húzásokkal.

Aztán, ha ezekkel mind meg vagyunk, akkor jöhet a puding próbája, a back test.

Jó elmélkedést, programozást, help olvasgatást!

Építkezés

2011-02-23T22:17:00.001+01:00

Már megint jó sok idő telt el, mentségemre legyen mondva, elég rendesen felborult a megszokott életritmusom. De lassan elülnek a hullámok, a FOREX persze marad, az automatikus kereskedelem és a robot építés még mindig a szívem csücske, így természetesen nem hagyok fel ezzel. Minden nap új tapasztalatokat szerzek.

Fura a mai cím, de mégis jó ide, ugyanis elkezdjük "megépíteni" a robotunkat. Nem kell igazi robotra gondolni, de ebben a szakmában így hívják azokat a programokat, amelyek automatikusan kereskednek.

FIGYELEM! Az itt közzétett programkódok saját szellemi termékeim, de szabadon felhasználhatja bárki. Felelősséget azonban nem tudok érte vállalni, mint ahogyan a kód használatából származó anyagi károkért sem! MINDENKI SAJÁT FELELŐSSÉGÉRE HASZNÁLJA! A kódok CSAK oktatási céllal kerültek ide! Kellő hozzáértés és fegyelem nélkül TILOS éles számlán használni!

A FOREX robotunk két egyéni indikátort használ, mindkettőt kiveséztem a legutóbbi post-ban. Az egyik a TVI, a másik pedig a TrendMagic. Illetve van még egy harmadik indikátor is, amely a stop-loss-okat húzogatja utánunk. Ő a Parabolic SAR.

A két egyéni indikátorral az a szerencsénk, hogy mindkettő forráskódját fel lehet lelni az interneten, ha esetleg valaki nem találná, vagy nem biztos abban, hogy azt találta meg, amire szükség van, az bátran írjon nekem levelet, "postafordultával" elküldöm az indikátorok forráskódját. Javaslom, hogy módosítás nélkül használja mindenki!

Mindkét indikátor színekkel jelzi, hogy szerinte a trend merre megy. De sajnos egyedül egyik sem megbízható, ezért van szükség arra, hogy legalább kettőt használjunk.

A TVI-ből ráadásul kettőt fogunk használni, mert egy kevés lesz.
Kicsit furmányos ez az indikátor, mert nem egy, hanem két forráskódból áll. Az egyik a TVI.mq4, amely a normális TVI jeleket számolja. A másik a TVI_2color.mq4, amely a nevéhez méltóan két színnel jelöli a trend lehetséges irányát. Ez utóbbi indikátor képtelen egyedül működni, csakis kizárólag az előzőekben említett TVI.mq4 indikátorral együtt működik, tehát mindkettőt be kell másolni az indicators mappába.

A TVI-nek három, a TVI_2color-nak négy paramétere van. Ezek magyarázatára nem térnék ki, legyen elég annyi, hogy elmondom hogyan kell beállítani őket.

A TVI paraméter beállításai tehát a következők :

r : 50
s : 50
u : 5
tf : 0

Ezekkel a paraméterekkel fel is tehetjük egy chart-ra tanulmányozni, hogy mit is mutat! Szerintem tanulságos.

A TrendMagic-ről is írtam részletesen legutóbb, összesen két paramétere van :

CCI : 50
ATR : 12

Ezt is feltehetjük ugyanarra a chart-ra, amire feltettük a TVI-t.
Más dolgunk már nincs is, mint megbarátkozni a Parabolic SAR-ral. Ennek is egy színes változatát használjuk, csak azért, mert programozás szempontjából könnyebb ezt kezelni. Aki átírta, úgy nevezte el, hogy "Parabolic trendchaser", vagyis trend hajhász... :o)
Beállításai :

AlertsEnabled : false
Step : 0.06
Maximum : 0.1
Precision : 7
TimeFrame : 0

A paraméterek értelmezését most szintén nem taglalnám! A lényege, hogy így kell beállítani. Aki nem akar a Parabolic trendchaser-rel bajlódni, az használhatja a beépített Parabolic SAR-t is, a Step és a Maximum paramétereket felhasználva ugyanezt az eredményt fogjuk kapni, csak nem lesz szép színes és később a programozás során nehezebb kezelni.
Ha ezekkel a beállításokkal ezt is felteszitek a chart-ra, akkor látható, hogy igen szűk stop-okat lehet vele húzni, ha a bróker hagyja. De erről kicsit később.

Tehát, meg is vagyunk az indikátorok beállításával. Látszik szépen a chart-on, hogy milyen jól együtt járnak ezek az indikátorok :

TVI-TrandMagic stratégia

A stratégia pedig rém egyszerű, amikor a TVI zöld, a TrendMagic kék, és a Parabolic alsó kék pöttyöket rajzol, akkor long pozíciót nyitunk és a Parabolic-nak megfelelően húzzuk a stop-ot. Amikor a trend vált, akkor egyszerűen "kistoppolódunk" és már készen is állunk a következő pozíció nyitásra.

A programunk tehát a következő részekből fog állni :

Indikátorok adatainak begyüjtése
A jelzések alapján pozíció nyitás
A nyitott pozíciók stop-jainak húzogatása

A zárással azért nem foglalkozunk, mert a kistoppolódás miatt úgysem kell zárnunk.

A program kód eleje mindig azzal kezdődik, hogy a felhasználótól bekérjük az indulási paramétereket, illetve az alapbeállítások módosítását tesszük lehetővé számukra. Akinek nem tetszik az 50-es érték a TVI esetében, bátran átállíthatja saját felelősségére.

Nem szeretném elmagyarázni a nyelv egyes elemeit, remélem mindenki programozott már és tudja mi az a változó, meg hogy globális változó, függvényhívás, deklaráció, definíció, stb.

Tehát a program azoknak a változóknak a definíciójával kezdődik, amelyeket a felhasználó számára is elérhetővé szeretnénk tenni, egyben a programunk ezeken keresztül tartja a kapcsolatot a felhasználóval, ha adatokat kérünk be.
Ezek a változók a hagyományos C#-ban megszokott típusúak lehetnek, de az elé írt extern klauzulával lehet őket láthatóvá tenni a felhasználó számára.
A mi esetünkben a következő lesz a lista :

extern double maxlots=0.01;
extern int slippage=5;
extern int TrendMagicCCI=50;
extern int TrendMagicATR=5;
extern int TVI_rs=50;

Látható tehát, milyen adatokat kérünk, illetve az is látható, hogy nem csak kérünk, de alapbeállításként fel is ajánlunk egy-egy értéket. Ennek ugyebár ott az értelme, hogyha a felhasználó ránk bízná a program paraméterezését, akkor is legyen valami induló adat.

Nézzük sorban őket:

maxlots : ez a kötéseink során fontos, azt fogja tartalmazni, milyen méretű pozíciót nyithatunk. Ez most egyenlőre egy fix érték lesz, amit ide beállítunk.
slippage : ez egy csúszó érték, amely szintén a kötések során fontos. Azt az értéket tartalmazza, amivel a bróker eltérhet az általunk megadott kötési, zárási ártól. Erről mindjárt írok egy-két sort, mert ez fontos, meg kell értenetek, mire való ez.
TrendMagicCCI : ez ugyebár a TrendMagic indikátorunk CCI paramétere
TrendMagicATR : ez pedig a TrendMagic indikátor ATR paramétere
TVI_rs : ez pedig a TVI indikátorunk r és s értéke (a kettőt mindig ugyanarra az értékre állítjuk) az u értéket viszont nem engedjük ki a kezünk közül, az fixen 5.

Tehát pár mondat a slippage-ről. Amikor a MetaTrader-en keresztük utasítást adunk a brókernek, hogy nyisson, vagy zárjon egy pozíciót, akkor meg kell adnunk egy árat. Ez az ár azonban nem biztos, hogy a pillanatnyi ár. Ha ugyanis miközben az utasítás az internet éterén keresztül beérkezik a brókerhez, ott feldolgozásra kerül és közben egy újabb tick érkezik, az ár máris megváltozik és a kötést nem engedi végrehajtani a rendszer.
Ezért vezették be a slippage nevű paramétert, amely megadja, hogy a bróker a pozícióink kezelésekor mennyivel térhet le az utasításban megadott ártól. Ez minden esetben az aktuális valutapár, vagy részvény értékének felel meg, tehát ha a tizedespont után 5 számjegyet látunk, akkor az ötödik számjegyre vetített értéket jelenti. Az alapként beállított 5-ös érték EURUSD esetében (ahol 5 számjegy követi a tizedespontot, de a negyedik számjegy jelenti az 1 PIP-et) mindössze 0.5 PIP csúszást enged meg a brókernek.

Ha ezt az értéket 0-ra állítanánk, egy gyorsan változó piac esetében többszöri próbálkozás ellenére sem biztos, hogy ott nyitunk pozíciót, ahol akarunk. Esetleg előfordulhat az is, hogy egyáltalán nem tudunk pozíciót nyitni, vagy zárni.

Az 5-ös érték általában jól működik és kellően kicsi ahhoz, hogy kötni lehessen. Nem ajánlott módosítani, de ezt mindenki maga döntheti el. Ha kivesszük az extern klauzulát előle, a felhasználó nem tudja piszkálni, de az érték ott lesz benne.

Ahogyan már egy korábbi post-ban ecseteltük, az Expert Advisor három részből épül fel. Van egy init(), egy deinint() és egy start() függvénye. Ezek közül az init() akkor fut le, amikor a chart-ra feltesszük a programot, de csak egyetlen egyszer fut le. A feladata azoknak a tevékenységeknek az elvégzése, amelyeket a kereskedés előtt egyszer meg kell tenni.
Ugyanígy a deinit() függvény pedig akkor fut le, amikor levesszük a chart-ról a FOREX robotunkat, ez is csak egyszer fut le, hasonlóképpen az előzőekhez a futás utáni takarítás a dolga.
A start() függvény viszont a szíve az Expert Advisor-nak, ugyanis ez fut le minden egyes alkalommal, amikor csak érkezik egy tick, azaz egy kereskedési adat.

Miután programunk nagyon egyszerű és nem helyez el mindenféle objektumot a chart-on (erről is lesz később szó), ezért csak a start() függvény megírására kell koncentrálnunk.

Mielőtt azonban a lelkét kezdenénk fejlesztgetni a robotunknak, érdemes az extern változók után felvenni a globális változóinkat.
Azokat a változókat érdemes ide felvenni, amelyek értékére két beérkező tick között is szükségük lesz, tehát ha ezt a start() függvényen belül vennénk fel, minden egyes tick alkalmával, amikor lefut start() függvény, a változó újra és újra létrejönne, de azzal a kezdőértékkel, amivel definiáljuk, illetve ha az nincs, akkor valamilyen véletlen szerű kezdőértékkel.
Ilyenek azok a globális változók, amelyek a program futása közben végig meg kell, hogy őrizzék az értéküket, amíg le nem állítjuk.

Tipikusan állapot jelző változókra van itt szükség, vagy számlálókra, és ehhez hasonlókra.
Valami ilyesmi lehet :

int currentbar;
string TMTrend, TVITrend;
int orders;
bool nyitott;

Némi magyarázat :

A currentbar változó fogja tartalmazni az aktuális gyertyák számát, amelyet a chart megjelenít. Ez fontos lesz majd.
a string változók arra valók, hogy az egyes indikátorok által jelzett trendet jelöljék. Ez lesz az alapja a pozíció nyitásnak
Az orders változó arra lesz hivatott, hogy a pozíció kezelések alkalmával a pozíció egyedi azonosítóját tartalmazza majd.
A nyitott nevű változónk pedig azt mutatja majd, hogy van-e nyitott pozíciónk már, avagy sem

Most pedig lássuk a FOREX robot lelkét!

Azzal fogjuk kezdeni, hogy amikor egy újabb tick érkezik, megvizsgáljuk, hogy ez a tick egy új gyertya legelső tick-je, vagy pedig egy már folyamatban lévő gyertya valahányadik tick-je.
Miért jó ez nekünk?
Azért, mert a tőzsdeiskolákban mindenhol azt tanítják, hogy csak a már bezárult gyertya az igazi gyertya, a még be nem zárult gyertya változhat, hiszen a piacon bármi megtörténhet. Előfordulhat, hogy a bika gyertyából az adott időintervallumon belül hirtelen medve gyertya lesz. Na, ekkor aztán fuccs a stratégiának. Tehát csak a bezárult gyertyákkal foglalkozunk.

A kód így néz ki :

if (currentbar < Bars)
      currentbar = Bars;
   else
      return;

A magyarázat pedig nagyon egyszerű.
A currentbar nevű változónk, amelyet globálisnak vettünk fel, tartalmazza a chart-on található gyertyák számát. Kezdetben egyébként valami teljesen kiszámíthatatlan értéket tartalmaz, tehát elsőre biztosan lefut a start() függvényünk. (ha ez semmiképpen sem akarjuk, akkor az init() függvényünkben ennek a változónak adhatunk értéket, valahogy így : currentbar = Bars; Így pontosan azt az értéket fogja tartalmazni, ami a chart-on van, így a programunk addig nem fut le, amíg az aktuális gyertya le nem zárul. Íme egy lehetséges és értelmes módja az init() függvény használatának.)
A Bars rendszerváltozó az aktuális gyertyák számát tartalmazza, amelybe beletartozik az éppen be nem zárt gyertya is. Ez a globális rendszerváltozó a MetaTrader saját globális változója és csakis olvasható értéket tartalmaz. Lesz még pár ilyen amivel megismerkedünk.
Tehát a kódrészlet úgy működik, hogy ha az általunk megjegyzett gyertyák száma kevesebb, mint a chart-on lévő aktuális gyertyák száma, akkor bizony ez éppen egy új gyertya nyitását jelenti, tehát jól megjegyezzük mennyi is a chart-on a gyertyák száma és hagyjuk lefutni a start() függvényt.
Ha viszont az eltárolt gyertyaszám megegyezik a chart-on lévő gyertyaszámmal, akkor az érkező tick az aktuális gyertyához tartozik, tehát egy return utasítással be is fejezzük a start() függvényünk futását.

Miután az új gyertyát megkezdő tick az előző gyertya záró tick-je is egyben, így a start() függvényünk minden esetben lefut, amikor egy újabb gyertya lezárul, de csakis akkor, nem máskor. Ilyen egyszerű.

A legközelebbi post-ban innen folytatjuk a kód írását. Talán kedvcsinálónak ennyi is elég lesz mára. Igyekszem nem három hónap múlva folytatni... :o)

Nézzük a stratégiát

2010-12-01T09:10:00.001+01:00

Lassan tradíciót csinálok abból, hogy a blog majdnem mindegyik bejegyzése úgy kezdődik, ahogyan ez is...
Nagyon régen sikerült utoljára írnom a blogba, talán azért is, mert mindig sokat szeretnék írni, de kevés az időm, de leginkább azért, mert folyamatosan tanulom a szakmát én is.
Ezért úgy döntöttem, hogy nem fogok hosszú írásokat közzétenni, hanem relatíve rövidebbeket, viszont ezt sűrűbben teszem majd.

Legutóbb azt írtam, hogy a megvalósítandó stratégiát fogom leírni, ami igaz is. Ezért most röviden a stratégiáról fogok írni.

Nagy általánosságban a stratégiákat három alapvető részre oszthatjuk, hogyha programozás technikailag nézzük a szerkezetét.

Pozíció nyitás
Pozíció módosítás
Pozíció zárás

A pozíció nyitásához azonban nem csak a stratégia számításai a fontosak, hanem a money management számítások is rendkívül fontosak! Tudom, hogy folyton ezen lovagolok, de higgyétek el, tényleg nagyon fontos!
Egyenlőre azonban a program fejlesztésére koncentrálunk, így a stratégiát úgy fogjuk elkészíteni, ahogyan én is szoktam a gyakorlatban csinálni.
A fejlesztés fázisai a következők lesznek :

A pozíció nyitások és zárások elméletének ellenőrzése
Money management-tel történő támogatása
Veszteségek további csökkentése
Nyereségek növelése
Demó számlán történő tesztelés
Éles számlán történő tesztelés kis összegekkel

Nézzük szépen sorban, mert hiszen komoly magyarázatra szorul mindegyik rész szerintem.

A pozíció nyitások és zárások elméletének ellenőrzése nem másról szól, mint arról, hogy a trader kitalálja milyen jelzések alapján akar kereskedni, majd ezekre a jelzésekre "összeüt" egy rövid kis kódot és backtest-tel leteszteli, hogy az általa kitalált elmélet mennyire állja meg a helyét.Ennek ugye ott az értelme, hogy a backtest alkalmával látni fogod, hogy valóban jókor nyit-e pozíciót a programod és jókor zárja-e le. Előfordulhat ugyanis, hogy kitalálod a frankót, de amikor backtest-telsz, azt fogod látni, hogy bizony nem minden esetben akkor nyit long-ot, amikor tényleg felfelé indul el az árfolyam, vagy az is lehet, hogy elindul felfelé az ár, de mégsem nyit long-ot. Tehát ez fontos, hogy a kitalált elméletet leellenőrizzük.

Money management támogatás. Itt egész egyszerűen arról van szó, hogy meghatározzuk azokat a kritériumokat, amely szerint a pozíció méreteket kitalálja a program magától. Ezt a részt persze ki is hagyhatnánk és mondhatnánk, hogy fix lot-okkal kereskedünk, ilyen is van, ezt fix pozíció méretnek nevezzük. Itt kell azonban kitalálnunk azt is, hogy hová húzzuk a stop-okat (SL), hová tesszük a take profit-okat (TP). Ezek ismeretében pedig ki tudjuk számítani a Risk/Reward arányt is (RR), ami meg fogja mondani nekünk, hogy érdemes-e egyáltalán pozícióba lépnünk. Sajnos ez egy elég bonyolult algoritmus, nem biztos, hogy ezt az elején fogjuk tárgyalni, de mindenképpen fontos.

A veszteségek csökkentése is egy olyan technika, amikor a backtest által nyújtott információkat használjuk fel arra, hogy növeljük a profit faktorunkat, vagyis a nyerő kereskedések számát meghagyva csökkentjük azoknak a pozíció nyitásoknak a számát, amelyek veszteséget termelnek. Ez persze azt jelenti, hogy kevesebb pozíciót fog nyitni a programunk, de legalább ezek nagyobb részt lesznek nyereségesek, mint veszteségesek.

A nyereségek növelése pedig azt a célt szolgálja, hogy a nyereséges pozíció nyitások nyereségét fogjuk feltornászni mindenféle trükkökkel, hogy azután a veszteségek eltörpüljenek mellettük. Nem kell óriási trükkökre gondolni, egyszerűen arról van szó, hogyha az árfolyam elindul felfelé és long-ot nyitunk például, akkor figyeljük, hogy az ár mozog-e még tovább felfelé. Ha igen, akkor újabb long-ot nyitunk, vagyis rákötünk az előző pozíciónyitásra. Ezt piramis építésnek, vagy piramidális pozíció építésnek is hívják. A pozíciók SL-i és TP-i ugyanazok és egyszerre is zárjuk őket. Elképzelhető, hogy záráskor lesznek veszteséges pozíciók, de a piramis építésekor a csúcson lévők lesznek a veszteségesek, az alattuk lévő (vagyis korábban nyitott) pozíciók azonban nagyobb és nagyobb nyereséggel rendelkeznek, ahogy szélesedik a piramis lefelé.

Ha minden a helyére kerül, akkor lehet tesztelni éles adatokkal egy demó számlán, ugyanis a backtest csak informál a lehetséges sikerekről, de mivel már a múlt, ezért az nem biztos, hogy a jövőre nézve is igaz. Az esélye meg van, de ki tudja mit hoz a jövő... Itt legalább egy, de inkább három hónapig teszteljük a programunkat, minden héten alaposan kiértékelve a nyitott és zárt pozíciókat.

Ha pedig elégedettek vagyunk a programunk teljesítményével a demó számlán, elkezdődhet az éles számlán történő tesztelés kis összegekkel. Itt egészen kicsi összegekről van szó, 500 USD, maximum 1000 USD-ről. Persze ez van, akinek komoly összeg, de ha már a demó számlán jól teljesített a programunk, akkor nyilván nem félünk attól, hogy elveszítjük a pénzünket. Itt azonban szintén komolyan kell venni néhány irányelvet, amit majd e rész tárgyalásakor részletesen le is írok.

És akkor most lássuk a stratégiát!
Ez egy régi stratégia, sokan használják kézi és félautomata kereskedésekhez (amikor csak jelez a program, hogy pozíciót kellene nyitni, vagy zárni, de nem nyitja/zárja). Egyébként rém egyszerű dologról van szó.
Három indikátort fogunk használni. Mielőtt azonban ténylegesen ismertetném a stratégiát szeretnék megosztani Veletek egy igen fontos dolgot.

A stratégiák megalkotásakor sokan vagyunk hajlamosak arra, hogy a beépített indikátorok és a tanult indikátorok alapján találjuk ki, hogy mikor nyitunk pozíciót és mikor zárjuk azt.
A probléma abból adódik, hogy ezek az általánosan ismert és a kereskedési platformokba beépített indikátorok még akkor születtek, amikor a számítástechnika gyerekcipőben járt, ezért nagyon általános információkat szolgáltatnak. Kézi kereskedéshez jók, ha az ember látja a chart-ot, mert akkor tudja, hogy most éppen oldalaz a piac, fölösleges hinni az ADX-nek. De egy automata program nem "látja" a chart-ot és akkor is pozícióba fog lépni, amikor oldalazás van.

Ez egyébként az automatikus programok egyik rákfenéje is, vagy ha úgy tetszik a Szent Grálja. Ha a program képes "rájönni" arra, hogy mikor van oldalazás, akkor nem fog pozícióba lépni az indikátorok jelzésére, ha pedig elindul a trend, akkor meg tök mindegy melyik klasszikus indikátort használod, akkor is nyerni fogsz, csak a nyereség nagysága különbözik. Ilyenkor az RSI, az ADX, a Stochastic, vagy bármi más igazat mond, köthetsz. De ha oldalazik az árfolyam, akkor is jelet fognak adni ezek az indikátorok, így becsapod magad és a spread miatt, meg a folyamatos zavar miatt elveszíted a fáradtságosan megkeresett pénzedet...

Nem szabad elfelejteni, hogy általános érvényű az a szabály, hogy a piac 70%-ban oldalazik és mindössze 30%-ban mozog trendszerűen!!! Ezt nagyon komolyan kell venni!

(Csak zárojelben jegyezném meg, hogy a másik megoldás az agresszív stratégia, de ez nagyon veszélyes. Ez tulajdonképpen olyan, mint a sörétes puska, mindenre lő, ami a grafikonon van, ráadásul hatalmas lot méretekkel (akár 6 lot is lehet), amit egy-két gyertya után be is zár. Ehhez azonban nagy tőke kell, még okosabb indikátorok és hihetetlen bátorság! Ezzel nem is fogunk foglalkozni, mert a mi szintünkön ez még annyira durva, hogy jobb, ha félünk tőle. Akinél dolgozik a tőzsdepszichológia, annál néhány óra alatt lenullázott számlát jelent ez a fajta kereskedés! Mivel nagy tőkéről van szó, a veszteség is nagy!!! Mindenkit óvva intenék ettől!!!)

Tehát, a hagyományos indikátorokat gyakorlatilag el is felejthetjük. Az említett három indikátorból kettőt használunk a pozíció megnyitására, a harmadikat (ami egyébként egy beépített indikátor lesz), pedig a SL húzásra használunk.
A stratégiánk is erre alapul, nincs TP, viszont van SL, RR nem számítható (itt a rizikó), viszont követő stop-okat húzunk, amit aztán az árfolyam kiüt. Tehát konkrét pozíció zárás sem lesz a stratégiában, hanem a SL-ra bízzuk a zárást. Attól a pillanattól kezdve, amikor a SL vonala a pozíció nyitás fölött lesz, már nyereséges a pozíció zárása, illetve jelen esetben a "kistoppolódása".

Tehát két olyan indikátort fogunk használni, melyek nincsenek beépítve a Metatrader-be, erről volt szó.
Az egyik egy - egyébként meglehetősen jól ismert - mások által sűrűn használt indikátor, a TVI.
A TVI, azaz a Trend Volume Index az OBV (On Balance Volume) indikátor továbbfejlesztett változata.
Az OBV nem használható eredményesen napközben, ellenben a TVI-t erre találták ki.

Bár minden tőzsdeiskolában azt tanítják, hogy a deviza kereskedésnél a forgalom értékeket nem szabad figyelembe venni, mert azok hamis adatok, ennek ellenére a Metatrader-ben a forgalmi információk megbízhatók, így nyugodtan használhatjuk a részvény kereskedésnél megszokott indikátorainkat, melyek a forgalmi adatokat is felhasználják. A TVI is ilyen indikátor. A forgalmi adatok és a Bid, Ask árak figyelembe vételével számol ki egy úgynevezett biztonsági mutatót, amely a vásárlás, vagy az eladás biztonságosságát hivatott mutatni egy görbe formájában a chart-on. Ráadásul nem követő indikátor, mert a forgalmi adatok jól mutatják meg egy árfolyam mozgás esetében, hogy mikor fárad ki a trend, vagy mikor tör ki az árfolyam.

A másik indikátor egy igen furfangos indikátor, a CCI (Common Channel Index) és az ATR (Average True Range) indikátorokat használja trend meghatározásra. A CCI önmagában is igen jól használható indikátor, különösképpen, ha a középvonal átlépést vizsgáljuk elég jól meg tudjuk mondani, hogy merre indul a trend, de sajnos igen "izgága" indikátor, ezért oldalazásban becsaphat bennünket. Az indikátorunk, amelyről szó van, az ATR-rel szelídíti meg a CCI mozgását, egy igen ügyes technikával. Így egy sokkal kevésbé ugráló vonalat kapunk, ráadásul mindezt a chart-on, tehát nem különálló ablakban. Ez az indikátor a TrendMagic.

E két indikátor jelzéseit fogjuk figyelni, hogy éppen mikor merre mozdul el, amikor pedig mindkét indikátor ugyanazt mutatja, akkor pozícióba lépünk a mutatott iránynak megfelelően.

A kilépésekkel és a SL-al nem sokat fogunk törődni, hanem a Parabolic SAR indikátor megfelelően paraméterezett változatával határozzuk meg a stop-okat, amelyet minden egyes gyertyánál módosítunk, így amikor elindul a trend, akkor egyszerűen követjük azt, amikor pedig megfordul, akkor a SL kilépteti pozíciót, és meg is kaptuk a pozíció nyereségét.
Ugyancsak eme indikátor miatt nem fogunk TP-t sem számolgatni, de aki szeretne majd, beállíthat TP-t. Ez esetben a hosszabb trendeket nem lehet majd maximális profittal kihasználni, de a semminél mindenképpen több lesz a nyereség, és ami fontos : biztos nyereség lesz.

Amire majd a fejlesztés során megoldást kell találnunk, az az oldalazásban történő pozíció nyitás kivédése, itt ugyanis kapunk majd jelet, de sajnos olyan rövidek a lokális trendek, hogy a spread és a SL miatt szinte semmi hasznunk nem marad, sőt, inkább veszteséges pozíció zárások történnek. De erre is van recept!

A következő post-ban összerakunk egy kódot, amit majd tesztelgetni fogunk mindenféle beállításokkal.

Kezdjünk programozni

2010-06-18T21:09:00.007+02:00

Átesett a blog némi ráncfelvarráson, mert elég lehangoló volt az egész, de talán most kicsit motiválóbb lesz, és Nektek is tetszeni fog.

Mostantól megpróbálok kicsit sűrűbben írni a blogba, mert a program írása közben is szeretném, ha tudnátok követni.
A következőkben írunk egy programot, amely kereskedni fog, méghozzá nyereségesen.
Megtanulunk egyszerűbb fogásokat, illetve olyan segédeszközöket készítünk - mellék termékként -, melyek a kézi kereskedésben is a segítségükre lehet. Kitalálunk egy jó kis Money Management stratégiát és tesztelünk, javítunk, okoskodunk és győzünk! Mert hát erről szól az egész! Nem?

Azt hiszem, hogy eleget filozofáltunk, el kellene kezdeni programozni.
Csapjunk a közepébe!

Hogy értsük is, hogy mit csinálunk, némi magyarázat előzetesen arról, amit csinálni fogunk.

A MetaTrader-ben alapvetően 6 különböző programfájlt készíthetünk, ebből 3 különféle van, ami futtatható programként viselkedik.
Mivel eleinte csak alap dolgokat fogunk csinálni, így nem tárgyaljuk egyenlőre a nem futtatható kódokat, koncentrálunk a futtatható kódokra!

FIGYELEM! Az itt leírt kódok működéséért, azok éles számlán való futtatásáért ezen blog írója nem vállal felelősséget! Bárki, aki követi az utasításokat, csakis kizárólag a saját felelősségére tegye! Éles számlán történő futtatása a tőke elvesztésével járhat! A leírt kódok kizárólag oktatási célokat szolgálnak.

A MetaTrader-ben 3 féle futtatható kódot írhatunk (kódnak nevezzük a program szövegét, az ember számára olvasható kódot, melyet le kell fordítanunk futtatható programmá, azaz a gép számára olvasható kóddá. Szokás forráskódnak is nevezni, mivel ez lesz a futó program forrása.) :

Script : ezek olyan nagyon egyszerű programok, melyek egyetlen egyszer futnak le. Azután a program végrehajtásnak vége szakad.
Indicator : ezek a kódok speciális programok, amelyek a chart-on indikátorként viselkednek. Meglehetősen bonyolult a programozása, ez később fogjuk tárgyalni, de tárgyaljuk mindenképpen, mert igen fontos. Az indikátorok eredményeit - akárcsak a beépített indikátorok eredményeit - fel tudjuk használni a kereskedő programjainkban, hogy döntéseket tudjunk hozni. De manuális kereskedésben is használhatjuk. Az indikátorokban nem használhatjuk a kereskedéssel kapcsolatos utasításokat.
Expert Advisor : ezek az igazi kereskedő programok, ezek képezik az automatikus kereskedés gerincét. Egy chart-on csak egy futhat, és nem több! De a jó hír az, hogy több chart is nyitva lehet egyszerre...

Miután az automata kereskedéshez Expert Advisor-t (mostantól egyszerűen csak EA-t) kell futtatnunk, így ezzel folytatjuk, később pedig elkészítjük első indikátorunkat, menet közben pedig script írási tudásunkat is csiszolgatjuk.

Egy EA ugyanúgy működik, mint egy klasszikus program. Bemenete és kimenete van. Bemenete a különböző paraméterek, melyekkel beállítjuk a programunk működését, kimenete pedig a megkeresett (rossz esetben az elveszített) pénz.

Amikor egy EA-t szeretnénk futtatni, akkor hozzá kell csatolnunk egy chart-hoz. Kétféleképpen tehetjük ezt meg, az egyik az, hogy egérrel megfogjuk a bal oldali listából és ráhúzzuk a chart-ra.
A másik megoldás pedig az, hogy az EA-n nyomunk egy jobb egér gombot, és a "Chart-hoz csatol" menüpontot választjuk a felugró menüből.

Ekkor felugrik egy ablak, ahol be tudjuk állítani az EA bemeneti paramétereit, illetve a futtatásához szükséges egyéb paramétereket.

Próbáld csak ki. Ott a "Moving Average" EA az "Expert Advisor" lenyíló listában a Navigáció ablakban.
Ha ráhúzod a chart-ra, akkor máris ott az ablak. Két fül van, az "Általános" és a "Bemenő adatok".

Az "Általános" fülön néhány nagyon fontos beállítás van. Keretekre van osztva, melyek a következők:

Általános :

Long & Short pozíciók : itt szabályozhatod, hogy long (vásárlás), vagy short (eladás) illetve mindkettőt engedélyezed a program futása során. Függetlenül attól, hogy mit írtál a programodban, itt felülbírálhatod!
Riasztások : ezekkel nem kell most foglalkoznunk, ahogy van, úgy jó

Élő kereskedés :

Élő kereskedés engedélyezése : itt mondhatod meg, hogy a programod végezhet-e élő kereskedést. Ha demó számlával tesztelgetsz, akkor a demó számlán fog "éles" kereskedéseket végezni azzal a pénzzel, amit a demó számlára kaptál. a viszont élő, azaz valódi pénzzel rendelkező számlád van, akkor a TE pénzeddel kereskedik!
Kézi megerősítés kérése : Ha nem vagyunk biztosak a programunk sikerében, akkor bepipálhatjuk, ekkor minden kötés előtt kézzel meg kell erősíteni, hogy mehet a pozíció nyitás. Ezzel persze elveszítjük az automatizáltságod, de legalább a mi döntésünk is benne van...

Biztonság :

Itt mindenféle rejtélyes dolgot lehet beállítani, hagyjuk úgy, ahogy van, nem érdekes most a beállítás.

A "Bemenő adatok" fülön pedig a programunk paraméterei vannak, ha a "Moving Average" EA-t húztad a grafikonra, akkor "Lots", "MaximumRisk" és ehhez hasonlókat látsz.

Mielőtt azonban futtatni kezdenénk bámilyen EA-t, legelőször is szedjük ízeire, vesézzük ki!

Ha a "Moving Average" EA-t kiválasztjuk a listában és nyomunk egy jobb egérgombot rajta, akkor a felugró menüből válasszuk ki a "Módosítás" menüpontot.
Ekkor a program megnyitja a MetaEditor nevű programot, amellyel a programjainak fogjuk szerkesztgetni ezentúl.

Ez egy tökéletes környezet a programjaink fejlesztéséhez, mert egy kódszerkesztőt, fordítót és súgót is magában foglaló rendszert ad a kezünkbe, amellyel igen hatékonyan lehet programot írni.

Ha minden jól megy, akkor láthatjuk a Moving Average.mq4 forráskódját, azaz magát az olvasható programot. A forráskódok fájl kiterjesztése mindig mq4, a lefordított program neve ugyanaz marad, de a kiterjesztése ex4 lesz.

Ha jól megfigyeljük, akkor a program kódja a következő részekből áll :

fejléc
init() függvény
start() függvény
deinit() függvény
egyéb függvények

A fejlécet mindjárt kitárgyaljuk, most legelőször a következő részek lényegét kell megértenünk.
Az init() függyvény a programunk indulásakor fut le, egyetlen egyszer. Egész konkrétan akkor fut le, amikor a paraméter ablak bezárul egy OK-val.

Ennek a fügvénynek a párja a deinit() függvény, amely a program leállításakor, újraindításakor fut le egyetlen egyszer.

E két függvénnyel óvatosan kell bánnunk, mert ha a bróker, vagy a VPS szolgáltató (erről is részletesen beszélgetünk majd) újraindít egy karbantartás miatt, akkor ezek a függvények lefuthatnak és ha nincsenek jól megírva, akkor komoly problémákat okozhatnak.
A deinit() függvény például vizsgálhatja a program leállításának okát a UninitializeReason() függvény segítségével, hogy miért állt le a program.
Ezek az okok sokfélék lehetnek, amelyekre mindre másképpen reagálhat a programunk. Lássuk csak :

REASON_REMOVE - Az EA-t eltávolítottuk a chart-ról, ez ugye egyértelmű. Ez az EA-k klasszikus végrehajtás megszakítása.
REASON_RECOMPILE - Újrafordítottuk az EA-t. Ennek elvileg csak fejlesztés közben szabadba előfordulnia, egy éles környezetben ez nem fordulhat elő. A lényeg, hogyha egy EA-t újrafordítunk, legtöbbször az a célra vezető, ha eltávolítjuk a chart-ról és utána újra rádobjuk az egérrel, mert előfordulhat, hogy nem úgy működik egy újrafordítás után, ahogy azt elvárjuk és ahogy kellene. Ha levesszük a chart-ról az EA-t és újra rádobjuk, ezeket a problémákat a legtöbbször ki tudjuk kerülni, meg tudjuk oldani.
REASON_CHARTCHANGE - A chart megváltozott. Vagy egy másik instrumentum került rá, vagy az időtávot változtattuk meg. Ez igen fontos lehet, mert ha egy EA-t egy bizonyos instrumentumra, vagy időtávra optimalizáltuk, komoly veszteséget termelhet a program, ha megváltoznak a körülmények a chart-on.
REASON_CHARTCLOSE - bezártuk az aktuális chart-ot, természetesen ilyenkor meg kell szakítani a program működését, mivel nincs értelme tovább futnia. Ekkor kapjuk ezt a kódot, hogy tudjuk nem más okból jött létre a program megszakítás.
REASON_PARAMETERS - A futó EA-nak megváltoztattuk valamelyik paraméterét. Ez mindig hatással van az EA életére, ezért ez egy nagyon fontos jelzés. Ilyenkor ugyanis újraindul az EA az új paraméterekkel. Nagyon nagyon fontos ok, tehát erre komolyan oda kell figyelnünk, amikor írjuk az EA-t.
REASON_ACCOUNT - Megváltozott a számlaszám, amelyen a chart-okat megjelenítjük, illetve ahol az EA fut. Ez gondolom nem is kell magyaráznom, hogy miért és mennyire fontos. Ha a számlaszámunk megváltozik, akkor megváltozhatnak a pozíció nyitási feltételek, a tőke nagysága, és akár maga a bróker is lehet teljesen más. Tehát ne higgyük, hogy ez elhanyagolható tényező lenne.

Természetesen azok az EA-k, melyek ezekkel a kódokkal törődnek, már nagyon profi programok, egyenlőre nem is fogunk ilyen programokat írni, esetleg nagyon elvétve foglalkozunk ezekkel a paraméterekkel.
Amivel legelőször foglalkozunk, az leginkább a jó stratégia kialakítása és leprogramozása, hogy nyereséget érjünk el. Hiszen ezért csináljuk az egészet.

A legfontosabb része a programunknak a start() függvény. Itt történik minden (legalábbis a dolgok 99%-a), ami a stratégiánk működését képviseli, illetve ami a kereskedéseinket illeti.
Ezt a függvény a MetaTrader minden egyes tick beérkezésekor lefuttatja egyszer. (azt ugye nem kell megmagyaráznom, hogy a tick az az esemény, amikor valamilyen tranzakció történik a piacon az adott instrumentummal, amely árváltozást okoz. Minden időtávon ugyanakkor érkeznek a tick-ek.)

Abban a pillanatban, amikor érkezik egy tick, a start() függvényünk lefut és vagy történik valami közben, vagy nem. Vagy pozíciót nyitunk, vagy nem. Vagy lezárjuk azt, vagy nem. Tulajdonképpen az egész stratégiánkat itt kódoljuk le. Ez a leglényegesebb része a programunknak. Éppen ezért, ha bármikor is az EA törzsére, vagy a futó kódra célozgatunk ebben a blogban, akkor erre a függvényre kell gondolnunk elsősorban.

A fejléc is igen fontos része a programunknak, mert bizony a fejlécben rengeteg maradandó tulajdonságát határozzuk meg az EA-nak. A fejlécünk tovább tagolódik, ennek megfelelően a következőket találjuk itt :

A program információs része, itt kommentek formájában tárolhatjuk a forráskódunkban a program nevét, verzióját, az esetleges tovább fejlesztési ötleteinket, és szinte bármit, amit csak akarunk.
Fordítási direktívákat, vagyis megmondhatjuk a fordító programnak, hogy amikor lefordítja a forráskódunkat a gép számára értelmes kóddá, akkor azt milyen egyéb feltételekkel hajtsa végre. Olyanokra kell itt gondolni, mint pl. a végleges kódba fixen beégetett információk (copyright infók, a szerző elérhetőségei link formájában, stb.), vagy a jó kis függvény könyvtárunkat is használja, vagy azt, hogy megmutassa-e a felhasznált indikátorokat, stb. Ezekkel meg fogunk ismerkedni hamarosan, mert minden programban szükség van ezekre. Nem túl bonyolult, nem kell megijedni tőle. Szeretetre méltó kis okosságok ezek.
Include-ok, melyek egy nem futtatható forráskódot illesztenek be a programunkba. Erről később beszélünk majd, a komolyabb fejlesztések során vesszük hasznát, kezdéshez egyáltalán nem foglalkozunk velük, vagy csak érintőlegesen.
Az úgynevezett extern változók, melyek tulajdonképpen a programunk bemenő adatainak való változók definíciói. Ez jelenti a programunk kapcsolatát a külvilággal.
Globális változók, melyeket egy programozással foglalkozó fejlesztőnek talán nem kell bemutatni. Azokról a változókról van szó, melyeket minden függvényünk, és maga a program törzse (start() függvény) is lát, írhatja, olvashatja.
Konstansok, melyek a teljes EA-ra vonatkoznak, tulajdonképpen olyan változók, melyek értékeit nem lehet megváltoztatni. Ezek leginkább a forráskód olvashatóságát javítják.

Az egyéb függvények azok a függvények, melyeket a start() függvényből hívunk meg és a program végrehajtás folyamán fontos tevékenységet végző program modulok, egységek. Ezt szinte mindig használni fogjuk. Ez nagyon fontos része lesz a programunknak. Már-már haladó szint, de mivel nélkülözhetetlen, fontos dolog.

Következő bejegyzés alkalmával már részletesebben kitárgyaljuk a megvalósítandó stratégiát, a pozíció nyitását és zárását, illetve belekóstolunk egy kicsit a Money Management-be is.
Szóval nekiesünk a kódolásnak!

Money Management általában

2010-05-20T06:34:00.006+02:00

Beszéljünk kicsit a Money Management-ről (mostantól MM)!

Nem véletlenül írok erről a témáról, ugyanis fájó tapasztalataim vannak. Nem viccelek!
Hogyha egy kicsit alaposabban végig gondoljuk azt, hogy miből is áll egy tőzsdéző (FOREX-ező, de ez most szinte mindegy) kereskedési gyakorlata, akkor azt fogjuk tapasztalni, hogy hűen igazodik az öt legfontosabb szabályhoz :

Keress több pénzt
Védd meg a pénzedet
Tervezd meg pénzügyeidet
Érj el hatástöbbszörözést
Javítsd pénzügyi tájékozottságodat

Nem egyedül találtam ki ezeket a szabályokat, sőt mi több, semmi közöm hozzá. Robert T. Kiyosaki "Fejleszd pénzügyi IQ-dat" c. könyve taglalja eme szabályokat.

(Aki esetleg nem tudná ki is ő, azoknak nagyon ajánlom, hogy nézzen utána. Kötelező olvasmány a "Gazdag papa, szegény papa", a "Cashflow négyszög" c. könyvei, az összes többi pedig ajánlott olvasmány!!! Komolyan mondom, hogy ezen könyvek nélkül SENKI ne nyisson éles számlát, különben el fog vérezni!!!)

Nézzük csak FOREX-re fordítva a dolgokat :

Keress több pénzt = legyen egy remek stratégiád, ami nyereséges, kicsi a drawdown (a veszteséges pozíció zárásokból adódó "visszaesések")
Védd meg a pénzedet = használj stop-loss-t (ez ugye mindenkinek a könyökén jön ki, mert minden oktató, könyv, szakember ezt szajkózza folyton), de ide tartozik az is, hogy válassz jó brókert, ahol nincs kötési jutalék, alacsonyak a kamatok, megfelelően jó méretű pozíciókat lehet felvenni és persze kevés pénzzel lehet indulni, ez volt az egyik alapkövetelmény, amiért elindult ez a blog...
Tervezd meg a pénzügyeidet = ha fogalmad sincs, hogy a stratégiáddal mennyi pénzt tudsz keresni, akkor ehhez a ponthoz hozzá sem tudsz szólni. Pedig fontos! Igaz, hogy a tőzsdén bármi megtörténhet, de akkor is kell, hogy legyen egy terved! Meg kell fogalmaznod, le kell írnod és szem előtt kell tartanod! Milyen egy terv nekünk FOREX-ezőknek? Hát mondjuk olyan, hogy "havi 5% nyereség elérése, maximum 10 PIP drawdown-nal". Merészebbeknek : "napi 1,5% nyereség elérése, havi szinten maximum 1% veszteséggel". Még merészebbeknek : "Egy év alatt megduplázom a befektetett tőkémet"
Érj el hatás többszörözést = akár a stratégiáddal, akár a pénzügyi tervezéseddel azt kell elérned, hogy a befektetett tőkéd egyre nagyobb és nagyobb legyen! Ezt a stratégiáddal úgy tudod elérni, hogyha a kötéseid ún. piramidális kötések. Utálom ezt a szót, de nincs jobb. Ez nagyjából annyit jelent, hogy a stratégiád nyit egy pozíciót, amelyet természetesen valamilyen jelre teszi, majd a már nyitott pozíció mellé egy ugyanolyan irányú újabb pozíciót nyit a következő jelre, és ezt egészen addig teszi, amíg mondjuk a trend egy irányba mozog. Amikor ki kell szállni, mert megfordul a trend, vagy oldalazik, akkor lesz tizenöt nyitott pozíciód, amelyek vagy mind nyereségesek, vagy legfeljebb kettő veszteséges, de a többi nyeresége bőségesen fedezi a veszteségeket. A pénzügyi tervezés maximum annyi lehet, hogy nem veszed ki havonta, vagy hetente a nyereségedet, így a stratégiád egyre többet és egyre nagyobb pozíciókat tud nyitni.
Javítsd pénzügyi tájékozottságodat = ezt gondolom felesleges taglalni, fontos, hogy más "rokon" devizapárokat is figyelj (mondjuk EURJPY esetén a többi EURXXX és más XXXJPY devizapárokat), de az is lényeges lehet, hogy figyeled a híreket. Ami még ennél is fontosabb, folyamatosan tapasztalatokat gyűjtesz és képzed magad a FOREX-en történő kereskedéssel kapcsolatban!

Most ugye a 2. pontról beszélgetnénk, az 1. pontot szándékosan nem tárgyaltam eddig. Azt fogom legutoljára.
De mind fontos és mind része a jó FOREX robotnak.

Az MT4-ben (vagy nem sokára za MT5-ben) az MM nagyon jól leprogramozható. A számlád információit csodás függvényekkel lehet lekérdezni, a korábban már említett paraméterekkel együtt.
Nézzük csak!

AccountBalance() --> Ez a függvény az éppen aktuális egyenlegről tájékoztat. Arról a pénzről, ami már a Tiéd, amit befektethetsz, vagy visszautalhatsz magadnak, vagyis a számládon lévő tényleges pénz.
AccountEquity() --> a számlán lévő pénz, + a nyitott pozíciók értéke. Mindenképpen pozitív érték kell legyen a kettő együtt. Ha a nyitott pozíciók értéke negatív, akkor a balance-nál mindenképpen kevesebb lesz, ha pozitív a nyitott pozíciók értéke, akkor több lesz a balance-nál. Ha viszont a nyitott pozíciók nagyon negatív értéket kezdenek felvenni, akkor a bizonyos equity értéknél a bróker cég bármikor dönthet a margin call végrehajtásáról, vagyis bezárja a pozícióidat és marad a számlán annyi, amennyi. Ezért fontos, hogy a balance jó nagy legyen, a kötés mérete pedig minél kisebb, hogy minél később jöjjön a margin call...
AccountFreeMargin() --> a még szabadon beköthető tőke mennyisége
AccountLeverage() --> A számlán lévő tőkeáttét nagysága. Ha azt adja vissza, hogy 100, akkor az azt jelenti, hogy az áttét 1:100.
AccountMargin() --> A bekötött tőke nagysága. Ez csupán annyit jelent, hogy mennyit költöttünk az aktuális pozíció megnyitására.
MarketInfo() --> Ennek a függvénynek igen sokféle funciója van, elsősorban a jelenleg is nyitva lévő chart-ról ad információkat. Két paramétere van, az első az aktuális instrumentum neve, a második pedig a megtudakolni kívánt információra vonatkozó azonosító.
A legfontosabbak :
MODE_DIGITS --> Az intrumentum árának tizedes pont utáni számjagyeinek száma. Ez igen fontos, amikor PIP-eket szeretnénk számolni!
MODE_SPREAD --> a jelenlegi spread mérete PIP-ekben. Ez ugye változhat (bár vannak brókerek, akik azt hirdetik magukról, hogy fix spread-ekkel dolgoznak), de két különféle instrumentumnak általában azért különbözik a spread-je.
MODE_STOPLEVEL --> sok brókernél korlátozzák a stop szinteket, vagyis megmondják, hogy mi az a minimális PIP, ahová a stop-odat teheted. Tehát nem teheted a kötési ár alá 5 PIP-el, ha ez az érték 20-at ad vissza. Ebben az esetben a minimális stop húzás az aktuális ár alatt 20 PIP-el van.
MODE_LOTSIZE --> ez azt mondja meg, hogy az aktuális instrumentum esetében mi a lot mérete. Ez a bázis valuta egységeiben értendő. Ez természetesen függ a tőkeáttéttől is! A tőkeáttéttel, valamint ezzel az értékkel lehet kiszámítani a bekötött tőke mennyiségét, ami ha minden igaz, akkor megegyezik a korábban már említett AccountMargin() függvény által kiszámított értékkel. (természetesen csak akkor, ha a kötés árával számolunk és nem a pillanatnyi árral!!!)
MODE_MINLOT --> A pozíció nyitásához szükséges minimális lot mérete! Ez az egyik legfontosabb és az egyik legmeghatározóbb érték, ami az adott instrumentum kereskedéséhez kell. Brókere válogatja, hogy ez mennyi! Általában a demó számlán egészen kicsi, de az éles számlán már nagyobb (beetetés). Szóval ne csodálkozzunk, ha a demón jól működő programunk az élesen "túlkereskedi" a számlánkat. (persze ilyen egy jó MM-mel nem fordulhat elő...)
MODE_LOTSTEP --> A már meglévő pozíció módosításához használható lot méret. Vagyis, ah rákötünk, esetleg a pozíciót részlegesen zárjuk, akkor mi az a lot méret, amivel ezt megtehetjük. Ez sokszor kisebb, jó esetben egyenlő az előző értékkel (MINLOT).
MODE_MAXLOT --> a kereskedés folyamán nyitható lot-ok együttes száma ezt nem lépheti túl. Többnyire mikró számlákon van ilyen, amikor a minimális lot méret mondjuk 0.05, akkor ez az érték 2 lot szokott lenni. Vagyik addig nyitogathatunk pozíciókat, amíg a nyitott pozíciók lot számának összege el nem éri ezt az értéket. Tehát a példával élve, ha minden pozíciónkat 0.05 lot-tal nyitjuk meg - és nem változtatjuk később -, akkor összesen 40 ilyen pozíciót lehet nyitni.

Nos, nagyjából ennyit érdemes tudni ezekről a függvényekről, később, amikor használjuk őket, úgyis kivesézzük tövéről-hegyére.

Jó olvasgatást mindenkinek!

Hosszú idő után...

2010-05-18T10:52:00.002+02:00

Nagyon régen írtam már a blogba, kaptam is néhány aggódó levelet, hogy mi lett a bloggal, hogy nem folytatom.

Nos, egy pici "off-topic" következik, akit nem érdekel, bátran hagyja ki.
Néhány magánéleti esemény változtatott rajtam igen sokat. Először is, rájöttem arra, hogy bár az ember társas lény, néha azért jó egyedül. De ennek is meg vannak a hátrányai. Néha baromi unalmas.
Másodszor egy igen keserű tapasztalattal lettem gazdagabb. Nem az számít, hogy mi mindent érünk el az életben, vagy az, hogy mennyi a magántulajdonunkban lévő ingóság, vagy ingatlan. Az számít, hány embert teszünk boldoggá, illetve hány ember élete lesz jobb általunk. Mennyien szeretnek... Na, de elég a filozófiából!
Off-topic vége.

Sokan kérdezték, mire jutottam a metával.
Sokra. Magam sem gondoltam volna milyen sokra. Attól tartok, nehéz lenne egyetlen bejegyzésbe sűríteni, úgyhogy majd szép apránként próbálom meg adagolni.

Nos, az egyik legjobb tapasztalatom a metával kapcsolatban, hogy nagyon fontos a jó bróker kiválasztása. Bármilyen hihetetlen, ez fontosabb lehet, mint maga a robot, amit leprogramozunk.
Hiába van egy nagyon jó robotunk, ha a számlánkat nem tudtuk megnyitni úgy, hogy megfelelően kis lot-okkal kereskedjünk, akkor elúszhat a számlánk. Sajnos számolnunk kell azzal, hogy az aktuális pozíciónk veszteséget is termelhet, bár a piac mindig megfordulhat, de negatív előjelű pozíciónkat ki kell bírja a számla.

Tudom, kicsit bonyolult, megpróbálom egy példával illusztrálni.
Adott egy számla, mondjuk 500 USD tőkével. A legkisebb pozíció, melyet nyithatunk, 0.1 lot. Ha elindul az ár a pozíciónkkal szemben (értsd: short-olsz, de az árak hirtelen nőni kezdenek). 500 dolláros számla és 1:100-as tőkeáttétel esetén 1 lot 100 000 egységet jelent. 1,5 dolláros EURUSD árfolyamnál ez azt jelenti, hogy a bekötött tőkénk minden egyes centnyi elmozdulásakor 10 dollárt mozog a nyitott pozíció értéke. 5 cent elmozdulás 50 dollárt jelent. Nem nehéz kitalálni, hogy 50 cent ellenirányú mozgás esetén el is fogy az 500 dolláros tőkénk és már jön is a margin call, a számlánk pedig nullán áll.

Ezzel szemben, ha a minimális pozíció nyitási lehetőség 0.01 lot, akkor a pénzbeli elmozdulások néhány dollárra rúgnak csak. Kisebbek a nyereségek, az igaz, de a számlánk lenullázásnak az esélye is kisebb.

Néhány FOREX bróker ezen a linken található : EarnForex.com
Aki tud angolul, annak könnyű lesz választani, bár sokat meg kell nézni ahhoz, hogy megtaláljuk a megfelelőt.
Amire nagyon figyeljünk, azok a következő kulcsszavak : commission, swap, minimum lot size, minimum deposit.

Az az ideális, ha commission nincs, tehát nem kérnek a pozíció nyitásokért külön pénzt. A másik nem nagyon figyelmen kívül hagyható tényező a swap, tehát a nyitott pozíciók után fizetett (vagy jó esetben kapott) kamat. Ha egyáltalán nincs, az a legjobb, de általában nem tudjuk elkerülni.

A következő két paraméter a minimum lot size, amiről már írtam, hogy jobb, ha minél kisebb, különösen, ha kicsi a kezdőtőkénk. az arányok nagyjából 500 dollár esetén 0.01 lot. Ettől csak jobbat keressünk, tehát ha 1000 dollárra jut 0.01 lot, az a legjobb.

Mára ennyi. Legközelebb a money management-ről fogok írni, legalábbis remélem. Lehet változik a koncepció, de majd meglátjuk. Az egyik legfontosabb dolog lesz az MM is!

Ninják helyett Szakértő Tanácsadók

2009-10-07T09:14:00.003+02:00

Sajnos nagyon régóta nem sikerült a blogba írnom egyetlen sort sem.
Most azonban igyekszem tovább folytatni a blog írását, mert úgy gondolom, hogy minden kisbefektetőnek joga van ahhoz, hogy sikeres nagybefektetővé váljon.

Ami a NinjaTrader-t illeti, sajnos nagyon komoly nehézségekbe ütköztem. Rögtön mindjárt a historikus adatok kinyerése a szerverekből. Ez ugye azért problematikus, mert ha nincsenek folyamatos adatok, akkor a backtest teljesen félrevezető lehet és nem jó értelembe véve.

A másik nagyon komoly hátrányossága, hogy nem kezeli a számlán lévő tőkét, de még csak eljárások sincsenek definiálva arra, hogy kezelni, lekérdezni lehessen.

További hátránya, hogy a stratégia leállításakor az összes nyitott pozíciót azonnal lezárja, függetlenül attól, hogy pozitív, avagy negatív a profitja.

Leginkább azonban a fejlesztéshez nélkülözhetetlen historikus adatok adták meg a kegyelem döfést. Ha ugyanis néhány napig el sem indítjuk a programot, akkor a hiányzó adatokat nem pótolja a program, hanem a grafikont ott folytatja, ahol abbahagyta. így az a néhány napi adat hiányzik, jó nagy rést hagyva a gyertyák között. Ez olyan szinten hamisítja meg a backtest eredményeit, hogy képtelenség két egyforma backtest-et generálni két különféle gépen.

Így hát felhagytam a NinjaTrader programozásával és másik platformot voltam kénytelen keresni.

Sokáig nem is kellett keresgélnem, mert megtaláltam azt a platformot, amit a legtöbb automata trader fejlesztő cég használ, ez pedig a MetaTrader.

A program nyelvezete jóval bonyolultabb - amolyan igazi programozós, kódolós -, viszont sokkal megbízhatóbb működésű platform, amit még kézi kereskedésre is lehet használni.

Fontos megemlíteni, hogy van magyarnyelvű felülete, ami viszont nem terjed ki a programozási felületre (MetaEditor), az sajnos angol maradt, bár a programozók ennek inkább örülni szoktak. A programozás nyelve az angol...

Hátránya még - a bonyolultabb nyelvezet miatt -, hogy a köthető devizapárok, részvények és CFD-k száma a brókercégek kínálatától függenek, ami általában nem sok, néhány főbb papírokra, devizapárokra szűkülnek. Itt azonban igen fontos megemlíteni, hogy nagyon sok - és ezt tényleg így kell érteni - nagyon sok brókercéggel van kapcsolatban a MetaQuotes, így gyakorlatilag amivel kereskedni szeretnénk, azzal tudunk kereskedni (van ahol nemesfémekkel, olajjal is!!!)

Ami viszont óriási előnye, hogy helyesen kezeli a historikus adatokat, a hiányzó adatokat automatikusan letölti a szerverről, remekül lehet benne kezelni a számlát, egyszerre egy irányba bármennyi kötést enged - természetesen a tőke erejéig -, a program leállítása után a nyitott pozíciókat ott hagyja, így azután az ember azt csinál velük, amit csak akar.

További óriási előnye még, hogy nem csak a program indításakor lehet paraméterezni, hanem a már futó programnak is meg lehet változtatni a paramétereit, menet közben. Így nem kell leállítani és újra elindítani a programot, illetve be lehet építeni a programba olyan funkciókat, melyeket ki- és be lehet kapcsolni menet közben.
Ez például arra is jó lehet, hogyha le akarjuk állítani a programot, akkor "kikapcsoljuk" a pozíció nyitásokat és csak a meglévő pozíciók ellenőrzött bezárásaival foglalkozik a program.

A programba épített súgó nagyszerű, valódi helyzetérzékeny súgó, tehát azonnal segítséget kapunk a program írása közben, ami egy ilyen bonyolult nyelvezet esetén nagyon fontos.

Másik érdekesség, amit eleinte hátránynak, később inkább előnynek tituláltam, az az, hogy a program minden tick-re lefut, így egy gyertyán belül több kötés is létrejöhet, több különböző áron - függően a pillanatnyi ártól.
Természetesen 4 sor beiktatásával megoldható, hogy minden gyertya befejezésekor fusson csak le a program, de nem ez az alapértelmezett.

Érdekes módon nem csak a számláról lehet információkat kinyerni, hanem a brókercégről is, a nevén kívül például azt, hogy mi az a minimális távolság, ahová engedi a stop-ok és a take profit-ok behúzását, de akár a spread-et is.

Sajnos a chart-ra rajzolni jóval zűrösebb, sok utasítással és igen bonyolultan lehet csak. Viszont ki lehet íratni a bal felső sarokba néhány fontos - általunk megválasztott - információt, ami mindig látszik - például mondjuk az egyenleget.

Az árak vizsgálatához és úgy egyébként bármilyen gyertyával foglalkozó eljárásnak meg lehet mondani, hogy milyen időtávon működjön, és akár azt is, hogy melyik instrumentumon, függetlenül attól, hogy a chart-on mit látunk. Hogy ez mire jó?
Például arra, hogyha az egyik devizapár hamarabb reagál a délutáni hírekre, mint a másik, akkor a másik chart-ján már lehet sejteni, hogy mi következik és már lehet is nyitni a pozíciót, mielőtt még jel alakulna ki.

Érdemes megemlíteni azt is, hogy a nyitott pozíciókkal egyenként kell foglalkozni a programban, tehát erre ki kell alakítani a megfelelő technikát a programozás során, de ez inkább előny, mint hátrány, ugyanis a tömeges pozíció kezelés legtöbbször veszteségeket szül.

Fantasztikus lehetőség az is, hogy ugyanazt a programot több chart-on is lehet futtatni, mégsem kell aggodalmaskodni amiatt, hogy elfogy a tőke és szétforgácsolja a program, hiszen ugyanazt a számlát használja mindegyik chart, tehát ha több instrumentumon futtatjuk, akkor szépen megosztoznak a tőkén testvériesen.

Egész egyszerűen azt kell, hogy mondjam, hogy eddig a legjobban használható platform, mind fejlesztésre, mind futtatásra. Maga a program is sokkal kisebb (4MB szemben a NinjaTrader 20MB-jával szemben) a működésközbeni memória felhasználásáról nem is beszélve! Ez utóbbi azért fontos, mert távoli szerveren nem mindegy, hogy mekkkora memória felhasználása van egy ilyen rendszernek. Sok-sok költséget lehet megtakarítani azzal, ha kisebb távoli gépet kell bérelnünk.

A végkövetkezetés tehát az, hogy a MetaTrader az eddigi legjobb fejlesztői platform, amit természetesen ingyenesen és korlátlanul használhatunk automatikus programok fejlesztésére, élő, valóságos adatokkal, demó számlán, játékpénzzel. Ha pedig beérett a programunk, irány az éles számla.

A címért pedig magyarázattal tartozom, a MetaTrader-ben a kereskedésre alkalmas programokat Expert Advisor-nak, azaz szakértő tanácsadónak nevezik, innen a furfangos cím.

A következő bejegyzésben a MetaTrader (ezentúl MT-nek rövidítem) lehetőségeiről fogok kicsit bővebben írni, illetve elkezdünk programozni is.

Addig is, aki szeretné, töltse le a programot és ismerkedjen vele.

Alapvető gyertyák, és alakzatok felismerése

2009-06-30T08:25:00.015+02:00

A múlt héten azt ígértem, hogy néhány alapvető gyertya felismerését fogom leírni, illetve megismerjük a NinjaTrader-t a legalapvetőbb szinten.

Ne is vesztegessük az időt, csapjunk a lovak közé.

Kezdjük a NinjaTrader-rel, úgyis ebben fogunk fejleszteni. Legelső lépésként, aki még nem töltötte le, annak javaslom, töltse le a Free licences változatot, ami ingyenes, korlátlanul tesztelgethetünk benne, fejleszhetünk, az egyetlen, amit nem tehetünk, az az, hogy élesben kereskedjünk vele, még akkor sem, ha van érvényes számlánk hozzá.
Tehát irány a www.ninjatrader.com oldal, ahol legelőször be kell vallanunk, hogy mi már használtuk korábban, avagy újak vagyunk. Válasszuk azt, hogy újak vagyunk (> New Users — Register here:) és válaszoljunk a három kérdésre. Az egyetlen igazán fontos adat, az az email címünk, javaslom, hogy akinek még nincs, az készítsen egy Gmail-es fiókot, ugyanis ez igen gyors, 7GB tárolási lehetőség és számtalan hasznos funkciója van, amelyet egyébként is érdemes használnunk.
A többi adat teljesen érdektelen, bármit beírhatunk, a többit a lapon hagyjuk érintetlenül, kivéve az alsó három jelölő négyzetet, ahol mindent be kell jelölnünk. (I trade the following asset classes: ; Futures, Forex, Equities). Ezután a lap alján a Submit gomb megnyomásával a letöltő oldalra jutunk, ahol a legfelső Download linkre kattintva letölthető a program.

Ha jól adtuk meg az email címünket, akkor meg is kaptuk email-ben regisztrációs kódot, ami nélkül nem tudjuk telepíteni a programot.
Szóval akkor jöhet a telepítés, itt majd kéri a kulcsot, amit kimásolunk a kapott levélből és bemásoljuk az ablakba, ahol kéri.

Ha elindítjuk a programot, akkor a Control Center-ben találjuk magunkat, ez lesz a "főhadiszállásunk", minden fontos dolgot innen lehet elérni.

Egy tisztességes fejlesztői környezetben, kell hogy legyen egy programkód szerkesztő eszköz, egy fordító, amely az általunk szerkesztett kódot értelmezi, majd lefordítja a számítógép számára érthető nyelvre, szükség lesz egy hibakereső rendszerre, amellyel a futás közbeni hibákra deríthetünk fényt, illetve egy teszt környezetre, ahol kipróbálhatjuk a fejlesztett programunkat.

A program fejlesztés menete többnyire a következő lépésekből áll :

A programkód megszerkesztése. A programkódot "szaknyelven" forráskódnak hívják, ezentúl mi is ezt a terminológiát használjuk. Azért hívják forráskódnak, mert ez a forrása annak a programnak, amit futtatunk. Nyilvánvaló, hogy az ember számára leírt szavak, kódok, csak az ember számára olvashatóak, értermezhetőek. A számítógép számára csak betűk és számok sorozata, amit nem ért. A forráskód szerkesztését szokták "program írásnak" nevezni.
Fordítás. A forráskódot lefordítjuk a számítógép számára is érthető nyelvre, azaz gépi kódra. Ez a kód nekünk embereknek érthetetlen, ezért van szükség a "hídra" ember és gép között, ez a fordítóprogram. (csak halkan jegyzem meg a hardcore programozók kedvéért, hogy itt természetesen nem valódi gépi kódról van szó, hanem egy .NET kódról, ami a Windows .NET-et emuláló környezet számára értelmezhető, de a mi szempontunkból ez teljesen lényegtelen.)
Tesztelés. A megírt és lefordított programot lefuttatjuk a teszt környezetben és megnézzük, hogy a kívánt eredményt hozza-e, avagy sem.

Nem említettem a hibajavítást, mert ezt folyamatosan kell végeznünk a fejlesztés során. Többféle hibával fogunk találkozni, melyek fajtái elég jól körülhatárolhatók :

Szintaktikai hiba. Ezek a hibák - mint a neve is mutatja - egyszerű "nyelvtani" hibák az adott programnyelvben. Például a zárójelek hiánya, a kapcsos zárójelek hiánya, a sor végi pontos vesszők hiánya, esetleg hiányzó paraméterek, stb. Minden programnyelvnek adott a "nyelvtana", azaz a szintatktikája. Ezt nagy vonalakban meg kell tanulni, de nem a végletekig, hiszen ott a Súgó, a kézikönyv, amit bármikor megnézhetünk.
Fordítási hibák. No, ezek már keményebb problémák. Ezek a hibák összefüggésben lehetnek az adott programnyelv "nyelvtanával", de többnyire olyan hibákról van szó, ami elméletileg a szintaxisnak megfelel, de fordítás közben mégsem lehet értelmezni. Ilyen hibák lehetnek például azok, amikor egy egész típusú paraméter helyett mondjuk egy szöveges paramétert adunk meg. A szintaxis előírja, hogy kell az a paraméter, de az már csak fordítás közben derül ki, hogy nem jót adtunk meg.
Futási hibák. Ezek azok a hibák, amelyek a legtöbb bosszúságot okozzák. Ezeket igen nehéz felderíteni, aki használt már Windows-t, az már találkozott is ilyennel (Application error, vagy Vista-soknál Critical error feliratú ablak). A futási hibák általában a számítógép operációs rendszere és a lefordított program közötti "nézet eltérésekből" adódnak. Nem is mindig a programozó hibája, és legtöbbször javítani sem lehet, csak elkerülni. Legtöbbször a hibaüzenet még csak nem is utal a hiba valódi okára, ezért nehéz dió. Szerencsére viszonylag ritkán fordul elő, NinjaTrader-ben még eddig nem is találkoztam ilyesmivel, talán nálam tapasztaltabb programozók már igen.
Logikai hibák. Na, ezek a hibák valójában nem hibák. Kakukktojások. A program lefordul, működik jól, de mégsem azt csinálja, amit kellene, pedig elvileg jól megírtuk a forráskódot. Hát igen. Ez igazából a programozó észjárásának a hibája, ami leginkább az adott programozási nyelv megismerésével küszöbölhető ki. Ha valaki nem ismeri elég jól az adott nyelvet, akkor ilyen logikai hibákat igen szépen el lehet követni, aztán meg a programozó csak csodálkozik, hogy nem úgy működik a program, ahogy kellene. Ilyenkor szoktak születni az olyan kijelentések, hogy ez a programnyelv nem jó, nem jól működik, használhatatlan, stb. Megoldás : programnyelv ismeret, próbálgatás, tesztelés.

Bármilyen hihetetlen, a NinjaTrader-ben minden megtalálható, ami a sikeres fejlesztéshez szükséges. Mindjárt el is kezdjük a fejlesztést. De leges legelőször beállítjuk magunknak a környezetet, amiben dolgozni fogunk.

Mivel szinte minden a rendelkezésünkre áll, ezért csak a teszteléshez szükséges környezetet kell beállítanunk, amely a mi esetünkben azt jelenti, hogy kellenek hisztórikus adatok, amelyekkel tesztelhetjük a programjainkat.
Ehhez szükséges adatforrásra van szükségünk, amely az adatokat szolgáltatja, ezt fogjuk beállítani.

Válasszuk ki a Tools menüben az Account Connections... menüpontot.
Ekkor valami ilyesmit kapunk :

Itt az Add... gombra kattintva adhatunk újabb adatforrást a fejlesztői környezetünkhöz. A megjelenő tájékoztató ablak közli, hogy most egy varázsló végig vezet bennünket a szükséges lépéseken, itt nincs is már dolgunk, mint a Next > gombra kattintani.

Ebben az ablakban a Connection name mezőba olyan nevet adunk, amilyet csak szeretnénk, célszerű a kapcsolatunk nevéhez kapcsolódót adni. Legyen mondjuk Gain Capital . A középső legördülő sávban a Gain-t válasszuk ki, és legvégül a Historical Data részben a középsőt, azaz a Use NinjaTrader servers opciót válasszuk ki.

A Next > gombbal tudunk tovább menni, ahol egyetlen teendőnk maradt, a Mode legördülő mezőben a Demo lehetőséget válasszuk ki, így nincs szükségünk jelszóra és azonosítóra.
Ismét a Next > gombbal mehetünk tovább, ahol a beállításaink összegzését olvashatjuk, majd a Finish gombra kattintva készen is vagyunk.

Ezzel készen is állunk a fejlesztési munkánk kezdésére.
Csatlakozzunk is az adatforráshoz a File menüben a Connect almenüben a korábban elkészített adatforrás nevét kell kiválasztani. (a mi példánkban Gain Capital)
Kis dallamocska jelzi, hogy sikerült...

A NinjaTrader-ben - ahogyan már említettem is - lehet indikátort és stratégiát is fejleszteni. Aki tőzsdézik, annak nem kell ezt elmagyarázni. Az indikátorok a mi jó barátaink, a stratégiánk pedig keresi a pénzt (jó esetben).

A NinjaTrader-ben ráadásul kétféle módon lehet ezek fejlesztését elkezdeni. Az egyik, hogy egy varázsló segítségével egyszerűen "behuzalozzuk" a logikát és már készen is vagyunk, nem kell a forráskód szerkesztésével, fordítással, meg egyéb pepecs munkával töltenünk az időt. Sok időt és bosszúságot takarítunk meg így.

Ennek azonban az az ára, hogy nem minden funkcionalitást tudunk megvalósítani.

Kezdjük.
A NinjaTrader-ben a Tools menüben válasszuk ki a New NinjaScript ... azon belül pedig a Strategy... menüpontot.
Rögtön megnyílik a varázsló.
Alul a szokásos gombok mellett van még két másik is, amelyeket bármikor megnyomhatjuk a varázsló futtatásakor. Az egyik a View Code... a másik pedig az Unlock Code. Az előbbi megmutatja azt a forráskódot, amelyet a varázsló generál a háttérben, miközben mi a logikát "huzalozzuk" éppen. A másik nemcsak megmutatja a kódot, de szerkeszthetővé is teszi, de ekkor már nem térhetünk vissza a varázslóhoz többé, ezért is "unlock", tehát a lezárt kódot nyitja fel.

Egyenlőre ne nyomogassuk ezeket a gombokat!
Később el sem tudjuk majd képzelni a programírást az Unlock Code gomb nélkül, nem is kell majd a varázsló.

Az első Next > gomb után a bemenő adatokat meghatározó képernyőre kerülünk, itt a MyInput0-t rögtön töröljük is ki, mert nincs rá szükség. Itt adhatjuk meg azokat a bemenő paramétereket, melyeket a stratégia futtatásakor kezdő adatként megadunk. Erre majd még később kitérünk.
Tehát itt is Next > gomb és máris a varázsló leglényegesebb képernyőjére jutottunk. Az ablak felső részében a feltételeket kell meghatároznunk, az alsó részében pedig azt a tevékenységet, amit a feltétel teljesülésekor végre akarunk hajtatni a stratégiánkkal.

A felső ablak melletti Add... gomb segítségével meg is fogalmazhatjuk az első feltételünket.
Jelen esetben ez az lesz, ha a gyertya záróára magasabb, mint a nyitóára, akkor a gyertya zöld.
Válasszuk ki a jobb oldali ablakban Price data könyvtárat, abból pedig a Close tételt. Ekkor az ablak alatt mindenféle beállítási lehetőség jelenik meg. Ezekkel most nem foglalkozunk, később esetleg. Itt nem fontos.

A bal oldali ablakban hasonlóképpen kell eljárnunk, de ott az Open tételt kell választanunk.
A két ablak között pedig keressük meg a megfelelő relációs jelet, ami itt ugyebár a ">" jel lesz.
Ezzel a feltételünket meg is fogalmaztuk.

Következhet a tevékenység, melyet a feltétel teljesülése esetén kell végrehajtanunk.
A lenti ablak melletti Add... gomb megnyomása után nyissuk ki a Drawing könyvtárat, melyben a Diamond tételt kell kiválasztanunk. Itt két dolgot kell még tennünk.
Az egyik a rombusz színe, amit vagy átírunk Green-re kézzel, vagy kiválasztjuk a listából a nekünk tetsző zöldet.
A másik pedig az Y mező lesz. Itt ugyanis a rombusz helyzetét fogjuk meghatározni a grafikonon a gyertyához képest. Ha hagyjuk a 0 értéket, akkor sajnos nem fog látszani. Tehát 0-tól eltérő értéket érdemes választani. Ha a mező végén található apró gombocskát megnyomjuk amin "..." szerepel, akkor egy újabb ablakot kapunk, ahol az Y értékét meghatározhatjuk. Válasszuk a Price Data könyvtárból a Close értéket, majd az alul megjelenő Parameters részben az Offset részbe írjunk 2-t. (mindjárt rátérünk mit is jelent ez)
Az OK megnyomása után egy másik OK a tevékenységre és készen is vagyunk.
Ahhoz az ablakhoz érkezünk vissza, ahol a feltételeket és a tevékenységeket határoztuk meg.
Ezt kell, hogy kapjuk. A Next > hatására a következő ablakban a Stop-loss értékeket határozhatnánk meg, de most erre nincs szükségünk, így ismét Next > majd az utolsó összegző ablakon egy Finish.

Ezzel el is készült a stratégiánk, ezt egy apró üzenet ablak közli is velünk.

A tesztelésére egy nagyon egyszerű módszer fogunk választani.

Válasszuk a File menü New..., majd a Chart... menüpontját. Állítsuk be a következőképpen :
Tehát EURUSD 1 percesen 15 napnyi hisztórikus adattal.
A megjelenő grafikonon a felső ikonsorból az utolsó előttit, egy sárga kerek gombra hasonlító $ jelű gombot nyomjunk meg.

Ezzel fogjuk a stratégiánkat hozzárendelni a grafikonhoz. FIGYELEM! Ha nem kapcsolódtunk adatforráshoz, akkor ez a gomb szürke lesz, nem tudunk majd stratégiát kiválasztani! Tehát csatlakozni kell előtte!

A megjelenő ablak bal felső részében keressük meg a stratégiánkat, azon a néven, amilyen néven a varázsló futtatásakor elneveztük. Duplán kattintsunk rá, majd OK gomb.

A grafikonon valami hasonlót kell látnunk :

Látható, hogy csak a zöld gyertyák fölé rajzolt zöld rombuszt a stratégiánk, tehát működik, méghozzá jól.

A következő post-ban a piros gyertyákat fogjuk megjelölni hasonló módon, de már nem a varázslóval készítjük el a stratégiát, hanem a forráskódot mi magunk írjuk meg, a varázslóra csak a macerásabb részeket bízzuk rá.

Aki esetleg kedvet érez hozzá, az elkészítheti magának a varázslóval a piros gyertyákat megjelölő stratégiát.

Aki pedig az egésznek az értelmét keresi, annak elmondom - a teljesség igénye nélkül -, hogy ezeknek komoly hasznát fogjuk venni, amikor majd a gyertyatrendeket fogjuk vizsgálgatni.
Hamarosan a doji és a marobozu gyertyák felismerésével folytatjuk, majd ezen alapkövekből felépítjük az első gyertyaalakzat felismerést.

Ezután pedig már automatikusan pozíciót is nyitunk.
Jó olvasást, gyakorlást addig is!

A stratégiákról

2009-06-26T12:41:00.004+02:00

Ahogyan az alapfogalmak megbeszélésekor is szó volt róla, stratégiának nevezzük azt a logikát, amellyel magát a kereskedést lebonyolítjuk, tehát magát a NinjaTrader-ben megírt programot.

Ahhoz, hogy jó stratégiát tudjunk írni, ahhoz tisztában kell lennünk a technikai elemzés fortélyaival, illetve a kézi kötésekben kell, hogy legyen gyakorlatunk, különben sosem fogjuk tudni leellenőrizni, hogy a programunk jól működik-e, de még azzal is problémánk lesz, hogy egyáltalán a stratégiát kitaláljuk.

Ezen az oldalon néhány olyan stratégiát fogunk megtárgyalni és leprogramozni, amelyek profit faktora még nem a legjobb, de azért nem veszteséges, és akár éles kereskedelemre is alkalmas.
Aki megfelelően kreatív, jó tőzsdéző, esetleg még programozni is tud, az biztosan össze tud majd rakni egy saját fejlesztésű stratégiát az itt leírt és fejlesztett építő kockákból.

Ahhoz azonban, hogy tényleg munkához tudjunk látni, a stratégiákról a legalapvetőbb dolgokat kell tisztáznunk, elsősorban "tőzsdeszakmai" szempontból.

Aki tanult tőzsdézni, az tudja, hogy a pozíciókat JEL-ekre kell nyitni és bezárni. Természetesen a veszteségekre is fel kell készülnünk, stop-loss használatával, vagy money management-tel.
A jeleket az árfolyamok, ezen belül a gyertyák, ezek ár alakzatai, valamint a hozzájuk kapcsolódó trendkövető és momentum indikátorok adják együttesen.
Tehát elsősorban az árak változásaira figyelünk, majd pedig az indikátorok jelzéseire. Az indikátorokból többet is használnunk kell (akár 8-10-et is), és ezek 80%-a kell, hogy adja a kötési jelet, az áralakzatok mellett.

Kulcsfontosságú természetesen a trendek felismerése is, ez ugyanis a fő csapásirányt fogja adni. Nyilván senki sem fog long-ot kötni egy csökkenő trendben, kivéve természetesen a trendellenes stratégiák esetén, de az már a legprofibbak kiváltsága. Tehát a trendkövető stratégiákkal foglalkozunk egyenlőre, talán később (ha majd lesz pénzem a haladó tanfolyamra), belekóstolunk a trendellenes stratégiákba is, de egyenlőre maradjunk a trendkövetőknél.

Mit jelent ez programozás szempontjából?
Nos, igen sokmindent.
Először is, meg kell tanítanunk a programunkat felismerni a trendeket, ezek változásait, még mélyebre hatolva pedig a gyertyatrendek felismerését kell leprogramoznunk. Ha a gyertyatrendeket jól és elég nagy megbízhatósággal felismeri a programunk, akkor már a teljes trendekkel is elboldogulhatunk, majd ezek törését is fel tudjuk ismertetni a programmal.

Mivel a NinjaTrader kezünkbe adja az indikátorokat, így az indikátorok által szolgáltatott jelek felismerése a gyertyatrendek alapján már gyerekjáték lesz.

A kettő együtt pedig a nyerő stratégia kidolgozása lesz!
Röviden tehát a kidolgozás menetrendje a következő sémát kell, hogy kövesse :

Árfolyam trendek felismerése

Gyertyaalakzatok felismerése (doji, marobozu, kulcsforduló, előrefele terhes, visszafelé terhes, stb.)
Gyertyatrendek felismerése
Völgyek, csúcsok felismerése
Trendek felismerése

Indikátorok

Indikátorok jelzéseinek felismerése
Indikátorok összevetése
Megfelelő indikátorok kiválasztása

Veszteségek kivédése, csökkentése

Stop-loss használata (első húzás és utána folyamatos után húzás)
Money management használata
Tőke kezelése, nyereségek visszaforgatása
Veszteségkeretek használata

A legkomolyabb feladat természetesen a gyertya alakzatok felismerése, bár mivel megszámlálható gyertyákról van szó, így ez nem olyan kihívás, mint mondjuk egy fülescsésze felismerése, ami kialakulhat 50, de akár 200 gyertyából is.

Sajnos programozás szempontjából nehezen fogható meg - de azért persze megfogható, csak nehezen - a nagyobb áralakzatok kialakulása, mint például a kettős csúcsok, kettős völgyek, fej és vállak, fülescsésze, árbóc, zászló, stb.
Később elképzelhető, hogy ezekre is fordítunk figyelmet, de mivel a stratégia logikája nem egy folyamatosan futó program, hanem minden egyes tick-re, vagy gyertyára fut le, így nekünk első körben - és utána még jó sokáig - elégséges lesz a rövidtávú gyertyatrendek, valamint az árfolyamtrendek felismerésére.

Az áralakzatok felismeréséből fakadó hiányokat pedig majd az indikátorok "előrejelzései", pótolják.
Egyenlőre tehát elég a gyertyákkal kapcsolatos trendek, alakzatok leprogramozása, mely mindössze néhány (de legalábbis megszámlálható számú) gyertyákból állnak.

Egy kicsit előre szaladva nézzünk bele a gyertyaalakzatokba.
Miből is állnak a gyertyaalakzatok javarészt.
Háromféle építőköve van a gyertya alakzatoknak, ezek a következők :

Fehér és fekete közönséges gyertyák
Doji gyertyák
Marobozu gyertyák

A fentiek kombinációjából állnak össze (maximum 5-8 gyertyából) a trenderősítő, trendváltó gyertyaalakzatok.
Tehát a legelső feladat ezen gyertyák pontos felismertetése a programmal.

A következő post-ban már ezek leprogramozásával fogunk foglalkozni, így megismerkedünk a NinjaTrader ehhez kapcsolódó funckióival is, a teljesség igénye nélkül.
Leprogramozzuk a doji, marobozu, valamint a fekete és fehér gyertyák felismerését, először az elmélet, majd pedig a gyakorlat oldaláról szemügyre véve.

Ezekből később indikátorokat faragunk, hogy majd a későbbiekben ezekre építkezve könnyedén írhassuk meg a stratégiánkat.

Addig is érdemes kicsit elmélkedni ezen gyertyák felismeréséről, hogy miféle matematikai szabályokkal lehetséges.

Mindenkinek jó elmélkedést! Jövő héten folytatjuk!

Alapfogalmak a stratégiákhoz

2009-06-25T07:18:00.006+02:00

A NinjaTrader kezelő felületével nem szeretnék foglalkozni, mindenki maga megtapasztalhatja, hogyan is néz ki és hogyan is működik.
A teljesség kedvéért azért majd a fejlesztési lépésekhez szükséges menüpontokat és azok használatát tárgyaljuk természetesen.

Szeretném azonban felhívni a figyelmet egy nagyon fontos dologra, és ha úgy tetszik, akkor ezt felfoghatjuk az automatizált kereskedés pszichológiájának is!
A programjaikat tesztelni csak a múltbéli adatok alaján tudjuk, mivel kristálygömböt még nem lehet kapni. A múltbéli adatok alapján viszont csak statisztikai valószínűséggel fogjuk tudni megállapítani, hogy mennyire hatékony a programunk. A jövőre vonatkozólag "csak" azt mondja meg, hogy nagy valószínűséggel milyen nyereséget tud elérni a program elméletileg, de ez - a jövő ismeretének hiányában - nem garantálható és akár extrém veszteségeket is produkálhat a program, ha nem jól van megírva. (veszteség elleni védekezési technikákról is lesz szó természetesen). Tehát a programozott kereskedés nem a tuti lottó ötös, hanem egy meglehetősen hatékony segítség, ha úgy tetszik egy intelligens harmadik kéz, amely akkor is dolgozik, ha a saját két kezünk tele van éppen munkával.

Néhány alapfogalmat érdemes tisztázni, mielőtt neki kezdünk programot írni. Kezdjük is.

Stratégia. Ez a NinjaTrader-ben más értelemmel bír, bár ha jobban meggondoljuk, akkor mégsem. A NinjaTrader-ben a stratégia tulajdonképpen maga az a program, amely helyettünk kereskedik. Egy egyszerű programkód, amelyben leírjuk, hogyan is kell kereskedni. Vagyis leírjuk a stratégiát. Így hát mégsem biztos, hogy mást jelent, de amikor NinjaTrader stratégiáról beszélünk, akkor természetesen arról a programról lesz szó, amit írunk, fejlesztgetünk.

Indikátor. Itt is kicsit skizoid az állapot, ugyanis a kézi kereskedésnél használatos indikátorokról van szó, de talán kicsit mégis többről. Kézi kereskedésnél az elemző programban ha odapakolunk egy indikátort a grafikonra, akkor tudjuk használni. Ezekből ugyebár kétféle van, az "overlay" és a "non-overlay". Vagyis amit a gyertyákra rajzol a program, és amit a gyertyák alá. Csak a tisztán látás kedvéért, overlay indikátor egy mozgó átlag, vagy a híres Bollinger-szalag, non-overlay pedig az RSI, MACD.
Nos, a NinjaTrader-ben az összes indikátort használhatjuk, akár egyidőben is, anélkül, hogy azt a grafikonon megjelenítenénk, ugyanis az indikátorokat külön "függvényekként" kezeli a program. (A függvényekről később még részletesen ejtünk szól, egyenlőre legyen elég annyi, hogy a programban az indikátorok értékét bármikor megkaphatjuk és felhasználhatjuk.)
Természetesen az indikátorokat ki lehet rajzolni a grafikonra, ha ezt külön leprogramozzuk, így amikor a stratégiát (azaz a kereskedő programot) elindítjuk, akkor az automatikusan felrajzolja a grafikonra. De akár kézzel is felrakhatjuk a grafikonra, ha nem akarunk a programban ezzel bíbelődni. Hozzátenném, hogy azért érdemes a stratégiában leprogramozni, hogy rajzolja az indikátorokat, mert így nem kell mind a 8 indikátort kézzel utólag felpakolászni, hanem a stratégia indításakor máris látjuk mi újság, és azonnal látjuk azt is, hogy jól működik-e a program.

Backtest (ejtsd : bekteszt). Ez egy igen hasznos funkció a NinjaTrader felületén. Arra való, hogy az általunk elkészített stratégiát, vagy indikátort (igen, ilyet is programozhatunk, és fogunk is, mert kell), lefuttassuk a régmúlt történelmi adatokon. Vagyis ezzel azt tudhatjuk meg, hogyha 2006 január elsejétől ezt a stratégiát futtattuk volna napjainkig, akkor mennyire lett volna hatékony. Ez tehát egy igen fontos funkció lesz a későbbiekben. Fogjuk is használni nagyon sokat a következővel együtt. FIGYELEM! A backtest által szolgáltatott eredmények nem azonosak a jövőben realizálható eredményekkel, tehát ez nem egy jövendőmondó funkció! Ez egy tesztelő funkció, ami nagy valószínűséggel vetíthető a jövőre is. De kizárólag statisztikai alapokon.

Optimalizálás. Ez talán a a backtest-nél is fontosabb funkció, ugyanis elképesztően sok időt képes megtakarítani nekünk, ráadásul képes megmondani, hogy a stratégiánkban leprogramozott "elméleti" tevékenységek mennyire hatékonyak, egyáltalán jól gondolkodtunk-e és érdemes-e tovább bíbelődni a stratégiánk további fejlesztgetésével.
Ez a funkció ugyanis azt csinálja, hogy a régmúlt történelmi adatokon lefuttatja a stratégiánkat, de az általunk meghatározott paraméterek különféle szélsőértékei között próbálgatva. Röviden és egyszerűen arról van szó, hogyha például az RSI indikátor alapjain működik a stratégiánk, akkor megadhatjuk, hogyha az RSI periódus ideje milyen szélső értékek között változhatnak (például 5 és 50 között), és így melyik az a periódus idő, amivel a legnagyobb nyereséget tudjuk elérni. Aki ezt nem találja hasznos dolognak, ne is indítsa el a NinjaTrader-t!!!

Profit faktor. A profit faktor nem más, mint a stratégiánk teljesítmény mutatója. Azt mutatja meg, hogy a kereskedés során mennyivel több pénzt keres a stratégia, mint amennyit elveszít. Tehát a 10-es profit faktor azt jelenti számunkra, hogy 10-szer annyi pénzt keres, mint amennyit elveszít. Számokban : 10 dollárt nyer, de 1-et elveszít. Mivel ez egy nagyon fontos mutató, így ennek a meghatározása kulcsfontosságú! A stratégiánk értékét, teljesítményét fogja mutatni.
Amikor majd az adózásról beszélünk, akkor fogjuk látni - és megtapasztalni -, hogy melyik az a profit faktor érték, amely még éppen optimális. (mert ugye nem szabad elfelejteni, hogy adózni azt azért kell, ráadásul vannak számlavezetési és bróker díjak is!)
Nagyjából azt lehet mondani, hogy 4-5 körül már jól teljesít a stratégiánk, 8-nál már nagyon jól teljesít, efölött pedig csak a csillagos ég van, tehát egy 10-es stratégiával már bátran nekivághatunk az éles kereskedésnek.
Sajnos arról is kell beszélnünk, hogy az 1-es profit faktor a null szaldós stratégia, 1 alatt pedig veszteséges. A nulla az pedig nulla. Az nem kereskedik. Negatív profit faktor pedig nem létezik.

A profit faktorról és a backtest, optimalizálás összefüggéseiről azért még egy igen fontos dolgot kell megtanulnunk.
A profit faktor értékét a backtest, illetve az optimalizálás során kapjuk meg. A két funkció használata a meghatározásához nélkülözhetetlen. Az optimalizálás során meghatározott paraméterekkel tudjuk a backtest-et lefuttatni, ezzel igazolva a stratégiánk és persze az optimalizálás sikerességét.

Viszont nem mindegy milyen időtávon és nem mindegy milyen idő intervallumon futtajuk ezeket.
Az optimalizálás - természetéből adódóan, azaz a próbálgatások száma miatt - igen sokáig eltarthat. Ezért hajlamosak vagyunk rövid időintervallumon futtatni, mondjuk az elmúlt két hét adataira támaszkodva.
Ezzel szemben a backtest viszonylag gyorsan fut le, ezért hajlamosak vagyunk hosszabb időintervallumon futtatni, mondjuk az elmúlt egy év adatain.

Így azután nem szabad azon csodálkozni, hogy az optimalizálás során kapott és kiszámított profit faktor nem lesz azonos a backtest eredményeivel.
Például, ha az optimalizálás az elmúlt két hét adatai alapján történik, és kijön, hogy a várható profit faktor 10 lesz, ha ilyen és ilyen paraméterekkel futtatjuk, de amikor a backtest-ben megadjuk az optimalizálás által "kiköpött" paramétereket és az elmúlt egy év adataival tesztelünk, akkor csodák-csodájára csak 4-es profit faktor jön ki.

Az optimalizálással és a backtest-tel ugyanúgy kell gondolkodnunk és bánnunk, mint a mozgóátlagokkal. Rövid távon nagyobb értékeket ér el, de bizonytalanabb, hosszabb távon nem ér el olyan nagy értékeket, de azt sokkal nagyobb bizonyossággal. Minél hosszabb időtávra futtatjuk az optimalizálást, annál reálisabb értéket fogunk kapni. De mindenképpen érdemes egy hosszabb és egy rövidebb időintervallumra futtani az optimaizálást és a kettő közötti "arany közép utat" választani.
Mindenesetre érdemes csak azokat a stratégiákat optimalizálni, amelyeket jól átgondolva írtunk meg, és a lehető legkevesebb paramétert használjuk benne.
Még így is lesznek olyan esetek, amikor az optimalizálás egy egész napig, vagy esetleg napokig fog futni. De megéri majd!
A stratégiák tesztelésekor erre még úgyis részletesen kitérünk.

Nos, erről ennyit egyenlőre, a következő post-ban kicsit beszélünk a stratégiák elméleti és gyakorlati felépítéséről, ezzel el is kezdjük a programozást.

Japán gyertyákhoz Ninja-kat!

2009-05-27T16:50:00.004+02:00

Ahogyan már a korábbiakban is ecseteltem, a legkifizetődőbb módszer a kispénzű befektetőknek a tőzsdei kereskedésre a FOREX hullámainak meglovaglása, illetve az automatizált kereskedési módszerek.

Az automatizált tőzsdei kereskedések sok szempontból előnyösek. A legfontosabb előnyei :

érzelmek nélkül (így a tőzsde pszichológiai problémákat kiküszöbölve) kereskedik, a meghatározott szabályok szerint.

További hatalmas előnye, hogy sosem fárad el, éjjel is kereskedik, és akkor is, amikor a munkahelyünkön dolgozunk.
Bármikor ellenőrizhető, és módosítható, leállítható, újraindítható, stb.
Pontosan azt csinálja, amit kell, illetve amit a program meghatároz

Hátránya is van azért, íme :

Nem képes bonyolult áralakzatok felismerésére (vagy csak aránytalanul sok időráfordítással készült program segítségével, tehát nem költséghatékony)
Leginkább a rövidtávú gyertyatrendeket lehet vele meglovagolni, azokat is inkább indikátorok segítségével.
A rosszul megírt program több kárt tehet, mint amennyi hasznot hajt.
A legtöbb automatizált kereskedési platform drága.

A hátrányokkal együtt lehet élni, igazán a program megírása a kihívás, illetve nem utolsó sorban a kereskedési platform és konfiguráció ára az, amin tudunk változtatni.

Kezdjük az egyszerűbbel, a kereskedési platformokkal.

A platformok népszerűségét két dolog határozza meg. Az egyik a devizapárok száma, a másik pedig a spread-ek nagysága.
Ebben listavezető - utcahosszal - az OANDA. Ez egy kanadai brókercég, amely egyedülállóan alacsony spread-ekkel forgalmaz devizapárokat. Ráadásul igen sok devizapár található, a kereskedési grafikus felülete az egyik legjobb, amit kézi kereskedésre használni lehet.

Aki szeretne FOREX-en kereskedni, annak melegen ajánlom.

Sajnos azonban az automatizált kereskedéshez szükséges programozói felületet nagyon drágán árulja, 600 USD havonta. Persze, ha az ember ennek töbszörösét is meg tudja keresni, akkor ez nem olyan nagy baj, de ez az összeg akkor is nagyon sok.

Ezt még nem tanulmányoztam, de azt tudom, hogy Java alapú API-t licenszelnek ennyi pénzért. Elképzelhető, hogy később kicsit komolyabban szemügyre veszem, mert azért az OANDA eléggé a szivemhez nőtt a gyakorlások során. Azt viszont már most tudom, hogy kell egy komplett Java-s fejlesztő környezet, amit a fejlesztő maga állít össze, kell, hogy legyen 600 USD a számlán mindig, valamint kell tesztelési lehetőség is, amit az FXGame-en lehet is. De ezt a környezetet fel kell állítani, szöszölni kell vele és nem utolsó sorban drága is.

A másik ilyen kereskedési platform a NinjaTrader. Ő egy igazi svájci bicska, ugyanis FOREX-en is lehet kereskedni vele, de akár az amerikai tőzsdén részvényekkel is.
Minden egy kupacban rendelkezésre áll, ugyanis a kapcsolatok beállítása után tesztelni lehet demo adatokkal, illetve úgynevezett backtest-et lehet csinálni a múltbeli adatokkal.
A nyelvezete leginkább a C#-hoz hasonlít, ráadásul a varázslóival olyanok is tudnak kódot generálni, akik egyébként nem tudnak programozni.

Ára is barátságos, az ingyenes verzióval lehet fejleszteni, backtest-elni, élesben kereskedni viszont kétféle megoldással lehet. Az egyik, hogy 50 USD / hónap díjat fizetünk érte (azaz lízingeljük), illetve megvásároljuk véglegesen (ekkor persze megszabadulunk a havi költségektől), ekkor 995 USD-t kell kifizetnünk érte.

Habár nem olcsó, sőt sokkal drágább, mint az OANDA, de ezt csak egyszer kell kifizetni, a lízingeléssel pedig az olcsóbb indulást tudjuk megoldani.
Sajnos az OANDA-hoz nem tudunk vele csatlakozni, viszont a GainCapital rendszeréhez igen, ahol a további lehetőségek a következők :

Mini számla, 250 USD minimális tőkével lehet számlát nyitni és 200:1 tőkeáttétel van.

Standard számla, 2500 USD minimális tőkével lehet számlát nyitni, itt viszont már csak 100:1 tőkeáttét van.

Nyilvánvalóan a mini számlával érdemes kezdeni. Ez ugye durván 60 000 HUF kezdőtőkét igényel, ha élesben is kereskedni akarunk, egyébként viszont semennyibe sem, ha csak fejlesztgetni és tesztelni szeretnénk.

Mivel addig számlát nyitni nem érdemes, ameddig nincs megfelelő stratégiánk (programunk a NinjaTrader-ben), így most egyenlőre a stratégia kifejlesztésével fogunk foglalkozni első körben.

Az ehhez szükséges információkat a következő post-ban fogom leírni. Addig is mindenkinek jó töprengést, és akinek esetleg van jobb ötlete, azt szivesen látom!

FOREX, a Szent Grál

2009-05-26T12:59:00.003+02:00

Ahogyan ígértem, elkezdem kikutatni a lehető legjobb formáját a tőzsdei szaktudás kiaknázásának.

A tőzsdei szaktudás szerencsére kompatibilis a devizapiacokon (FOREX) mozgó árakkal is, így nem meglepő módon a devizapiacokon is kamatoztatni lehet azt, amit a grafikonokról tanult az ember fia.

Nézzük csak, milyen előnyökkel és hátrányokkal rendelkezik a FOREX!

Előnyök :

folyamatos nyitvatartás, hétköznapokon 24 órában
rengeteg devizapár, a legtöbb ügynökségnél komoly likviditással
általában nincs brókerdíj, mindössze a spread-el nyújtotta árkülönbözettel kell számolnunk
általában nincs minimális összeg, amelyet meghatároznak a számlanyitáskor, sőt, számlavezetési díj sem szokott lenni (persze tisztelet a kivételeknek, mert azért van)
magas tőkeáttétel

Hátrányok:

magasabb az adókulcsa (25%)
a nyereségek nem állíthatók szembe a veszteségekkel
kevés elemző eszköz
nincs egységes "deviza tőzsde", brókercégenként változik a spread, és az árfolyamok alakulása. Nagyjából persze egyfelé mennek az árak, de nem egyforma gyorsasággal és mértékben

Nézzük csak mi az, ami nekünk - kispénzzel kezdőknek - fontos a fentiek közül.

Az adózás nem olyan nagy probléma, ha van miből kifizetni 25%-ot, akkor miért is ne!
A nyereségek nem állíthatók szembe a veszteségekkel, vagyis ha nyerek 1 milliót, akkor azután akkor is ki kell fizetnem a 25% adót, ha másnap az egészet elveszítem! Vagyis olyan stratégiát kell választani, ami a lehetőségekhez mérten inkább nyerő, semmint vesztő. Minél magasabb a nyereséges kötések száma, annál nyereségesebb a kereskedés, még a 25%-os adózás ellenére is.
Nincs számlanyitási díj és minimálisan befizetendő összeg (vagy ha van, akkor csekély)
Kevés elemző eszköz áll rendelkezésre, de ezen más elemző szoftverekkel lehet segíteni, különösen, ha sikerül találni egy általánosan használható szoftvert (ami mondjuk FOREX-hez is jó és persze a részvényekhez is... van ilyen, igen!)
az, hogy nem egységes a devizapiac, az csöppet sem baj, leginkább a jó brókercéget kell kiválasztani!

Az előnyöket azért nem vettem bele a felsorolásba, mert az egyértelműen csak jó nekünk!

Sajnos azonban a legtöbbünknek nem nagyon sok az ideje tőzsdézni, ugyanis - szerintem nyugodtan mondhatom, hogy mindannyiunknak - munkahelyre kell járni dolgozni, mert egyenlőre még abból élünk.
Ezért aztán jó ötlet a FOREX, mert azt lehet este is művelni, amikor az ember a munkából hazamegy. Az persze más kérdés, hogy kit mennyire fárasztanak le a munkahelyén.

Van azonban még valami, ami a figyelmemet felkeltette, ez pedig az automatizált tőzsdei kereskedés. Azért érdekes a dolog, mert ugye a kereskedést általában emberek végzik, tehát kell hozzá jó szem, kell hozzá szaktudás, és persze kell hozzá megfelelő asszociatív képesség, hogy az ember felismerje az áralakzatokat.

Erre egy program szinte biztos, hogy nem képes. Viszont egy csomó minden másra igen. Képes a gyertya alakzatokat felismerni, képes indikátorokkal dolgozni, és képes éjjel-nappal kereskedni is, ha úgy írjuk meg a programot.

Vannak persze hátrányai is. Nyilvánvalóan képes sok pénzt veszíteni is, ha a program nincs jól megírva!

Viszont képes akkor is pénzt keresni, amikor mi a munkahelyünkön dolgozunk, éjjel, amikor alszunk (néha akkor vannak a legdurvább emelkedések-esések) és akkor is meg tudja nyomni a gombot, amikor mi pszichológiailag képtelenek vagyunk rá.

A programok írása azonban heteket, hónapokat vesz igénybe, és sokszor így sem elég hatékony.

A blogban néhány alapvető metódust fogok leírni, amivel bizonyos gyertya alakzatokat lehet felismerni, indikátorok segítségével pedig minimalizálni lehet a veszteséges kötések számát.

Az ilyen programok további előnye, hogy bármilyen időtávon működnek, tehát akár 1 perces időtávon is!

Holnap tovább vesézem a lehetőségeket! Elsősorban a kezdőtőke szempontjából természetesen!