Renko signalen 1 minuut

[Confusion]

Beste allemaal,

Via viewtopic.php?f=2&t=457&hilit=renko ben ik hier op dit forum uitgekomen en ik vroeg me af of hetgeen in de bijlage mogelijk is.

Ik zou bijv. graag op de AEX index of liever nog AEX future met pre-market en after hours data een Renko chart bouwen waarvan ik alleen de brick size kan aanpassen. Ik zou deze op een 1 minuut chart willen draaien.

Graag zou ik bovenstaande willen backtesten voor bijv. heel 2019.

Is dit mogelijk uberhaupt? Zo ja, kan iemand dat coden? Als dat hier niet zo werkt, mijn excuses maar ik ben net nieuw.

Ik ben niet heel erg wegwijs in WS nog, dus als er uitleg bij kan dan heel graag.

Mvg,
Conf

[Eric]

Zoals jij het voor ogen hebt zitten hier nogal wat haken en ogen aan met betrekking tot het backtesten.

Allereerst zijn de Renko Bars bedoeld als visueel hulpmiddel; ze volgen derhalve niet de normale tijdas. Dit betekent dat backtesten van indicatoren die je erop loslaat geen correcte resultaten gaat opleveren.

Het zal niet onmogelijk zijn om e.e.a. om te bouwen zodat het backtesten wel kan, maar dat is nogal een klus. Daarbij is de vraag waarom je kiest voor Renko Bars als basis voor een dergelijk systeem? Het is (vanwege de niet-native implementatie) technisch een lastige omweg, terwijl het systeem in basis sterk lijkt op een Moving Stoploss indicator. Waarom kies je speciaal voor Renko bars?

---
Eric

[Confusion]

Hoi Eric,

Dank je wel voor je antwoord.

Het is mij bekend dat Renko niet de normale tijdas gebruikt. Daarom wil ik brick size icm met 1 minuut gebruiken omdat dat het dichtst bij de waarheid komt.

Naast WS gebruik ik ook Tradingview en helaas kan ik daar maar 2 weken terug testen als combi brick size (M1). Voor die periode krijg je de combi brick size + H1, maar dat geeft dus echt een vertekend beeld. Dan denk je hele mooie cleane grafieken te hebben maar dat vertekend dus heel erg omdat er soms in dat uur wel 3 of 4 blokken tegelijk bijkomen. Als je dan dus op de 2 blok zou willen instappen, wordt dat een moeilijk verhaal. Tevens mist een heel stuk ruis die je in M1 wel hebt, maar H1 niet. Zie bijlage. Zwarte pijl is waar je zou zijn ingestapt als je de brick size + H1 volgt. Daarom zou ik de Renko + M1 combi als uitgangspunt. Graag dan op eerste blok in tegengestelde richting exit en tweede blok entry.

Het enige wat ik zou moeten kunnen veranderen is de brick size.

[Confusion]

Ter verduidelijking hier nog eens wat ik bedoel. Ik heb dit zelf in elkaar geflanst op Tradingview en dit werkt voor mij. Echter heb ik gewoon niet genoeg data op M1 om te bepalen wat de optimale brick size is omdat hij dat alleen voor de laatste 14 dagen laat zien en daarvoor overschakeld op H1.

Met de TaiPan data denk ik dat dat te doen moet zijn?

[Eric]

Ik heb nog eens gekeken, maar ik snap de omweg via Renko Bars nog steeds niet. Waarom zijn Renko Bars voor dit systeem belangrijk? Waarom definieer je niet gewoon:
- Als Koers < BrickSize onder laatste top dan Close Long
- Als Koers < 2*BrickSize onder laatste top dan Open Short
- Als Koers > BrickSize boven laatste bodem dan Close Short
- Als Koers > 2*BrickSize boven laatste bodem dan Open Long

