My afl collection

Status
Not open for further replies.

shivangi77

Well-Known Member
any renko based afl plz upload afl of renko.

SRI (Super Renko Indicator)





Code:
 SetBarsRequired(100000,100000);
//------------------------------------------------------------------+
// Block 1                                                          |
//------------------------------------------------------------------+
  VR=ParamToggle("View Renko","Bricks|Lines/Bars",0);                
  FV=Param("Initial size volatility",0.5,0.001,50,0.001);            
  MV=Param("Method calculation volatility",0,0,2,1);                 
  PeriodVol=Param("Period calculation volatility",14,2,100,1);       
  Multiplier=Param("Multiplier volatility",1,0.1,10,0.1);           
  MR=ParamToggle("Method Renko","floating|fixed",1);         
  SG=ParamToggle("Show gap","No|Yes",1);                     
  CG=ParamColor("Colour show gap",11);                     
  MaxBS=Param("Maximum size brick",0,0,10,0.1);             
  MinBS=Param("Minimum size brick",0,0,10,0.1);              
  RenkoUp=ParamColor("Colour Renko upwards",colorBlack);      
  RenkoDown=ParamColor("Colour Renko downwards",colorBlack);
  SB=ParamStyle("View bars",defaultval=styleCandle,mask=maskPrice);    
  color3=ParamColor("Colour bars",colorBlack);
  History=Param("History size",5000,2,BarCount-1,1);              
//------------------------------------------------------------------+
// Block 2                                                          |
//------------------------------------------------------------------+
  i=Max(BarCount-1-History,PeriodVol+1);                             
  r=j=0;                                                             
  direction=0;                                                       
  iGapUp=iGapDown=0; 
  rOpen[0]=rHigh[0]=rLow[0]=rClose[0]=jUp=jDown=Open[i];             
//------------------------------------------------------------------- 
  switch(MV)
    {
     case 0: Volatility=FV; break;                                   
     case 1: Volatility=ATR(PeriodVol)*Multiplier; break;             
     case 2: Volatility=StDev(Open,PeriodVol)*Multiplier; break;     
    }         
  BrickSize=Volatility[i-1];                                         
//-------------------------------------------------------------------+
// Block 3                                                           |
//-------------------------------------------------------------------+
  while(i<=BarCount-1)
    { 
     if(SG==1)
       {
        if(High[i-1]<Low[i])
          {
           iGapUp[i]=1;                                       
          }
          else
          {
           if(Low[i-1]>High[i])
             {
              iGapDown[i]=1;
             }
          }
       } 
//------------------------------------------------------------------- 
     if(MR==0)  
       {
        BrickSize=Volatility[i-1];
        if(MaxBS>0) {BrickSize=Min(MaxBS,BrickSize);}                 
        if(MinBS>0) {BrickSize=Max(MinBS,BrickSize);}                
       } 
//------------------------------------------------------------------+
// Block 4                                                          |
//------------------------------------------------------------------+
     if(direction==0)                                                 
       {                                                   
        if(Open[i]-rClose[r]>BrickSize)                              
          {                                                 
           rClose[r]=rOpen[r]+BrickSize;
           rHigh[r]=rClose[r];
           direction=1;
//------------------------------------------------------------------- 
           BrickSize=Volatility[i];
           if(MaxBS>0) {BrickSize=Min(MaxBS,BrickSize);}                
           if(MinBS>0) {BrickSize=Max(MinBS,BrickSize);}
//------------------------------------------------------------------- 
           if(iGapUp[i]==1|iGapDown[i]==1)                           
             {
              color[r]=CG;                                           
             }
             else
             {
              color[r]=RenkoUp;                                      
             }
           continue;                                                                                       
          }                                                           
//------------------------------------------------------------------- 
          else
          {
           if(rClose[r]-Open[i]>BrickSize)                             
             {
              rClose[r]=rOpen[r]-BrickSize;
              rLow[r]=rClose[r];
              direction=2;
//------------------------------------------------------------------- 
              BrickSize=Volatility[i];
              if(MaxBS>0) {BrickSize=Min(MaxBS,BrickSize);}                
              if(MinBS>0) {BrickSize=Max(MinBS,BrickSize);}
//------------------------------------------------------------------- 
              if(iGapUp[i]==1|iGapDown[i]==1)
                {
                 color[r]=CG;                                        
                }
                else
                {
                 color[r]=RenkoDown;                                         
                }
              continue;                                         
             }
          }
       }
//------------------------------------------------------------------+
// Block 5                                                          |
//------------------------------------------------------------------+
       else                                                         
       { 
        if(direction==1)                                             
          {
           if(rOpen[r]-Open[i]>BrickSize)                                                                     
             {
              r++;
              rOpen[r]=rOpen[r-1];
              rHigh[r]=rOpen[r];
              rClose[r]=rOpen[r]-BrickSize;
              rLow[r]=rClose[r];
              direction=2;
//------------------------------------------------------------------- 
              BrickSize=Volatility[i];
              if(MaxBS>0) {BrickSize=Min(MaxBS,BrickSize);}                
              if(MinBS>0) {BrickSize=Max(MinBS,BrickSize);}
//------------------------------------------------------------------- 
              if(iGapUp[i]==1|iGapDown[i]==1)
                {
                 color[r]=CG;                                        
                }
                else
                {
                 color[r]=RenkoDown;                                         
                }
              continue;                                                   
             }
//------------------------------------------------------------------- 
             else
             {
              while(Open[i]-rClose[r]>BrickSize)        
                {
                 r++;
                 rOpen[r]=rClose[r-1];
                 rLow[r]=rOpen[r];
                 rClose[r]=rOpen[r]+BrickSize;
                 rHigh[r]=rClose[r];
//------------------------------------------------------------------- 
                 BrickSize=Volatility[i];
                 if(MaxBS>0) {BrickSize=Min(MaxBS,BrickSize);}                
                 if(MinBS>0) {BrickSize=Max(MinBS,BrickSize);}
//------------------------------------------------------------------- 
                 if(iGapUp[i]==1|iGapDown[i]==1)
                   {
                    color[r]=CG;                                        
                   }
                   else
                   {
                    color[r]=RenkoUp;                                         
                   }
                }
             }
          }
//------------------------------------------------------------------+
// Block 6                                                          |
//------------------------------------------------------------------+
          else
          {
           if(direction==2)                                          
             {
              if(Open[i]-rOpen[r]>BrickSize)
                {
                 r++;
                 rOpen[r]=rOpen[r-1];
                 rLow[r]=rOpen[r];
                 rClose[r]=rOpen[r]+BrickSize;
                 rHigh[r]=rClose[r];
                 direction=1;
//------------------------------------------------------------------- 
                 BrickSize=Volatility[i];
                 if(MaxBS>0) {BrickSize=Min(MaxBS,BrickSize);}                
                 if(MinBS>0) {BrickSize=Max(MinBS,BrickSize);}
//------------------------------------------------------------------- 
                 if(iGapUp[i]==1|iGapDown[i]==1)
                   {
                    color[r]=CG;                                        
                   }
                   else
                   {
                    color[r]=RenkoUp;                                         
                   }
                 continue;  
                }
//------------------------------------------------------------------- 
                else
                {
                 while(rClose[r]-Open[i]>BrickSize)                                                        
                   {
                    r++;
                    rOpen[r]=rClose[r-1];
                    rHigh[r]=rOpen[r];
                    rClose[r]=rOpen[r]-BrickSize;
                    rLow[r]=rClose[r];
//------------------------------------------------------------------- 
                    BrickSize=Volatility[i];
                    if(MaxBS>0) {BrickSize=Min(MaxBS,BrickSize);}                
                    if(MinBS>0) {BrickSize=Max(MinBS,BrickSize);}
//-------------------------------------------------------------------
                    if(iGapUp[i]==1|iGapDown[i]==1)
                      {
                       color[r]=CG;                                        
                      }
                      else
                      {
                       color[r]=RenkoDown;                                         
                      }
                    }
                }
             }
          }
       }                                                             
//------------------------------------------------------------------+
// Block 7                                                          |
//------------------------------------------------------------------+
     if(VR==1)                                                       
       {
        jOpen[j]=Open[i];
        jHigh[j]=High[i];
        jLow[j]=Low[i];
        jClose[j]=Close[i];
//-------------------------------------------------------------------
        if(direction==1)
          {
           jUp[j]=rClose[r];
           jDown[j]=rOpen[r];
           color2[j]=color[r];
          }
          else
          {
           if(direction==2)
             {
              jUp[j]=rOpen[r];
              jDown[j]=rClose[r];
              color2[j]=color[r];
             }
          }
        j++;
       }                                                                    
     i++;                                                                                         
    }                                                                
