Tömbök

Annak az információnak a nagy részét, amit az alkalmazási programok használnak tömbök tartalmazzák.

A tömbök fogalma

Tömb az azonos típusú változók rendezett érték készletének az összefoglaló neve. A tömbök egy dimenziósak és többdimenziósak lehetnek. Egy tömbben levő dimenziók maximális száma négy lehet. Bármilyen adattípust elhelyezhetünk tömbökben.

A tömbelem egy tömb része; egy indexelt változó, aminek van neve és valamilyen érték.

59. ábra. Az egész számtípus tömbjeinek a grafikus bemutatása: a) egy dimenziós; b) kétdimenziós; c) háromdimenziós.

Indexelés

A tömbelem-index egy vagy több egész értékű állandó, változó vagy kifejezés felsorolása vesszővel elválasztva és szögletes zárójelbe zárva. A tömbelem-index egyértelműen meghatározza egy tömb valamely elemének a helyét. A tömbelem-indexet egy változó (tömbnév) után helyezzük el és a tömbelem integrál részét képzi. Az MQL4-ben az indexelés nullával kezdődik.

Az olyan indexelés is helyes, amelynél az indexek vesszővel vannak felsorolva.

Az olyan indexelés is elfogadható, amikor mindegyik index külön szögletes zárójelben van.

Egy kétdimenziós tömb mindennapos analógja egy moziterem. A sor száma az első index értéke, és a soron belül levő ülőhely száma a második index, a nézők a tömbelemek, a néző vezetékneve a tömbelem értéke, a mozijegy (a sor és ülőhely meghatározása) egy módszer, amivel hozzáférünk egy tömbelem értékéhez.

Tömbdeklaráció és hozzáférés a tömbelemekhez

Mielőtt használ egy tömböt egy programban, azt deklarálni kell. Egy tömböt ugyanúgy, mint egy változót deklarálhatunk globális és helyi szinten. Mint az várható volt, a globális tömbelemek értékei elérhetőek az egész programból, a helyi tömbelemek értékei csak abból a függvényből, amiben deklarálva van. Egy tömböt nem deklarálhatnak az ügyfélterminál szintjén, vagyis az ügyfélterminál globális változóit nem gyűjthetik egy tömbbe. A tömbelemek értéki bármilyen típusúak lehetnek. A tömbelemek értékeinek a típusa az, amit a tömbdeklarációnál megadtak. Amikor deklarálunk egy tömböt meg kell adni a tömb elemeinek típusát, a tömb nevét és a dimenziókban lévő elemek számát:

A tömbelemekhez csak elemenként férhetünk hozzá, vagyis egy adott pillanatban csak egy összetevőhöz férhetünk hozzá. A tömbösszetevők típusát nem adjuk meg a programban. A tömbösszetevő értéket hozzá lehet rendelni vagy meg lehet változtatni az értékadó operátorral:

A tömbelemek értéke az 59. ábrán a következő:

- az egydimenziós tömb Mas[4] elem értéke a 34 egész szám;

- a kétdimenziós tömb Mas[3,7] elem értéke a 28 egész szám;

- a háromdimenziós tömb Mas[5,4,1] elem értéke a 77 egész szám.