Dit is 10x eenvoudiger te implementeren en duidelijker te analyseren. Ik zie namelijk ook verschillen in de Renko implementatie van Tradingview en Wall Street, dus daar zit al een eerste onduidelijkheid.

Het geeft wellicht minimale verschillen in de aan/verkoopmomenten (vanwege de afronding naar Renko bars) maar een trading simulatie op een dergelijke korte termijn heeft sowieso beperkingen omdat Wall Street voor de grafieken uitgaat van 1min bars en niet van tick data.

---
Eric

[Confusion]

Beste Eric,

Als dat via die manier hetzelfde werkt als de Renko, vind ik het natuurlijk helemaal prima. Het gaat mij voornamelijk om het backtesten met 1 minuut data over een langere periode. Ik vraag me dan alleen wel af hoe dat dan zit met de "Renko Opstelling" als in: stel de brick size is 2 punten, dan zal de Renko chart bijv. vandaag 612,00 kiezen als top, terwijl de echte top misschien wel op 613,90 lag. Als je dan de definities neemt die jij aangeeft, neemt ie dan 612 als "top" of 613,90? Dit is enorm belangrijk met betrekking tot de draaipunten die als trailing stop fungeren.

Daarnaast heb ik een vraag over jouw "definities":
- Bij de draaipunten is een nieuwe brick in tegenovergestelde richting al 2 blokken en de nieuwe open 3, aangezien je de laatste blok in de vorige kleur ook in zijn geheel moet nemen. Correct?

[Eric]

Ik begrijp dat het allemaal heel nauw luistert, maar goed, de consequentie is dan wel dat het lastig wordt om te controleren of de signalen kloppen omdat je met twee verschillende grafieken werkt: de Renko chart en de koersgrafiek waar de signalen in moeten worden gegeven. Bij deze een poging, de signalen komen in de koersgrafiek en de Renko bars worden gekleurd bij een signaal. Aan jou om te controleren of het allemaal klopt, want dat is nogal lastig zoals ik probeerde aan te geven.

Code: Selecteer alles

{- Filename: Renko Bars Signals -}

type
  TTrend = (ttUnknown, ttUp, ttDown);

var
  sSignals: TSeries;
  
procedure AddBars(Trend: TTrend; Range: real; BarY1, BarY2: integer; var sOpen, sHigh, sLow, sClose: TSeries);
var
  OldCount, NewCount: integer;
  j, n: integer;
begin
  OldCount := GetArrayLength(sOpen);
  n := OldCount;
  if Trend = ttUp then
  begin
    NewCount := OldCount + BarY2 - BarY1 + 1;
    SetArrayLength(sOpen, NewCount);
    SetArrayLength(sHigh, NewCount);
    SetArrayLength(sLow, NewCount);
    SetArrayLength(sClose, NewCount);
    for j:=BarY1 to BarY2 do
    begin
      sOpen[n] := (j+1)*Range;
      sLow[n] := j*Range;
      sHigh[n] := (j+1)*Range;
      sClose[n] := j*Range;
      n := n+1;
    end;
  end else
  begin
    NewCount := OldCount + BarY1 - BarY2 + 1;
    SetArrayLength(sOpen, NewCount);
    SetArrayLength(sHigh, NewCount);
    SetArrayLength(sLow, NewCount);
    SetArrayLength(sClose, NewCount);
    for j:=BarY1 downto BarY2 do
    begin
      sOpen[n] := j*Range;
      sHigh[n] := (j+1)*Range;
      sLow[n] := j*Range;
      sClose[n] := (j+1)*Range;
      n := n+1;
    end;
  end
end;

procedure PricesToRenkoBars(Ticks: TSeries; Range: real; var sOpen, sHigh, sLow, sClose: TSeries);
var 
  BarY, BarY1, BarY2, i: integer;
  Trend: TTrend;
