SOM EA

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

//| SOM_v02.mq4 |

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

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

#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];

}