//+------------------------------------------------------------------+
//|                                                   NeuroProba.mq4 |
//|                      Copyright © 2005, MetaQuotes Software Corp. |
//|                                        http://www.metaquotes.net |
//+------------------------------------------------------------------+
#property copyright "Copyright © 2005, MetaQuotes Software Corp."
#property link      "http://www.metaquotes.net"

#property indicator_separate_window
#property indicator_buffers 3
#property indicator_color1 Yellow
#property indicator_color2 Blue
#property indicator_color3 Red
//---- input parameters
extern int       BeginBar=300; // ????????? ??? ? ????????? ???????
extern int       EndBar=201; // ???????? ??? ? ????????? ???????
extern int       StudyNumber=100; // ?????????? ????????? ??????
extern double    Betta=0.5; // ???????? ????????????? ???????
extern double    StudyCoeff=0.1; // ??????????? ????????
extern double    MaxRandom=0.66;//2.0/MathSqrt(9);
//---- buffers
double NeuroExitBuffer[]; // ???????? ???????? ?????????
double TeacherBuffer[]; // ????????? ???????? ????????? (????????? ???????)
double ErrorBuffer[]; // ?????????? ?? ?????? ????
//---- 
double deviation; // ?????????? ?? ?????? ???? ???????? 
double GradientFirstLay[9][9];// ??? ??????? ????????? 1-?? ????
double GradientSecondLay[9]; //  ??? ??????? ????????? 2-?? ????
double OutputFirstLay[9]; // ????? ?????? ??????? ???????
double SecondSum;// ????? ????????? ???? - ???????? ????????????? ???????
double FirstLayWeights[9][9]; // ???? ???????? ??????? (???????? ????)
double OutputSecondWeights[9]; // ???? ????????? ???????
double InputNormalX[100][9]; // ??????????????? ??????? ??????? ????????
double InputX[9]; // ??????? ??????? ?????? (?????????????????)
double Norm?;// ????? ???????? ???????? ???????
double U_First[9];// ???????? ?? ?????? ???? ??????? (???????) ????????
double U_Second;//  ???????? ?? ?????? ????????? ??????? (???????? ????????????? ???????)
double SigmaCurr;
double Differ;
//+----------------------------------------------
//  ??????????????? ????????? ??????? ?? ????????? (0,MaxValue), ???? ???????? ???????? - ?? (0,1)
//+----------------------------------------------
double NormalRand(double MaxValue=1.0)
   {
   double answer;
   answer=MathRand()/32767.0;
   answer=MaxValue*answer;
   return(answer);
   }
//+----------------------------------------------
//  ??????????????? ????????? ???????
//+----------------------------------------------


//------------------------------------------
// ??????????? ????????????? ???????  (??????? ???????????????)
//------------------------------------------
double Sigma(double argument)
   {
   double help;
   help=(MathExp(argument)-MathExp(-argument))/(MathExp(argument)+MathExp(-argument));
   return(help);
   }
//------------------------------------------
// ??????????? ????????????? ???????
//------------------------------------------

//------------------------------------------
// ?????????? ????????? ????????????? ???????
//------------------------------------------
double GetArgument()
   {
   int j;
   double answer=0.0;
   for (j=0;j<9;j++)
      {
      answer=answer+OutputSecondWeights[j]*OutputFirstLay[j];
      }
   return(answer);
   }
//------------------------------------------
// ?????????? ????????? ????????????? ???????
//------------------------------------------

//------------------------------------------
// ?????????? ??????? ???????? ??????? ????
//------------------------------------------
void GetFirstLayOutput()
   {
   int j,t;
   for (j=0;j<9;j++)
      {
      OutputFirstLay[j]=0.0;      
      for (t=0;t<9;t++)
         {
         OutputFirstLay[j]=OutputFirstLay[j]+FirstLayWeights[j,t]*InputX[t];
         }
      }
   return(0);
   }
//------------------------------------------
// ?????????? ??????? ???????? ??????? ????
//------------------------------------------

//------------------------------------------
// ?????????? ????????? ????? ???????? 
//------------------------------------------
void SetGradientWeights()
   {
   int j,t;
   for (j=0;j<9;j++)
      {
      //GradientFirstLay[j,t]=0.0;
      for (t=0;t<9;t++)
         {
         GradientFirstLay[j,t]=OutputSecondWeights[j]*InputX[t]*deviation*Differ;
         //GradientFirstLay[j,t]=GradientFirstLay[j,t]+OutputSecondWeights[j]*InputX[t];
         }
      //GradientFirstLay[j,t]=GradientFirstLay[j,t]*deviation*Differ;
      GradientSecondLay[j]=OutputFirstLay[j]*deviation*Differ;
      }
   }
//------------------------------------------
// ?????????? ????????? ????? ???????? 
//------------------------------------------

//------------------------------------------
// ????????? ????? ???????? 
//------------------------------------------
void ChangeWeigts()
   {
   int i,k;
   for (i=0;i<9;i++)
      {
      for (k=0;k<9;k++)
         {
         FirstLayWeights[i,k]=FirstLayWeights[i,k]-StudyCoeff*GradientFirstLay[i,k];
         }
      OutputSecondWeights [i]=OutputSecondWeights [i]-StudyCoeff*GradientSecondLay[i];// ????????? ????? ????????? ???????
      } 
   }
//------------------------------------------
// ????????? ????? ????????
//------------------------------------------

//------------------------------------------
// ????? ? ?????? ????? ????????
//------------------------------------------
void PrintWeights()
   {
   int i,k;
   for (i=0;i<9;i++)
      {
      for (k=0;k<9;k++)   
         {
//         Print("W1["+i+","+k+"]=",FirstLayWeights[i,k]);
         }
//      Print("W2["+i+"]=",OutputSecondWeights[i]);
      }
   }