begin
  sSignals := CreateSeries(10*GetArrayLength(Ticks));
  BarY1 := -1;
  Trend := ttUnknown;
  for i:=0 to GetArrayLength(Ticks)-1 do
  begin 
    BarY := trunc(Ticks[i] / Range);

    if Trend = ttUp then
    begin
      if BarY > BarY2+1 then
      begin
        BarY2 := BarY-1;
        if BarY2-BarY1 >= 2 then
        begin
          if EnterLong(i div 2) then
            sSignals[GetArrayLength(sOpen)+1] := 1;
        end;
      end else
      if BarY < BarY2-1 then
      begin
        AddBars(Trend, Range, BarY1, BarY2, sOpen, sHigh, sLow, sClose);
        if ExitLong(i div 2) then
          sSignals[GetArrayLength(sOpen)] := 0;
        Trend := ttDown;
        BarY1 := BarY2-1;
        BarY2 := BarY+1;
        if BarY1-BarY2 >= 2 then
        begin
          if EnterShort(i div 2) then
            sSignals[GetArrayLength(sOpen)+1] := -1;
        end;
      end;
    end else
    if Trend = ttDown then
    begin
      if BarY < BarY2-1 then
      begin
        BarY2 := BarY+1;
        if BarY1-BarY2 >= 2 then
        begin
          if EnterShort(i div 2) then
            sSignals[GetArrayLength(sOpen)+1] := -1;
        end;
      end else
      if BarY > BarY2+1 then
      begin
        AddBars(Trend, Range, BarY1, BarY2, sOpen, sHigh, sLow, sClose);
        if ExitShort(i div 2) then
          sSignals[GetArrayLength(sOpen)] := 0;
        Trend := ttUp;
        BarY1 := BarY2+1;
        BarY2 := BarY-1;
        if BarY2-BarY1 >= 2 then
        begin
          if EnterLong(i div 2) then
            sSignals[GetArrayLength(sOpen)+1] := 1;
        end;
      end;
    end else
    begin
      if BarY1 < 0 then BarY1 := BarY;
      BarY2 := BarY;
      if BarY2 > BarY1 then Trend := ttUp else if BarY2 < BarY1 then Trend := ttDown;
    end;
  end;
  if BarY1 > 0 then AddBars(Trend, Range, BarY1, BarY2, sOpen, sHigh, sLow, sClose);
end;

var 
  nRange: real; 
  sROpen, sRHigh, sRLow, sRClose, sTicks: TSeries; 
  i, n: integer; 
begin 
{ Indicator parameters } 
  nRange := CreateParameterReal('Bar range', 0.01, 999, 3, true);

{ Indicator eigenschappen } 
  with Indicator do 
  begin 
{ Aantal benodigde koersen om eerste indicatorwaarde te berekenen } 
    RequiredBars := 0; 
    SignalView := svShowInMain;
  end; 

{ combineer open & close tot een serie ticks } 
  sTicks := CreateSeries(2*BarCount); 
  for i:=0 to BarCount-1 do 
  begin 
    sTicks[2*i] := Open[i]; 
    sTicks[2*i+1] := Close[i]; 
  end; 
  
{ Bereken de Renko bars }
  PricesToRenkoBars(sTicks, nRange, sROpen, sRHigh, sRLow, sRClose);

