Article: Effective usage of Arrays in MQL | Forex Factory

Options

Go to
Permalinks
Print Thread

Similar Threads

MQL Coding - Let’s talk about how to code mql 0 replies

Passing Array Elements Between Arrays. 1 reply

Help understanding multidimensional arrays, ...? 15 replies

Can arrays be boolean variables? 2 replies

Attachments: Article: Effective usage of Arrays in MQL
Exit Attachments

Article: Effective usage of Arrays in MQL

  • #1
  • First Post: Edited 1:26pm Apr 25, 2009 9:21am | Edited 1:26pm
Every MQL programmer knows that a lot of concepts in MQL programming surrounds the usage of buffers. The "buffers" in MQL context are actually nothing more than arrays that are managed internally by MT4 itself. However, not a lot has been published on the use of Arrays and I find that rather... (I can't find a suitable word). I truly believe if one knows how to manipulate arrays at will, one can do wonders with MQL. That includes overcoming certain limitations of the MQL language. This spurs me to write a little something about our unsung hero, our beacon of hope, our all time (sometimes agonising) saviour... The ARRAY

This post is dedicated to discussions over the use of Arrays and nothing else. You are free to post questions and I (or other programmers) can help where we can.

Before reading on, I urge all beginners to at least read up on what an Array is. A good explanation article can be found here http://book.mql4.com/variables/arrays


--------------------------------------------------------

Defining an array's size based on user input


If ever you wanted an array that doesn't have a fixed size at compilation time but rather changes based on user's needs then this trick is for you.

For those of you who tried the code below but failed, this post aims to offer a workaround.

Inserted Code
extern int Size = 5;

int myArray[Size];

The snipplet above will result in a couple of compilation error.

-> 'Size' - integer number expected
-> ']' - comma or semicolon expected

That's because "Size" actually has no value at this point in time yet. It only gets the value of 5 at the time you load this (script, indicator or EA) onto chart.

Which is why I'm going to introduce you to an array user's best friend

int ArrayResize( object&array[], int new_size)
Sets a new size for the first dimension. If executed successfully, it returns count of all elements contained in the array after resizing, otherwise, returns -1, and array is not resized.
Note: Array declared at a local level in a function and resized will remain unchanged after the function has completed its operation. After the function has been recalled, such array will have a size differing from the declared one.

The following code snipplet will use ArrayResize to workaround the compilation error.

Inserted Code
extern int Size = 5;

int myArray[];
//+------------------------------------------------------------------+
//| expert initialization function |
//+------------------------------------------------------------------+
int init()
{
   ArrayResize( myArray, Size );
}

What this does is simple. myArray has no size at compile time. but we know that upon loading, the init() function always run first, and by that time, all extern variables are initialised, which means the value of Size has been put in and we use ArrayResize to change the size of myArray to whatever it is the user had placed in the input tab.

I've been using this for quite a while and I'm sure this method can some good in the right hands.

My next post will be about how to use Arrays to mimic buffers in order to overcome indicator's limitation of only allowing 8 buffers.
(I've once written a single indicator that requires 17 buffers for its computations)
Programming for a better future.
  • #2
  • Apr 26, 2009 2:42pm Apr 26, 2009 2:42pm
Zen, thanks for this info. I use arrays extensively throughout my coding. I look forward to reading more of your posts.

David
  • #3
  • Apr 27, 2009 9:27am Apr 27, 2009 9:27am
I'lll be back from my reservist training by the end of the week. Will post the promised article then. Thanks for your patience.

regards,
Zen
Programming for a better future.
  • #4
  • May 3, 2009 1:23am May 3, 2009 1:23am
In indicators, there's mainly 2 ways of using buffers. One way is to use it for plotting lines and historgrams, etc, the other is to have a buffer solely for assisting in calculations.

e.g. bufferA which was set for display, has its values derived from bufferB (meant for calculation).

Unfortunately the total number of buffers allowed in MQL4 is 8. That includes both for display and for calculations added together. This led to programmers having to scrimp and save their buffer usage to a point they may need to create multiple indicators for a single purpose. What this article aims to acheive is to try and allow programmers to stretch their buffer usage to its boundaries.

IMPORTANT NOTE: I cannot extend the number of buffers you can use for display. But what I can do is allow you to use arrays as a substitute for buffers used for calculations. That way you can use those limited 8 buffers solely for display purposes.

Before venturing into the codes, let's first understand what a buffer in MQL4 is all about.

A buffer in MQL4 is essentially an array which has its size defined by the number of candles on chart. And each of the value it contains corresponds to a particular candle. The first position in the buffer [0] will hold the value for the current candle. the second position in the buffer [1] will hold the value for the previous candle, and so on... when a new candle appears, the buffer will automatically receive a new position, and all the values it contains must shift. Meaning, value which was in position [0] will now shift to position [1] and so on...

e.g.

there's 1627 candles on chart currently.
bufferA will have 1627 positions. From bufferA[0] to bufferA[1626] - Note that position starts from 0
when a new candle appears, there will be 1628 candles.
bufferA will also have 1628 positions. From bufferA[0] to bufferA[1627] and the values must be shifted

[0] go to [1]
[1] go to [2]
[2] go to [3]
...
...
[1625] go to [1626]
[1626] go to [1627]

All the above are done automatically for you when you use buffers. To use arrays as buffers, you'll have to mimic these behavious of adding and shifting values.

Problem 1:
How do you create an Array which has the same number of positions as the number of candles on chart?

This question can actually be broken into 2 segments. How do you get the number of candles on chart? and how do you assign that number to the size of an array?

For the first part, get yourself aquainted with "Bars". This is the predefined variable within MQL that constantly updates itself with the number of candles in the current chart.

For the Second part, yes you probably guessed it, the answer was in the previous post. Just use ArrayResize

let's say I have an array called buffer9[] which I want to have it become a buffer for calculation. The first step would be

Inserted Code
ArrayResize( buffer9, Bars);

Problem 2:
How do I detect when its time to resize my array due to a new candle?

What I do for this is to have a datetime variable known as ArrayResizeTime and first assign it to the current candle's time Time[0]. And I constantly check the value. If a new candle appears, Time[0] will change and become different from my ArrayResizeTime value. That's when I resize the array and then assign the new Time[0] to ArrayResizeTime so that the cycle repeats.

Inserted Code
if (Time[0] != ArrayResizeTime && allLoaded)  // don't worry about allLoaded for now
{
   //Print("New Candle!!!");
   ResizeAllArrays();
   ArrayResizeTime = Time[0];
}

Problem 3:
How do I resize the array and shift its values?

Inserted Code
void ResizeAllArrays()
{
   ArrayResize( buffer9, Bars);
   // must shift the contents like how buffers does it.
   for (int i=Bars-1; i>0; i--)
   {
      buffer9[i] = buffer9[i-1];
   }
}

Now that the core problems are solved, it ain't hard to snap together something to work with. What I'm posting here is a generic template you can use at will. Probably a few tweaks here and there is necessary depending on how your indicator is meant to work. Post questions if there's anything you don't understand in this code snipplet.

Inserted Code
#property indicator_separate_window
#property indicator_buffers 8

#property indicator_color1 Green
#property indicator_color2 Red
#property indicator_color3 DarkGray
#property indicator_color4 Green
#property indicator_color5 Red
#property indicator_color6 DarkGray
#property indicator_color7 Blue
#property indicator_color8 White

// buffers for display
double buffer1[];
double buffer2[];
double buffer3[];
double buffer4[];
double buffer5[];
double buffer6[];
double buffer7[];
double buffer8[];
// buffers for calculation
double buffer9[];
double buffer10[];
double buffer11[];
double buffer12[];
double buffer13[];
double buffer14[];
double buffer15[];
double buffer16[];

bool allLoaded = false;
datetime ArrayResizeTime;
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int init()
{
   allLoaded = false;
   ArrayResizeTime = Time[0];
//---- all 8 buffers used for display
   SetIndexStyle(0, DRAW_HISTOGRAM, STYLE_SOLID, 2, Green);
   SetIndexBuffer(0, buffer1);   
   SetIndexStyle(1, DRAW_HISTOGRAM, STYLE_SOLID, 2, Red);
   SetIndexBuffer(1, buffer2);   
   SetIndexStyle(2, DRAW_HISTOGRAM, STYLE_SOLID, 2, DarkGray);
   SetIndexBuffer(2, buffer3);   
   SetIndexStyle(3, DRAW_LINE, STYLE_SOLID, 1, DarkGray);
   SetIndexBuffer(3, buffer4);   
   SetIndexStyle(4, DRAW_LINE, STYLE_SOLID, 1, Red);
   SetIndexBuffer(4, buffer5);   
   SetIndexStyle(5, DRAW_LINE, STYLE_SOLID, 1, Green);
   SetIndexBuffer(5, buffer6);   
   SetIndexStyle(6, DRAW_LINE, STYLE_SOLID, 1, Blue);
   SetIndexBuffer(6, buffer7);   
   SetIndexStyle(7, DRAW_LINE, STYLE_SOLID, 1, White);
   SetIndexBuffer(7, buffer8);   
//----   
   return(0);
}
//+------------------------------------------------------------------+
//| Custom indicator deinitialization function                       |
//+------------------------------------------------------------------+
int deinit()
{
//----
   
//----
   return(0);
}

void ResizeAllArrays()
{
   ArrayResize( buffer9, Bars);
   ArrayResize( buffer10, Bars);
   ArrayResize( buffer11, Bars);
   ArrayResize( buffer12, Bars);
   ArrayResize( buffer13, Bars);
   ArrayResize( buffer14, Bars);
   ArrayResize( buffer15, Bars);
   ArrayResize( buffer16, Bars);
   // must shift the contents like how buffers does it.
   for (int i=Bars-1; i>0; i--)
   {
      buffer9[i] = buffer9[i-1];
      buffer10[i] = buffer10[i-1];
      buffer11[i] = buffer11[i-1];
      buffer12[i] = buffer12[i-1];
      buffer13[i] = buffer13[i-1];
      buffer14[i] = buffer14[i-1];
      buffer15[i] = buffer15[i-1];
      buffer16[i] = buffer16[i-1];
   }
}

void Calculate(int index)
{
   // Conduct the necessary calculations here
}

//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int start()
{
   int i;                           // Bar index       
   int Counted_bars;                // Number of counted bars
   //--------------------------------------------------------------------   
   Counted_bars=IndicatorCounted(); // Number of counted bars   
   i=Bars-Counted_bars-1;           // Index of the first uncounted   

   // This is the first time those additional arrays were assigned its size
   if (!allLoaded)
   {
      ArrayResize( buffer9, Bars);
      ArrayResize( buffer10, Bars);
      ArrayResize( buffer11, Bars);
      ArrayResize( buffer12, Bars);
      ArrayResize( buffer13, Bars);
      ArrayResize( buffer14, Bars);
      ArrayResize( buffer15, Bars);
      ArrayResize( buffer16, Bars);
   }
   while(i>=0)                      // Loop for uncounted bars     
   {
      if (i == 0)
      {
         if (Time[0] != ArrayResizeTime && allLoaded)
         {
            //Print("New Candle!!!");
            ResizeAllArrays();
            ArrayResizeTime = Time[0];
         }
         buffer9[i] = EMPTY_VALUE;
         buffer10[i] = EMPTY_VALUE;
         buffer11[i] = EMPTY_VALUE;
         buffer12[i] = EMPTY_VALUE;
         buffer13[i] = EMPTY_VALUE;
         buffer14[i] = EMPTY_VALUE;
         buffer15[i] = EMPTY_VALUE;
         buffer16[i] = EMPTY_VALUE;
      }
      Calculate(i);
      i--;
   }
   allLoaded = true;
   return(0);
}
//+------------------------------------------------------------------+

regards,
Zen
Programming for a better future.
  • #5
  • Jul 15, 2009 10:35am Jul 15, 2009 10:35am
I found Your post just when I was about to pull my last hair out.
Very well written. Much appreciated!!!

Bluefish
  • #6
  • Jul 16, 2009 6:37am Jul 16, 2009 6:37am
Good job taking on the task of enlightening others of the virtues arrays ...
I feel some explanation of Series Arrays is also needed here :

Normal arrays that you declare are stored in memory in a block from low index to high index like this :

0,1,2,3,4,5,etc.

Series arrays created behind the scenes by MT4 are stored in the opposite direction like this

etc,5,4,3,2,1,0

Examples of MT4 series arrays are Time[], Close[], buffer1[] etc.

There is a good reason for this, and its to do with the way the history of price data is stored. As the (chart) history grows, newer values are written to the end of the disk file, pushing older values into the file. So when a chunk of data is read from a history file and placed in memory it appears backwards

EG in a 1 minute chart

3minsago,2minsago,1minago,now

To avoid needing to swap the data around it is merely referenced backwards IE 0 = now, 1 = 1minago, 2 2minago etc.

If it were referenced the other way around then the 'now' bar would be index 4, but in another minute it would be 5, then 6 etc. which would make life much more difficult than having 'now' always in position 0.

Moving on, Mt4 provides the ability to swap the way in which your arrays are referenced using the function ArraySetAsSeries

Most of the time it doesnt matter to us which way round the arrays are stored or referenced, however it does when using the function ArrayResize

ArrayResize always adds (or removes) elements from the right hand end of the array EG

double array1[];

ArrayResize(array1,5);

// index 0,1,2,3,4
// Values A,B,C,D,E

ArrayResize(array1,7);

// adds two more elements to the right so we get
// 0,1,2,3,4,5,6
// A,B,C,D,E,?,?

ArrayResize(array1,3);
// deletes 4 elements from the right so we get
// 0,1,2
// A,B,C


N.B. The stored values, and the index that references each element remain unchanged.

If however we flip the array using ArraySetAsSeries before (and after) resizing the array we can add or remove elements from the left hand side of the array

double array1[];

ArrayResize(array1,5);

// index 0,1,2,3,4
// values A,B,C,D,E

ArraySetAsSeries(array1,true);
ArrayResize(array1,7);
ArraySetAsSeries(array1,false);

// adds two more elements to the LEFT so we get
// 0,1,2,3,4,5,6
// ?,?,A,B,C,D,E

ArraySetAsSeries(array1,true);
ArrayResize(array1,3);
ArraySetAsSeries(array1,false);

// deletes 4 elements from the LEFT so we get
// 0,1,2
// C,D,E

N.B. the values remain unchanged but their index position within the array DOES change.

Armed with this knowledge we can now rewrite your function without the need to shuffle all the elements in each array making it run noticably faster on large arrays.

void ResizeAllArrays()
{
ArraySetAsSeries( buffer9,true);
ArrayResize( buffer9, Bars);
ArraySetAsSeries( buffer9,false);

ArraySetAsSeries( buffer10,true);
ArrayResize( buffer10, Bars);
ArraySetAsSeries( buffer10,false);

ArraySetAsSeries( buffer11,true);
ArrayResize( buffer11, Bars);
ArraySetAsSeries( buffer11,false);

ArraySetAsSeries( buffer12,true);
ArrayResize( buffer12, Bars);
ArraySetAsSeries( buffer12,false);

ArraySetAsSeries( buffer13,true);
ArrayResize( buffer13, Bars);
ArraySetAsSeries( buffer13,false);

ArraySetAsSeries( buffer14,true);
ArrayResize( buffer14, Bars);
ArraySetAsSeries( buffer14,false);

ArraySetAsSeries( buffer15,true);
ArrayResize( buffer15, Bars);
ArraySetAsSeries( buffer15,false);

ArraySetAsSeries( buffer16,true);
ArrayResize( buffer16, Bars);
ArraySetAsSeries( buffer16,false);
}
  • #7
  • Jul 16, 2009 5:48pm Jul 16, 2009 5:48pm
To conclude (after a rude interuption)

In this particular case we only ever want reference the arrays as a Series
So we start with the same declaration, but we immediately set the array as a series.


double buffer9[];
...
double buffer16[];


init()
{
SetArrayAsSeries(buffer9,true);
...
SetArrayAsSeries(buffer16,true);

ResizeAllArrays();


}


now each time a new bar appears and we use the ResizeArray function, element 0 will shift back to element 1 automatically and a new element 0 will be added.

And so the final logical conclusion is reached where the following function is all that is required.

void ResizeAllArrays()
{
ArrayResize( buffer9, Bars);
ArrayResize( buffer10, Bars);
ArrayResize( buffer11, Bars);
ArrayResize( buffer12, Bars);
ArrayResize( buffer13, Bars);
ArrayResize( buffer14, Bars);
ArrayResize( buffer15, Bars);
ArrayResize( buffer16, Bars);
}
  • #8
  • Edited 10:40am Apr 14, 2010 9:43am | Edited 10:40am
Very informative, now I understand the use of asSeries.
However, there is one problem with the above code. Once the number of bars on the chart reaches the maximum (tools -> options -> charts,) then Bars will no longer change, resize won't do anything, and the arrays don't shift.
Need to add something like:
Inserted Code
static Bars.prev;
if (Bars == Bars.prev) { // or ArraySize(buffer9)== Bars
  ArrayResize( buffer9, Bars-1);
  ...
}
Bars.prev = Bars;
ArrayResize( buffer9, Bars-1);
...
After thinking a little more, I realize that the above won't work.
Once you reach max bars, the shifting fails.
  • #9
  • Apr 21, 2010 4:24am Apr 21, 2010 4:24am
Ok well spotted.

It would be nice to use IndicatorCounted function to determine the number of new bars but after some investigation it reports 1 bar on a normal tick but 2 bars for the first tick of a new bar. Since we may have missed multiple bars (maybe connection failure etc) the best strategy would be :


Inserted Code
double buffer9[];
...
double buffer16[];

datetime lastsizetime=0;
int lastbars=0;

int init()
{
SetArrayAsSeries(buffer9,true);
...
SetArrayAsSeries(buffer16,true);

lastsizetime=0;
lastbars=0;

ResizeAllArrays();


}

int Start()
{

  if (lastsizetime !=Time[0]) ResizeAllArrays();

/// do your stuff

}


void ResizeAllArrays()
{
if ((lastsizetime ==0) || (lastbars !=Bars))
{
ArrayResize( buffer9, Bars);
ArrayResize( buffer10, Bars);
ArrayResize( buffer11, Bars);
ArrayResize( buffer12, Bars);
ArrayResize( buffer13, Bars);
ArrayResize( buffer14, Bars);
ArrayResize( buffer15, Bars);
ArrayResize( buffer16, Bars);
}
else
{
  ///calc how many bars are new : usually just 1 but cant rely on IndicatorCounted function
  int count=0;
  while ((Time[count] > lastsizetime) && (count <Bars)) count++;
  if ((count >0) && (lastbars==Bars ))
  {
   SetArrayAsSeries(buffer9,false);
   ArrayResize( buffer9, Bars-count);
   SetArrayAsSeries(buffer9,true);
   ArrayResize( buffer9, Bars);
    .....
   SetArrayAsSeries(buffer16,false);
   ArrayResize( buffer16, Bars-count);
   SetArrayAsSeries(buffer16,true);
   ArrayResize( buffer16, Bars);
  
  }
}

lastsizetime = Time[0];
lastbars=Bars;
}
  • #10
  • Edited 10:03am Jun 13, 2011 8:59am | Edited 10:03am
Quoting rangebound
In this particular case we only ever want reference the arrays as a Series
.......
And so the final logical conclusion is reached where the following function is all that is required.

void ResizeAllArrays()
{
ArrayResize( buffer9, Bars);
ArrayResize( buffer10, Bars);
.......
Doesn't work. Here a quote from mladen over at tsd:
Quote
Just found out a workaround on Metatrader stuppidity no.???

if anyone uses arrays in code set as series, be sure to unset it as series before resizing if you want to save values stored in the array, in short

if you have anywhere in code something like this

Inserted Code
ArraySetAsSeries(Buffer,true);
later on the code


Inserted Code
ArrayResize(Buffer,Bars);
produces wrong array as result, you must use

Inserted Code
ArraySetAsSeries(Buffer,false); 
ArrayResize(Buffer,Bars); 
ArraySetAsSeries(Buffer,true);

I have tried it, generally if the arrays have to be referenced as Series (e.g. if iMAOnArray() is used), the above does the shift. If they are not AsSeries, an inverse flip trick has to be done (as described in your previous post). So the rule always seems to be:

switch the array to opposite type
resize to Bars
switch back to original type
Quoting WHRoeder
Once the number of bars on the chart reaches the maximum (tools -> options -> charts,) then Bars will no longer change, resize won't do anything, and the arrays don't shift.
MT4 carelessly adds bars to a chart even if Max Bars on chart limit reached. After restart, Bars will start at the set limit and increment. There will always be 'Bars++' on a new bar, so no issue here.
MarginTrader All Time Return: na
  • #11
  • Apr 14, 2012 1:19pm Apr 14, 2012 1:19pm
Quoting MaryJane
MT4 carelessly adds bars to a chart even if Max Bars on chart limit reached. After restart, Bars will start at the set limit and increment. There will always be 'Bars++' on a new bar, so no issue here.
According to http://forum.mql4.com/46987#611724 Bars will sometimes be reduced back to max bars on chart and IndicatorCounted() will return zero when that happens.
  • #12
  • Apr 16, 2012 5:57pm Apr 16, 2012 5:57pm
I found 'IndicatorCounted()' to be buggy too. I dont use it in my code. I prefer to do my own calculations of bars. I found that the series array functions are back wards, that is, in more ways then one.

There are ways to create multiple related indicators into one code file. Say as an example, you want to have an indicator displayed in different time frames. All you have to do is use regular arrays and transfer that data to the buffers on a timed base. That is say show M1 cart of indicator then show M5 then M15 etc.. Or show the pound data then eur data etc.. You can have an unlimited out put and yes with more then 8 buffers too.

Although, with every thing that I have done, I have not exceded the need for more then the 8.




Below are code fragments

The red is the bar calculatations
The blue is the timing which groupe and which chart to show
the purple is the code for loading and unloading data. Hint you must load a buffer with empty values after each use before you reload them with new data, if not the buffers will retain the old datas range and the chart will be sized with the range of the old data not the new data.

Inserted Code
[color=red]          @_BarsToDraw   =  $_NewBars;[/color]
[color=red]          @_BarsInView   =  WindowFirstVisibleBar() - 1;[/color]
[color=red]          @_BarsOnChart  =  WindowBarsPerChart   () - 1;[/color]
[color=red]          @_BarsToChart  =  @_BarsInView - LeftScale;[/color]
[color=blue]           @_BarKey     =  IFFn( $_GetDevice( $_ControlID, "Show Bar[0]" ), OpenBar, CloseBar );[/color]
[color=blue]           @_PlayWave   =  $_GetDevice( $_ControlID, "PlaySoundAlert" );[/color]
[color=blue]           @_GroupKey   =  $_GetDevice( $_ControlID, "Show Group"     );[/color]
[color=blue]           @_ChartKey   =  $_GetDevice( $_ControlID, "Show Chart"     );[/color]
[color=blue]           @_ChartLock  =  $_GetDevice( $_ControlID, "Chart Lock"     );[/color]
[color=darkorchid]           MapBuffers  ( $_LaunchBuffers, 7 );[/color]
            Inefficiency( @_BarsCalculated, @_ChartKey, @_LastBarsDraw );
[color=darkorchid]               if( @_GroupKey == 3 ) {[/color]
[color=darkorchid]                   if( @_LastChartShow != @_ChartKey || @_LastBarsDraw != @_BarsToChart ) {[/color]
[color=darkorchid]                       @_BarsToDraw  =  @_BarsToChart;[/color]
[color=darkorchid]                       $_DeleteGraphicPage( 4.4 );[/color]
[color=darkorchid]                       MapBuffers( $_UnLoadBuffers, @_LastChartShow );[/color]
[color=darkorchid]                       MapBuffers( $_LoadBuffers,   @_ChartKey );[/color]
[color=darkorchid]                   } // End If, @_LastChart:[/color]
[color=darkorchid]                   @_LastChartShow  =  @_ChartKey;[/color]
[color=darkorchid]                   @_LastBarsDraw   =  @_BarsToChart;[/color]
                    OutPut();
                    LaunchMenu( MouseMenu, ON, @_ChartKey, @_ChartLock );
                } else {
[color=darkorchid]                   @_LastChartShow  =  Empty;[/color]
[color=darkorchid]                   @_LastBarsDraw   =  Empty;[/color]
[color=darkorchid]                   MapBuffers( $_ReMoveBuffers, $_ALL );[/color]
                    $_ClearAllGraphics ( $_ProgramObject );
                } // End If, @_GroupKey:


The code below does the loading and reloading of the data



Inserted Code
        switch( @_ChartKey ) {
            case Minor:
                $_TransferData( AlphaCritical, Interim1, AlphaData, @_BarKey, @_BarsToDraw );
                $_TransferData( BetaCritical,  Interim1, BetaData,  @_BarKey, @_BarsToDraw );
                $_TransferData( FearIndex,     Interim1, FearData,  @_BarKey, @_BarsToDraw );
                $_TransferData( GreedIndex,    Interim1, GreedData, @_BarKey, @_BarsToDraw );
                break;
            case Secondary:
                $_TransferData( AlphaCritical, Interim2, AlphaData, @_BarKey, @_BarsToDraw );
                $_TransferData( BetaCritical,  Interim2, BetaData,  @_BarKey, @_BarsToDraw );
                $_TransferData( FearIndex,     Interim2, FearData,  @_BarKey, @_BarsToDraw );
                $_TransferData( GreedIndex,    Interim2, GreedData, @_BarKey, @_BarsToDraw );
                break;
            case Primary:
                $_TransferData( AlphaCritical, Interim3, AlphaData, @_BarKey, @_BarsToDraw );
                $_TransferData( BetaCritical,  Interim3, BetaData,  @_BarKey, @_BarsToDraw );
                $_TransferData( FearIndex,     Interim3, FearData,  @_BarKey, @_BarsToDraw );
                $_TransferData( GreedIndex,    Interim3, GreedData, @_BarKey, @_BarsToDraw );
                $_CreateLevels( SKIndex, SecondKnuckle, @_BarKey, @_BarsToDraw, @_BarsToChart );
                $_LabelIndex( "SK Index", FearIndex, GreedIndex, SecondKnuckle, 2 );
                break;
            case Extended:
                $_TransferData( AlphaCritical, Interim4, AlphaData, @_BarKey, @_BarsToDraw );
                $_TransferData( BetaCritical,  Interim4, BetaData,  @_BarKey, @_BarsToDraw );
                $_TransferData( FearIndex,     Interim4, FearData,  @_BarKey, @_BarsToDraw );
                $_TransferData( GreedIndex,    Interim4, GreedData, @_BarKey, @_BarsToDraw );
                break;


and the function below does the actural loading of the data, from a regular array to the buffer,


Inserted Code
void
    $_TransferData( double& Buffer[], double Array[][], int Study, int LastBar, int BarDraw ) {
        int   Index   =   Empty;
        int   Back    =   Empty;
        int   Total   =   ArrayRange( Array, 0 );
            for( Index = BarDraw, Back = Total - Index - 1; Index >= 0; Index --, Back ++ )
                Buffer[ Index ]  =  Array[ Back ][ Study ];
            if( LastBar == CloseBar )   {   Buffer[ OpenBar ]  =  DUMP;   }
            Buffer[ @_BarsInView - LeftScale + 1 ]  =  DUMP;
    return;
} // End Routine Procedure, $_TransferData:




I have created what I called the 'iPack File' an indicator file with multiple indicators but what is even more that was to have mutiple iPack Files share a common window.



Keit
Trader Keit ... Methods Of A Dirt Road Mad Man....
  • #13
  • Dec 26, 2012 6:03pm Dec 26, 2012 6:03pm
This is a newbie question so please help
if I have a 2D array , but I don't know its size
How do I check if all the values of the array are set to zero ?
  • #14
  • Dec 26, 2012 8:15pm Dec 26, 2012 8:15pm
Quoting icon
This is a newbie question so please help
if I have a 2D array , but I don't know its size
How do I check if all the values of the array are set to zero ?
Inserted Code
bool isClear2D(double arr[][], double v=0.){
   for (int i=ArrayRange(arr,0)-1; i>= 0; i--)
      for (int j=ArrayRange(arr,1)-1; j>= 0; j--)
         if (arr[i][j] != v) return(false);
   return(true);
}
  • #15
  • Nov 7, 2013 4:45am Nov 7, 2013 4:45am
Hi there, I have a question related to 2-dim arrays. I want to create a 2-dim buffer array in a sub function on the local level. It seems that the 2nd dim size must and can be only defined by a dedicated number. Is that true ? I tried to define the 2nd dim size using a defined integer letter like "n" but this doesn't work. Is there no possibility to change the size of the 2nd dim ?
  • #16
  • Nov 7, 2013 5:50am Nov 7, 2013 5:50am
Quoting Profitiser
Hi there, I have a question related to 2-dim arrays. I want to create a 2-dim buffer array in a sub function on the local level. It seems that the 2nd dim size must and can be only defined by a dedicated number. Is that true ? I tried to define the 2nd dim size using a defined integer letter like "n" but this doesn't work. Is there no possibility to change the size of the 2nd dim ?
correct, you cannot re-size or dynamically size the 2nd dimension.

but it is quite simple to use alternative methods, if your 2nd dimension is only a few then just have a few single dimension arrays instead, or if it is greater, then a simple routine could use a single dimension array to emulate a multi-dimension array.
  • #17
  • Feb 1, 2014 10:00am Feb 1, 2014 10:00am
Quoting rangebound
ArrayResize always adds (or removes) elements from the right hand end of the array
Very good explanations by Zen Leow and rangebound, helped me alot. Just a small but important point: ArrayResize does NOT always remove elements from the right hand side, but from the end of the array. If the array is a series array, then the end of the array is on the left hand side, because series arrays are indexed right to left. Here is a code snippet that incorporates all that has been discussed on this thread. It will resize any array, series OR non-series, up to a maximum size. Thereafter it will perform a shift of the elements, leaving a space for the latest data value at index 0.

Inserted Code
//+------------------------------------------------------------------+
//Usage:
//        _advance(myArray, MAXARRAYSIZE);
//        myArray[0] = newDataValue;
//+------------------------------------------------------------------+
void _advance(double & array[], int limit)
{
    int arrSz;
    bool state;
  
    arrSz = ArraySize(array);
    state = ArrayGetAsSeries(array);  
 
    if (arrSz < limit) {
        ArraySetAsSeries(array, !state);
        ArrayResize(array, arrSz + 1);
        ArraySetAsSeries(array, state);
    }
    else
    {
        ArrayResize(array, arrSz-1);
        ArraySetAsSeries(array, !state);
        ArrayResize(array, arrSz);
        ArraySetAsSeries(array, state);
    }  
}
  • #18
  • Mar 30, 2017 7:27am Mar 30, 2017 7:27am
Thanks for all the above comments. I am a newbie programmer in MQ4, very helpful.
It seems to me that HariFF has made a good summary with that code. But one extra remark: this works only with one-dimensional arrays.

With multidimensional arrays ArrayResize always adds a new record AT THE END, irrespective of the Series-state !

So if you want for multidimensional arrays absolutely to have them numbered where 0 is "now", then you have to re-number the elements "manually", that is: after ArrayResize, move the array-elements one by one to their new index-number.

Please correct me if I am wrong.
  • #19
  • Jun 27, 2017 6:41am Jun 27, 2017 6:41am
Quoting Sensor
...this works only with one-dimensional arrays. With multidimensional arrays ArrayResize always adds a new record AT THE END, irrespective of the Series-state ! So if you want for multidimensional arrays absolutely to have them numbered where 0 is "now", then you have to re-number the elements "manually", that is: after ArrayResize, move the array-elements one by one to their new index-number. Please correct me if I am wrong.
According to what I remember of the MQL documentation, ArrayResize is useful only for dynamic arrays, and in the case of multi-dimensional arrays the first dimension has to be dynamic, ie, no fixed size.

Im updating this thread because Ive recently been trying to work with Array of Array - the above code gets around MQL restrictions regarding structures containing dynamic arrays or strings. It works in all the cases I need, and gets around limitations with ArrayCopy and assignment of non-simple structures.

I defined the code as a template, so that it could be used with various datatypes. There is a EA to test it as well.
Attached File(s)
File Type: mq4 PublicTestArrayOfDynamicArray.mq4   10 KB | 741 downloads

It displays a list of 15 integers on screen, from various dynamic arrays (non-series, series, with structs as members containing: i) integer ii) string iii) dynamic array as a member).

For the last array (dynamic array of dynamic arrays) the outer array has a defined maximum of 5 elements, each of which is a dynamic array of maximum 3 elements. So remember that as the limit of the outer array is reached (ARRSZ in test ea) and the last dynamic array member drops off the list, the main array will lose three integers off the end.

Enjoy
  • #20
  • Edited 5:38am Jun 29, 2017 3:57am | Edited 5:38am
Quoting HarriFF
{quote} According to what I remember of the MQL documentation, ArrayResize is useful only for dynamic arrays, and in the case of multi-dimensional arrays the first dimension has to be dynamic, ie, no fixed size. Im updating this thread because Ive recently been trying to work with Array of Array - the above code gets around MQL restrictions regarding structures containing dynamic arrays or strings. It works in all the cases I need, and gets around limitations with ArrayCopy and assignment of non-simple structures. I defined the code as a template,...
Hi Harrison,

You put in a lot of thought in this implementation and you're on the right track as far as handling multidimensional dynamic arrays, but using structs aren't necessary and aren't good form. Fortunately since the MT4 updates MQ has included some of the MT5 libraries in MT4. With this you get their implementation of vectors with a lot of enhanced functionality. I would like to note that as far as multidimensional arrays go, 95% of the code I see are using them as structs eg. rates[][4] when it should be a class or struct eg. rates[i].high, rates[i].low... and so on.

There are occasionally times when you legitimately need multidimensional dynamic vectors so here is an example of how to do it with the MQL library.

Inserted Code
//+------------------------------------------------------------------+
//|                             MultiDimensional_Dynamic_Vectors.mq4 |
//|                                                      nicholishen |
//|                                   www.reddit.com/u/nicholishenFX |
//+------------------------------------------------------------------+
#property copyright "nicholishen"
#property link      "www.reddit.com/u/nicholishenFX"
#property version   "1.00"
#property strict
#define MATRIX_SIZE 30
#include <Arrays\ArrayObj.mqh>
#include <Arrays\ArrayInt.mqh>
// inheriting CArrayObj and making it a template class so we can overload the []
// operator to return the pointer to the indexed objects
 
template<typename T>
class vector : public CArrayObj
{
public:
   T operator[](const int index)const{return (T)At(index);}
};
//+------------------------------------------------------------------+
//| Script program start function                                    |
//+------------------------------------------------------------------+
void OnStart()
{
   MathSrand(GetTickCount());
  
   // declare an object of class vector and cast with type CArrayInt pointer
   vector<CArrayInt*> int_matrix;
  
   for(int i=0;i<MATRIX_SIZE;i++)
   {
      CArrayInt *int_vector = new CArrayInt();     // new ArrayInt vector on heap  
      for(int j=0;j<MATRIX_SIZE;j++)
      {
         int_vector.Add(rand());                   // add random numbers to array
      }
      int_matrix.Add(int_vector);                  // add int_vector pointer to matrix for automatic memory managment
   }
   string res = "========== BEFORE SORT ==========\n\n";
   for(int i=0;i<int_matrix.Total();i++)           // int_matrix.Total() returns the number of CArrayInt pointer elements on array
   {
      for(int j=0;j<int_matrix[i].Total();j++)     // int_matrix[i].Total() return the number of elements in vector i
      {
         res+= string(int_matrix[i][j]);
         res = j < int_matrix[i].Total() -1 ? res+" , " : res; // we won't add a comma to the last int in row
      }
      res+="\n";
   }
   Comment(res);
   Sleep(2500);
   res = "========== AFTER SORT ==========\n\n";
   for(int i=0;i<int_matrix.Total();i++)          
   {
      int_matrix[i].Sort();                        // let's sort it for fun
      for(int j=0;j<int_matrix[i].Total();j++)    
      {
         res+= string(int_matrix[i][j]);
         res = j < int_matrix[i].Total() -1 ? res+" , " : res;
      }
      res+="\n";
   }
   Comment(res);
}
//+------------------------------------------------------------------+

We can even get fancy and sort the matrix vertically by the sum in all horizontal rows. We achieve this by creating a child class of CArrayInt and adding two new public methods. 1. TotalOnArray a method that simply adds up all the numbers in the array. 2. override the Compare method from the CObject class

Inserted Code
class CMyIntArray : public CArrayInt
{
public:
   int TotalOnArray() const
   {
      int res = 0;
      for(int i=0;i<Total();i++)
         res+=this[i];
      return res;
   }
   int Compare(const CObject* node,const int mode=0)const override
   {
      CMyIntArray *that = (CMyIntArray*)node;
      if(this.TotalOnArray() > that.TotalOnArray())
         return 1;
      else if(this.TotalOnArray() < that.TotalOnArray())
         return -1;
      else
         return 0;
   }
};

As you can see, we didn't have to use any of the Array functions, we have a lot more functionality, and our code was much shorter and more readable. We can still make this better. Attached you'll find a clean version where the only code in the start function is:
Inserted Code
void OnStart()
{
   CMyIntMatrix int_matrix(MATRIX_COLUMNS,MATRIX_ROWS);  
}
Attached File(s)
File Type: mq4 MultiDimensional_Dynamic_Vectors_fancy.mq4   4 KB | 684 downloads
File Type: mq4 MultiDimensional_Dynamic_Vectors_simple.mq4   2 KB | 703 downloads
File Type: mq4 MultiDimensional_Dynamic_Vectors_Clean.mq4   4 KB | 654 downloads
0 traders viewing now