Categoria: Risultati strategie

Qui si tratta molto di statistica e dati. Backtest di strategie per poter capire quali strategie sono valide.

Strategia che inganna

Profitti da capogiro e equityline bellissima! Ma non è tutto oro ciò che luccica, ecco perché questa è una strategia che inganna.

Ciao, sono Drilon e sono un programmatore con la passione per la finanza personale, in questo blog condivido il mio percorso.

Questa è una strategia che all’apparenza è potentissima però bisogna sapere cosa c’è sotto per valutare al meglio.

La logica che c’è sotto è: COMPRA quando il macd incrocia dal basso verso l’alto, fine!

Molto semplice ma già da qui si può intuire che se si utilizza su un asset che non cresce sempre il profitto va a quel paese.

In questo caso è stata applicata all’SP500 che sappiamo che cresce sempre da più di 100 anni “per struttura” (è l’andamento del mercato, l’uomo crea valore sempre, se non fosse così vorrebbe dire che come specie si andrebbe a peggiorare, ma questo è tutto un altro discorso).

Quindi questa strategia è efficace? SI MA non hai bisogno di questa strategia per fare una cosa del genere, alla fine è un PAC (Piani d’accumulo).

Questo è un esempio su BITCOIN

Ma vediamo su un asset più volatile come Palantir (PLTR)

Na merda! Ma questo perchè? Perché Palantir è stata listata, è andata per un paio di mesi verso l’alto e poi è crollata, quindi le posizioni sono tutte in negativo, poi magari tra 10 anni Palantir sarà la nuova Apple, però chi lo può sapere?!

Proprio questo è il problema, quindi tanto vale fare un PAC autonomamente.

Questo era un esempio del perché è importante capire come funziona una strategia, non si può applicare a tutto ed è un attimo perdere soldi. Attenzione alla strategia che inganna!

Se hai dubbi o domande fammele pure su Telegram: https://t.me/+0xQYD3WKIAA5Mjg8

Seguimi su instagram: https://www.instagram.com/investoinvestigando.it/

Ecco il codice per TradingView:

//@version=5
strategy(title="Forex", overlay=true,  precision=3)

ema = ta.ema(close, 200)

