#_LinRegres_Neuro_GA

//+------------------------------------------------------------------+
//|                                           LinRegres_Neuro_GA.mq4 |
//+------------------------------------------------------------------+
#property copyright "Copyright © 2006, klot."
#property link      "klot@mail.ru"
//------
#define MAXPOP	   200      // ìàêñèìàëüíîå êîëè÷åñòâî îñîáåé â ïîïóëÿöèè
#define MAXWITCH	18       // êîëè÷åñòâî îïòèìèçèðóåìûõ ïàðàìåòðîâ
//-------
#property indicator_separate_window
#property indicator_buffers 1
#property indicator_color1 Aqua
#property indicator_level1 0.0
#property indicator_level2 1.0
#property indicator_level3 -1.0
//---- indicator parameters
//----
extern   int      barn = 130;    // ÷èñëî áàðîâ äëÿ îïòèìèçàöèè ÒÑ ïî èñòîðèè
//extern   double      th= 1.0;    // ïîðîã äëÿ òîðãîâîé ñèñòåìû
//---- indicator buffers
double profits[];
double signal[];
//-------------
extern bool Optimize=false;
static datetime New_Time=0;
static int Nosob=-1;
//-------------
double ww[13];
//-----
double fitness[MAXPOP];
//-----
double population[MAXPOP][MAXWITCH];  // Population
//+------------------------------------------------------------------+
//|   Ôóíêöèÿ âîçâðàùàåò õðîìîñîìó (gene[])  îñîáè (int p)           |
//+------------------------------------------------------------------+
void GetGene(int p, double &gene[]) 
{
   for(int j=0; j<MAXWITCH; j++) gene[j]=population[p][j];
   return;
 }