{ maak de range bars Series dezelfde lengte als de koersen, en zorg dat de 
  laatste bars samenvallen met de laatste koersen } 
  n := GetArrayLength(sROpen); 
  if n < BarCount then 
  begin 
    SetArrayLength(sROpen, BarCount); 
    SetArrayLength(sRHigh, BarCount); 
    SetArrayLength(sRLow, BarCount); 
    SetArrayLength(sRClose, BarCount); 
    SetArrayLength(sSignals, BarCount);
    sROpen := ShiftSeries(sROpen, BarCount-n); 
    sRHigh := ShiftSeries(sRHigh, BarCount-n); 
    sRLow := ShiftSeries(sRLow, BarCount-n); 
    sRClose := ShiftSeries(sRClose, BarCount-n); 
    sSignals := ShiftSeries(sSignals, BarCount-n);
    for i:=0 to BarCount-n-1 do
    begin 
      sROpen[i] := NaN; 
      sRHigh[i] := NaN; 
      sRLow[i] := NaN; 
      sRClose[i] := NaN; 
      sSignals[i] := NaN;
    end; 
  end else 
  if n > BarCount then 
  begin 
    sROpen := ShiftSeries(sROpen, BarCount-n); 
    sRHigh := ShiftSeries(sRHigh, BarCount-n); 
    sRLow := ShiftSeries(sRLow, BarCount-n); 
    sRClose := ShiftSeries(sRClose, BarCount-n); 
    sSignals := ShiftSeries(sSignals, BarCount-n);
    SetArrayLength(sROpen, BarCount);
    SetArrayLength(sRHigh, BarCount); 
    SetArrayLength(sRLow, BarCount); 
    SetArrayLength(sRClose, BarCount); 
    SetArrayLength(sSignals, BarCount);
  end;
  for i:=0 to BarCount-1 do if not IsNaN(sSignals[i]) then
  begin
    if sSignals[i] > 0 then SetBarColor(0, i, clLime) else
      if sSignals[i] < 0 then SetBarColor(0, i, clRed) else
        SetBarColor(0, i, clSilver);
  end;

  with CreateLineOHLC(sROpen, sRHigh, sRLow, sRClose) do 
  begin 
    Name := 'Renko Bars';
    Color := RGB(0,0,255);
    LineType := ltHighLowClose;
  end; 
end.

---
Eric

[petdev]

Eric,
Ik heb hier wat mee zitten stoeien en vind de Renko-indicator voor intraday (5min. met 0.5 pnt. op AEX) visueel zeer aangenaam. Ik probeerde echter een optimalisatie/backtest en dat gaat volkomen de mist in, omdat je dan ook overnight posities meeneemt, die tot veel grotere verlies-trades leiden (als gevolg van gaps), dan intraday mogelijk is. Dat je dan ook winsttrades overnight hebt is evident.
Zou je het volgende willen inbouwen?
Extra Input-variabele: een tijdstip waarop automatisch de laatste positie van de dag long/short wordt gesloten.
Dit zou voor de AEX dan bijv. 17:30 en voor FTI 22:00 kunnen zijn, maar ook (naar keuze) een ander tijdstip.
Alvast bedankt.

Groet, Peter.

[Eric]

Ik denk dat dit hem is:

Code: Selecteer alles

{- Filename: Renko Bars Signals -}

type
  TTrend = (ttUnknown, ttUp, ttDown);

var
  sSignals: TSeries;
  
type
  TTick = record
    DateTime: TDateTime;
    Value: real;
  end;
  TTicks = array of TTick;

procedure AddBars(Trend: TTrend; Range: real; BarY1, BarY2: integer; var sOpen, sHigh, sLow, sClose: TSeries);
var
  OldCount, NewCount: integer;
  j, n: integer;
begin
  OldCount := GetArrayLength(sOpen);
  n := OldCount;
  if Trend = ttUp then
  begin
    NewCount := OldCount + BarY2 - BarY1 + 1;
    SetArrayLength(sOpen, NewCount);
    SetArrayLength(sHigh, NewCount);
    SetArrayLength(sLow, NewCount);
    SetArrayLength(sClose, NewCount);
    for j:=BarY1 to BarY2 do
    begin
      sOpen[n] := (j+1)*Range;
      sLow[n] := j*Range;
      sHigh[n] := (j+1)*Range;
      sClose[n] := j*Range;
      n := n+1;
    end;
  end else
  begin
    NewCount := OldCount + BarY1 - BarY2 + 1;
    SetArrayLength(sOpen, NewCount);
    SetArrayLength(sHigh, NewCount);
    SetArrayLength(sLow, NewCount);
    SetArrayLength(sClose, NewCount);
    for j:=BarY1 downto BarY2 do
    begin
      sOpen[n] := j*Range;
      sHigh[n] := (j+1)*Range;
      sLow[n] := j*Range;
      sClose[n] := (j+1)*Range;
      n := n+1;
    end;
  end