//------------------------------------------------------------------+
// Block 8                                                          |
//------------------------------------------------------------------+
  if(VR==1)                                                          
    {
     delta=BarCount-j;
     jOpen=Ref(jOpen,-delta);                                        
     jHigh=Ref(jHigh,-delta);                                        
     jLow=Ref(jLow,-delta);
     jClose=Ref(jClose,-delta);
     jUp=Ref(jUp,-delta);
     jDown=Ref(jDown,-delta);
     color2=Ref(color2,-delta);
     SetChartOptions(0,chartShowArrows|chartShowDates);
     _N(Title = StrFormat("{{NAME}} - {{INTERVAL}} {{DATE}} Open %g, Hi %g, Lo %g, Close %g (%.1f%%) {{VALUES}}", O, H, L, C, SelectedValue( ROC( C, 1 ) ) ));
     PlotOHLC(jOpen,jHigh,jLow,jClose,"SRI",color3,SB);                       
     Plot(jUp,"Up",color2,styleThick);                                                 
     Plot(jDown,"Down",color2,styleThick); 
    }
//-------------------------------------------------------------------
    else                                                            
    {  
     delta=BarCount-1-r;                                              
     rOpen=Ref(rOpen,-delta);                                        
     rHigh=Ref(rHigh,-delta);                                        
     rLow=Ref(rLow,-delta);
     rClose=Ref(rClose,-delta);
     color=Ref(color,-delta);
     PlotOHLC(rOpen,rHigh,rLow,rClose,"SRI",color,styleCandle);      
    }
If Nothing is showing on chart then increase backfill data and change parameters.
 

shivangi77

Well-Known Member
Renko chart





Code:
// Renko  Chart
// Graham Kavanagh  13 Aug 2004 ver C
// Custom Indicator, date axis does not apply
 
 
 SetBarsRequired(10000,10000);
 
// Brick size is dependant on what you want, if too small will not produce a chart due to insufficient x-axis bars
//Brick = LastValue( ATR(100) );
//Brick = LastValue( Max(0.02*C, 0.05) );
Brick = Param( "Brick Size", 0.1, 0.01, 1.00, 0.01 );
reverse = 2;
 
// Convert the closing price to rising and falling rounded bricks
CF = ceil(C/Brick);
CR = floor(C/Brick);
 
// initialize first element
j = 0;
RKC[j] = CF[0];
RKO[j] = CF[0] + 1;
 
down[j] = 1;  // By default the first bar is a down bar.
up[j] = 0;
 
// Loop to produce the Renko values in number of bricks
 
for( i=1; i<BarCount-1; i++ )
{
if( CF[i] <= RKC[j] - 1 && down[j] ) // Continue down
    {
        num = RKC[j] - CF[i];
        for( x=1; x<=num; x++ )
        {
            j++;
            up[j] = 0;
            down[j] = 1;
            RKC[j] = RKC[j-1] - 1;
            RKO[j] = RKC[j] + 1;
        }
    }
    else
    {
        if( CR[i] >= RKC[j] + Reverse && down[j] )  // Change down to up
        {
            num = CR[i] - RKC[j];
            j++;
            up[j] = 1;
            down[j] = 0;
            RKC[j] = RKC[j-1] + 2;
            RKO[j] = RKC[j] - 1;            
            for( x=2; x<=num; x++ )
            {
                j++;
                up[j] = 1;
                down[j] = 0;
                RKC[j] = RKC[j-1] + 1;
                RKO[j] = RKC[j] - 1;
            }
        }
        else
        {
            if( CR[i] >= RKC[j] + 1 && up[j] ) // Continue Up
            {
                num = CR[i] - RKC[j];
                for( x=1; x<=num; x++ )
                {
                    j++;
                    Up[j] = 1;
                    Down[j] = 0;
                    RKC[j] = RKC[j-1] + 1;
                    RKO[j] = RKC[j] - 1;
                }
            }
            else
            {
                if( CF[i] <= RKC[j] - Reverse && up[j] )  // Change up to down
                {
                    num = RKC[j] - CF[i];
                    j++;
                    Up[j] = 0;
                    Down[j] = 1;
                    RKC[j] = RKC[j-1] - 2;
                    RKO[j] = RKC[j] + 1;
                    for( x=2; x<=num; x++ )
                    {
                        j++;
                        up[j] = 0;
                        down[j] = 1;
                        RKC[j] = RKC[j-1] - 1;
                        RKO[j] = RKC[j] + 1;
                    }
                }
            }
        }
    }
}
 
 
// move the chart to right end of chart space, ie last brick on last bar position
delta =  BarCount-1 - j;
 
RKC = Ref( RKC, -delta );
RKO = Ref( RKO, -delta );
 
Up = Ref( Up, -delta );
Down = Ref( Down, -delta );
 
/*
rC = RKC * Brick;// + (Up-down)*Brick/2;
rO = RC - (Up-down)*Brick;
rH = Max(rC,rO);
rL = Min(rC,rO);
*/
 
 
C = RKC * Brick;// + (Up-down)*Brick/2;
O = C - (Up-down)*Brick;
H = Max(C,O);
L = Min(C,O);
 
Plot( C, "", colorGrey50,styleCandle); 
// plot chart
//plotOHLC( rO, rH, rL, rC, "Renko Price " , colorBlack, styleCandle);
GraphXSpace=5;
 
Title = Name() + " - {{INTERVAL}} {{DATE}} - Renko Chart : Last Value = " + RKC * Brick + ", Brick Size = " + Brick;

Change Brick size if it gives any error
 

shivangi77

Well-Known Member
Coppock Indicator


SOURCE


Code:
_SECTION_BEGIN("Ultimate Trend Cycle");

SetChartBkColor(colorBlack);
aa=(H+L+2*C)/4;
A=EMA(aa,13);
B=EMA(aa,39);
A1=EMA(aa,23);
B1=EMA(aa,70);
D1=A1/B1;
K2=EMA(D1,3);
D=A/B;
K1=EMA(D,3);
K=ROC(K1,1);
K3=EMA(EMA(ROC(K2,1)*50,3),3);
ifish=EMA(EMA(EMA(EMA(EMA(K,3),3),3),3),3)*60;
Color=IIf(ifish>0,IIf(ifish>Ref(ifish,-1),colorDarkGreen,colorYellow),IIf(ifish>Ref(ifish ,-1),colorBlue,colorRed));
Plot(ifish,"Ultimate Trend Cycle Force Index Ribbon",Color,styleHistogram | styleThick, maskHistogram);
Plot(K3,"",colorGreen,styleLine);
Plot(Ref(K3,-1),"",colorRed,styleLine);
_SECTION_END();
/////////////////////////////////////////////////////////////////////////////////////
_SECTION_BEGIN("DOTS For CCI_Ozel");

a1=EMA(CCI(5),3);
a2=EMA(CCI(10),3);
a3=EMA(CCI(15),3);
b1=StDev(a1,5);
b2=StDev(a2,10);
b3=StDev(a3,15);
RMOV=((a1*b1)+(a2*b2)+(a3*b3))/(b1+b2+b3);
K1=EMA(EMA(EMA(RMOV,3),3),3);

PlotShapes(IIf(K1 > 0,shapeSmallCircle,shapeNone),colorBrightGreen,0,0 ,0);
PlotShapes(IIf(K1 <= 0,shapeSmallCircle,shapeNone),colorRed,0,0,0);

_SECTION_END();
/////////////////////////////////////////////////////////////////////////////////////
_SECTION_BEGIN("Trend Direction and Force Index Ribbon");
MMA=EMA(C,15);
SMMA=EMA(MMA,15);
IMPETMMA=MMA - Ref(MMA,-1);
IMPETSMMA=SMMA - Ref(SMMA,-1);
DIVMA= abs(MMA - SMMA);
AVERIMPET= (IMPETMMA+IMPETSMMA)/2;
K1=DIVMA;
K2=AVERIMPET*AVERIMPET*AVERIMPET;
TDF= K1*K2;
NTDF1=EMA(TDF/HHV(abs(TDF),15*3),3)*100;
NTDF=EMA(NTDF1,3);
Bull_Trend=NTDF>4;
Bear_Trend=NTDF<=-4;
Ribbon_kol=IIf(Bull_Trend,colorGreen, IIf(Bear_Trend,colorRed, colorOrange));
Plot(2, "", Ribbon_kol, styleOwnScale|styleArea|styleNoLabel, -0.5,100);

_SECTION_END();
/////////////////////////////////////////////////////////////////////////////////////