//------------------------------------------
// ????? ? ?????? ????? ????????
//------------------------------------------

//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int init()
  {
//---- indicators
   SetIndexStyle(0,DRAW_LINE);
   SetIndexBuffer(0,NeuroExitBuffer);
   SetIndexStyle(1,DRAW_LINE);
   SetIndexBuffer(1,TeacherBuffer);
   SetIndexStyle(2,DRAW_LINE);
   SetIndexBuffer(2,ErrorBuffer);
   SetIndexLabel(0,"Answer");
   SetIndexLabel(1,"Teacher");
   SetIndexLabel(2,"Error");
   ArrayInitialize(NeuroExitBuffer,0.0);      
   ArrayInitialize(TeacherBuffer,0.0);      
   ArrayInitialize(ErrorBuffer,0.0); 
//------------------------------------------
// ?????????? ??????? ??????? ????????
//------------------------------------------
   int i,k,m,n,p; // m - ?????? ????? ????????? ???????, p - ??????? ????? ????????
   for (i=BeginBar;i>=EndBar;i--)
      {
      Norm?=0.0;
      for (k=0;k<=8;k++)
         {InputX[k]=Close[i]-Close[i+k+1];
         Norm?=Norm?+InputX[k]*InputX[k];
         }
      Norm?=MathSqrt(Norm?);   
      for (k=0;k<=8;k++)
         {      
         InputNormalX[BeginBar-i,k]=InputX[k]/Norm?;
         TeacherBuffer[BeginBar-i]=0.0;
         if (iCustom(NULL,0,"Kaufman2",1,i)>0) TeacherBuffer[BeginBar-i]=1;
         if (iCustom(NULL,0,"Kaufman2",2,i)>0) TeacherBuffer[BeginBar-i]=-1;
      //TeacherBuffer[BeginBar-i]=iCustom(NULL,0,"KaufmanTrend",0,BeginBar);      
         }
       }
//------------------------------------------
// ?????????? ??????? ??????? ????????
//------------------------------------------
   MathSrand(LocalTime());
//------------------------------------------
// ?????????? ????? ???????? ?????????? ??????????
//------------------------------------------
   for (i=0;i<9;i++)
      {
      for (k=0;k<9;k++)
         {
         FirstLayWeights[i,k]=NormalRand(MaxRandom);
//         Print("FirstLayWeights["+i+","+k+"]=",FirstLayWeights[i,k]);
         }
      OutputSecondWeights[i]=NormalRand(MaxRandom);
      }
//------------------------------------------
// ?????????? ????? ???????? ?????????? ??????????
//------------------------------------------
   PrintWeights();
//   Print("Sigma=",Sigma(NormalRand()));
   Print("????????????? ?????????");

//------------------------------------------
// ????????
//------------------------------------------
for (p=1;p<=StudyNumber;p++) // ???? ???????? - p-????? ????????
   {
   for (n=0;n<100;n++) // ?????? ?? ??????? ??????? ???????? -  n-????? ?????????? ???????
      {
      for (int z=0;z<9;z++) InputX[z]=InputNormalX[n,z]; // ???????? ??????? ?????? ?? ??????? ?????????????? ??????????????? ????????
      GetFirstLayOutput();
      U_Second=GetArgument();
      Print("p=",p," n=",n," U_Second=",U_Second);
      PrintWeights();
      SigmaCurr=Sigma(Betta*U_Second);
      Differ=Betta*(1-SigmaCurr*SigmaCurr); // ??????????? ?? ???????? ????????????????
      deviation=TeacherBuffer[BeginBar-n]-SigmaCurr; //?????? ????????, ?????? ???? ????????????????? ????
      SetGradientWeights();
      ChangeWeigts();
      }// ?????? ?? ??????? ??????? ????????   
   }// ???? ????????
//------------------------------------------
// ????????
//------------------------------------------
   PrintWeights();
   Comment("???????? ?????????");

//----
   return(0);
  }
//+------------------------------------------------------------------+
//| Custor indicator deinitialization function                       |
//+------------------------------------------------------------------+
int deinit()
  {
//---- TODO: add your code here
//----
   return(0);
  }
//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int start()
  {
   int i,m;
   int counted_bars=IndicatorCounted();
   if (counted_bars<0) return(-1);
   int limit;
   //limit=Bars-10-counted_bars;
   limit=300;
   for (i=limit;i>=0;i--) 
      {
      if (iCustom(NULL,0,"Kaufman2",1,i)>0) TeacherBuffer[i]=1;
      if (iCustom(NULL,0,"Kaufman2",2,i)>0) TeacherBuffer[i]=-1;
      Norm?=0.0;
      for (m=0;m<9;m++)
         {
         InputX[m]=Close[i]-Close[i+m+1];
         Norm?=Norm?+InputX[m]*InputX[m];
         }
      Norm?=MathSqrt(Norm?);
      Print("Norm?=",Norm?);
      for (m=0;m<9;m++)
         {
         InputX[m]=InputX[m]/Norm?;
         }
      GetFirstLayOutput();
      U_Second=GetArgument();
      Print("U_Second=",U_Second);
      NeuroExitBuffer[i]=Sigma(Betta*U_Second);
      //Print("NeuroExitBuffer["+i+"]=",NeuroExitBuffer[i]);
      ErrorBuffer[i]=TeacherBuffer[i]-NeuroExitBuffer[i];
      }
//---- TODO: add your code here
   
//----
   return(0);
  }
//+------------------------------------------------------------------+