end;

procedure PricesToRenkoBars(Ticks: TTicks; Range: real; var sOpen, sHigh, sLow, sClose: TSeries; StopTime: TDateTime);
var
  BarY, BarY1, BarY2, i: integer;
  Trend: TTrend;
  tm: TDateTime;
begin
  sSignals := CreateSeries(10*GetArrayLength(Ticks));
  BarY1 := -1;
  Trend := ttUnknown;
  for i:=0 to GetArrayLength(Ticks)-1 do
  begin
    BarY := trunc(Ticks[i].Value / Range);
    tm := frac(Ticks[i].DateTime);

    if tm >= StopTime then
    begin
      if ExitAny(i div 2) then
        sSignals[GetArrayLength(sOpen)] := 0;
    end else
    if Trend = ttUp then
    begin
      if BarY > BarY2+1 then
      begin
        BarY2 := BarY-1;
        if BarY2-BarY1 >= 2 then
        begin
          if EnterLong(i div 2) then
            sSignals[GetArrayLength(sOpen)+1] := 1;
        end;
      end else
      if BarY < BarY2-1 then
      begin
        AddBars(Trend, Range, BarY1, BarY2, sOpen, sHigh, sLow, sClose);
        if ExitLong(i div 2) then
          sSignals[GetArrayLength(sOpen)] := 0;
        Trend := ttDown;
        BarY1 := BarY2-1;
        BarY2 := BarY+1;
        if BarY1-BarY2 >= 2 then
        begin
          if EnterShort(i div 2) then
            sSignals[GetArrayLength(sOpen)+1] := -1;
        end;
      end;
    end else
    if Trend = ttDown then
    begin
      if BarY < BarY2-1 then
      begin
        BarY2 := BarY+1;
        if BarY1-BarY2 >= 2 then
        begin
          if EnterShort(i div 2) then
            sSignals[GetArrayLength(sOpen)+1] := -1;
        end;
      end else
      if BarY > BarY2+1 then
      begin
        AddBars(Trend, Range, BarY1, BarY2, sOpen, sHigh, sLow, sClose);
        if ExitShort(i div 2) then
          sSignals[GetArrayLength(sOpen)] := 0;
        Trend := ttUp;
        BarY1 := BarY2+1;
        BarY2 := BarY-1;
        if BarY2-BarY1 >= 2 then
        begin
          if EnterLong(i div 2) then
            sSignals[GetArrayLength(sOpen)+1] := 1;
        end;
      end;
    end else
    begin
      if BarY1 < 0 then BarY1 := BarY;
      BarY2 := BarY;
      if BarY2 > BarY1 then Trend := ttUp else if BarY2 < BarY1 then Trend := ttDown;
    end;
  end;
  if BarY1 > 0 then AddBars(Trend, Range, BarY1, BarY2, sOpen, sHigh, sLow, sClose);
end;

var
  nRange: real;
  sROpen, sRHigh, sRLow, sRClose: TSeries;
  sTicks: TTicks;
  i, n: integer;
  tStopTime: TDateTime;
begin
{ Indicator parameters }
  nRange := CreateParameterReal('Bar range', 0.01, 999, 3, true);
  tStopTime := CreateParameterTime('Stop trading at', 17/24);

{ Indicator eigenschappen }
  with Indicator do
  begin
{ Aantal benodigde koersen om eerste indicatorwaarde te berekenen }
    RequiredBars := 0;
    SignalView := svShowInMain;
  end;