_SECTION_BEGIN("StochRSI_Special");
x=(( RSI(21) - LLV(RSI(21) ,21)) / ((HHV(RSI(21 ) ,21)) - LLV(RSI(21),21)))*100;
Value1=0.1*((x)-50);
Value2=WMA(Value1,7);
KK=(exp(Value2)-1)/(exp(Value2)+1);

Plot(0,"",IIf(EMA(KK,3)>0.50,colorBrightGreen,colo rRed) ,4+styleNoLabel);

_SECTION_END();
/////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////
_SECTION_BEGIN("Coppock Trade Signal v1.1");

//PARAMETERS:
ROC1Periods =Param("ROC1 periods",14,2,200,1,0);
ROC2Periods =Param("ROC2 periods",11,2,200,1,0);
WMAPeriods =Param("WMA periods",10,2,200,1,0);
CoppockCurve =ParamToggle("Use Coppock curve","No|Yes",0);
CoppockBar =ParamToggle("Use Coppock bar","No|Yes",1);
ColBull =ParamColor("Bull color",colorBlue);
ColBear =ParamColor("Bear color",colorRed);
UseTradeSignal =ParamToggle("Use trade signal","No|Yes",1);
CoppockFilter =Param("Coppock filter",20,2,200,1,0);
ColBuy =ParamColor("Buy color",colorBrightGreen);
ColSell =ParamColor("Sell color",colorDarkRed);
ColBg =ParamToggle("Show background color","No|Yes",1);

//MAIN:
Coppock=WMA((ROC(C,ROC1Periods)+ROC(C,ROC2Periods) ),WMAPeriods);
InitialCalculationLength=Max(ROC1Periods,ROC2Perio ds)+WMAPeriods;
for(i=0;i<BarCount;i++)
{
if(i<InitialCalculationLength) //initial zero
{
Coppock[i]=0.0;
if(UseTradeSignal){Buy=0; Sell=0;}
}
}
LastCoppock1=Ref(Coppock,-1);
LastCoppock2=Ref(Coppock,-2);
TradeStatus=IIf(Coppock>0,IIf(Coppock>LastCoppock1 ,ColBull,IIf(Coppock<LastCoppock1,ColBear,IIf(Copp ock==LastCoppock1
&& LastCoppock1>LastCoppock2,ColBull,ColBear))),

IIf(Coppock>LastCoppock1,ColBull,IIf(Coppock<LastC oppock1,ColBear,IIf(Coppock==LastCoppock1
&& LastCoppock1>LastCoppock2,ColBull,ColBear))));
StyleTitle=IIf(CoppockCurve && CoppockBar,styleNoTitle,0);
StyleLabel=IIf(CoppockCurve && CoppockBar,styleNoLabel,0);
if(CoppockCurve)
Plot(Coppock,"",TradeStatus,styleLine|styleThick|S tyleTitle|styleNoDraw);
if(CoppockBar)
Plot(Coppock,"",TradeStatus,styleHistogram|styleNo Draw);
if(UseTradeSignal)
{
CoppockIsBuy=TradeStatus==ColBull;
CoppockIsSell=TradeStatus==ColBear;
CoppockBuyValue=ValueWhen(CoppockIsBuy,Coppock,1);
CoppockSellValue=ValueWhen(CoppockIsSell,Coppock,1 );
Buy=!Ref(CoppockIsBuy,-1) && Coppock<0 && CoppockIsBuy &&
abs(CoppockBuyValue)>=CoppockFilter;
Sell=!Ref(CoppockIsSell,-1) && Coppock>0 && CoppockIsSell &&
abs(CoppockSellValue)>=CoppockFilter;
PlotShapes(IIf(Buy,shapeUpArrow,shapeNone),ColBuy, 0,0);
PlotShapes(IIf(Sell,shapeDownArrow,shapeNone),ColS ell,0,0);
}
if(ColBg)

_SECTION_END();
 
polyfit is just a function, NOT a afl, so far I know !
Grateful, for your prompt reply !!! Actually I found this AFL in wise trader....but it is requiring the PolyFit.afl....what it is told to include. However I'm showing the
Regards.

code:

===================================================

_SECTION_BEGIN("Chart Settings");
SetChartOptions(0,chartShowArrows|chartShowDates);
SetChartBkColor(ParamColor("Outer Panel",colorPaleBlue));
SetChartBkGradientFill(ParamColor("Upper Chart",colorBlack),ParamColor("Lower Chart",colorBlack));
_SECTION_END();


_SECTION_BEGIN("Katsayi Optimizeli 6.nci Dereceden Polynom'un WMA()'si Alinmis Deklem");
PG = ParamToggle(" Polynom Gstermek ","hide|show",0);

ACID=Param("Sper Ince Ayar",1,1,180,0.001);
Derece3 = ParamToggle("3.nc Derece Polynom ","hide|show",0);
Derece4 = ParamToggle("4.nc Derece Polynom ","hide|show",0);
Derece5 = ParamToggle("5.nc Derece Polynom ","hide|show",0);
Derece6 = ParamToggle("6.nc Derece Polynom ","hide|show",0);
Shape = ParamToggle(" Oklari Gstermek ","hide|show",0);

Katsayi43=(Param("3.Katsayi1",0,-2,30,0.001));
Katsayi53=Param("3.Katsayi2",0,-2,30,0.001);
Katsayi63=Param("3.Katsayi3",0,-2,30,0.001);

Katsayi34=Param("4.Katsayi1",0,-30,30,0.001);
Katsayi44=Param("4.Katsayi2",0,-30,30,0.001);
Katsayi54=Param("4.Katsayi3",0,-30,30,0.001);
Katsayi64=Param("4.Katsayi4",0,-30,30,0.001);

Katsayi25=Param("5.Katsayi1",0,-30,30,0.001);
Katsayi35=Param("5.Katsayi2",0,-30,30,0.001);
Katsayi45=Param("5.Katsayi3",0,-30,30,0.001);
Katsayi55=Param("5.Katsayi4",0,-30,30,0.001);
Katsayi65=Param("5.Katsayi5",0,-30,30,0.001);

Katsayi16=Param("6.Katsayi1",0,-30,30,0.001);
Katsayi26=Param("6.Katsayi2",0,-30,30,0.001);
Katsayi36=Param("6.Katsayi3",0,-30,30,0.001);
Katsayi46=Param("6.Katsayi4",0,-30,30,0.001);
Katsayi56=Param("6.Katsayi5",0,-30,30,0.001);
Katsayi66=Param("6.Katsayi6",0,-30,30,0.001);

