// Downloaded From https://www.WiseStockTrader.com
_SECTION_BEGIN("jesselevenmore");
//------------------------------------------------------------------------------
//  Formula Name   : Project Freedom - Jesse Livermore Secret Market Key
//  Author         : KH Tang 
//  Date Updated   : 30 Apr 2007 
//  Origin         : Personal Study and Understanding of Livermore's work
//  Version        : 1.0 
//  Blog			  : http://blessedfool.gaia.com/blog
//------------------------------------------------------------------------------

/*
//------------------------------------------------------------------------------
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)

For  detailed explanation of the system Jesse Livermore Orginal Work.
 Note: Livermore's system used a threshold of 6 points for stocks priced 
 over $30.
 For modern Market, due to different markets has wide range of prices.  The
 threshold price is set in Percentage...(default 10%)

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

// General Graphic Control
GraphXSpace = 15;

SetChartBkGradientFill( ParamColor("BgTop", colorSkyblue),
        ParamColor("BgBottom",
colorWhite),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)
	//  With this, one can program anything in a flowchart. :-)

	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(InUpTrend AND StateNo==5,1,  // and NatReact
			IIf(InUpTrend AND StateNo==2,4,  // and NatRally
			IIf(InUpTrend AND StateNo==4,2,  // and SecReact
			IIf(InUpTrend AND StateNo==3,3,  // and SecRally
			IIf(StateNo==6,-5,               // DownTrend
			IIf(InDnTrend AND StateNo==2,-1, // and NatRally         
			IIf(InDnTrend AND StateNo==5,-4, // and NatReact
			IIf(InDnTrend AND StateNo==3,-2, // and SecRally
			                             -3  // and SecReact
			)))))))));

Plot(WeightNo,"Livermore Secret Market Key Stage Diagram",IIf(WeightNo>0 AND
WeightNo==5,colorGreen,
                         IIf(WeightNo>0,colorBlue,
							 IIf(WeightNo<0 AND WeightNo==-5,colorRed,colorPink))),styleStaircase);
Plot(0,"",colorBlack,styleNoLabel);

//End of Livermore Market Key Section
_SECTION_END();