Livermore Secret Market Key Indicator

July 1st, 2015, 02:04 PM

I came across an indicator written for this Market Key for AFL, but would like one for use in trade station.

The details of the indicator can be found here. I attached the flow chart schematic as a pdf.

Thanks in advance, as I do not have coding experience.

July 1st, 2015, 02:13 PM

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

/*
//------------------------------------------------------------------------------
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 a detailed explanation of the system Jesse Livermore Orginal Work.
Note: Livermore's system used a threshold of 6 points for stocks priced
over $30.
//------------------------------------------------------------------------------
*/

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

July 3rd, 2015, 05:25 AM

thanks both for sharing.

February 27th, 2016, 12:04 PM

Did anyone code this? If will you post the file(s)to import?

Livermore Secret Market Key Indicator

Discussion in TradeStation

Livermore Secret Market Key Indicator