Moveto=Param("Saga Sola Kaydir",1,1,1456,2);
Moveto1=Param("Yukari Asagi Kaydir",1,1,1456,2);
if(PG)
{

GfxSelectPen( colorGreen, 4 );
GfxSelectSolidBrush( colorYellow );

GfxRoundRect( 20+Moveto, 30+Moveto1, 300+Moveto, 430+Moveto1, 15, 15 );

GfxSelectPen( colorRed);
GfxSetTextColor( colorBlue );
GfxSetTextAlign( 0 );
GfxSetBkColor( colorYellow );
GfxTextOut( "Sper Ince Ayar : "+ StrFormat("%-3.000d",ACID), 50+Moveto, 35+Moveto1 );


PlotOHLC(O, H, L, C, "Data", colorWhite, styleBar | styleThick);
pi=22/7;

Rtd = 180 / Pi;
Dtr = 1 / Rtd;
x=(O+C+H+L)/4;


if(Derece3)
{

Katsayi43=Katsayi43*(ACID*DTR);
Katsayi53=Katsayi53*(ACID*DTR);
Katsayi63=Katsayi63*(ACID*DTR);

y3=Katsayi43*x*exp(3) + Katsayi53*x*exp(2) + Katsayi63*x;
y3m=WMA(x,y3);

for( i = 1 ; i < BarCount-2; i++ )
{
if (y3m <y3m[i-1] && y3m <y3m[i+1]) Lpml=1;
else
Lpml =0;

if (y3m >y3m[i-1] && y3m >y3m[i+1]) Lpmh=1;
else
Lpmh =0;
}

GR =ExRem(LpmH,Lpmh);
RD =ExRem(Lpml,Lpml);

if(Shape)
{
PlotShapes(IIf(GR!=0,shapeDownArrow,shapeNone),colorRed,H,y3m,-30);
PlotShapes(IIf(RD!=0,shapeUpArrow,shapeNone),colorBrightGreen,L,y3m,-30);
}



Plot(y3m,"",IIf(y3m>Ref(y3m,-1),colorLime,colorRed),styleLine|styleThick);

GfxTextOut( "3.nc Derece Katsayi-1 : "+ StrFormat("%-3.000d",Katsayi43), 50+Moveto, 60+Moveto1);
GfxTextOut( "3.nc Derece Katsayi-2 : "+ StrFormat("%-3.000d",Katsayi53), 50+Moveto, 80+Moveto1);
GfxTextOut( "3.nc Derece Katsayi-3 : "+ StrFormat("%-3.000d",Katsayi63), 50+Moveto, 100+Moveto1);

}

if(Derece4)
{

Katsayi34=Katsayi34*(ACID*DTR);
Katsayi44=Katsayi44*(ACID*DTR);
Katsayi54=Katsayi54*(ACID*DTR);
Katsayi64=Katsayi64*(ACID*DTR);

y4=Katsayi34*x*exp(4) +Katsayi44*x*exp(3) + Katsayi54*x*exp(2) + Katsayi64*x;
y4m=WMA(x,y4);


for( i = 1 ; i < BarCount-2; i++ )
{
if (y4m <y4m[i-1] && y4m <y4m[i+1]) Lpml=1;
else
Lpml =0;

if (y4m >y4m[i-1] && y4m >y4m[i+1]) Lpmh=1;
else
Lpmh =0;
}

GR =ExRem(LpmH,Lpmh);
RD =ExRem(Lpml,Lpml);

if(Shape)
{

PlotShapes(IIf(GR!=0,shapeDownArrow,shapeNone),colorRed,H,y4m,-40);
PlotShapes(IIf(RD!=0,shapeUpArrow,shapeNone),colorBrightGreen,L,y4m,-40);
}


Plot(y4m,"",IIf(y4m>Ref(y4m,-1),colorLime,colorRed),styleLine|styleThick);



GfxTextOut( "4.nc Derece Katsayi-1 : "+ StrFormat("%-3.000d",Katsayi34), 50+Moveto, 120+Moveto1);
GfxTextOut( "4.nc Derece Katsayi-2 : "+ StrFormat("%-3.000d",Katsayi44), 50+Moveto, 140+Moveto1);
GfxTextOut( "4.nc Derece Katsayi-3 : "+ StrFormat("%-3.000d",Katsayi54), 50+Moveto, 160+Moveto1);
GfxTextOut( "4.nc Derece Katsayi-4 : "+ StrFormat("%-3.000d",Katsayi64), 50+Moveto, 180+Moveto1);



}

if(Derece5)
{

Katsayi25=Katsayi25*(ACID*DTR);
Katsayi35=Katsayi35*(ACID*DTR);
Katsayi45=Katsayi45*(ACID*DTR);
Katsayi55=Katsayi55*(ACID*DTR);
Katsayi65=Katsayi65*(ACID*DTR);

y5=Katsayi25*x*exp(5) + Katsayi35*x*exp(4) +Katsayi45*x*exp(3) + Katsayi55*x*exp(2) + Katsayi65*x;
y5m=WMA(x,y5);

for( i = 1 ; i < BarCount-2; i++ )
{
if (y5m <y5m[i-1] && y5m <y5m[i+1]) Lpml=1;
else
Lpml =0;

if (y5m >y5m[i-1] && y5m >y5m[i+1]) Lpmh=1;
else
Lpmh =0;
}

GR =ExRem(LpmH,Lpmh);
RD =ExRem(Lpml,Lpml);

if(Shape)
{

PlotShapes(IIf(GR!=0,shapeDownArrow,shapeNone),colorRed,H,y5m,-50);
PlotShapes(IIf(RD!=0,shapeUpArrow,shapeNone),colorBrightGreen,L,y5m,-50);
}


Plot(y5m,"",IIf(y5m>Ref(y5m,-1),colorLime,colorRed),styleLine|styleThick);


GfxTextOut( "5.nc Derece Katsayi-1 : "+ StrFormat("%-3.000d",Katsayi25), 50+Moveto, 200+Moveto1);
GfxTextOut( "5.nc Derece Katsayi-2 : "+ StrFormat("%-3.000d",Katsayi35), 50+Moveto, 220+Moveto1);
GfxTextOut( "5.nc Derece Katsayi-3 : "+ StrFormat("%-3.000d",Katsayi45), 50+Moveto, 240+Moveto1);
GfxTextOut( "5.nc Derece Katsayi-4 : "+ StrFormat("%-3.000d",Katsayi55), 50+Moveto, 260+Moveto1);
GfxTextOut( "5.nc Derece Katsayi-5 : "+ StrFormat("%-3.000d",Katsayi65), 50+Moveto, 280+Moveto1);


}

if(Derece6)
{


Katsayi16=Katsayi16*(ACID*DTR);
Katsayi26=Katsayi26*(ACID*DTR);
Katsayi36=Katsayi36*(ACID*DTR);
Katsayi46=Katsayi46*(ACID*DTR);
Katsayi56=Katsayi56*(ACID*DTR);
Katsayi66=Katsayi66*(ACID*DTR);

y6 =Katsayi16*x*exp(6)+Katsayi26*x*exp(5) +Katsayi36*x*exp(4) + Katsayi46*x*exp(3) + Katsayi56*x*exp(2) + Katsayi66*x;
y6m=WMA(x,y6);

for( i = 1 ; i < BarCount-2; i++ )
{
if (y6m <y6m[i-1] && y6m <y6m[i+1]) Lpml=1;
else
Lpml =0;

if (y6m >y6m[i-1] && y6m >y6m[i+1]) Lpmh=1;
else
Lpmh =0;
}

GR =ExRem(LpmH,Lpmh);
RD =ExRem(Lpml,Lpml);

if(Shape)
{

PlotShapes(IIf(GR!=0,shapeHollowCircle,shapeNone),colorRed,H,y6m,0);
PlotShapes(IIf(RD!=0,shapeHollowCircle,shapeNone),colorBrightGreen,L,y6m,0);
}




Plot(y6m,"",IIf(y6m>Ref(y6m,-1),colorYellow,colorRed),styleLine|styleThick);


GfxTextOut( "6.nc Derece Katsayi-1 : "+ StrFormat("%-3.000d",Katsayi16), 50+Moveto, 300+Moveto1);
GfxTextOut( "6.nc Derece Katsayi-2 : "+ StrFormat("%-3.000d",Katsayi26), 50+Moveto, 320+Moveto1);
GfxTextOut( "6.nc Derece Katsayi-3 : "+ StrFormat("%-3.000d",Katsayi36), 50+Moveto, 340+Moveto1);
GfxTextOut( "6.nc Derece Katsayi-4 : "+ StrFormat("%-3.000d",Katsayi46), 50+Moveto, 360+Moveto1);
GfxTextOut( "6.nc Derece Katsayi-5 : "+ StrFormat("%-3.000d",Katsayi56), 50+Moveto, 380+Moveto1);
GfxTextOut( "6.nc Derece Katsayi-6 : "+ StrFormat("%-3.000d",Katsayi66), 50+Moveto, 400+Moveto1);

}


}

_SECTION_END();


_SECTION_BEGIN("Colored Bollinger Bands");

Bg = ParamToggle(" Bollinger gster ","hide|show",0);
pr=Param( "Period",20,0,100,1);
P = ParamField("Price field",-1);
Style = ParamStyle("Style") | styleNoRescale | styleNoLabel |styleDashed;


if(Bg)
{

BBT=BBandTop(P,pr,2);
BBB=BBandBot(P,pr,2);
topcond = (Cross(BBT,C)OR C>BBT)AND Ref(C, -1)> BBT;
botcond = ( Cross(C,BBB))AND Ref(C, -1 < BBB);
bbtcolor = IIf( BBT> Ref (BBT, -1), colorDarkGreen,colorYellow );
bbbcolor = IIf( BBB > Ref (BBB, -1), colorDarkGreen,colorYellow );
PlotOHLC(O, H, L, C, "Data", colorWhite, styleBar | styleThick);

Plot( BBT, "BBTop" + _PARAM_VALUES(), bbtcolor, styleLine|styleThick);
Plot( BBB, "BBBot" + _PARAM_VALUES(), bbbcolor, styleLine|styleThick );

Buy=botcond;
Sell=topcond ;

//PlotShapes(shapeUpArrow * Buy, colorGreen, 0, L, - 10);
//PlotShapes(shapeDownArrow * Sell, colorRed, 0, H, - 10);

}
_SECTION_END();


_SECTION_BEGIN("Hurst Cycle");

#include <PolyFit.afl>

