SOM EA

//+------------------------------------------------------------------+

//|                                                      SOM_v02.mq4 |

//|                      Copyright © 2010, MetaQuotes Software Corp. |

//|                                        http://www.metaquotes.net |

//+------------------------------------------------------------------+

#property copyright "Copyright © 2010, MetaQuotes Software Corp."

#property link      "http://www.metaquotes.net"

#define BUY_MAP 1

#define SELL_MAP 0

#define HOLD_MAP 2

//Map size for BUY and SELL

#define MAPBASE 10000

//Map size for HOLD

#define HOLDBASE 25000

//Number of map memory-cells for each bar

#define VBASE 7

int LastBars = 0;

double vector[VBASE]; //Vector with memory-cells for current bar

double vectorp[VBASE]; //Vector with memory-cells for previous bar

//3 Maps

double MapBuy[MAPBASE][VBASE];

double MapSell[MAPBASE][VBASE];

double MapHold[HOLDBASE][VBASE];

extern string MapPath = "rl.txt";

//+------------------------------------------------------------------+

//| expert initialization function                                   |

//+------------------------------------------------------------------+

int init()

  {

//----

   InitKohonenMap();

   LoadKohonenMap();   

//----

   return(0);

  }

//+------------------------------------------------------------------+

//| expert deinitialization function                                 |

//+------------------------------------------------------------------+

int deinit()

  {

//----

   SaveKohonenMap();

//----

   return(0);

  }

//+------------------------------------------------------------------+

//| expert start function                                            |

//+------------------------------------------------------------------+

int start()

  {

//----

   double bmu[3] = {0, 0, 0};

   vector[0] = 0;

   vector[1] = 1;

   vector[2] = 2;

   vector[3] = 3;

   vector[4] = 4;

   vector[5] = 5;

   vector[6] = 6;

   MapLookup(vector, bmu);   

  //if ((bmu[0] < bmu[1]) && (bmu[0] < bmu[2])) Buy();

  //else if ((bmu[1] < bmu[0]) && (bmu[1] < bmu[2])) Sell();

  Print("BMU Buy: ", bmu[0], " BMU Sell: ", bmu[1], " BMU Hold: ", bmu[2]);

   vectorp[0] = 0;

   vectorp[1] = 1;

   vectorp[2] = 2;

   vectorp[3] = 3;

   vectorp[4] = 4;

   vectorp[5] = 5;

   vectorp[6] = 6;

  //if () 

  TeachMap(BUY_MAP, vectorp);

  //else if ()  

  TeachMap(SELL_MAP, vectorp);

  //else 

  TeachMap(HOLD_MAP, vectorp);

//----

   return(0);

  }

//+------------------------------------------------------------------+

void InitKohonenMap()

{

   for (int i = 0; i < MAPBASE; i++)

   {

      for (int v = 0; i < VBASE; i++)

      {

         MapSell[i][v] = 0;

         MapBuy[i][v] = 0;

      }

   }

   for (i = 0; i < HOLDBASE; i++)

   {

      for (v = 0; i < VBASE; i++)

      {

         MapHold[i][v] = 0;

      }

   }

}

void LoadKohonenMap()

{

   int handle = FileOpen(MapPath, FILE_BIN|FILE_WRITE|FILE_READ);

   if (handle < 1)

   {

      Print("File couldn't be opened; the last error is ", GetLastError());

      return(0);

   }

   FileReadArray(handle, MapBuy, 0, MAPBASE*VBASE);

   FileReadArray(handle, MapSell, 0, MAPBASE*VBASE);

   FileReadArray(handle, MapHold, 0, HOLDBASE*VBASE);

   FileClose(handle);

}

void SaveKohonenMap()

{

   int handle = FileOpen(MapPath, FILE_BIN|FILE_WRITE|FILE_READ);

   if (handle < 1)

   {

      Print("File couldn't be opened; the last error is ", GetLastError());

      return(0);

   }

   FileWriteArray(handle, MapBuy, 0, MAPBASE*VBASE);

   FileWriteArray(handle, MapSell, 0, MAPBASE*VBASE);

   FileWriteArray(handle, MapHold, 0, HOLDBASE*VBASE);

}  

void MapLookup(double vector[], double& BMU[])

{

   BMU[0] = FindBMU(BUY_MAP, vector);

BMU[1] = FindBMU(SELL_MAP, vector);

BMU[2] = FindBMU(HOLD_MAP, vector);

int i = 0;

//BUY

for (i = 0; i < MAPBASE; i++)

{

      int z  = 0;

      double vec[VBASE];

      for (int v = 0; v < VBASE; v++)

  {

    if (MapBuy[i][v] == 0) z++;

    vec[v] = MapBuy[i][v];

  }

  if (z == VBASE) break;

  double E = EuclidDistance(vec, vector);

}

//SELL

for (i = 0; i < MAPBASE; i++)

{

      z  = 0;

      for (v = 0; v < VBASE; v++)

  {

    if (MapSell[i][v] == 0) z++;

    vec[v] = MapSell[i][v];

  }

  if (z == VBASE) break;

  E = EuclidDistance(vec, vector);

}

//HOLD

for (i = 0; i < HOLDBASE; i++)

{

      z  = 0;

      for (v = 0; v < VBASE; v++)

  {

    if (MapHold[i][v] == 0) z++;

    vec[v] = MapHold[i][v];

  }

  if (z == VBASE) break;

  E = EuclidDistance(vec, vector);

}

}

double FindBMU(int Buy, double vector[])

{

int N = 0;

if (Buy == 1) N = MAPBASE;

else if (Buy == 0) N = MAPBASE;

else N = HOLDBASE;

double BestEuclidDistance = 9999999;

double vec[VBASE];

for (int i = 0; i < N; i++)

{

double E;

      for (int v = 0; v < VBASE; v++)

  {

    if (Buy == 1) vec[v] = MapBuy[i][v];

    else if (Buy == 0) vec[v] = MapSell[i][v];

    else vec[v] = MapHold[i][v];

}

E = EuclidDistance(vec, vector);

if (E < BestEuclidDistance)

{

BestEuclidDistance = E;

}

}

return(BestEuclidDistance);

}

double EuclidDistance(double VectorFromMap[], double vector[])

{

double E = 0;

for (int v = 0; v < VBASE; v++)

{

E += MathPow((VectorFromMap[v]*10000 - vector[v]*10000), 2);

}

E = MathSqrt(E);

return(E);

}

void TeachMap(int Buy, double vector[])

{

int BMUx = -1;

int N;

int x;

if (Buy == 1) N = MAPBASE;

else if (Buy == 0) N = MAPBASE;

else N = HOLDBASE;

for (x = 0; x < N; x++)

{

bool flag = false;

for (int v = 0; v < VBASE; v++)

{

if (Buy == 1) {if (MapBuy[x][v] != 0) flag = true;}

else if (Buy == 0) {if (MapSell[x][v] != 0) flag = true;}

else {if (MapHold[x][v] != 0) flag = true;}

}

if (flag == false) break;

}

for (v = 0; v < VBASE; v++)

{

if (Buy == 1) MapBuy[x][v] = vector[v];

else if (Buy == 0) MapSell[x][v] = vector[v];

else MapHold[x][v] = vector[v];

}

}