Join our facebook group for Amibroker afl code discussion https://www.facebook.com/groups/603980776889348

Enter Hold Exit Zone Line

Enter Hold Exit Zone Line
Enter Hold Exit Zone Line

//www.aflcode.com
//------------------------------------------------------------------------------
Program Overview

This program classifies price action into the following states based upon rules 
his book - "How to Trade in Stocks"

StateNo1 - Up Trend
StateNo2 - Nat Rally
StateNo3 - Sec Rally
StateNo4 - Dn Trend
StateNo5 - Nat React
StateNo6 - Sec React

State change is determined by a user specified threshold of price change.
The program also determines a number of pivot points:

UpTrendPP  - Peak Up Trend Price
NatRallyPP - Peak Nat Rally Price
DnTrendPP  - Bottom Dn Trend Price
NatReactPP - Bottom Nat React Price

This program may be used as a basis for a number of studies:
- trend paint bars,
- pivot price indicator lines
- strategies (trend following AND/OR breakout/breakDn)

//------------------------------------------------------------------------------
*/

// General Graphic Control
GraphXSpace = 15;

SetChartBkGradientFill( ParamColor("BgTop", colorWhite),
        ParamColor("BgBottom", colorSkyblue),ParamColor("titleblock",colorWhite));

ThresholdPercentValue = Param("Threshold in Percent units",10,4,15,1);
 