p1 = Param("CMA Period 1", 13, 0, 999, 1);
p2 = Param("CMA Period 2", 25, 0, 999, 1);
p3 = Param("CMA Period 3", 50, 0, 999, 1);
p4 = Param("CMA Period 4", 100, 0, 999, 1);
p5 = Param("CMA Period 5", 200, 0, 999, 1);
p6 = Param("CMA Period 6", 600, 0, 999, 1);

BType = ParamList("Band Type", "Percent|Amount");

Pct1 = Param("Pct or Amt 1", 1.6, 0, 33, 0.05);
Pct2 = Param("Pct or Amt 2", 2.4, 0, 33, 0.05);
Pct3 = Param("Pct or Amt 3", 3.6, 0, 33, 0.05);
Pct4 = Param("Pct or Amt 4", 5.4, 0, 33, 0.05);
Pct5 = Param("Pct or Amt 5", 8.1, 0, 33, 0.05);
Pct6 = Param("Pct or Amt 6",12.0, 0, 33, 0.05);

ePFac = Param("Extrapolation Period Factor", 0.35, 0.10, 5.00, 0.05);
ePOrd = Param("Extrapolation PolyFit Order", 2, 1, 8, 1);
eAuto = Param("Extrapolation Auto Fixup Passes", 5, 0, 9, 1);
eLFac = Param("Extrapolation AF Lag Factor", 0.33, 0, 1, 0.01);
eFFac = Param("Extrapolation AF Factor", 0.25, 0, 1, 0.01);
eFLen = Param("Extrapolation Future Length", 0, 0, 10, 1);
HT = ParamToggle("Hurst Cycle Gstermek ","hide|show",0);
BI = BarIndex();
SVBI = SelectedValue(BI);
LVBI = LastValue(BI);
Data = (H + L) / 2;

Title = EncodeColor(colorWhite) + " Hurst / Millard DE " +
EncodeColor(colorDefault) + " - BI = " + NumToStr(BI, 1.0) + " - CMA Periods =
";



GraphXSpace = 5;




function CMA_DE(Period, Percent, Red, Green, Blue)
{
Pm = int(Period * 2 / 3);
if (Pm % 2 == 0)
Pm = Pm + 1;
Pn = Period - Pm;
if (Pn < 3)
Pn = 3;
if (Pm <= Pn)
Pm = Pn + 2;
if (Pn % 2 == 0)
Pn = Pn + 1;

if (SVBI - (Pm + Pn) * (1 + eLFac + 0.02) > 0)
{
Lag = (Pm - 1) / 2 + (Pn - 1) / 2;
ExtraF = Lag + eFLen;
CMA = Ref(MA(MA(Data, Pm), Pn), Lag);
EndBar = SVBI - Lag;
BegBar = EndBar - round(Period * ePFac) + 1;
if (EndBar - BegBar < 2)
BegBar = EndBar - 2;

CMA = IIf(BI <= SVBI - Lag, CMA, -1e10);

if (BType == "Amount")
{
UBIS = CMA + Percent;
LBIS = CMA - Percent;
}
else
if (BType == "Percent")
{
UBIS = CMA * (1 + Percent / 100);
LBIS = CMA * (1 - Percent / 100);
}

Plot(UBIS, "", ColorRGB(Red, Green, Blue), styleThick);
Plot(LBIS, "", ColorRGB(Red, Green, Blue), styleThick);

if (Red > 0) Red = 254;
if (Green > 0) Green = 254;
if (Blue > 0) Blue = 254;

CMAx = PolyFit(CMA, BegBar, EndBar, ePOrd, 0, ExtraF);
CMAx = IIf(BI >= SVBI - Lag - ExtraF, CMAx, -1e10);

if (BType == "Amount")
{
CMAx = CMAx + CMA[SVBI - Lag] - CMAx[SVBI - Lag - ExtraF];
UBOS = CMAx + Percent;
LBOS = CMAx - Percent;
}
else
{
CMAx = CMAx * CMA[SVBI - Lag] / CMAx[SVBI - Lag - ExtraF];
UBOS = CMAx * (1 + Percent / 100);
LBOS = CMAx * (1 - Percent / 100);
}

k = 0;

for (j = 1; j <= eAuto; j++)
{
k = j;
AdjBar = 0;

for (i = SVBI - ExtraF; i >= SVBI - ExtraF - Lag * eLFac; i--)
{
if (i + ExtraF <= LVBI)
{
if (UBOS < (H[i + ExtraF] + L[i + ExtraF]) / 2)
{
AdjBar = i + ExtraF;
Target = CMAx + (C[i + ExtraF] - CMAx) * eFFac;
}
if (LBOS > (H[i + ExtraF] + L[i + ExtraF]) / 2)
{
AdjBar = i + ExtraF;
Target = CMAx - (CMAx - C[i + ExtraF]) * eFFac;
}
if (AdjBar > 0)
i = 0;
}
}

if (AdjBar > 0)
{
ExtraB = AdjBar - EndBar;
ExtraF = ExtraF - ExtraB;
EndBar = EndBar + ExtraB;

StepSize = (Target - CMA[SVBI - Lag]) / (EndBar - (SVBI -
Lag));

CMA = IIf(BI <= SVBI - Lag, CMA, 0);

for (i = SVBI - Lag + 1; i <= EndBar; i++)
{
CMA = CMA[i - 1] + StepSize;
}

CMAx = PolyFit(CMA, BegBar, EndBar, ePOrd, 0, ExtraF);
CMAx = IIf(BI >= SVBI - Lag - ExtraF, CMAx, -1e10);

if (BType == "Amount")
{
CMAx = CMAx + CMA[SVBI - Lag] - CMAx[SVBI - Lag - ExtraF];
UBOS = CMAx + Percent;
LBOS = CMAx - Percent;
}
else
{
CMAx = CMAx * CMA[SVBI - Lag] / CMAx[SVBI - Lag - ExtraF];
UBOS = CMAx * (1 + Percent / 100);
LBOS = CMAx * (1 - Percent / 100);
}
}
else
j = 999;
}

k = k - 1;

Plot(UBOS, "", ColorRGB(Red, Green, Blue), styleThick, Null, Null,
ExtraF);
Plot(LBOS, "", ColorRGB(Red, Green, Blue), styleThick, Null, Null,
ExtraF);

Title = Title + EncodeColor(ColorRGB(Red, Green, Blue)) +
NumToStr(Period, 1.0) + " (" + NumToStr(Pm, 1.0) + "/" + NumToStr(Pn, 1.0) + ")
" + NumToStr(k, 1.0) + " ";

PlotShapes((BI == SVBI - Lag) * shapeSmallUpTriangle, ColorRGB(Red,
Green, Blue), 0, CMA * (1 - Percent / 100), -15);
PlotShapes((BI == SVBI - Lag) * shapeSmallDownTriangle, ColorRGB(Red,
Green, Blue), 0, CMA * (1 + Percent / 100), -15);

}
return;
}
if(HT)
{
PlotOHLC(O, H, L, C, "Data", colorWhite, styleBar | styleThick);
if (p1 > 0)
CMA_DE(p1, Pct1, 000, 160, 000);
if (p2 > 0)
CMA_DE(p2, Pct2, 160, 112, 000);
if (p3 > 0)
CMA_DE(p3, Pct3, 160, 000, 000);
if (p4 > 0)
CMA_DE(p4, Pct4, 160, 000, 160);
if (p5 > 0)
CMA_DE(p5, Pct5, 000, 000, 160);
if (p6 > 0)
CMA_DE(p6, Pct6, 0, 160, 160);
}
_SECTION_END();

_SECTION_BEGIN(" DESTEK DIREN");

DDG = ParamToggle("Destek Diren Gstermek ","hide|show",0);
chartflag = ParamToggle("Heikin Ashi","show|hide",1);