{ combineer open & close tot een serie ticks }
  SetArrayLength(sTicks, 2*BarCount);
  for i:=0 to BarCount-1 do
  begin
    sTicks[2*i].DateTime := DateTime[i];
    sTicks[2*i].Value := Open[i];
    sTicks[2*i+1].DateTime := DateTime[i];
    sTicks[2*i+1].Value := Close[i];
  end;

{ Bereken de Renko bars }
  PricesToRenkoBars(sTicks, nRange, sROpen, sRHigh, sRLow, sRClose, tStopTime);

{ maak de range bars Series dezelfde lengte als de koersen, en zorg dat de
  laatste bars samenvallen met de laatste koersen }
  n := GetArrayLength(sROpen);
  if n < BarCount then
  begin
    SetArrayLength(sROpen, BarCount);
    SetArrayLength(sRHigh, BarCount);
    SetArrayLength(sRLow, BarCount);
    SetArrayLength(sRClose, BarCount);
    SetArrayLength(sSignals, BarCount);
    sROpen := ShiftSeries(sROpen, BarCount-n);
    sRHigh := ShiftSeries(sRHigh, BarCount-n);
    sRLow := ShiftSeries(sRLow, BarCount-n);
    sRClose := ShiftSeries(sRClose, BarCount-n);
    sSignals := ShiftSeries(sSignals, BarCount-n);
    for i:=0 to BarCount-n-1 do
    begin
      sROpen[i] := NaN;
      sRHigh[i] := NaN;
      sRLow[i] := NaN;
      sRClose[i] := NaN;
      sSignals[i] := NaN;
    end;
  end else
  if n > BarCount then
  begin
    sROpen := ShiftSeries(sROpen, BarCount-n);
    sRHigh := ShiftSeries(sRHigh, BarCount-n);
    sRLow := ShiftSeries(sRLow, BarCount-n);
    sRClose := ShiftSeries(sRClose, BarCount-n);
    sSignals := ShiftSeries(sSignals, BarCount-n);
    SetArrayLength(sROpen, BarCount);
    SetArrayLength(sRHigh, BarCount);
    SetArrayLength(sRLow, BarCount);
    SetArrayLength(sRClose, BarCount);
    SetArrayLength(sSignals, BarCount);
  end;
  for i:=0 to BarCount-1 do if not IsNaN(sSignals[i]) then
  begin
    if sSignals[i] > 0 then SetBarColor(0, i, clLime) else
      if sSignals[i] < 0 then SetBarColor(0, i, clRed) else
        SetBarColor(0, i, clSilver);
  end;

  with CreateLineOHLC(sROpen, sRHigh, sRLow, sRClose) do
  begin
    Name := 'Renko Bars';
    Color := RGB(0,0,255);
    LineType := ltHighLowClose;
  end;
end.

---
Eric

[petdev]

Eric,
Bedankt voor de gedane aanpassing en arbeid.
Ik koppel even mijn bevindingen terug.
* Geoptimaliseerd plus simulatie voor 5/15/30/60/180 min met blocksize 0.05 step 0.05 tot 5.00 op AEX 2 jaar.
* De grote drawdowns/runups overnight worden hierdoor inderdaad geëlimineerd.
* Per saldo is het eindresultaat niet significant anders, De winst/verlies ratio, hitrate en totale winst zitten in dezelfde grootte-orde. Wel minder fluctuatie in de TSV.
* Beste resultaten nog te behalen met 30/60 min., echter enorm veel transacties en een winst-per-transactie waar niemand warm van zal worden.
* Bij plotten waarden rondom de optimale instelling verwacht men een soort Gausscurve. Hier vindt je
echter een scatterdiagram, waar geen logica in terug te vinden is.

Conclusie:
* Deze excercitie leidt niet tot een systeem waarop men sec kan bouwen. Misschien bruikbaar als
ondersteuning om entry/exit intraday te zoeken voor trades op dagsystemen gebaseerd.
* Optimaliseren/curvefitting is altijd omstreden en lijkt op intraday-timeframes helemaal onberekenbaar.

Groet, Peter.