Ciao, oggi torno a parlarti di una strategia automatica che ho scritto e testato personalmente, siamo sempre a una strategia da utilizzare sempre. Sono Drilon e sono un programmatore con la passione per la finanza personale!

La strategia ha dato risultati veramente interessanti, utilizzabile per ogni tipologia di portafoglio.

Idea

L’idea di base è quella di una “toccata e fuga” poiché noi siamo dei piccoli pesci per il mercato, non possiamo immaginare di combattere gli squali. L’imitiamoci a prendere il nostro e stare tranquilli.

Attenzione però, non è scalping perché non si punta tanto in pochissimo tempo per poter guadagnare qualcosa.

L’idea è di prendere una piccola parte di un grande movimento, infatti l’obiettivo è quello di prendere 10/15 pips e fine.

Vedi questo grafico? Indica la probabilità di arrivare al target (lato sinistro asse delle Y) in un numero di candele (lato basso asse delle X). Quindi perchè puntare a fare 200 pips se statisticamente è provato che è molto difficile? Andiamo a fare operazioni quasi certe!

Quindi, tornando alla strategia, l’idea è di utilizzare un qualcosa che ci indichi il trend principale (Media Mobile Esponenziale) e qualcosa che ci indichi quando entrare a mercato e per quanto starci, il 100% di probabilità di arrivare a target non c’è! Utilizzerò lo Stochastic! Quindi avremo qualcosa del genere:

Come si opera?

Allora si entra a mercato quando le medie mobili esponenziali sono verso lo stesso trend e lo stochastic incrocia ed entra nella zona azzurra, con un piccolo dettaglio però, bisogna entrare a mercato solo se l’intreccio attuale dello stochastic è avvenuto seguendo il trend rispetto all’intreccio precedente.

Mi spiego meglio!

Esempio di operazione di SELL

Abbiamo le medie mobili esponenziali tutte tendenti verso il basso, entriamo nel punto 3 perché l’intreccio precedente dello stochastic è avvenuto nel punto 2 ed il prezzo nel punto 2 era maggiore rispetto al punto 3, quindi conferma il trend ribassista sul quale noi vogliamo puntare.

Nel punto 2 non si entra poiché c’è stato un intreccio precedente nel punto 1 che è avvenuto a un prezzo più basso, quindi nel punto 2 poteva esserci un’inversione (Poi è sceso ma è l’incertezza del mercato).

Se si guarda più indietro in realtà noi si sarebbe entrati nel punto 1 perché il precedente intreccio dello stochastic era a un prezzo più alto, ma questo era giusto per farti un esempio e capire la strategia.

Ma quando esco? L’obiettivo è 10 pips di target oppure quando lo stochastic arriva nella zona opposta alla nostra, nel caso del sell si esce quando lo stochastic arriva sotto i 20.

Stessa cosa, capovolta, per quanto riguarda il buy

Codice

Dopo aver fatto l’optimization questo è il risultato:

In 11 anni ha eseguito 181 ordini, di cui 170 andati a target e 11 chiusi in negativo!

Non male eh? Il profitto però, come vedi, non è altissimo, è di 228$ che in 11 anni fanno abbastanza schifo, però questo a noi ci serve solo come test per capire se la strategia funziona o no! Questo è stato fatto puntando sempre il minimo (0.01 lotti)

Vuoi sapere la cosa bella? Che ha un drawdown di soli 33$!

Quindi se hai un capitale di 100$ puoi già partire con questa strategia, se hai un capitale di 1k puoi aumentare i lotti e utilizzarne (0.1) e otterresti un guadagno di circa 2280$ rischiando 330$.

Quindi dipende anche dal budget personale!

Questi sono i parametri da utilizzare:

Poi comunque puoi sbizzarrirti come più credi, facendo altri test e altri parametri.

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 = 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 = 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 = 2)]
        public int multiplier { get; set; }

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

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

        [Parameter(DefaultValue = 3)]
        public int stochParams { get; set; }

        private ExponentialMovingAverage emaFast;
        private ExponentialMovingAverage emaSlow;
        private StochasticOscillator stoch;
        
        double stochLevel = 0.0;


        protected override void OnStart()
        {
            // Put your initialization logic here

        }

        protected override void OnBar()
        {
            // Put your core logic here
            emaFast = Indicators.ExponentialMovingAverage(Source, fastPeriod);
            emaSlow = Indicators.ExponentialMovingAverage(Source, slowPeriod);
            stoch = Indicators.StochasticOscillator(stochLength, stochParams, stochParams, MovingAverageType.Exponential);
            
            
            int currentBar = Bars.Count - 1;
            bool check = checkTime();
            var positions = Positions.FindAll("Order");
            if (check == true)
            {
                

                //Open(TradeType.Buy, lots);
                
                if(emaFast.Result.LastValue > emaSlow.Result.LastValue && stoch.PercentK[currentBar] > stoch.PercentD[currentBar] && stoch.PercentK[currentBar - 1] <= 20 && stochLevel == 0.0){
                    stochLevel = Bars.LastBar.Close;
                }
                
                if(emaFast.Result.LastValue < emaSlow.Result.LastValue && stoch.PercentK[currentBar] < stoch.PercentD[currentBar] && stoch.PercentK[currentBar - 1] >= 80 && stochLevel == 0.0){
                    stochLevel = Bars.LastBar.Close;
                }

                if (emaFast.Result.LastValue > emaSlow.Result.LastValue && stoch.PercentK[currentBar] > stoch.PercentD[currentBar] && stoch.PercentK[currentBar - 1] <= 20 && Bars.LastBar.Close > stochLevel)
                {
                    stochLevel = 0.0;
                    //stopLoss = (Bars[currentBar-1].Close - Bars[currentBar-1].Low)*100000;
                    Open(TradeType.Buy, lots);
                }

                if (emaFast.Result.LastValue < emaSlow.Result.LastValue && stoch.PercentK[currentBar] < stoch.PercentD[currentBar] && stoch.PercentK[currentBar - 1] >= 80 && Bars.LastBar.Close < stochLevel)
                {
                    stochLevel = 0.0;
                    //stopLoss = (Bars[currentBar-1].High - Bars[currentBar-1].Close)*100000;
                    Open(TradeType.Sell, lots);
                }

            }
            
            if(positions.Length>0 && (positions[0].TradeType == TradeType.Buy)){
                if(stoch.PercentK[currentBar] >= 80){
                    Close(TradeType.Buy);
                }
            }
            
            
            if(positions.Length>0 && (positions[0].TradeType == TradeType.Buy)){
                if(stoch.PercentK[currentBar] <= 20){
                    Close(TradeType.Sell);
                }
            }

        }

        protected override void OnStop()
        {
            // Put your deinitialization logic here
        }

        private bool checkTime()
        {
            DateTime date = Server.Time;
            if (date.Hour >= hourEnter && date.Hour <= hourExit)
            {
                return true;
            }
            else
            {
                return false;
            }
        }

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


}

Questo è il broker che utilizzo: https://www.icmarkets.eu/en/

Questa è un’altra strategia: https://www.investoinvestigando.it/algotrading-macd-ema/