xx = Cum(1);
nbar = Param("nbar",5,2,50,1);
if(DDG)
{
PHigh = H > Ref(HHV(H,nbar),-1) AND Ref(HHV(H,nbar),nbar) <= H;
PHighPrice = ValueWhen(PHigh,H);
PLow = L < Ref(LLV(L,nbar),-1) AND Ref(LLV(L,nbar),nbar) >= L;
PLowPrice = ValueWhen(PLow,L);

startval_L = ValueWhen(PLow,L,1);
endval_L = ValueWhen(PLow,L,0);
startbar_L = ValueWhen(PLow,xx,1);
endbar_L = ValueWhen(PLow,xx,0);
aa_L = (endval_L-startval_L)/(endbar_L-startbar_L);
bb_L = startval_L;
trendline_L = aa_L * (xx - startbar_L) + bb_L;
dtrendline_L = trendline_L - Ref(trendline_L,-1);

startval_L_extend = ValueWhen(PLow,L,2);
endval_L_extend = ValueWhen(PLow,L,1);
startbar_L_extend = ValueWhen(PLow,xx,2);
endbar_L_extend = ValueWhen(PLow,xx,1);
aa_L_extend = (endval_L_extend-startval_L_extend)/(endbar_L_extend-startbar_L_extend);
bb_L_extend = startval_L;
trendline_L_extend = aa_L_extend * (xx - startbar_L) + endval_L_extend;

dtrendline_L_extend = trendline_L_extend - Ref(trendline_L_extend,-1);
dtrendline_L_extend = IIf(PLow,Ref(dtrendline_L,-1),dtrendline_L_extend);

startval_L_extend2 = ValueWhen(PLow,L,3);
endval_L_extend2 = ValueWhen(PLow,L,2);
startbar_L_extend2 = ValueWhen(PLow,xx,3);
endbar_L_extend2 = ValueWhen(PLow,xx,2);
aa_L_extend2 = (endval_L_extend2-startval_L_extend2)/(endbar_L_extend2-startbar_L_extend2);
bb_L_extend2 = endval_L_extend2;
trendline_L_extend2 = aa_L_extend2 * (xx - endbar_L_extend2) + endval_L_extend2;

dtrendline_L_extend2 = trendline_L_extend2 - Ref(trendline_L_extend2,-1);
dtrendline_L_extend2 = IIf(PLow,Ref(dtrendline_L_extend,-1),dtrendline_L_extend2);

startval_H = ValueWhen(PHigh,H,1);
endval_H = ValueWhen(PHigh,H,0);
startbar_H = ValueWhen(PHigh,xx,1);
endbar_H = ValueWhen(PHigh,xx,0);
aa_H = (endval_H-startval_H)/(endbar_H-startbar_H);
bb_H = startval_H;
trendline_H = aa_H * (xx - startbar_H) + bb_H;
dtrendline_H = trendline_H - Ref(trendline_H,-1);

startval_H_extend = ValueWhen(PHigh,H,2);
endval_H_extend = ValueWhen(PHigh,H,1);
startbar_H_extend = ValueWhen(PHigh,xx,2);
endbar_H_extend = ValueWhen(PHigh,xx,1);
aa_H_extend = (endval_H_extend-startval_H_extend)/(endbar_H_extend-startbar_H_extend);
bb_H_extend = startval_H;
trendline_H_extend = aa_H_extend * (xx - startbar_H) + endval_H_extend;
dtrendline_H_extend = trendline_H_extend - Ref(trendline_H_extend,-1);
dtrendline_H_extend = IIf(PHigh,Ref(dtrendline_H,-1),dtrendline_H_extend);

startval_H_extend2 = ValueWhen(PHigh,H,3);
endval_H_extend2 = ValueWhen(PHigh,H,2);
startbar_H_extend2 = ValueWhen(PHigh,xx,3);
endbar_H_extend2 = ValueWhen(PHigh,xx,2);
aa_H_extend2 = (endval_H_extend2-startval_H_extend2)/(endbar_H_extend2-startbar_H_extend2);
bb_H_extend2 = endval_H_extend2;
trendline_H_extend2 = aa_H_extend2 * (xx - endbar_H_extend2) + endval_H_extend2;

dtrendline_H_extend2 = trendline_H_extend2 - Ref(trendline_H_extend2,-1);
dtrendline_H_extend2 = IIf(PHigh,Ref(dtrendline_H_extend,-1),dtrendline_H_extend2);

tld = ParamToggle("All trendlines","show|hide",1);
if (tld)
{

trendline_L = IIf(dtrendline_L > 0,trendline_L,Null);
trendline_L_extend = IIf(dtrendline_L_extend > 0,trendline_L_extend,Null);
trendline_L_extend2 = IIf(dtrendline_L_extend2 > 0,trendline_L_extend2,Null);
trendline_H = IIf(dtrendline_H < 0,trendline_H,Null);
trendline_H_extend = IIf(dtrendline_H_extend < 0,trendline_H_extend,Null);
trendline_H_extend2 = IIf(dtrendline_H_extend2 < 0,trendline_H_extend2,Null);
}

trendline_L_extend2 = IIf(BarsSince(Plow) <= nbar,trendline_L_extend2,Null);
trendline_H_extend2 = IIf(BarsSince(PHigh) <= nbar,trendline_H_extend2,Null);

GraphXSpace = 5;
SetChartOptions(0, chartShowDates);

if (chartFlag)
{
PlotOHLC(O, H, L, C, "Data", colorWhite, styleBar | styleThick);
}
else
{
HaClose = (O+H+L+C)/4;
HaOpen = AMA( Ref( HaClose, -1 ), 0.5 );
HaHigh = Max( H, Max( HaClose, HaOpen ) );
HaLow = Min( L, Min( HaClose, HaOpen ) );
PlotOHLC( HaOpen, HaHigh, HaLow, HaClose, "Modified " + Name(), colorWhite, styleBar);
}

PlotShapes(shapeUpArrow*PLow,colorYellow,0,L,-20);
PlotShapes(shapeDownArrow*PHigh,colorWhite,0,H,-20);


Plot(trendline_L, "", colorLime,styleLine|styleThick);

Plot(IIf(BarsSince(Plow) <= nbar,trendline_L_extend,Null), "", colorLightGrey, styleLine | styleThick);
Plot(IIf(BarsSince(Plow) > nbar,trendline_L_extend,Null), "",colorBrightGreen, styleLine | styleThick);

Plot(IIf(BarsSince(Plow) <= nbar,trendline_L_extend2,Null), "",colorDarkGreen, styleLine| styleThick);

Plot(trendline_H, "", colorRed,styleLine|styleThick);

Plot(IIf(BarsSince(PHigh) <= nbar,trendline_H_extend,Null), "", colorLightGrey, styleLine | styleThick);
Plot(IIf(BarsSince(PHigh) > nbar,trendline_H_extend,Null), "",colorOrange, styleLine | styleThick);

Plot(IIf(BarsSince(PHigh) <= nbar,trendline_H_extend2,Null), "",colorOrange, styleLine | styleThick);


signalFlag = ParamToggle("Possible Signals","show|hide",1);

if (signalFlag)
{

Buy = (!IsEmpty(trendline_H_extend) AND Cross(C,trendline_H_extend) AND BarsSince(PHigh) > nbar) OR
(!IsEmpty(trendline_H_extend2) AND Cross(C,trendline_H_extend2) AND !PHigh) OR
(PHigh AND C > trendline_H_extend2 AND Ref(C,-1) < Ref(trendline_H_extend,-1) AND !IsEmpty(trendline_H_extend) AND !IsEmpty(trendline_H_extend2) );
BuyPrice = C;
Short = (!IsEmpty(trendline_L_extend) AND Cross(trendline_L_extend,C) AND BarsSince(PLow) > nbar) OR
(!IsEmpty(trendline_L_extend2) AND Cross(trendline_L_extend2,C) AND !PLow) OR
(PLow AND C < trendline_L_extend2 AND Ref(C,-1) > Ref(trendline_L_extend,-1) AND !IsEmpty(trendline_L_extend) AND !IsEmpty(trendline_L_extend2));
ShortPrice = C;
Sell = 0;
Cover = 0;


}

_SECTION_END();

_SECTION_BEGIN(" EXPLORE");

AL=(!IsEmpty(trendline_H_extend) AND Cross(C,trendline_H_extend) AND BarsSince(PHigh) > nbar) OR
(!IsEmpty(trendline_H_extend2) AND Cross(C,trendline_H_extend2) AND !PHigh) OR
(PHigh AND C > trendline_H_extend2 AND Ref(C,-1) < Ref(trendline_H_extend,-1) AND !IsEmpty(trendline_H_extend) AND !IsEmpty(trendline_H_extend2) );
BuyPrice = C;

SAT=(!IsEmpty(trendline_L_extend) AND Cross(trendline_L_extend,C) AND BarsSince(PLow) > nbar) OR
(!IsEmpty(trendline_L_extend2) AND Cross(trendline_L_extend2,C) AND !PLow) OR
(PLow AND C < trendline_L_extend2 AND Ref(C,-1) > Ref(trendline_L_extend,-1) AND !IsEmpty(trendline_L_extend) AND !IsEmpty(trendline_L_extend2));
ShortPrice = C;

AL_status=WriteIf(AL,"Alis Yap"," ");

SAT_status=WriteIf(SAT,"Satis Yap"," ");

AL_col=IIf(AL, colorDarkGreen , colorWhite);

SAT_col=IIf(SAT, colorRed,colorWhite);


Filter= AL OR SAT;

AddColumn(C, "KAPANIS", 1.2, IIf(C > Ref(C,-1),colorBlue, colorRed));
AddTextColumn(AL_status, "ALIS", 1.2, colorWhite, Al_col);
AddTextColumn(SAT_status, "SATIS", 1.2, colorWhite, SAT_col);
}

