#_i_Intra_day_v1

Download script
Author: Copyright � 2006, klot.
#_i_Intra_day_v1

This script is designed as a technical analysis tool for trading platforms, specifically tailored to help traders visualize key price levels and market structures within a single trading day. It combines automated drawing of "session" boundaries with advanced mathematical modeling to identify potential price ranges.

Here is the breakdown of its logic in non-technical terms:

1. Time and Session Management

The script automatically identifies and marks specific windows of time on your chart. It establishes boundaries for different global trading sessions (such as Asian, European, or American sessions) based on user-defined hours. By marking these "Begin," "End," and "Session" points, it helps traders understand which parts of the day are currently active or have already concluded.

2. Dynamic Range Identification

The script calculates significant price levels dynamically rather than using static numbers:

  • Asian Session extremes: It scans the Asian trading period to find the highest and lowest prices reached, drawing horizontal lines to represent these boundaries.
  • Volatility-Adjusted Day Ranges: It measures the average daily volatility (using a standard volatility indicator) and projects "High" and "Low" levels for the day. These are not just the absolute highs and lows, but adjusted values that give traders a sense of the expected price "envelope" based on recent market movement.

3. Trend Smoothing and Wave Analysis

To help filter out the "noise" of tiny price fluctuations, the script employs two distinct logic paths:

  • ZigZag Logic: It identifies major structural "waves" in the price action. By connecting significant peaks and valleys, it helps the trader see the underlying direction of the market, ignoring minor movements that might otherwise distract a manual observer.
  • Polynomial Curve Fitting (Gauss Modeling): This is the most advanced part of the script. It uses a mathematical method called "Gaussian Elimination" to perform regression analysis. Essentially, it looks at recent price history and attempts to create a smooth, mathematical curve that best fits where the price has been moving.

4. Visual Feedback (Channels)

Based on the mathematical curve mentioned above, the script calculates a "buffer" or "envelope" around that curve. It then draws two lines:

  • An upper boundary (High)
  • A lower boundary (Low)

These lines act as a visual channel. If the price stays within these channels, the market is following the calculated trend; if it breaks out, it may signal a significant shift in momentum.

Summary for the Trader

In short, this tool transforms a messy chart into a structured environment. It tells you:

  1. Where you are: By marking session boundaries clearly.
  2. Where the limits are: By projecting the highs and lows of previous sessions and predicted daily ranges.
  3. Where the price is headed: By filtering out noise to show major trend waves and providing a mathematical "channel" that follows the current momentum of the market.
Price Data Components
Series array that contains the highest prices of each barSeries array that contains the lowest prices of each barSeries array that contains close prices for each bar
Miscellaneous
Implements a curve of type %1
6 Views
0 Downloads
0 Favorites
#_i_Intra_day_v1 
//+------------------------------------------------------------------+
//|                                                    Intra_Day.mq4 |
//+------------------------------------------------------------------+
#property copyright "Copyright © 2006, klot."
#property link      "klot@mail.ru"