Például, a Mas[10][15] tömbben az elem index legkisebb értéke Mas[0,0], és a legnagyobb értéke az  elem indexnek Mas[9,14] .

 (http://docs.MQL4.com) vagy a Meta Editor Helpben. Ezek közül a függvények közül néhányat tovább elemzünk.

Tömb inicializálás

Egy tömböt a megfelelő típus állandói által inicializálhatunk. Egydimenziós és többdimenziós tömböket inicializál az állandóknak az egydimenziós sorozata, amiket vesszők választanak el. A sorozatot kapcsos zárójelekbe zárjuk:

int Mas_i[3][4] = { 0, 1, 2, 3, 10, 11, 12, 13, 20, 21, 22, 23 };
 
double Mas_d[2][3] = { 0.1, 0.2, -0.3, -10.2, 1.5, 7.0 };
 
bool Mas_b[5] = { false, true, false, true, true }

Az tömb inicializásakor egy vagy több állandót kihagyhatunk. Ez esetben a számszerű típus megfelelő tömbelemeit nulla inicializálja, a string típusú tömbök elemei a "" string érték inicializálja  (idézőjelek tartalom nélkül), egy üres karaktersorozat (nem kell összekeverni egy üres hellyel). A következő program bemutatja a tömbök értékeit, amelyeket néhány érték kihagyásával inicializált egy változó sorozat ( arrayalert.mq4 script ):

//--------------------------------------------------------------------
// arrayalert.mq4
// The code should be used for educational purpose only.
//--------------------------------------------------------------------
int start() // Special funct. start()
 {
 string Mas_s[4] = {"a","b", ,"d"}; // String array
 int Mas_i[6] = { 0,1,2, ,4,5 }; // Integer type array
 Alert(Mas_s[0],Mas_s[1],Mas_s[2],Mas_s[3]); // Displaying
 Alert(Mas_i[0],Mas_i[1],Mas_i[2],Mas_i[3],Mas_i[4],Mas_i[5]);
 return; // Exit start()
 }
//--------------------------------------------------------------------

Ha egy egy-dimenziós tömb mérete nincs megadva, azt az inicializáló változó sorozat mérete alapján meghatározza a szerkesztő. Egy tömböt inicializálhat a beépített ArrayInitialize() függvény is. Minden tömb statikus, vagyis statikus típusú még akkor is, ha az inicializálásnál ezt nyíltan nem jelzik. Ez azt jelenti, hogy minden tömb megőrzi az értékeit azon függvények hívásai között is, amelyekben a tömböt deklarálták ( lásd: A változók típusai).

Minden tömb, amit az MQL4-ben használunk két csoportba osztható: felhasználói tömbök (a programozó által létrehozott) és elöre definiált tömbök (tömbök előre definiált nevekkel és adattípusokkal). A felhasználói tömbök méretei és az elemeik értékei attól függenek, hogy a programot hogyan hozták létre, vagyis a programozótól. A felhasználói tömbelemek értékei a programvégrehajtás ideje alatt rögzítettek és csak a számítások befejezése után tudjuk őket megváltoztatni. Azonban az elöre definiált tömbök elemeinek az értékeit nem változtathatjuk meg, a méretük növekszik, amikor a történelmi adatokat frissíti a terminál.

Felhasználói tömbök

A 'switch' operátor fejezet 18. feladatában megoldottunk egy példát. Tegyük azt bonyolultabbá (növeljük a pontok számát, és 100-ig írjuk ki szavakban) és gyakoroljuk a tömbök használatát.

A 25. feladat megoldása, ami egy string típusú tömböt használ a következői:  (stringarray.mq4  Expert Advisor ):

//--------------------------------------------------------------------
// stringarray.mq4
// The code should be used for educational purpose only.
//--------------------------------------------------------------------
extern double Level=1.3200;                    // Preset level 
string Text[101];                              // Array declaration
//--------------------------------------------------------------------
int init()                                      // Special funct. init()
  {                                            // Assigning values
  Text[1]="one ";            Text[15]="fifteen ";
  Text[2]="two ";            Text[16]="sixteen ";
  Text[3]="three ";          Text[17]="seventeen ";
  Text[4]="four ";            Text[18]="eighteen ";
  Text[5]="five ";            Text[19]="nineteen ";
  Text[6]="six ";            Text[20]="twenty ";
  Text[7]="seven ";          Text[30]="thirty ";
  Text[8]="eight ";          Text[40]="forty ";
  Text[9]="nine ";            Text[50]="fifty ";
  Text[10]="ten ";            Text[60]="sixty";
  Text[11]="eleven ";        Text[70]="seventy ";
  Text[12]="twelve ";        Text[80]="eighty ";
  Text[13]="thirteen ";      Text[90]="ninety";
  Text[14]="fourteen ";      Text[100]= "hundred";
  // Calculating values
  for(int i=20; i<=90; i=i+10)                // Cycle for tens
    {
      for(int j=1; j<=9; j++)                  // Cycle for units
        Text[i+j]=Text[i] + Text[j];          // Calculating value  
    }
  return;                                    // Exit init()
  }
//--------------------------------------------------------------------
int start()                                    // Special funct. start()
  {
  int Delta=NormalizeDouble((Bid-Level)/Point,0);// Excess 
//--------------------------------------------------------------------
  if (Delta>=0)                                // Price is not higher than level
    {
      Alert("Price below level");              // Alert
      return;                                  // Exit start()
    }
//--------------------------------------------------------------------
  if (Delta<100)                              // Price higher than 100
    {
      Alert("More than hundred points");        // Alert
      return;                                  // Exit start()
    }
//--------------------------------------------------------------------
  Alert("Plus ",Text[Delta],"pt.");            // Displaying
  return;                                      // Exit start()
  }
//--------------------------------------------------------------------

A probléma megoldására a Text[] string tömböt használjuk. A program végrehajtása alatt a tömbelemek értékeit nem változhatnak meg. A tömböt globális szinten deklaráljuk (a különleges függvényeken kívül), a kezdeti tömb előkészítés az init()-ben történik. Így a start() függvényben csak a szükséges számításokat végezzük minden ticknél.

A Text[] tömbelemek értékeit string állandóként jelöljük ki. A továbbiakban, a ciklusokban kiszámolt értékeket összeadjuk és hozzárendeljük a string sorokat.

 for (int i = 20; i<=90; i=i+10) // Cycle for tens
 {
 for (int j=1; j<=9; j++) // Cycle for units
 Text[i+j] = Text[i] + Text[j]; // Calculating value 
 }

Ezeket a számításokat könnyen megérthetjük: a 21-99 indexszel rendelkező tömbelemekhez (kivétel a 10 többszöröseinek indexei) a megfelelő string értéket kiszámoljuk. Figyeld az indexeket a következő sorban:

 Text[i+j] = Text[i] + Text[j]; // Calculating value

Indexként változókat (amely értékei megváltoznak a ciklusban) és kifejezéseket használunk. Az i és j változók értékeitől függően, a program összegezni fogja az értékeket, és ezt az értéket el fogja küldeni a megfelelő Text[] tömbelemekhez, ahol a kiszámított (i+j) eredménye fogja kijelölni a tömbelem értékét. Például, ha a számítás eredményeként i értéke 30 és j értéke7, azon elemek neve, amelyeket össze kell fűzni a Text[30] és Text[7] tömbelem értéke, ezt az eredményt jelöli ki a Text[37]. Bármilyen másik egész számtípusú változót használhatunk tömbelem indexként. Ebben a példában a start() függvényben a Delta változót használjuk tömb indexként - Text[Delta].

A start() különleges függvénynek egyszerű kódja van. A Delta értékétől függő számításokat végzünk. Ha ez kisebb vagy egyenlő mint 100 pont, akkor a megfelelő üzenet mutatása után a start() végrehajtás befejeződik. Ha az érték a meghatározott tartományon belül van, a riasztást a problémafelvetés szerint mutatja.

60. ábra. A kívánt értéket mutatja a  stringarray.mq4  EA

Figyelj 18. feladat megoldására. Ha ugyanazt a megoldás használtuk volna a 25. feladat megoldására, a 'switch' operátor körülbelül 100 sort tartalmazna - egy sort mindegyik megoldási variációhoz. A programfejlesztés ilyen megközelítése nem megfelelő. Azonfelül, az olyan megoldások kezelhetetlenek ahol több tíz, több száz vagy több ezer változó értékével kell dolgozni. Ilyen esetben a tömbök használata indokolt és nagyon kényelmes.

Előre  definiált  tömbök

Az előre definiált tömb egy tömb előre meghatározott névvel (Open, Close, High, Low, Volume és Time), amely tömbök elemei tartalmazzák a történelmi bárok megfelelő jellemzőinek az értékeit.

A Zéró bár az aktuális bár, ami még teljesen nem alakult ki. Az ablakban a zéró bár jobbról az utolsó.

Bárok (és megfelelő előre definiált tömbindexek) számolását a null bártól indítjuk. A [0] indexszel rendelkező előre definiált tömb elemek értékei azok az értékek, amelyek a zéró bárt jellemzik. Például Open[0] értéke a zéró bár nyitó ára. 61. ábra mutatja a bárok indexelését és a bárjellemzők összegzését.

61. ábra. Mindegyik bárt az értékek készlete jellemez, amit az arrays-timeseries tartalmaz.
A bárokat a zéró bártól számoljuk.

A 61. ábrán a zéro bárnak a következő jellemzői vannak:

Egy idő után az aktuális bár kialakul és egy új bár fog meg jelenni az ablakban. Most ez az új bár lesz a zéró bár, és a kialakult teljes bár lesz az első ([1]indexszel):

62. ábra. A bárok egy idő után elmozdulnak, míg a számozás nem mozdul el.

Most az előre definiált tömb elemeinek az  értékei a következők lesznek:

A későbbiekben, az ablakban új bárok fognak megjelenni. A formálódó, jobbszélső bár sorszáma mindig nulla lesz, az ettől balra lévő lesz az első bár, a következő - az második, stb. A bár tulajdonságait nem változtathatjuk meg: a példában a bárt 14:34-nél nyitották ki, és a nyitási idő mindig 14:34 fog maradni, a többi paraméter szintén változatlan marad. Azonban ennek a bárnak az indexe az új bárok megjelenése után növekedni fog.

Tehát az  előre definiált tömbökkel kapcsolatban a legfontosabb szabály a következő:

Tudni kell, hogy a bár nyitási időpontját a percek többszörösével számolják, a másodperceket nem vesznek számításba. Más szóval, ha a 14:34 és 14:35 közötti időszakban egy új tick 14:34:07-nél érkezett, akkor a legnagyobb felbontásnál, a perces idősíkon 14:43-nál fog megjelenni. A 15 perces felbontásban a bár nyitási időpontok a 15 perc többszörösei, egy órán belül az első bárt az óra 00 percében, a másodikat a 15. a harmadikat a 30. és a negyediket a 45. percében nyitja.

A előre definiált tömbökben történő indexelés jelentőségének megértéséhez oldjunk meg egy egyszerű feladatot:

Figyelem, az ilyen problémák megoldása lehetetlen anélkül, hogy az előre definiált tömböket alkalmaznánk. Annak az Expert Advisornak, amely meghatározza az legnagyobb és a legkisebb árat az előre beállított számú utolsó bár között, a következő lehet a megoldása  (extremumprice.mq4):

//--------------------------------------------------------------------
// extremumprice.mq4 
// The code should be used for educational purpose only.
//--------------------------------------------------------------------
extern int Quant_Bars=30; // Amount of bars
//--------------------------------------------------------------------
int start() // Special funct. start()
 {
 int i; // Bar number 
 double Minimum=Bid, // Minimal price
 Maximum=Bid; // Maximal price
 
 for(i=0;i<=Quant_Bars-1;i++) // From zero (!) to..
 { // ..Quant_Bars-1 (!)
 if (Low[i]< Minimum) // If < than known
 Minimum=Low[i]; // it will be min
 if (High[i]> Maximum) // If > than known
 Maximum=High[i]; // it will be max
 }
 Alert("For the last ",Quant_Bars, // Show message 
 " bars Min= ",Minimum," Max= ",Maximum);
 return; // Exit start()
 }
//--------------------------------------------------------------------

Az extremumprice.mq4 programban egy egyszerű algoritmust használunk. Az elemezni kívánt bárok számát a Quant_Bars extern változóban adjuk meg. A program elején a vételi árat jelöljük ki a kívánt Minimumnak és Maximumnak. A legnagyobb és legkisebb értékek keresése a ciklusoperátorban történik:

 for(i=0;i<=Quant_Bars-1;i++) // From zero (!) to..
 { // ..Quant_Bars-1 (!)
 if (Low[i]< Minimum) // If < than known
 Minimum = Low[i]; // it will be min
 if (High[i]> Maximum) // If > than known
 Maximum = High[i]; // it will be max
 }

Itt megadjuk a Low[i] és High[i] előre definiált tömbelemek feldolgozott index érték tartományát (i integer változó). Figyelj az 1. Kifejezésre és a Feltételre a ciklusoperátor fejlécében:

 for(i=0;i<=Quant_Bars-1;i++) // From zero (!) to..

Az első ismétlést a nulla értékű indexszel végezzük. Ez azt jelenti, hogy az első ismétlésben a zéró bár értékeit elemezzük. Így szavatolt, hogy azokat az utolsó ár-értékeket, amik megjelentek az ablakban, szintén számításba vegyük. Az Előre definiált változók rész tartalmazza azt a szabályt, ami szerint minden előre definiált változó értékét, köztük az előre definiált tömböket is, frissíti a terminál a különleges függvények kezdetekor. Ezért az árértékek változatlanok fognak maradni a számítások alatt.

Az előre definiált tömb indexének felső határa a feldolgozott bárok számánál egyel kisebb. A példánkban a bárok száma 30. Ez azt jelenti, hogy a legnagyobb indexérték 29. Az előre definiált tömb elemek index értékei 0-tól 29-ig terjednek, vagyis 30 bárt fogunk feldolgozni a ciklusban.

Könnyű megérteni a számításokat a ciklusoperátor-törzsben:

 if (Low[i]< Minimum) // If < than known
 Minimum = Low[i]; // it will be min
 if (High[i]> Maximum) // If > than known
 Maximum = High[i]; // it will be max

Ha a Low[i] árfolyamérték (az ismétlés alatt az aktuális indexhez tartozó ár érték) alacsonyabb az eddigi minimális értéknél ez az új érték válik a minimális értékké. Ugyanezzel a módszerrel kiszámoljuk ki a legnagyobb értéket is. A ciklusok végén megkapjuk a Minimum és Maximum változók kívánt értékét. A további programsorokban ezeket az értékeket jelezzük ki.

A program végrehajtásával ezt az eredményt kapjuk:

63. ábra. Az  extremumprice.mq4 EA végrehajtásának eredménye.

Figyeljük meg, hogy az Expert Advisor végtelenül hosszú ideig helyesen működhet, és a program ugyanazokat az index értékeket fogja használni (ebben az esetben 0-tól 29-ig). A null indexszel rendelkező előre definiált tömbelemek értékei változni fognak az új tick megjelenésekor (kivéve az Open[] és Time[] értékeit, mert azok már nem változhatnak a null báron).

Néhány esetben akkor kell valamilyen műveletet végrehajtanunk, amikor egy bár teljesen kialakult. Ez például az olyan algoritmusokban fontos, amik a gyertyaelemzésen alapultak. Ilyen esetben csak a teljesen kialakult bárokat vesszük számításba.

A feladat megoldáshoz meg kell határozni egy új bár kezdetét és észlelni kell egy új ticket a nullbáron. Van erre egy egyszerű és megbízható módszer - figyeljük a nullbár nyitási idejét. A nullbár nyitási ideje az a bárjellemző, ami nem változik a bár kialakulása alatt. Az új tickek, amik egy bár kialakulása alatt jönnek, megváltoztathatják a High[0], Close[0] és Volume[0] értékét. De az Open[0] és Time[0] értékét nem változtathatják meg.

//--------------------------------------------------------------------
// newbar.mq4 
// The code should be used for educational purpose only.
//--------------------------------------------------------------------
extern int Quant_Bars=15; // Amount of bars
bool New_Bar=false; // Flag of a new bar
//--------------------------------------------------------------------
int start() // Special funct. start()
 {
 double Minimum, // Minimal price
 Maximum; // Maximal price
//--------------------------------------------------------------------
 Fun_New_Bar(); // Function call
 if (New_Bar==false) // If bar is not new..
 return; // ..return
//--------------------------------------------------------------------
 int Ind_max =ArrayMaximum(High,Quant_Bars,1);// Bar index of max. price 
 int Ind_min =ArrayMinimum(Low, Quant_Bars,1);// Bar index of min. price 
 Maximum=High[Ind_max]; // Desired max. price
 Minimum=Low[Ind_min]; // Desired min. price
 Alert("For the last ",Quant_Bars, // Show message 
 " bars Min= ",Minimum," Max= ",Maximum);
 return; // Exit start()
 }
//--------------------------------------------------------------------
void Fun_New_Bar() // Funct. detecting ..
 { // .. a new bar
 static datetime New_Time=0; // Time of the current bar
 New_Bar=false; // No new bar
 if(New_Time!=Time[0]) // Compare time
 {
 New_Time=Time[0]; // Now time is so
 New_Bar=true; // A new bar detected
 }
 }
//--------------------------------------------------------------------

A New_Bar globális változót használjuk a programban. Ha az értéke 'true', ez azt jelenti, hogy az utoljára ismert tick egy új bár első tickje. Ha a New_Bar érték 'false' az utoljára ismert tick az aktuális nulla báron belül van, vagyis nem a bár első tickje.

Flag (zászló) egy változó, aminek az értékét valamely esemény vagy tény határozza meg.

Expert Advisorban a New_Bar változót egy flag-ként használjuk. Az értéke közvetlenül egy új bár képződésének tényétől függ.

Az új bár észlelését jelző számításokat a Fun_New_Bar() felhasználói függvényben helyeztük el. A függvény első sorában a New_Time statikus változót deklaráljuk (emlékezzünk, a statikus változók nem vesztik el az értékeiket, a függvény végrehajtása után). Mindegyik függvényhívásnál a New_Bar globális változó értékét 'false'-ra állítjuk. Egy új bár észlelését 'if' operator végrehajtása végzi:

 if(New_Time != Time[0]) // Compare time
 {
 New_Time = Time[0]; // Now time is so
 New_Bar = true; // A new bar detected
 }

Ha New_Time értéke (az előző munkamenetben kiszámolt) nem egyenlő a Time[0]-val, ez jelenti egy új bár képződésének a tényét. Ezesetben a vezérlés lekerül az 'if' operátor testhez, ahol a null bár új nyitási idejét tároljuk és az új értéket kapja a New_Bar változó (azt is mondhatjuk, hogy a zászlót egy emelkedő pozícióba helyeztük).

Miközben ilyen problémákat oldunk meg, fontos számba venni a felhasznált különböző flag-ek sajátosságait. Ebben az esetben a New_Bar sajátossága az, hogy az értéket (flag) még azelőtt kell frissíteni mielőtt az értékét a számításban felhasználnánk (ebben az esetben - a különleges start()függvényben). A New_Bar értékét meghatározó felhasználói függvényt, ezért kell a program elején meghívni, még az első olyan számítás előtt, amiben a New_Bar-t használjuk. A különleges start() függvény felépítése ennek megfelel: felhasználói függvényhívást közvetlenül a változók deklarációja után hajtjuk végre.

A kívánt értékek számítása csak akkor szükséges, ha a start()-ot egy olyan tick indítja el, ami egy új bárt kezd. Ezért a start() indítása után azonnal vizsgálja egy új bárképződést, a flag helyzetét (a New_Bar értékét elemzi):

 if (New_Bar == false) // If bar is not new..
 return; // ..return

Ha az utolsó tick, ami elindította start() végrehajtását, nem alakít egy új bárt, a vezérlés átkerül egy olyan operátorhoz, ami befejezi a start() végrehajtását. És csak ha egy új bár nyílik, akkor kerül a vezérlés tovább a következő sorra (mit a feladatmegoldás igényel).

A 64. ábrán láthatjuk a programvégrehajtás alatt, az előre beállított időintervallumban lévő legnagyobb és legkisebb árak változását:

64. ábra. A newbar.mq4 Expert Advisor végrehajtásának eredmény.