_SECTION_END();

_SECTION_BEGIN("Parabolic Sar");

acc=Param("Acceleration factor",0.02,0.01,0.05,0.01);
af_start=Param("Starting AF value",0.02,0.01,0.05,0.01);
af_max=Param("Maximum AF value",0.2,0.1,0.3,0.01);
Ct=Param("Crossover threshold in %",1,0,3,0.5);

PS = ParamToggle(" Parabolic Sar Gstermek ","hide|show",0);

Ct1=Ct/100;

IAF = acc;
MaxAF = af_max;
psar = Close;
long = 1;
af = af_start;
ep = Low[ 0 ];
hp = High [ 0 ];
lp = Low [ 0 ];

for( i = 2; i < BarCount; i++ )
{
if ( long )
{
psar [ i ] = psar [ i-1 ] + af * ( hp - psar [ i-1 ] );
}
else
{
psar [ i ] = psar [ i-1 ] + af * ( lp - psar [ i-1 ] );
}

reverse = 0;

if ( long )
{
if ( Low [ i ] < psar [ i ] * (1-Ct1) )
{
long = 0; reverse = 1;
psar [ i ] = hp;
lp = Low [ i ];
af = af_start;
}
}
else
{
if ( High [ i ] > psar [ i ] * (1+Ct1) )
{
long = 1; reverse = 1;
psar [ i ] = lp;
hp = High [ i ];
af = af_start;
}
}

if ( reverse == 0 )
{
if ( long )
{
if ( High [ i ] > hp )
{
hp = High [ i ];
af = af + IAF;
if( af > MaxAF ) af = MaxAF;
}

if( Low[ i - 1 ] < psar[ i ] ) psar[ i ] = Low[ i - 1 ];
if( Low[ i - 2 ] < psar[ i ] ) psar[ i ] = Low[ i - 2 ];
}
else
{
if ( Low [ i ] < lp )
{
lp = Low [ i ];
af = af + IAF;
if( af > MaxAF ) af = MaxAF;
}

if( High[ i - 1 ] > psar[ i ] ) psar[ i ] = High[ i - 1 ];
if( High[ i - 2 ] > psar[ i ] ) psar[ i ] = High[ i - 2 ];

}
}
}

if(PS)
{
Plot( psar, _DEFAULT_NAME(), ParamColor( "Color", colorYellow), styleDots | styleNoLine | styleThick );
PlotOHLC(O, H, L, C, "Data", colorWhite, styleBar | styleThick);
}
_SECTION_END();
 
Hi Shivangi,
I'm wondering to see your helping attitude for the members of this forum. I think your contribution will give the maximum benefit to all members. I found a good chart, which I am uploading here, I am very eagerly searching the AFL of .."Tested Auto.....",

I will be grateful if you kindly upload the code for this one. Regards.
 
Last edited:

Shailu

Active Member



SRI (Super Renko Indicator)





Code:
 SetBarsRequired(100000,100000);
//------------------------------------------------------------------+
// Block 1                                                          |
//------------------------------------------------------------------+
  VR=ParamToggle("View Renko","Bricks|Lines/Bars",0);                
  FV=Param("Initial size volatility",0.5,0.001,50,0.001);            
  MV=Param("Method calculation volatility",0,0,2,1);                 
  PeriodVol=Param("Period calculation volatility",14,2,100,1);       
  Multiplier=Param("Multiplier volatility",1,0.1,10,0.1);           
  MR=ParamToggle("Method Renko","floating|fixed",1);         
  SG=ParamToggle("Show gap","No|Yes",1);                     
  CG=ParamColor("Colour show gap",11);                     
  MaxBS=Param("Maximum size brick",0,0,10,0.1);             
  MinBS=Param("Minimum size brick",0,0,10,0.1);              
  RenkoUp=ParamColor("Colour Renko upwards",colorBlack);      
  RenkoDown=ParamColor("Colour Renko downwards",colorBlack);
  SB=ParamStyle("View bars",defaultval=styleCandle,mask=maskPrice);    
  color3=ParamColor("Colour bars",colorBlack);
  History=Param("History size",5000,2,BarCount-1,1);              
//------------------------------------------------------------------+
// Block 2                                                          |
//------------------------------------------------------------------+
  i=Max(BarCount-1-History,PeriodVol+1);                             
  r=j=0;                                                             
  direction=0;                                                       
  iGapUp=iGapDown=0; 
  rOpen[0]=rHigh[0]=rLow[0]=rClose[0]=jUp=jDown=Open[i];             
//------------------------------------------------------------------- 
  switch(MV)
    {
     case 0: Volatility=FV; break;                                   
     case 1: Volatility=ATR(PeriodVol)*Multiplier; break;             
     case 2: Volatility=StDev(Open,PeriodVol)*Multiplier; break;     
    }         
  BrickSize=Volatility[i-1];                                         
//-------------------------------------------------------------------+
// Block 3                                                           |
//-------------------------------------------------------------------+
  while(i<=BarCount-1)
    { 
     if(SG==1)
       {
        if(High[i-1]<Low[i])
          {
           iGapUp[i]=1;                                       
          }
          else
          {
           if(Low[i-1]>High[i])
             {
              iGapDown[i]=1;
             }
          }
       } 
//------------------------------------------------------------------- 
     if(MR==0)  
       {
        BrickSize=Volatility[i-1];
        if(MaxBS>0) {BrickSize=Min(MaxBS,BrickSize);}                 
        if(MinBS>0) {BrickSize=Max(MinBS,BrickSize);}                
       } 
//------------------------------------------------------------------+
// Block 4                                                          |
//------------------------------------------------------------------+
     if(direction==0)                                                 
       {                                                   
        if(Open[i]-rClose[r]>BrickSize)                              
          {                                                 
           rClose[r]=rOpen[r]+BrickSize;
           rHigh[r]=rClose[r];
           direction=1;
//------------------------------------------------------------------- 
           BrickSize=Volatility[i];
           if(MaxBS>0) {BrickSize=Min(MaxBS,BrickSize);}                
           if(MinBS>0) {BrickSize=Max(MinBS,BrickSize);}
//------------------------------------------------------------------- 
           if(iGapUp[i]==1|iGapDown[i]==1)                           
             {
              color[r]=CG;                                           
             }
             else
             {
              color[r]=RenkoUp;                                      
             }
           continue;                                                                                       
          }                                                           
//------------------------------------------------------------------- 
          else
          {
           if(rClose[r]-Open[i]>BrickSize)                             
             {
              rClose[r]=rOpen[r]-BrickSize;
              rLow[r]=rClose[r];
              direction=2;
//------------------------------------------------------------------- 
              BrickSize=Volatility[i];
              if(MaxBS>0) {BrickSize=Min(MaxBS,BrickSize);}                
              if(MinBS>0) {BrickSize=Max(MinBS,BrickSize);}
//------------------------------------------------------------------- 
              if(iGapUp[i]==1|iGapDown[i]==1)
                {
                 color[r]=CG;                                        
                }
                else
                {
                 color[r]=RenkoDown;                                         
                }
              continue;                                         
             }
          }
       }
//------------------------------------------------------------------+
// Block 5                                                          |
//------------------------------------------------------------------+
       else                                                         
       { 
        if(direction==1)                                             
          {
           if(rOpen[r]-Open[i]>BrickSize)                                                                     
             {
              r++;
              rOpen[r]=rOpen[r-1];
              rHigh[r]=rOpen[r];
              rClose[r]=rOpen[r]-BrickSize;
              rLow[r]=rClose[r];
              direction=2;
//------------------------------------------------------------------- 
              BrickSize=Volatility[i];
              if(MaxBS>0) {BrickSize=Min(MaxBS,BrickSize);}                
              if(MinBS>0) {BrickSize=Max(MinBS,BrickSize);}
//------------------------------------------------------------------- 
              if(iGapUp[i]==1|iGapDown[i]==1)
                {
                 color[r]=CG;                                        
                }
                else
                {
                 color[r]=RenkoDown;                                         
                }
              continue;                                                   
             }
//------------------------------------------------------------------- 
             else
             {
              while(Open[i]-rClose[r]>BrickSize)        
                {
                 r++;
                 rOpen[r]=rClose[r-1];
                 rLow[r]=rOpen[r];
                 rClose[r]=rOpen[r]+BrickSize;
                 rHigh[r]=rClose[r];
//------------------------------------------------------------------- 
                 BrickSize=Volatility[i];
                 if(MaxBS>0) {BrickSize=Min(MaxBS,BrickSize);}                
                 if(MinBS>0) {BrickSize=Max(MinBS,BrickSize);}
//------------------------------------------------------------------- 
                 if(iGapUp[i]==1|iGapDown[i]==1)
                   {
                    color[r]=CG;                                        
                   }
                   else
                   {
                    color[r]=RenkoUp;                                         
                   }
                }
             }
          }
//------------------------------------------------------------------+
// Block 6                                                          |
//------------------------------------------------------------------+
          else
          {
           if(direction==2)                                          
             {
              if(Open[i]-rOpen[r]>BrickSize)
                {
                 r++;
                 rOpen[r]=rOpen[r-1];
                 rLow[r]=rOpen[r];
                 rClose[r]=rOpen[r]+BrickSize;
                 rHigh[r]=rClose[r];
                 direction=1;
//------------------------------------------------------------------- 
                 BrickSize=Volatility[i];
                 if(MaxBS>0) {BrickSize=Min(MaxBS,BrickSize);}                
                 if(MinBS>0) {BrickSize=Max(MinBS,BrickSize);}
//------------------------------------------------------------------- 
                 if(iGapUp[i]==1|iGapDown[i]==1)
                   {
                    color[r]=CG;                                        
                   }
                   else
                   {
                    color[r]=RenkoUp;                                         
                   }
                 continue;  
                }
//------------------------------------------------------------------- 
                else
                {
                 while(rClose[r]-Open[i]>BrickSize)                                                        
                   {
                    r++;
                    rOpen[r]=rClose[r-1];
                    rHigh[r]=rOpen[r];
                    rClose[r]=rOpen[r]-BrickSize;
                    rLow[r]=rClose[r];
//------------------------------------------------------------------- 
                    BrickSize=Volatility[i];
                    if(MaxBS>0) {BrickSize=Min(MaxBS,BrickSize);}                
                    if(MinBS>0) {BrickSize=Max(MinBS,BrickSize);}
//-------------------------------------------------------------------
                    if(iGapUp[i]==1|iGapDown[i]==1)
                      {
                       color[r]=CG;                                        
                      }
                      else
                      {
                       color[r]=RenkoDown;                                         
                      }
                    }
                }
             }
          }
       }                                                             
//------------------------------------------------------------------+
// Block 7                                                          |
//------------------------------------------------------------------+
     if(VR==1)                                                       
       {
        jOpen[j]=Open[i];
        jHigh[j]=High[i];
        jLow[j]=Low[i];
        jClose[j]=Close[i];
//-------------------------------------------------------------------
        if(direction==1)
          {
           jUp[j]=rClose[r];
           jDown[j]=rOpen[r];
           color2[j]=color[r];
          }
          else
          {
           if(direction==2)
             {
              jUp[j]=rOpen[r];
              jDown[j]=rClose[r];
              color2[j]=color[r];
             }
          }
        j++;
       }                                                                    
     i++;                                                                                         
    }                                                                