//+------------------------------------------------------------------+
//|  Îñíîâíàÿ ôóíêöèÿ îïòèìèçàöèè   âîçâðàùàåò èíäåêñ íàèáîëåå       |
//|     ïðèñïîñîáëåííîé îñîáè                                        |
//+------------------------------------------------------------------+
int Solve() {
	int osob = -1;
	double fit=-1;
	// Generate initial population.
	MathSrand(TimeLocal());
   //--- Ãåíåðèðóåñòÿ íà÷àëüíàÿ ïîïóëÿöèÿ -------------
	for(int i=0; i<MAXPOP; i++) {			
		for (int j=0; j<MAXWITCH; j++) {		
			   if (j<13 ) population[i][j]=(MathRand() % 401)/100.0-2.0;
			   if (j==13 ) population[i][j]=(MathRand() % 100)/100.0;
			   if (j>13 ) population[i][j]=(MathRand() % 70)+3;
		}
	}
   //---
	int iterations = 0;	                 // Keep record of the iterations.
	int TotalIterations = 0;
	double Bestfit=-1;
	int Bestosob=-1;
	//+-- Öèêë ýâîëþöèè ------------------------------------+
	//| Åñëè â òå÷åíèè 20 ïîêîëåíèé óëó÷øåíèÿ íå ïðîèñõîäÿò +
	//| Îïòèìèçàöèÿ çàâåðøàåòñÿ                             +
	//+-----------------------------------------------------+			
	while ( (iterations<20) ) {
	   //---
      osob=CreateFitnesses(fit);
	   //--- Ñáðàñûâàåì ñ÷åò÷èê êàæäûé ðàç åñëè ïðîèñõîäèò èçìåíåíèå ----
	   if( (osob!=Bestosob) || (fit>Bestfit) ) {
	      //---
	  	   iterations=0;
	      Bestfit=fit;
	      Bestosob=osob;
	      //Print("Îñîáü ¹ ",osob,"  TotalIterations = ",TotalIterations);
		}
	   //---
	   CreateNewPopulation(Bestosob);
	   //---
		iterations++;
		TotalIterations++;
	}
   //---
   Print("TotalIterations = ",TotalIterations, " Ëó÷øàÿ îñîáú ¹ ",Bestosob," fit = ",Bestfit);
	return (Bestosob);
}
//+------------------------------------------------------------------+
//|   Ôóíêöèÿ âîçâðàùàåò èíäåêñ ë÷øåé îñîáè                          |
//|   è ñðåäíþþ ïðèáûëü ïî âñåé ïîïóëÿöèè   (double &avgfit)         |
//+------------------------------------------------------------------+
int CreateFitnesses(double &avgfit) {
   //---
   double gene[];
   double www[];
   double th=0;
   int p1,p2,p3,p4;
	double max=0;
	int maxFitnessIndex=-1;
   ArrayResize(gene,MAXWITCH);
   ArrayResize(www,13);
	//---
	avgfit=0;
	for(int i=0;i<MAXPOP;i++) {
	   //---
	   GetGene(i,gene);
	   ArrayCopy(www,gene,0,0,13);
      th=gene[13];
      p1=gene[14];
      p2=gene[15];
      p3=gene[16];
      p4=gene[17];
		fitness[i]=TStrategy1(www,th,p1,p2,p3,p4,true);
		//---
		if (fitness[i]>max ) {  
		   max=fitness[i];
			maxFitnessIndex=i;
		}
		avgfit += fitness[i];
	}
	avgfit=avgfit/MAXPOP;
	//---
	return(maxFitnessIndex);
}
//+------------------------------------------------------------------+
//|   Ôóíêöèÿ ñîçäàåò íîâóþ ïîïóëÿöèþ ïóòåì ñêðåùèâàíèÿ              |
//|   âñåõ îñîáåé â ïîïóëÿöèè ñ íàèáîëåå ëó÷øåé                      |
//+------------------------------------------------------------------+
void CreateNewPopulation(int osob) {
   //---
	int i=0,j=0;
	int crossover=0;
	int mutate=0;
	double xromosoma[];
	ArrayResize(xromosoma,MAXWITCH);
	//--- Õðîìîñîìà ýëèòíîé îñîáè --------
	GetGene(osob,xromosoma);
	//---
	MathSrand(TimeLocal()+MathRand());
	//---
	for( i=0; i<MAXPOP; i++ ) {
	   //---
		if ( i==osob ) {	 // Èñêëþ÷àåì ñêðåùèâàíèå ñàìó ñ ñîáîé
		 continue; 
		}
		//---- ×àñòü îñîáåé â ïîïóëÿöèè ïîäâåðãàþòñÿ ìóòàöèÿì -----
		mutate=(MathRand() % 101);
		//----
		if( mutate > 40 ) {
		    //---- Ðàñ÷èòûâàåì êàêèå ãåíû ýëèòíîé îñîáè áóäóò ïåðåäàíû ïîòîìêàì -----
		    crossover = (MathRand() % MAXWITCH);
		    //----
		    if ( crossover<MAXWITCH/2.0 ) { 
		       //---- Îïëîäîòâîðåíèå -----
		       for( j=crossover; j<MAXWITCH; j++ ) {
			      population[i][j]=xromosoma[j];
		       } 
		     } else {
		          for( j=0; j<crossover; j++ ) {
			         population[i][j]=xromosoma[j];
		          }
		    }
		    //---
		} else { //---Èíà÷å ïðîèñõîäèò ìóòàöèÿ
		     for( j=0; j<MAXWITCH; j++ ) {
			   if (j<13 ) population[i][j]=(MathRand() % 401)/100.0-2.0;
			   if (j==13 ) population[i][j]=(MathRand() % 100)/100.0;
			   if (j>13 ) population[i][j]=(MathRand() % 70)+3;
		    }
		}
	}
	//---
	return;
}
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int init()
  {
   IndicatorBuffers(2);
//---- drawing settings
   SetIndexStyle(0,DRAW_SECTION);
//---- indicator buffers mapping
   SetIndexBuffer(1,profits);
   SetIndexBuffer(0,signal);
   SetIndexEmptyValue(0,0.0);
//---- indicator short name
   IndicatorShortName("LinRegres_Neuro_GA("+barn+")");
//---- initialization done
   //-------
   MathSrand(TimeLocal());
   for(int i=0; i<13; i++) ww[i]=(MathRand() % 401)/100.0-2.0;
   //-------
   return(0);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int start()
  {
      //------
     double th=0;
     double gene[];
     int p1=0,p2=0,p3=0,p4=0;
     ArrayResize(gene,MAXWITCH);
     //---
     int nbar=iBarShift(Symbol(),PERIOD_MN1,Time[0]);
     //---
     if( Optimize==true && New_Time!=iTime(Symbol(),PERIOD_MN1,nbar) )  {
         //----
         Nosob=Solve();
         //----
         if( Nosob!=-1 )GetGene(Nosob,gene);
         //----
         WriteFileNeuro(gene);
         //----
        New_Time=iTime(Symbol(),PERIOD_MN1,nbar);
      }
    //---
    if (ReadFileNeuro(gene) ) {
    //---
      ArrayCopy(ww,gene,0,0,13);
      th=gene[13];
      p1=gene[14];
      p2=gene[15];
      p3=gene[16];
      p4=gene[17];
    }
      double profit=TStrategy1(ww,th,p1,p2,p3,p4,false);
    //}
    Comment("Îáùàÿ ïðèáûëü= ",profit," Ëó÷øàÿ îñîáú ¹ ",Nosob," th = ",th," p1 = ",p1," p2 = ",p2," p3 = ",p3," p4 = ",p4);
    //-----
 return(0);
}
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
bool ReadFileNeuro(double& www[])
{
   int handle;
   string Fname="LinReres_NeuroWich.dat";
   int N=ArraySize(www);
   handle=FileOpen(Fname, FILE_BIN|FILE_READ);
   if(handle>0) {
         FileReadArray(handle,www,0,N);
         FileClose(handle);
         return (true);
   } else 
   return (false);
}
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void WriteFileNeuro(double www[])
{
   int handle;
   //-----
   int N=ArraySize(www);
   string Fname="LinReres_NeuroWich.dat";
   //-------
   handle=FileOpen(Fname,FILE_BIN|FILE_WRITE);
   if(handle>0) {
      FileWriteArray(handle,www,0,N);
      //-------
      FileFlush(handle);
      FileClose(handle);
   }
   return;
}
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
double TStrategy1(double wa[],double trh,int p1,int p2,int p3,int p4, int fOpt=false)
{
   int shift,k=0;
   string name="Signal";
   double in[];
   int lastbuy=0,lastsell=0,trend=0;
   double profit,profit0;
   double spread=MarketInfo(Symbol(),MODE_SPREAD)*Point;
   double Buy[],Sell[];
   ArrayResize(in,4);
   ArrayResize(Buy,barn);
   ArrayResize(Sell,barn);
   ArrayInitialize(Buy,0.0);
   ArrayInitialize(Sell,0.0);
   //--------------T3 ñãëàæèâàíèå---------------------------------+
   double e1, e2, e3, e4, e5, e6, c1, c2, c3, c4, w1, w2, b2, b3;
   double n,t3,b;
   //----
      n=6.0;
      b=0.75;
      //-----
      b2=b*b;
      b3=b2*b;
      c1=-b3;
      c2=(3.0*(b2+b3));
      c3=-3.0*(2.0*b2+b+b3);
      c4=(1.0+3.0*b+b3+3*b2);
      //------
      if (n<1) n=1;
      n = 1.0+0.5*(n-1);
      w1 = 2.0/(n+1);
      w2 = 1.0-w1;
   //-------------------------------------------------------------+*/
   //-------------------------------------------------------------
   if(!fOpt) for(shift=barn; shift>=0; shift--) ObjectDelete(name+shift);
   profit=0;
   profit0=0;
   for(shift=barn; shift>=0; shift--) {
      //-----Âõîäû ñåòè ----
      in[0]=LinRegresSlope2(p1,shift+1);
      in[1]=LinRegresSlope2(p2,shift+1);
      in[2]=LinRegresSlope2(p3,shift+1);
      in[3]=LinRegresSlope2(p4,shift+1);
      //----- Âûõîä ñåòè -------------
      signal[shift] = neuronet1(wa,in);
      //----- T3 ñãëàæèâàíèå --------
      e1 = w1*signal[shift] + w2*e1;
      e2 = w1*e1 + w2*e2;
      e3 = w1*e2 + w2*e3;
      e4 = w1*e3 + w2*e4;
      e5 = w1*e4 + w2*e5;
      e6 = w1*e5 + w2*e6;
      //-----
      t3=c1*e6+c2*e5+c3*e4+c4*e3;
      signal[shift]=t3;///------*/
      //-------------------------------------------------------------+
      //| Ñèãíàëû                                                    |
      //-------------------------------------------------------------+
      if( signal[shift]>signal[shift+1] && signal[shift+2]>signal[shift+1]
          && signal[shift+1]<-trh && trend!=1 ) {
         Buy[shift]=Close[shift]+spread;
         trend=1;
         lastbuy=shift;
         if(!fOpt){
            ObjectCreate(name+shift,OBJ_ARROW,0,Time[shift],Buy[shift]);
            ObjectSet(name+shift,OBJPROP_ARROWCODE,225);
         }
         k++;
      }
      //------
      if( signal[shift]<signal[shift+1] && signal[shift+2]<signal[shift+1]
          && signal[shift+1]>trh && trend!=-1 ) { 
         Sell[shift]=Close[shift]-spread;
         trend=-1;
         lastsell=shift;
         if(!fOpt){
            ObjectCreate(name+shift,OBJ_ARROW,0,Time[shift],Sell[shift]);
            ObjectSet(name+shift,OBJPROP_ARROWCODE,226);
         }
         k++;
      }
      //------Ïîäñ÷åò ïðîôèòà-------------
      if( k>1 && ((Buy[shift]!=0 && Sell[lastsell]!=0) ||
                  (Buy[lastbuy]!=0 && Sell[shift]!=0)) )    {
         //-------
         profit+=(Sell[lastsell]-Buy[lastbuy])/Point;
      }
     //------
     profits[shift]=profit;
   }
   //------Ïîäñ÷åò ïðîôèòà òåêóùåé ñäåëêè -------------
   profit0=0;
   if( lastbuy<lastsell &&  lastbuy>0 ) profit0=(Close[0]-Buy[lastbuy])/Point;
   if( lastsell<lastbuy && lastsell>0 ) profit0=(Sell[lastsell]-Close[0])/Point;
   //-----------------------+
   return(profit+profit0);
}
//+------------------------------------------------------------------+
//| 2-õ ñëîéíàÿ íåéðîñåòü èç 3-õ íåéðîíîâ                            |
//| ïåðâûé ñëîé - äâà íåéðîíà                                        |
//| âòîðîé ñëîé - îäèí íåéðîí                                        |
//| âåñà W[0], W[N+1], W[2*N+2] - çàäàþò ñìåùåíèå íåéðîíîâ           |
//| N - ÷èñëî âõîäîâ                                                 |
//| ×èñëî ïîäñòðàèâàåìûõ âåñîâ ðàñ÷èòûâàåòñÿ êàê N*2+2+3             |
//+------------------------------------------------------------------+
double neuronet1(double W[],double x[]) 
  {
   int i;
   int N=ArraySize(x);
   if(ArraySize(W)!=N*2+5) {
      Print("Îøèáêà! Ðàçìåð ìàññèâà âåñîâ äîëæåí áûòü = ",N*2+5);
      return(0);
   }
   double sum=0.0;
   double Out1=0.0, Out2=0.0;
   //---Neuron 1 ----------------+
   sum=W[0];
   //---
   for(i=1; i<=N; i++) { 
      sum+=W[i]*x[i-1];
   }
   Out1=MathArctan(sum);//th(sum);
   //---Neuron 2 ----------------+
   sum=W[N+1];
   //---
   for(i=N+2; i<=2*N+1; i++) { 
      sum+=W[i]*x[i-(N+2)];
   }
   Out2=MathArctan(sum);//th(sum);
   //---Neuron 3 ----------------+
   return(MathArctan(Out1*W[2*N+3]+Out2*W[2*N+4]+W[2*N+2]));
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
double LinRegresSlope2(int length, int shift)
{
   int m_pos[2];
   m_pos[0]=shift;
   m_pos[1]=shift+length;
   int n=m_pos[1]-m_pos[0]+1;
//---- calculate price values
   double value=Close[m_pos[0]];
   double a,b,c;
   double sumy=value;
   double sumx=0.0;
   double sumxy=0.0;
   double sumx2=0.0;
   for(int i=1; i<n; i++)
     {
      value=Close[m_pos[0]+i];
      sumy+=value;
      sumxy+=value*i;
      sumx+=i;
      sumx2+=i*i;
     }
   c=sumx2*n-sumx*sumx;
   if(c==0.0) c=0.000001;
   b=(sumxy*n-sumx*sumy)/c;
   a=(sumy-sumx*b)/n;
   //m_value[0]=a;
   //m_value[Extlength]=a+b*n;
   //return(th(3000*(a -(a+b*n))/n));
   return(MathArctan(10000*(a -(a+b*n))/n));
}
/*
double Normalize(int PeriodNorm, int i)
{
      double ma=iMA(NULL,0,PeriodNorm,0,MODE_SMA,PRICE_CLOSE,i);
      double dev=1.5*iStdDev(NULL,0,PeriodNorm,0,MODE_SMA,PRICE_CLOSE,i);
      if(dev==0) dev=0.000001;
      //-----
      return((Close[i]-ma)/dev);
}*/
/*//+-----------------------------------------------------------------+
//| Ãèïåðáîëè÷åñêèé òàíãåíñ                                         |
//+-----------------------------------------------------------------+
double th(double x)
{
   double x_=MathExp(x);
   double _x=MathExp(-x);
   //-----
   double a=(x_+_x);
   double b=(x_-_x);
   if( a==0) a=0.00000001;
   return(b/a);
}*/
//+------------------------------------------------------------------+
//| expert deinitialization function                                 |
//+------------------------------------------------------------------+
int deinit()
  {
//----
  ObjectsDeleteAll();
//----
   return(0);
  }