#property indicator_chart_window
#property indicator_buffers 4
#property indicator_color1 Aqua
#property indicator_color2 LightSkyBlue
#property indicator_color3 Blue
#property indicator_color4 Blue
//---- indicator parameters
extern int Hour_Begin_Day=21;
extern int Asian_end_hour=7;
extern int Europa_end_hour=15;
extern int ExtDepth=9;
extern int perATR=50;
extern int m=1;
int i0=0;
extern double kkk=0.88;
//---- indicator buffers
int begin,end;
datetime begin_time,end_time,asia_t,amer_t;
double low_asia,high_asia,low_day,high_day,atr;
double zzL[];
double zzH[];
double zz[];
//-----------------------
double fx[];
double fxH[];
double fxL[];
double a[10,10],b[10],x[10],sx[20];
double sum;
int pp;
int nn;
int bar;
//*******************************************
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int init()
  {
   IndicatorBuffers(6);
//---- drawing settings
   SetIndexStyle(0,DRAW_SECTION);
//---- indicator buffers mapping
   SetIndexBuffer(0,zz);
   SetIndexBuffer(4,zzH);
   SetIndexBuffer(5,zzL);
   SetIndexEmptyValue(0,0.0);
   SetIndexEmptyValue(4,0.0);
   SetIndexEmptyValue(5,0.0);
//-------------------------
   SetIndexStyle(1,DRAW_LINE);
   SetIndexBuffer(1,fx);
   SetIndexStyle(2,DRAW_LINE);
   SetIndexBuffer(2,fxH);
   SetIndexStyle(3,DRAW_LINE);
   SetIndexBuffer(3,fxL);
   nn=m+1;
//---- indicator short name
   IndicatorShortName("Intra_Day");
//---- initialization done

   return(0);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
  int deinit()
  {
//----
   obje_del();
//----
   return(0);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int start()
  {
   int    asia_b,i;
   if(Bars<(1440/Period()))return(0);

   datetime _cur_time=iTime(NULL,0,0);
   int      _nbar_day=iBarShift(NULL,PERIOD_D1,_cur_time);

   begin_time=iTime(NULL,PERIOD_D1,_nbar_day)-(24-Hour_Begin_Day)*3600;
   begin=iBarShift(NULL,0,begin_time);
   asia_t=iTime(NULL,PERIOD_D1,_nbar_day)+(Asian_end_hour*3600);
   amer_t=iTime(NULL,PERIOD_D1,_nbar_day)+(Europa_end_hour*3600);
   end_time=iTime(NULL,PERIOD_D1,_nbar_day)+(Hour_Begin_Day*3600);
   asia_b=iBarShift(NULL,0,asia_t);
   end=iBarShift(NULL,0,end_time);
   //atr=iATR(NULL,PERIOD_D1,perATR,_nbar_day+1);
   atr=0;
   for(i=perATR; i>=1; i--)
     {
      atr+=iHigh(NULL,PERIOD_D1,_nbar_day+i)-iLow(NULL,PERIOD_D1,_nbar_day+i);
     }
   atr=atr/perATR;

   low_asia=Low[Lowest(NULL,0,MODE_LOW,(begin-asia_b),asia_b+1)];
   high_asia=High[Highest(NULL,0,MODE_HIGH,(begin-asia_b),asia_b+1)];

   low_day=High[Highest(NULL,0,MODE_HIGH,begin,0)]-atr;
   high_day=Low[Lowest(NULL,0,MODE_LOW,begin,0)]+atr;

   _ZigZag(begin);
   _reg_cannel(begin);
   obje_del();
   obje_creat();

   return(0);
  }
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
void obje_del()
  {
   ObjectDelete("Begin");
   ObjectDelete("Asian");
   ObjectDelete("End");
   ObjectDelete("Amer");
   ObjectDelete("Open");
   ObjectDelete("High_asian");
   ObjectDelete("Low_asian");
   ObjectDelete("low_day");
   ObjectDelete("high_day");
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void obje_creat()
  {
   ObjectCreate("Begin",OBJ_VLINE,0,begin_time,0);
   ObjectCreate("Asian",OBJ_VLINE,0,asia_t,0);
   ObjectCreate("Amer",OBJ_VLINE,0,amer_t,0);
   ObjectCreate("End",OBJ_VLINE,0,end_time,0);
//---------------------
   ObjectCreate("Open",OBJ_TREND,0,begin_time,Open[begin],Time[0],Open[begin]);
   ObjectSet("Open",OBJPROP_RAY,false);
   ObjectSet("Open",OBJPROP_STYLE,STYLE_DOT);

   ObjectCreate("High_asian",OBJ_TREND,0,begin_time,high_asia,Time[0],high_asia);
   ObjectSet("High_asian",OBJPROP_RAY,false);
   ObjectSet("High_asian",OBJPROP_STYLE,STYLE_DASH);
   ObjectSet("High_asian",OBJPROP_COLOR,DarkOrange);

   ObjectCreate("Low_asian",OBJ_TREND,0,begin_time,low_asia,Time[0],low_asia);
   ObjectSet("Low_asian",OBJPROP_RAY,false);
   ObjectSet("Low_asian",OBJPROP_STYLE,STYLE_DASH);
   ObjectSet("Low_asian",OBJPROP_COLOR,DarkOrange);

   ObjectCreate("low_day",OBJ_TREND,0,Time[0]-900*Period(),low_day,Time[0]+900*Period(),low_day);
   ObjectSet("low_day",OBJPROP_RAY,false);
   ObjectSet("low_day",OBJPROP_COLOR,Yellow);

   ObjectCreate("high_day",OBJ_TREND,0,Time[0]-900*Period(),high_day,Time[0]+900*Period(),high_day);
   ObjectSet("high_day",OBJPROP_RAY,false);
   ObjectSet("high_day",OBJPROP_COLOR,Yellow);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void _ZigZag(int nbar)
  {
   int    i,shift,pos,lasthighpos,lastlowpos,curhighpos,curlowpos;
   double curlow,curhigh,lasthigh,lastlow,waveH,waveL;
   double min, max;
   ArrayInitialize(zz,0.0);
   ArrayInitialize(zzL,0.0);
   ArrayInitialize(zzH,0.0);

   lasthighpos=nbar; lastlowpos=nbar;
   lastlow=Low[lastlowpos];lasthigh=High[lasthighpos];
   zz[lastlowpos]=lastlow; zz[lasthighpos]=lasthigh;

   for(shift=nbar-ExtDepth; shift>=0; shift--)
     {
      curlowpos=Lowest(NULL,0,MODE_LOW,ExtDepth,shift);
      curlow=Low[curlowpos];
      curhighpos=Highest(NULL,0,MODE_HIGH,ExtDepth,shift);
      curhigh=High[curhighpos];
      //------------------------------------------------
      if(curlow>=lastlow){ lastlow=curlow; }
      else
        {
         //èäåì âíèç
         if(lasthighpos>curlowpos )
           {
            zzL[curlowpos]=curlow;
            ///*
            min=100000; pos=lasthighpos;
            for(i=lasthighpos; i>=curlowpos; i--)
              {
               if (zzL[i]==0.0) continue;
               if (zzL[i]<min) { min=zzL[i]; pos=i; }
               zz[i]=0.0;
              }
            zz[pos]=min;
            //*/
           }
         lastlowpos=curlowpos;
         lastlow=curlow;
        }
      //--- high
      if(curhigh<=lasthigh) { lasthigh=curhigh;}
      else
        {
         // èäåì ââåðõ
         if(lastlowpos>curhighpos)
           {
            zzH[curhighpos]=curhigh;
            ///*
            max=-100000; pos=lastlowpos;
            for(i=lastlowpos; i>=curhighpos; i--)
              {
               if (zzH[i]==0.0) continue;
               if (zzH[i]>max) { max=zzH[i]; pos=i; }
               zz[i]=0.0;
              }
            zz[pos]=max;
            //*/     
           }
         lasthighpos=curhighpos;
         lasthigh=curhigh;
        }
      //----------------------------------------------------------------------
     }
   return(0);
  }
//+------------------------------------------------------------------+
void _reg_cannel(int p)
  {
   int i,n,k;
   //**********************************************************
   double val0,val1,val2,val3,val4;
   int kk;

   //**********************************************************

   sx[1]=p+1;
   SetIndexDrawBegin(1,Bars-p);
   SetIndexDrawBegin(2,Bars-p);
   SetIndexDrawBegin(3,Bars-p);
//----------------------sx---------------------
   for(i=1; i<=nn*2-2; i++)
     {
      sum=0.0;
      for(n=i0; n<=i0+p; n++) {sum+=MathPow(n,i);}
      sx[i+1]=sum;
     }
//----------------------syx--------------------
   for(i=1; i<=nn; i++)
     {
      sum=0.0;
      for(n=i0; n<=i0+p; n++)
        {
         if (i==1) sum+=Close[n];
         else
            sum+=Close[n]*MathPow(n,i-1);
        }
      b[i]=sum;
     }
   //===============Matrix========================
   for(int j=1; j<=nn; j++)
     {
      for(i=1; i<=nn; i++)
        {
         k=i+j-1;
         a[i,j]=sx[k];
        }
     }
   //===============Gauss=========================
   af_Gauss(nn,a,b,x);
   //=============================================
   for(i=i0; i<=i0+p; i++)
     {
      sum=0;
      for(k=1; k<=m; k++) sum+=x[k+1]*MathPow(i,k);
      fx[i]=x[1]+sum;
     }
//-------------------------------------------------------------
   //*************************************************************
   for(i=i0; i<=i0+p; i++)
     {
      if(fx[p]>fx[0])
        {
         val1=0; val2=0; val3=0; val4=0;
         for(kk=i0;kk<=i0+p;kk++)
           {
            val3=fx[kk]-iClose(NULL,0,kk);
            val1=iClose(NULL,0,kk)-fx[kk];
            val2=MathMax(val2,val1);
            val4=MathMax(val4,val3);
           }
        }
      if(fx[p]<=fx[0])
        {
         val1=0; val2=0; val3=0; val4=0;
         for(kk=i0;kk<=i0+p;kk++)
           {
            val1=iClose(NULL,0,kk)-fx[kk];
            val3=fx[kk]-iClose(NULL,0,kk);
            val2=MathMax(val2,val1);
            val4=MathMax(val4,val3);
           }

        }
      val0=MathMin(val2,val4);
      fxH[i]=fx[i]+val0*kkk;
      fxL[i]=fx[i]-val0*kkk;
     }
//-------------------------------------------------------------
   //*************************************************************
   //  Comment( " p = ",p,"  pp = ",pp);
   return(0);
  }
//*************************************************************** 
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void af_Gauss(int n, double& a[][],double& b[], double& x[])
  {
   int i,j,k,l;
   double q,m,t;

   for(k=1; k<=n-1; k++)
     {
      l=0;
      m=0;
      for(i=k; i<=n; i++)
        {
         if (MathAbs(a[i,k])>m) {m=MathAbs(a[i,k]); l=i;}
        }
      if (l==0) return(0);

      if (l!=k)
        {
         for(j=1; j<=n; j++)
           {
            t=a[k,j];
            a[k,j]=a[l,j];
            a[l,j]=t;
           }
         t=b[k];
         b[k]=b[l];
         b[l]=t;
        }

      for(i=k+1;i<=n;i++)
        {
         q=a[i,k]/a[k,k];
         for(j=1;j<=n;j++)
           {
            if (j==k) a[i,j]=0;
            else
               a[i,j]=a[i,j]-q*a[k,j];
           }
         b[i]=b[i]-q*b[k];
        }
     }

   x[n]=b[n]/a[n,n];

   for(i=n-1;i>=1;i--)
     {
      t=0;
      for(j=1;j<=n-i;j++)
        {
         t=t+a[i,i+j]*x[i+j];
         x[i]=(1/a[i,i])*(b[i]-t);
        }
     }
   return;
  }
//********************************************************************** 

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

Comments