for( i=0; i<BarCount; i++ )
{

 if(i==0)
 { //Initialization
  //var:
  StateNo[i]=1;
  InUpTrend[i]=True;
  InDnTrend[i]=False;

  SecRally[i] = NatRally[i] = UpTrend[i] = Close[i];
  SecReact[i] = NatReact[i] = DnTrend[i] =Close[i];

  NatRallyReset[i]=True;
       NatReactReset[i]=True;

  UpTrendPP[i]=C[0];
       NatRallyPP[i]=C[0];
  NatReactPP[i]=C[0];
  DnTrendPP[i]=C[0];

    }  //end;

else  //{Main}
{  //begin  //{calc current Threshold if required}

 //  Memory Refresh Manually... Work like refreshing the D-Ram.
 //  This is the fastest trick to handle the issue with AMI-AFL. (KH Tang)

 StateNo[i]=StateNo[i-1];
 InUpTrend[i]=InUpTrend[i-1];
 InDnTrend[i]=InDnTrend[i-1];

 UpTrend[i] = UpTrend[i-1];
 NatRally[i] = NatRally[i-1];
 SecRally[i] = SecRally[i-1];
 SecReact[i] = SecReact[i-1];
 NatReact[i] = NatReact[i-1];
 DnTrend[i] = DnTrend[i-1];

 NatRallyReset[i]=NatRallyReset[i-1];
  NatReactReset[i]=NatReactReset[i-1];

 UpTrendPP[i]=UpTrendPP[i-1];
 NatRallyPP[i]=NatRallyPP[i-1];
 NatReactPP[i]=NatReactPP[i-1];
 DnTrendPP[i]=DnTrendPP[i-1];

 ThresholdPct[i]=ThresholdPercentValue[i]/100; 


//------------------------------------------------------------------------------
//111111111111111111111111111111111111111111111111111111111111111111111111111111
//------------------------------------------------------------------------------
    //State No 1: In Up Trend Column
 if(StateNo[i-1]==1)//
 {//UpTrend Routine
  if(C[i]>=C[i-1])
  {//Price Move Up
   if(C[i]>UpTrend[i])
   {
    StateNo[i]=1;//Remain in UpTrend - 1111111111111111111111111111111
    InUpTrend[i]=True;
    InDnTrend[i]=False;
    UpTrend[i]=C[i];
   }
  }//End of Price Move Up
  else
  {//Price Move Dn
   if((InDnTrend[i] AND C[i]<DnTrendPP[i]) OR   //PivotPoint Check
    (InUpTrend[i] AND C[i]< UpTrend[i]/(1+2*ThresholdPct[i])) )
   {//Drop to DnTrend
    StateNo[i]=6;//Dn Trend - 6666666666666666666666666666666666666666 
    InDnTrend[i]=True; 
    InUpTrend[i]=False;
    DnTrend[i]=C[i];
    UpTrendPP[i]=UpTrend[i];
   }// End of Drop to DnTrend   
   else
   {
    if(C[i]<(UpTrend[i]/(1+ThresholdPct[i])))
    {//Drop Below Current State React 
     if(NatReactReset[i] OR C[i] < NatReact[i])
     {//First Time or Below NatReact
      StateNo[i]=5;//Nat React - 55555555555555555555555555555555    
      NatReactReset[i]=False;
      NatReact[i]=C[i];
      UpTrendPP[i]=UpTrend[i];
     }//End of First Time or Below NatReact
     else
     {//Drop to SecReact 
      StateNo[i]=4;//SecReact - 444444444444444444444444444444444
      SecReact[i]=C[i];
      UpTrendPP[i]=UpTrend[i];
     }//End of Drop to SecReact
    }
   }//End of Drop Below Current Price React
  }//End of Price Move Dn  
 }//End of UpTrend Routine
 
//------------------------------------------------------------------------------
//222222222222222222222222222222222222222222222222222222222222222222222222222222
//------------------------------------------------------------------------------
 //State No 2: In Nat Rally Column
 else if(StateNo[i-1]==2)//
 {//NatRally Routine
  //NatRallyReset=False;

  if(C[i]>C[i-1])
  {//Price Move Up
   if( (InUpTrend[i] AND C[i]>UpTrendPP[i]) OR
    (InDnTrend[i] AND C[i]> DnTrend[i]*(1+2*ThresholdPct[i])) )
   {//Price move to UpTrend - 1111111111111111111111111111111111111111111
    StateNo[i]=1;
    InUpTrend[i]=True;
    InDnTrend[i]=False;
    UpTrend[i]=C[i];
   }//End of Price Move to UpTrend
   else
   {
    if(C[i]>NatRally[i])
    {//Price Continue to move to higher NatRally 
     StateNo[i]=2;//Remain in NatRally - 222222222222222222222222222
     NatRally[i]=C[i];
     NatRallyReset[i]=False;
    }//End of Price Continue to move to higher NatRally
   }
  }//End of Price Move Up
  else //of(C[i]>C[i-1]) 
  {//Price Move Dn
   if((InDnTrend[i] AND C[i]<DnTrendPP[i]) OR
    (InUpTrend[i] AND C[i]< UpTrend[i]/(1+2*ThresholdPct[i])) )
   {//Drop to DnTrend
    StateNo[i]=6;//Dn Trend - 6666666666666666666666666666666666666666
    InDnTrend[i]=True; 
    InUpTrend[i]=False;
    DnTrend[i]=C[i];
    NatRallyPP[i]=NatRally[i];
   }// End of Drop to DnTrend   
   else
   {
    if(C[i]<(NatRally[i]/(1+ThresholdPct[i])))
    {//Drop Below Current State React 
     if(NatReactReset[i] OR C[i] < NatReact[i])
     {//First Time or Below NatReact
      StateNo[i]=5;//Nat React - 55555555555555555555555555555555     
      NatReactReset[i]=False;
      NatReact[i]=C[i];
      NatRallyPP[i]=NatRally[i];
     }//End of First Time or Below NatReact
     else
     {//Drop to SecReact 
      StateNo[i]=4;//SecReact - 444444444444444444444444444444444
      SecReact[i]=C[i];
      NatRallyPP[i]=NatRally[i];
     }//End of Drop to SecReact
    }
   }//End of Drop Below Current Price React
  }//End of Price Move Dn
 }//End of NatRally Routine

//------------------------------------------------------------------------------
//333333333333333333333333333333333333333333333333333333333333333333333333333333
//------------------------------------------------------------------------------
 //State No 3: In Sec Rally Column 
 else if(StateNo[i-1]==3) //
 {//SecRally Routine
  if(C[i]>C[i-1])
  {//Price Move Up
   if( (InUpTrend[i] AND C[i]>UpTrendPP[i]) OR
    (InDnTrend[i] AND C[i]> DnTrend[i]*(1+2*ThresholdPct[i])) )
   {//Price move to UpTrend - 1111111111111111111111111111111111111111111
    StateNo[i]=1;
    InUpTrend[i]=True;
    InDnTrend[i]=False;
    UpTrend[i]=C[i];
   }//End of Price Move to UpTrend
   else
   {
    if(C[i]>NatRally[i])
    {//Price Continue to move to higher NatRally 
     StateNo[i]=2;//Remain in NatRally - 222222222222222222222222222
     NatRally[i]=C[i];
     NatRallyReset[i]=False;

    }//End of Price Continue to move to higher NatRally
    else
    {//Remain at SecRally State
     if(C[i]>SecRally[i])
     {//New Higher Sec Price - 3333333333333333333333333333333333333
      StateNo[i]=3;//Remain in SecRally State
      SecRally[i]=C[i];//Update new higher price
     }//End of New Higher Sec Price
    }//End of Remain at Sec State
   }
  }//End of Price Move Up
  else //of(C[i]>C[i-1]) 
  {//Price Move Dn
   if((InDnTrend[i] AND C[i]<DnTrendPP[i]) OR
    (InUpTrend[i] AND C[i]< UpTrend[i]/(1+2*ThresholdPct[i])) )
   {//Drop to DnTrend
    StateNo[i]=6;//Dn Trend - 666666666666666666666666666666666666666 6 
    InDnTrend[i]=True; 
    InUpTrend[i]=False;
    DnTrend[i]=C[i];
   }// End of Drop to DnTrend   
   else
   {
    if(C[i]<(SecRally[i]/(1+ThresholdPct[i])))
    {//Drop Below Current State React 
     if(C[i] < NatReact[i])
     {//First Time or Below NatReact
      StateNo[i]=5;//Nat React - 55555555555555555555555555555555    
      NatReact[i]=C[i];
     }//End of First Time or Below NatReact
     else
     {//Drop to SecReact 
      StateNo[i]=4;//SecReact - 444444444444444444444444444444444
      SecReact[i]=C[i];
     }//End of Drop to SecReact
    }
   }//End of Drop Below Current Price React
  }//End of Price Move Dn
 }//End of SecRally Routine

//------------------------------------------------------------------------------
//444444444444444444444444444444444444444444444444444444444444444444444444444444
//------------------------------------------------------------------------------
 //State No 4: In Sec React Column  
 //Note that these two state are sharing the same processing routine
 else if(StateNo[i-1]==4)//
 {//SecReact Routine

  if(C[i]>C[i-1])
  {//Price Move Up
   if( (InUpTrend[i] AND C[i]>UpTrendPP[i]) OR
    (InDnTrend[i] AND C[i]> DnTrend[i]*(1+2*ThresholdPct[i])) )
   {//Price move to UpTrend - 1111111111111111111111111111111111111111111
    StateNo[i]=1;
    InUpTrend[i]=True;
    InDnTrend[i]=False;
    UpTrend[i]=C[i];
   }//End of Price Move to UpTrend
   else
   {
    if(C[i]>(SecReact[i]*(1+ThresholdPct[i])))
    {//Raise Above Current State React 
     if(C[i]>NatRally[i])
      {
       StateNo[i]=2;//Move to NatRally - 2222222222222222222222
       NatRally[i]=C[i];
       NatRallyReset[i]=False;
      }
     else
      {//Raise to SeconaryRally
       StateNo[i]=3;//Raise to SecRally - 333333333333333333333
       SecRally[i]=C[i];
      }//End of Raise to SecRally
    }// End of Raise Above Current State React
   }
  }//End of Price Move Up
  else //of(C[i]>C[i-1]) 
  {//Price Move Dn
   if((InDnTrend[i] AND C[i]<DnTrendPP[i]) OR
    (InUpTrend[i] AND C[i]< UpTrend[i]/(1+2*ThresholdPct[i])) )
   {//Drop to DnTrend
    StateNo[i]=6;//Dn Trend - 6666666666666666666666666666666666666666  
    InDnTrend[i]=True; 
    InUpTrend[i]=False;
    DnTrend[i]=C[i];
   }// End of Drop to DnTrend   
   else
   {
    if(C[i]<NatReact[i])
    {//Raise Above NatReact     
     StateNo[i]=5;//NatReact - 5555555555555555555555555555555555555
     NatReact[i]=C[i];
    }//Raise Above NatReact 
    else
    {//Remain at SecReact
     if(C[i]<SecReact[i])
     {//Lower SecReact
      SecReact[i]=C[i];
     }//End of Lower SecReact
    }//End of Remain at SecReact
   }
  }//End of Price Move Dn
 }//End of Sec React Routine

//------------------------------------------------------------------------------
//555555555555555555555555555555555555555555555555555555555555555555555555555555
//------------------------------------------------------------------------------
 //State No 5: In Nat React Column
 else if(StateNo[i-1]==5)//
 {//NatReact Routine
  //NatReactReset=False;
  if(C[i]>C[i-1])
  {//Price Move Up
   if( (InUpTrend[i] AND C[i]>UpTrendPP[i]) OR
    (InDnTrend[i] AND C[i]> DnTrend[i]*(1+2*ThresholdPct[i])) )
   {//Price move to UpTrend - 1111111111111111111111111111111111111111111
    StateNo[i]=1;
    InUpTrend[i]=True;
    InDnTrend[i]=False;
    UpTrend[i]=C[i];
    NatReactPP[i]=NatReact[i];
   }//End of Price Move to UpTrend
   else
   {
    if(C[i]>(NatReact[i]*(1+ThresholdPct[i])))
    {//Raise Above Current State React 
     if(NatRallyReset[i] OR C[i]>NatRally[i])
      {
       StateNo[i]=2;//Move to NatRally - 2222222222222222222222
       NatRallyReset[i]=False;
       NatRally[i]=C[i];
       NatReactPP[i]=NatReact[i];
      }
     else
      {//Raise to SeconaryRally
       StateNo[i]=3;//Raise to SecRally - 333333333333333333333
       SecRally[i]=C[i];
       NatReactPP[i]=NatReact[i];
      }//End of Raise to SecRally
    }// End of Raise Above Current State React
   }
  }//End of Price Move Up
  else //of(C[i]>C[i-1]) - Common with State 1
  {//Price Move Dn
   if((InDnTrend[i] AND C[i]<DnTrendPP[i]) OR
    (InUpTrend[i] AND C[i]< UpTrend[i]/(1+2*ThresholdPct[i])) )
   {//Drop to DnTrend
    StateNo[i]=6;//Dn Trend - 6666666666666666666666666666666666666666  
    InDnTrend[i]=True; 
    InUpTrend[i]=False;
    DnTrend[i]=C[i];
   }// End of Drop to DnTrend   
   else
   {
    if(C[i]<NatReact[i])
    {//Raise Above NatReact     
     StateNo[i]=5;//NatReact - 5555555555555555555555555555555555555
     NatReact[i]=C[i];
    }//Raise Above NatReact 
   }
  }//End of Price Move Dn
 }//End of NatReact Routine
//------------------------------------------------------------------------------
//666666666666666666666666666666666666666666666666666666666666666666666666666666
//------------------------------------------------------------------------------
 //State No 6: In Dn Trend Column
 else if(StateNo[i-1]==6)//
 // Must be in State No 6
 {//DnTrend Routine
  if(C[i]>C[i-1])
  {//Price Move Up
   if( (InUpTrend[i] AND C[i]>UpTrendPP[i]) OR
    (InDnTrend[i] AND C[i]> DnTrend[i]*(1+2*ThresholdPct[i])) )
   {//Price move to UpTrend - 1111111111111111111111111111111111111111111
    StateNo[i]=1;
    InUpTrend[i]=True;
    InDnTrend[i]=False;
    UpTrend[i]=C[i];
    DnTrendPP[i]=DnTrend[i];
   }//End of Price Move to UpTrend
   else
   {
    if(C[i]>(DnTrend[i]*(1+ThresholdPct[i])))
    {//Raise Above Current State React 
     if(NatRallyReset[i] OR C[i]>NatRally[i])
      {
       StateNo[i]=2;//Move to NatRally - 2222222222222222222222
       NatRallyReset[i]=False;
       NatRally[i]=C[i];
       DnTrendPP[i]=DnTrend[i];
      }
     else
      {//Raise to SeconaryRally
       StateNo[i]=3;//Raise to SecRally - 333333333333333333333
       SecRally[i]=C[i];
       DnTrendPP[i]=DnTrend[i];
      }//End of Raise to SecRally
    }// End of Raise Above Current State React
   }
  }//End of Price Move Up
  else //of(C[i]>C[i-1]) - Common with State 1
  {//Price Move Dn
   if(C[i]<DnTrend[i])
   {//Price move futher Dn
    StateNo[i]=6;//Dn Trend - 6666666666666666666666666666666666666666  
    InDnTrend[i]=True; 
    InUpTrend[i]=False;
    DnTrend[i]=C[i];
   }//End of Price move Futher Dn   
  }//End of Price Move Dn
 }//End of DnTrend Routine

//------------------------------------------------------------------------------

 //Checking and Processing Parameters here... 
 //Reset Value of Rally and React Values if needed
 
 // React Values become Obseleted Price moved to high up. Reset them.
   if(InUpTrend[i] AND NatReact[i] < UpTrend[i]/(1+2*ThresholdPct[i]) )
 {
  NatReactReset[i]=True;
 }
 // Rally Values become Obaseleted as Price move to low Dn. Reset them
 if(InDnTrend[i] AND NatRally[i] > DnTrend[i]*(1+2*ThresholdPct[i]) )   
 {
  NatRallyReset[i]=True;
 }

  }  //end; //{main}
} //End of For i Loop!

//Plotting Section - Just for testing

//InUpTrend
WeightNo= IIf(StateNo==1,5,  // UpTrend
   IIf(StateNo==2,3,  // and NatRally
   IIf(StateNo==3,1,  // and SecRally
   IIf(StateNo==4,-1,  // and SecReact
   IIf(StateNo==5,-3,  // and NatReact
   IIf(StateNo==6,-5, // DownTrend
                   0  // and SecReact
   ))))));

Plot(WeightNo,"Livermore Market Key Stage",IIf(WeightNo>0 AND WeightNo==5,colorGreen,
                         IIf(WeightNo>0,colorBlue,
        IIf(WeightNo<0 AND WeightNo==-5,colorRed,colorOrange))),styleStaircase|styleDots);


//End of Livermore Market Key Section



Plot(0,"",colorBlack);
Plot(6,"",colorWhite);
Plot(-6,"",colorWhite);

Buy = WeightNo==5;
Sell= WeightNo<5;

Short= WeightNo==-5;
Cover= WeightNo>-5;

Buy=ExRem(Buy,Sell);
Sell=ExRem(Sell,Buy);

Short=ExRem(Short,Cover);
Cover=ExRem(Cover,Short);
Previous
Next Post »