//------------------------------------------------------------------+
// Block 8                                                          |
//------------------------------------------------------------------+
  if(VR==1)                                                          
    {
     delta=BarCount-j;
     jOpen=Ref(jOpen,-delta);                                        
     jHigh=Ref(jHigh,-delta);                                        
     jLow=Ref(jLow,-delta);
     jClose=Ref(jClose,-delta);
     jUp=Ref(jUp,-delta);
     jDown=Ref(jDown,-delta);
     color2=Ref(color2,-delta);
     SetChartOptions(0,chartShowArrows|chartShowDates);
     _N(Title = StrFormat("{{NAME}} - {{INTERVAL}} {{DATE}} Open %g, Hi %g, Lo %g, Close %g (%.1f%%) {{VALUES}}", O, H, L, C, SelectedValue( ROC( C, 1 ) ) ));
     PlotOHLC(jOpen,jHigh,jLow,jClose,"SRI",color3,SB);                       
     Plot(jUp,"Up",color2,styleThick);                                                 
     Plot(jDown,"Down",color2,styleThick); 
    }
//-------------------------------------------------------------------
    else                                                            
    {  
     delta=BarCount-1-r;                                              
     rOpen=Ref(rOpen,-delta);                                        
     rHigh=Ref(rHigh,-delta);                                        
     rLow=Ref(rLow,-delta);
     rClose=Ref(rClose,-delta);
     color=Ref(color,-delta);
     PlotOHLC(rOpen,rHigh,rLow,rClose,"SRI",color,styleCandle);      
    }
If Nothing is showing on chart then increase backfill data and change parameters.
afl is not working... i m using free data .
 

Shailu

Active Member
Renko chart





Code:
// Renko  Chart
// Graham Kavanagh  13 Aug 2004 ver C
// Custom Indicator, date axis does not apply
 
 
 SetBarsRequired(10000,10000);
 
// Brick size is dependant on what you want, if too small will not produce a chart due to insufficient x-axis bars
//Brick = LastValue( ATR(100) );
//Brick = LastValue( Max(0.02*C, 0.05) );
Brick = Param( "Brick Size", 0.1, 0.01, 1.00, 0.01 );
reverse = 2;
 
// Convert the closing price to rising and falling rounded bricks
CF = ceil(C/Brick);
CR = floor(C/Brick);
 
// initialize first element
j = 0;
RKC[j] = CF[0];
RKO[j] = CF[0] + 1;
 
down[j] = 1;  // By default the first bar is a down bar.
up[j] = 0;
 
// Loop to produce the Renko values in number of bricks
 
for( i=1; i<BarCount-1; i++ )
{
if( CF[i] <= RKC[j] - 1 && down[j] ) // Continue down
    {
        num = RKC[j] - CF[i];
        for( x=1; x<=num; x++ )
        {
            j++;
            up[j] = 0;
            down[j] = 1;
            RKC[j] = RKC[j-1] - 1;
            RKO[j] = RKC[j] + 1;
        }
    }
    else
    {
        if( CR[i] >= RKC[j] + Reverse && down[j] )  // Change down to up
        {
            num = CR[i] - RKC[j];
            j++;
            up[j] = 1;
            down[j] = 0;
            RKC[j] = RKC[j-1] + 2;
            RKO[j] = RKC[j] - 1;            
            for( x=2; x<=num; x++ )
            {
                j++;
                up[j] = 1;
                down[j] = 0;
                RKC[j] = RKC[j-1] + 1;
                RKO[j] = RKC[j] - 1;
            }
        }
        else
        {
            if( CR[i] >= RKC[j] + 1 && up[j] ) // Continue Up
            {
                num = CR[i] - RKC[j];
                for( x=1; x<=num; x++ )
                {
                    j++;
                    Up[j] = 1;
                    Down[j] = 0;
                    RKC[j] = RKC[j-1] + 1;
                    RKO[j] = RKC[j] - 1;
                }
            }
            else
            {
                if( CF[i] <= RKC[j] - Reverse && up[j] )  // Change up to down
                {
                    num = RKC[j] - CF[i];
                    j++;
                    Up[j] = 0;
                    Down[j] = 1;
                    RKC[j] = RKC[j-1] - 2;
                    RKO[j] = RKC[j] + 1;
                    for( x=2; x<=num; x++ )
                    {
                        j++;
                        up[j] = 0;
                        down[j] = 1;
                        RKC[j] = RKC[j-1] - 1;
                        RKO[j] = RKC[j] + 1;
                    }
                }
            }
        }
    }
}
 
 
// move the chart to right end of chart space, ie last brick on last bar position
delta =  BarCount-1 - j;
 
RKC = Ref( RKC, -delta );
RKO = Ref( RKO, -delta );
 
Up = Ref( Up, -delta );
Down = Ref( Down, -delta );
 
/*
rC = RKC * Brick;// + (Up-down)*Brick/2;
rO = RC - (Up-down)*Brick;
rH = Max(rC,rO);
rL = Min(rC,rO);
*/
 
 
C = RKC * Brick;// + (Up-down)*Brick/2;
O = C - (Up-down)*Brick;
H = Max(C,O);
L = Min(C,O);
 
Plot( C, "", colorGrey50,styleCandle); 
// plot chart
//plotOHLC( rO, rH, rL, rC, "Renko Price " , colorBlack, styleCandle);
GraphXSpace=5;
 
Title = Name() + " - {{INTERVAL}} {{DATE}} - Renko Chart : Last Value = " + RKC * Brick + ", Brick Size = " + Brick;

Change Brick size if it gives any error
this is also not working.:annoyed::annoyed:
 
Status
Not open for further replies.

Similar threads