//macd
fast_length = input(title="Fast Length", defval=12)
slow_length = input(title="Slow Length", defval=26)
src = input(title="Source", defval=close)
signal_length = input.int(title="Signal Smoothing",  minval = 1, maxval = 50, defval = 9)
sma_source = input.string(title="Oscillator MA Type",  defval="EMA", options=["SMA", "EMA"])
sma_signal = input.string(title="Signal Line MA Type", defval="EMA", options=["SMA", "EMA"])
// Plot colors
col_macd = input(#2962FF, "MACD Line  ", group="Color Settings", inline="MACD")
col_signal = input(#FF6D00, "Signal Line  ", group="Color Settings", inline="Signal")
col_grow_above = input(#26A69A, "Above   Grow", group="Histogram", inline="Above")
col_fall_above = input(#B2DFDB, "Fall", group="Histogram", inline="Above")
col_grow_below = input(#FFCDD2, "Below Grow", group="Histogram", inline="Below")
col_fall_below = input(#FF5252, "Fall", group="Histogram", inline="Below")
// Calculating
fast_ma = sma_source == "SMA" ? ta.sma(src, fast_length) : ta.ema(src, fast_length)
slow_ma = sma_source == "SMA" ? ta.sma(src, slow_length) : ta.ema(src, slow_length)
macd = fast_ma - slow_ma
signal = sma_signal == "SMA" ? ta.sma(macd, signal_length) : ta.ema(macd, signal_length)
buySignal = ta.crossover(macd, signal)
sellSignal = ta.crossunder(macd,signal)
var count = 0
if(buySignal and close > ema)
    stopLoss = 10000.0
    for i = 0 to 5
        stopLoss := low[i] < stopLoss ? low[i] : stopLoss
    
    takeProfit = close + (close-stopLoss)*2
    count := count + 1
    strategy.order("buy"+str.tostring(count), strategy.long, 1, when = true)

// Questo serve per dire quando chiudere le operazioni
if(year == 2023 and month == 06)
    strategy.close_all("Close")

EURUSD – EMA – Strategia automatica

Ciao, oggi ti parlo di una delle strategie più semplici che ci siano, ovvero l’intersezione di due Medie Mobili Esponenziali (EMA).

Ciao sono Drilon e sono un programmatore con la passione per la finanza personale, questo è il mio blog dove racconto il mio percorso.

Idea di base

L’idea di base della strategia è quella di aprire un ordine BUY quando l’ema a breve termine va sopra l’ema a lungo termine, aprire un ordine SEL quando l’ema a breve termine va sotto l’ema a lungo termine.

All’apertura di un ordine si chiude l’ordine nel verso opposto!

Processo

Partendo dall’ottimizzazione dei parametri in un periodo che va dal 2019 al 2023 trovo le migliori combinazioni in questo lasso di tempo. Dopodiché la testo in un range più ampio che va dal 2011 al 2023.

Se in entrambe le situazioni la strategia si comporta bene ed ha un andamento che reputo valido a quel punto la metto in live.

Ottimizzazione

Ottimizzazione

Questo è quello che ho ottenuto dall’ottimizzazione, un andamento abbastanza costante.

L’ottimizzazione l’ho fatta sul timeframe, e le lunghezze delle due ema. Volendo si può mettere un filtro temporale sulle ore e vedere in che range di tempo conviene operare (Next step).

Backtest

backtest

Questo è il risultato del backtest dal 2011 al 2023! Non è male un 35% di profitto (ho aumentato i lotti rispetto all’ottimizzazione)

Non ha nemmeno un drawdown eccessivo però l’andamento non mi convince, non è costante. Si nota che nei primi 90 ordini non si comporta bene.
Il prossimo step sarebbe quello di andare a vedere il grafico e vedere cosa è successo in quei 90 ordini.

In questo modo possiamo trovare qualcosa per migliorare la strategia.

Conclusione

Personalmente non è una strategia che mi convince e che metterei in live, ci si può lavorare però per com’è ora assolutamente no. Il problema è che il mercato ovviamente non si comporta sempre allo stesso modo, quindi è veramente difficile trovare un setup di medie mobili che funzioni sempre.

Codice

using System;
using System.Linq;
using cAlgo.API;
using cAlgo.API.Indicators;
using cAlgo.API.Internals;
using cAlgo.Indicators;

namespace cAlgo.Robots
{
    [Robot(TimeZone = TimeZones.UTC, AccessRights = AccessRights.None)]
    public class IIScalping : Robot
    {

        [Parameter("Source", Group = "Data series")]
        public DataSeries Source { get; set; }

        [Parameter(DefaultValue = 100000)]
        public double takeProfit { get; set; }

        [Parameter(DefaultValue = 100000)]
        public double stopLoss { get; set; }

        [Parameter(DefaultValue = 60)]
        public int fastPeriod { get; set; }

        [Parameter(DefaultValue = 240)]
        public int slowPeriod { get; set; }

        [Parameter(DefaultValue = 0.01)]
        public double lots { get; set; }

        [Parameter(DefaultValue = 1)]
        public int maxOrder { get; set; }

        private ExponentialMovingAverage emaFast;
        private ExponentialMovingAverage emaSlow;

        protected override void OnBar()
        {
            // Put your core logic here
            emaFast = Indicators.ExponentialMovingAverage(Source, fastPeriod);
            emaSlow = Indicators.ExponentialMovingAverage(Source, slowPeriod);
            
            
            int currentBar = Bars.Count - 1;
            var positions = Positions.FindAll("Order");
      
                

                if (emaFast.Result.LastValue > emaSlow.Result.LastValue)
                {
                    Close(TradeType.Sell);
                    Open(TradeType.Buy, lots);
                }

                if (emaFast.Result.LastValue < emaSlow.Result.LastValue)
                {
                    Close(TradeType.Buy);
                    Open(TradeType.Sell, lots);
                }

        }

        private void Close(TradeType tradeType)
        {
            foreach (var position in Positions.FindAll("Order", SymbolName, tradeType))
                ClosePosition(position);
        }

        private void Open(TradeType tradeType, double lots)
        {
            var position = Positions.FindAll("Order", SymbolName, tradeType);
            var volumeInUnits = Symbol.QuantityToVolumeInUnits(lots);
            if (position == null || position.Length < maxOrder)
                ExecuteMarketOrder(tradeType, SymbolName, (double)volumeInUnits, "Order", stopLoss, takeProfit);
        }
    }
}

Parametri:

  • takeProfit: 10000 (non si utilizza)
  • stopLoss: 10000 (non si utilizza)
  • fastPeriod: 65
  • slowPeriod: 34
  • maxOrder: 1 (ordini aperti contemporaneamente)

Dynamic Range Revert Money Management

Ciao, la strategia Dynamic Range Revert Money Management è una miglioria alla strategia Dynamic Range Revert! (Pazzesco vero?! 😀 ) Si tratta della stessa strategia dove però i lotti cambiano in percentuale.

Ciao sono Drilon e sono un programmatore con la passione per la finanza personale. In questa strategia si imposta quanto del nostro capitale si vuole rischiare ad ogni trade, ad esempio l’1%! La logica che c’è sotto poi è la stessa che trovi qui (no dovevi cliccare QUI, c’è il link, non in questo, dai te lo rimetto qui, stasera mi è presa così…non sono simpatico scusa)

Risultati

Andiamo al sodo e vediamo il risultato!

dynamic range revert money management – risultati

Questo grafico è l’equityline, ovvero l’andamento. Partendo da 450$ si arriva a circa 3400$.

Aspetta non è così semplice, questa vale solo per EURCAD a timeframe 1 minuto!

Niente male lo so, ma non farti ingannare dai, ovviamente questo è un backtest, in live i risultati non saranno così, per via dello spread e le commissioni che qui è sono statiche (non zero, non mi ricordo che valore di preciso).

Ok abbiamo visto il grafico, vediamo più nel dettaglio però.

Un dato molto importante per me è sempre il Drawdown poiché devo essere in grado di sostenerlo sia economicamente che mentalmente (terribile veder scendere il valore dei soldi). In questo caso si tratta di circa un 12% di drawdown.

Non è tantissimo, però non è nemmeno poco, anche se per un guadagno del genere ne potrebbe valere la pena!

Vediamo che ha aperto circa 3000 ordini, quindi i dati sono abbastanza affidabile. Se un backtest di una strategia si fa su 10 ordini i dati che ottieni puoi evidenziarli, sottolinearli, accartocciare il foglio e buttare tutto! NON SONO ABBASTANZA! NON è ATTENDIBILE!

Un altro valore importante sono gli ordini consecutivi che sono andati in stopLoss, anche questo principalmente per una questione mentale (il rischio rendimento vedrai che non è come ti aspetti).

Personalmente, preferisco fare piccoli profitti costanti e prendere una batosta raramente, rispetto a prendere tanti stopLoss e un grande takeProfit. Mentalmente mi ammazza e mi porterebbe a fare cazzate!

Vabbè basta, io il mio l’ho detto, tieni il codice!

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using cAlgo.API;
using cAlgo.API.Collections;
using cAlgo.API.Indicators;
using cAlgo.API.Internals;

namespace cAlgo.Robots
{
    [Robot(AccessRights = AccessRights.None)]
    public class IIDynamicRangeBreakoutREVERTMM : Robot
    {
        [Parameter(DefaultValue = 10)]
        public double takeProfit { get; set; }

        [Parameter(DefaultValue = 10)]
        public double stopLoss { get; set; }

        [Parameter(DefaultValue = 8)]
        public int hourEnter { get; set; }

        [Parameter(DefaultValue = 18)]
        public int hourExit { get; set; }
        
        [Parameter(DefaultValue = 8)]
        public int hourClosingOpen{ get; set; }

        [Parameter(DefaultValue = 18)]
        public int hourClosingExit { get; set; }
        
        [Parameter(DefaultValue = 1)]
        public int maxOrder { get; set; }
        
        [Parameter(DefaultValue = 0)]
        public double maxRange { get; set; }
        
        [Parameter(DefaultValue = 999999)]
        public double minRange { get; set; }
        
        [Parameter(DefaultValue = 0.01)]
        public double lots { get; set; }
        
        [Parameter(DefaultValue = 3)]
        public int stopLossRiskPercent { get; set; }
        
        protected override void OnStart()
        {
            Positions.Closed += OnPositionsClosed;
        }

        protected override void OnTick()
        {
            // Handle price updates here
            if(!checkTime()){
                // Break Range
                if(Bars.LastBar.Close > maxRange && maxRange != 0){
                    // Open BUY
                    lots = DisplayPositionSizeRiskOnChart();
                    if(lots >= 0.00){
                        Open(TradeType.Sell, lots);
                        maxRange = 0;
                        minRange = 999999;
                    }
                }  
                
                if(Bars.LastBar.Close < minRange && minRange != 999999){
                    // Open SELL
                    lots = DisplayPositionSizeRiskOnChart();
                    if(lots >= 0.00){
                        Open(TradeType.Buy, lots);
                        maxRange = 0;
                        minRange = 999999;
                    }
                }
            }
            
            /*if(checkClosingTime()){
                CloseAll();
            }*/
        }
        
        protected override void OnBar()
        {
        
            if(checkTime()){
                // Set Range
                if(Bars.LastBar.High > maxRange ){
                    maxRange = Bars.LastBar.High;
                }  
                
                if(Bars.LastBar.Low < minRange ){
                    minRange = Bars.LastBar.Low;
                }
            }    
        }

        protected override void OnStop()
        {
            CloseAll();
        }
        
        private bool checkTime()
        {
            DateTime date = Server.Time;
            if (date.Hour >= hourEnter && date.Hour <= hourExit && hourEnter <= hourExit)
            {
                return true;
            }
            else
            {
                return false;
            }
        }
        
        private bool checkClosingTime()
        {
            DateTime date = Server.Time;
            if (date.Hour >= hourClosingOpen && date.Hour <= hourClosingExit && hourClosingOpen <= hourClosingExit)
            {
                return true;
            }
            else
            {
                return false;
            }
        }
        
        private void CloseAll()
        {
            foreach (var position in Positions.FindAll("DynamicRangeBreakoutREVERT", SymbolName))
            {
                ClosePosition(position);
            }
        }
        
        private void Close(TradeType tradeType)
        {
            foreach (var position in Positions.FindAll("DynamicRangeBreakoutREVERT", SymbolName, tradeType))
                ClosePosition(position);
        }

        private void Open(TradeType tradeType, double lots)
        {
            var position = Positions.FindAll("DynamicRangeBreakoutREVERT", SymbolName, tradeType);
            var volumeInUnits = Symbol.QuantityToVolumeInUnits(lots);
            if (position == null || position.Length < maxOrder)
                ExecuteMarketOrder(tradeType, SymbolName, volumeInUnits, "DynamicRangeBreakoutREVERT", stopLoss, takeProfit);
        }
        
        private void OnPositionsClosed(PositionClosedEventArgs args)
        {
            Print("Closed positions");
            var position = args.Position;

           /* if (position.NetProfit > 0)
            {
                lots = 0.03;
            }
            else
            {
                lots *= 2;
            }*/
        }
        
        
        private double DisplayPositionSizeRiskOnChart()
        {
            double costPerPip = (double)((int)(Symbol.PipValue * 10000000)) / 100;
 
            double positionSizeForRisk = (Account.Balance * stopLossRiskPercent / 100) / (stopLoss * costPerPip);
            Print(Account.Balance, " ",positionSizeForRisk, " ",(stopLoss * costPerPip));
            
            string text = stopLossRiskPercent + "% x " + stopLoss + "pip = " + Math.Round(positionSizeForRisk, 2) + " lot";
 
            ChartObjects.DrawText("positionRisk", text, StaticPosition.TopRight, Colors.Yellow);
            return Math.Round(positionSizeForRisk, 2);
        }
    }
} 

questi sono i parametri che devi impostare:

  • takeProfit: 15
  • stopLoss: 40
  • hourEnter: 18
  • hourExit: 19
  • hourClosingEnter: 18
  • hourClosingExit: 23
  • maxOrder: 1
  • minRange: 99999
  • lots: 0.01
  • stopLossRisk: 1

Mi raccomando, la strategia può funzionare anche con altre valute, ma con questi parametri specifici funziona sono in EURCAD a 1 minuto!

Da qui puoi vedere come utilizzare cTrader (piattaforma che utilizzo): LINK

Se hai dubbi o domande fammele pure su Telegram: https://t.me/+0xQYD3WKIAA5Mjg8

Seguimi su instagram: https://www.instagram.com/investoinvestigando.it/

Dynamic Range Revert – Scalping

Ciao, la strategia “Dynamic Range Revert – Scalping” è una strategia molto semplice, utilizzata da molte persone, anche dai trader retail… ma noi non abbiamo tempo da perdere, noi vogliamo tutto automatico!

Ciao, sono Drilon e sono un programmatore con la passione per la finanza personale, mi piace scrivere strategie automatiche e vedere che risultati portano. Questa strategia è l’inversa di un’altra strategia che ho scritto in precedenza (https://www.investoinvestigando.it/dynamic-breakout-scalping/).

Idea

L’idea di base è molto semplice, c’è un range di tempo in cui viene definito un range di prezzo, ovvero un massimo e un minimo. Dopodiché abbiamo un altro range di tempo nel quale si attende la rottura del range di prezzo in uno dei due lati.

Una volta subita la rottura apriamo un ordine al contrario, ovvero se abbiamo il punto di rottura nel prezzo MIN, apriamo un ordine in BUY e viceversa. Quindi l’idea è quella di trovare dei falsi breakout.

Ok, adesso sappiamo quando entrare, ma quando è il momento di uscire? L’idea è quella di dare “respiro/tempo” al mercato di andare a raggiungere il nostro target. Il target è di circa 10 pips poiché, statisticamente, abbiamo il 98% di probabilità di arrivare a target! Quindi non c’è un vero stop loss ma c’è un altro momento in cui usciamo dal trade, non possiamo mica stare a mercato per sempre…

Il secondo modo di uscita è dato da un orario nel quale il mercato inizia a calmarsi e non c’è molto movimento, quindi che si sia in profitto o in perdita, si chiude e andiamo al giorno dopo! Nessuna strategia di trading è perfetta al 100%, ma….

Risultati

Backtest

Come puoi vedere, in 11 anni la strategia rende molto bene! Non farti fregare dal numero grosso di 71k di profitto e del 718% di profitto, perché quello dipende da quanto budget uno ha, sono ordini fatti con 1 lotto (non alla portata di tutti). Da questa figura ci interessa sapere solo l’andamento, vedere se è costante oppure no. Basta! Ora andiamo nel dettaglio

Vediamo che ci sono stati 2534 ordini di cui 2115 in profitto quindi abbiamo un 83% di win rate (probabilità di vincere un trade). Andiamo a vedere le note dolenti!

Abbiamo un Drawdown del 62% che è tantissimo…molti trader quando vai al 50% ti chiudono l’operazioni in automatico. Poi abbiamo che il peggior trader ha fatto perdere 1348€ e qui la domanda che ci dobbiamo fare è “Ho abbastanza budget da sopportare una perdita del genere? Mentalmente come mi farebbe sentire una perdita del genere?”

Vediamo che ci sono stati massimo 3 ordini consecutivi andati in negativo, perchè è importante questo dato? Sempre a livello mentale, perchè magari ci sono persone che preferiscono guadagnare poco ma guadagnare spesso, invece ci sono altre persone che riescono a sopportare più perdite consecutive per poi fare dei grossi guadagni! Questo dipende tutto da come siamo fatti mentalmente.

Personalmente preferisco rischiare di meno ma avere un guadagno costante. Quindi cosa faccio? Invece di puntare 1 lotto ad ogni trade, vado a diminuire!

Immagina puntando 0.1 lotti, guadagno totale in 11 anni è di circa 7,1k, quindi è molto inferiore, però quanto rischiamo? Il drawdown scende al 6,2% (niente male eh) ed il peggior trade mi fa perdere 134,8€. Diventa tutto più accettabile giusto? Se è ancora troppo, diminuisci i lotti fino a quando non sei confidente e a tuo agio con la strategia, l’importante è che nel tempo siamo in profitto

Si lo so vuoi il codice e vuoi provare da solo, ecco qui:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using cAlgo.API;
using cAlgo.API.Collections;
using cAlgo.API.Indicators;
using cAlgo.API.Internals;

namespace cAlgo.Robots
{
    [Robot(AccessRights = AccessRights.None)]
    public class IIDynamicRangeBreakoutREVERT : Robot
    {
        [Parameter(DefaultValue = 10)]
        public double takeProfit { get; set; }

        [Parameter(DefaultValue = 10)]
        public double stopLoss { get; set; }

        [Parameter(DefaultValue = 8)]
        public int hourEnter { get; set; }

        [Parameter(DefaultValue = 18)]
        public int hourExit { get; set; }
        
        [Parameter(DefaultValue = 8)]
        public int hourClosingOpen{ get; set; }

        [Parameter(DefaultValue = 18)]
        public int hourClosingExit { get; set; }
        
        [Parameter(DefaultValue = 1)]
        public int maxOrder { get; set; }
        
        [Parameter(DefaultValue = 0)]
        public double maxRange { get; set; }
        
        [Parameter(DefaultValue = 999999)]
        public double minRange { get; set; }
        
        [Parameter(DefaultValue = 0.01)]
        public double lots { get; set; }
        

        protected override void OnTick()
        {
            // Handle price updates here
            if(!checkTime()){
                // Break Range
                if(Bars.LastBar.Close > maxRange && maxRange != 0){
                    // Open BUY
                    Open(TradeType.Sell, lots);
                    maxRange = 0;
                    minRange = 999999;
                }  
                
                if(Bars.LastBar.Close < minRange && minRange != 999999){
                    // Open SELL
                    Open(TradeType.Buy, lots);
                    maxRange = 0;
                    minRange = 999999;
                }
            }
            
            if(checkClosingTime()){
                CloseAll();
            }
        }
        
        protected override void OnBar()
        {
        
            if(checkTime()){
                Print("DENTRO");
                // Set Range
                if(Bars.LastBar.High > maxRange ){
                    maxRange = Bars.LastBar.High;
                }  
                
                if(Bars.LastBar.Low < minRange ){
                    minRange = Bars.LastBar.Low;
                }
            }    
        }

        protected override void OnStop()
        {
            CloseAll();
        }
        
        private bool checkTime()
        {
            DateTime date = Server.Time;
            if (date.Hour >= hourEnter && date.Hour <= hourExit && hourEnter <= hourExit && hourClosingOpen > hourExit)
            {
                return true;
            }
            else
            {
                return false;
            }
        }
        
        private bool checkClosingTime()
        {
            DateTime date = Server.Time;
            if (date.Hour >= hourClosingOpen && date.Hour <= hourClosingExit && hourClosingOpen <= hourClosingExit)
            {
                return true;
            }
            else
            {
                return false;
            }
        }
        
        private void CloseAll()
        {
            foreach (var position in Positions)
            {
                ClosePosition(position);
            }
        }
        
        private void Close(TradeType tradeType)
        {
            foreach (var position in Positions.FindAll("Order", SymbolName, tradeType))
                ClosePosition(position);
        }

        private void Open(TradeType tradeType, double lots)
        {
            var position = Positions.FindAll("Order", SymbolName, tradeType);
            var volumeInUnits = Symbol.QuantityToVolumeInUnits(lots);
            if (position == null || position.Length < maxOrder)
                ExecuteMarketOrder(tradeType, SymbolName, volumeInUnits, "Order", stopLoss, takeProfit);
        }
    }
}

PARAMETRI:

Timeframe e valuta: EURUSD – 1m

takeProfit: 20

stopLoss: 90

hourEnter: 14

hourExit: 15

hourClosingOpen: 23

hourClosingExit: 15

maxOrder:1

maxRange: 0

minRange: 99999999

lots: a piacimento

Se vuoi vedere delle strategie da utilizzare inizia da qui: https://www.investoinvestigando.it/una-strategia-per-sempre-algotrading/

Se hai dubbi o domande fammele pure su Telegram: https://t.me/+0xQYD3WKIAA5Mjg8

Seguimi su instagram: https://www.instagram.com/investoinvestigando.it/

Dynamic Breakout – Scalping

Ciao oggi ti vado a parlare di una strategia di scalping (Dynamic Breakout – Scalping) che ho trovato online e che ho un po’ ridefinito secondo le mie idee.

Logica di base

La logica di base è quella di definire un range di max e min durante un determinato periodo della giornata, ad esempio dalle 2 di notte alle 7 di mattina, dopodiché se il prezzo va sopra o sotto questi range entrare a mercato.

Esempio di breakout dinamico

In quest’immagine vediamo un esempio di un caso ideale della strategia.

Ma quando chiudere l’operazione?

Per questo ho messo due possibilità, una al raggiungimento di un TakeProfit e l’altra è una chiusura a tempo, ovvero in un determinato orario della giornata!

La strategia l’ho trovata in questo canale YouTube: https://www.youtube.com/c/RenéBalke/videos

Andiamo nel codice

A questo punto ho codificato la strategia e sono andato a ottimizzarla per USDJPY (quello utilizzato nel video) però non ho ottenuto dei buoni risultati. Si sempre profittevole, però troppo volatile per i miei gusti.

USDJPY

Sono andato a provarla in un’altra coppia, ovvero EURUSD e qui le cose si sono fatte interessanti.

EURUSD - Brakout strategy
EURUSD – Brakout strategy

Come puoi vedere dall’immagine c’è una crescita costante e un rischio minimo. Questo è stato ottenuto con 0.01 lotti e vediamo che c’è un drawdown di $42 e un guadagno di $437, tutto questo in un periodo di 11 anni.

Come dico tutte le volte, non guardare tanto il fatto che in 11 anni 400$ siano pochi, bisogna vedere se la strategia è profittevole in un tempo abbastanza lungo, dopo sei sempre in tempo ad aumentare i lotti e ad aumentare il guadagno…ma anche il drawdown possibile.

I parametri migliori che sono venuti fuori per questa strategia, in EURUSD sono i seguenti:

TimeFrame: 1m
TakeProfit: 5
StopLoss: 100000 (è senza stop loss la strategia)
hourEnter: 6
hourExit: 8
hourClosingOpen: 19
hourClosingExit: 19
maxOrder: 1
maxRange: 0
minRange: 999999
lots: 0.01

Ti ricordo di testarla anche in altre coppie e trovare i settaggi migliori prima di operare veramente.

Ed ecco il codice della strategia, se vuoi sapere come inserirlo e utilizzare la piattaforma guarda qui: https://www.investoinvestigando.it/come-usare-ctrader/

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using cAlgo.API;
using cAlgo.API.Collections;
using cAlgo.API.Indicators;
using cAlgo.API.Internals;

namespace cAlgo.Robots
{
    [Robot(AccessRights = AccessRights.None)]
    public class IIDynamicRangeBreakout : Robot
    {
        [Parameter(DefaultValue = 10)]
        public double takeProfit { get; set; }

        [Parameter(DefaultValue = 10)]
        public double stopLoss { get; set; }

        [Parameter(DefaultValue = 8)]
        public int hourEnter { get; set; }

        [Parameter(DefaultValue = 18)]
        public int hourExit { get; set; }
        
        [Parameter(DefaultValue = 8)]
        public int hourClosingOpen{ get; set; }

        [Parameter(DefaultValue = 18)]
        public int hourClosingExit { get; set; }
        
        [Parameter(DefaultValue = 1)]
        public int maxOrder { get; set; }
        
        [Parameter(DefaultValue = 0)]
        public double maxRange { get; set; }
        
        [Parameter(DefaultValue = 999999)]
        public double minRange { get; set; }
        
        [Parameter(DefaultValue = 0.01)]
        public double lots { get; set; }
        

        protected override void OnTick()
        {
            // Handle price updates here
            if(!checkTime()){
                // Break Range
                if(Bars.LastBar.Close > maxRange && maxRange != 0){
                    // Open BUY
                    Open(TradeType.Buy, lots);
                    maxRange = 0;
                    minRange = 999999;
                }  
                
                if(Bars.LastBar.Close < minRange && minRange != 999999){
                    // Open SELL
                    Open(TradeType.Sell, lots);
                    maxRange = 0;
                    minRange = 999999;
                }
            }
            
            if(checkClosingTime()){
                CloseAll();
            }
        }
        
        protected override void OnBar()
        {
        
            if(checkTime()){
                Print("DENTRO");
                // Set Range
                if(Bars.LastBar.High > maxRange ){
                    maxRange = Bars.LastBar.High;
                }  
                
                if(Bars.LastBar.Low < minRange ){
                    minRange = Bars.LastBar.Low;
                }
            }    
        }

        protected override void OnStop()
        {
            CloseAll();
        }
        
        private bool checkTime()
        {
            DateTime date = Server.Time;
            if (date.Hour >= hourEnter && date.Hour <= hourExit && hourEnter <= hourExit && hourClosingOpen > hourExit)
            {
                return true;
            }
            else
            {
                return false;
            }
        }
        
        private bool checkClosingTime()
        {
            DateTime date = Server.Time;
            if (date.Hour >= hourClosingOpen && date.Hour <= hourClosingExit && hourClosingOpen <= hourClosingExit)
            {
                return true;
            }
            else
            {
                return false;
            }
        }
        
        private void CloseAll()
        {
            foreach (var position in Positions)
            {
                ClosePosition(position);
            }
        }
        
        private void Close(TradeType tradeType)
        {
            foreach (var position in Positions.FindAll("Order", SymbolName, tradeType))
                ClosePosition(position);
        }

        private void Open(TradeType tradeType, double lots)
        {
            var position = Positions.FindAll("Order", SymbolName, tradeType);
            var volumeInUnits = Symbol.QuantityToVolumeInUnits(lots);
            if (position == null || position.Length < maxOrder)
                ExecuteMarketOrder(tradeType, SymbolName, volumeInUnits, "Order", stopLoss, takeProfit);
        }
    }
}

Se vuoi vedere delle strategie da utilizzare inizia da qui: https://www.investoinvestigando.it/una-strategia-per-sempre-algotrading/

Se hai dubbi o domande fammele pure su Telegram: https://t.me/+0xQYD3WKIAA5Mjg8

Seguimi su instagram: https://www.instagram.com/investoinvestigando.it/