IMG-BLOG
11 Mai 2020
Par Forex-Robot Trader | 11 Mai, 2020 | Trading automatic, Robot forex, Programmation MQL4 |

Qu'est-ce qu'un algorithme de trading automatique?


Le trading automatique est apparu depuis 1980 suite à l'informatisation des marchés boursiers offrant des possibilités de traitement en temps réel des informations financières. Cela a depuis permis de développer des méthodes d'évaluations mathématiques pour identifier les moments où les transactions rapportent des bénéfices.
Un algorithme de trading automatique ou plus communément un «robot trader» est une série d'instructions détaillées exécutées en boucle et appliquant une stratégie définie à l'avance par un Algo-trader, ou une équipe composée au moins de spéculateurs et de programmeurs expérimentés.


Comment ça marche concrètement?

Imaginez que vous soyez un trader de la paire EUR / USD et que vous définissiez vos conditions de prise de position comme suite :

  • Achetez lorsque le RSI (Relative Strength Index) de la période 14 est inférieur à 20,0 et les moyennes mobiles des périodes 32 et 8 se croisent
  • Vendre lorsque le RSI de la période 14 est supérieur à 80,0 et que les moyennes mobiles des périodes 32 et 8 se croisent
  • Ne rien faire si aucune des conditions ci-dessus n'est remplie

En utilisant des instructions simples pour exprimer chacune des conditions, vous permettrez à la machine de trouver ces configurations et d'agir sur elles.
Vous avez la possibilité de coder des méthodes beaucoup plus complexes (même si les meilleurs algorithmes appliquent généralement des stratégies simples), d'ajouter des méthodes de gestion de portefeuille, d'ajouter des alertes aux panneaux de tracking etc… Un algorithme de trading est une salade de fonctions simples.


Langages et plateformes de programmation

Il existe de nombreux langages de programmation pour de tels algorithmes, et le plus souvent en fonction du courtier. Celles-ci restent cependant liées au langage Java d'Oracle, C ++ ou moins souvent C # (car orienté objet). Voici quelques exemples :

  • Interactive brokers: Java, C++, Python, .NET (C#), C++ (MFC), ActiveX, DDE
  • ProRealTime: ProBuilder
  • Meta Quotes: MQL4

Voici un exemple d'algorithme de robot de trading en langage MQL4:


                                  //+------------------------------------------------------------------+
//|                                                  MACD Sample.mq4 |
//|                   Copyright 2005-2014, MetaQuotes Software Corp. |
//|                                              http://www.mql4.com |
//+------------------------------------------------------------------+
#property copyright   "2005-2014, MetaQuotes Software Corp."
#property link        "http://www.mql4.com"

input double TakeProfit    =50;
input double Lots          =0.1;
input double TrailingStop  =30;
input double MACDOpenLevel =3;
input double MACDCloseLevel=2;
input int    MATrendPeriod =26;
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void OnTick(void)
  {
   double MacdCurrent,MacdPrevious;
   double SignalCurrent,SignalPrevious;
   double MaCurrent,MaPrevious;
   int    cnt,ticket,total;
//---
// initial data checks
// it is important to make sure that the expert works with a normal
// chart and the user did not make any mistakes setting external 
// variables (Lots, StopLoss, TakeProfit, 
// TrailingStop) in our case, we check TakeProfit
// on a chart of less than 100 bars
//---
   if(Bars<100)
     {
      Print("bars less than 100");
      return;
     }
   if(TakeProfit<10)
     {
      Print("TakeProfit less than 10");
      return;
     }
//--- to simplify the coding and speed up access data are put into internal variables
   MacdCurrent=iMACD(NULL,0,12,26,9,PRICE_CLOSE,MODE_MAIN,0);
   MacdPrevious=iMACD(NULL,0,12,26,9,PRICE_CLOSE,MODE_MAIN,1);
   SignalCurrent=iMACD(NULL,0,12,26,9,PRICE_CLOSE,MODE_SIGNAL,0);
   SignalPrevious=iMACD(NULL,0,12,26,9,PRICE_CLOSE,MODE_SIGNAL,1);
   MaCurrent=iMA(NULL,0,MATrendPeriod,0,MODE_EMA,PRICE_CLOSE,0);
   MaPrevious=iMA(NULL,0,MATrendPeriod,0,MODE_EMA,PRICE_CLOSE,1);

   total=OrdersTotal();
   if(total<1)
     {
      //--- no opened orders identified
      if(AccountFreeMargin()<(1000*Lots))
        {
         Print("We have no money. Free Margin = ",AccountFreeMargin());
         return;
        }
      //--- check for long position (BUY) possibility
      if(MacdCurrent<0 && MacdCurrent>SignalCurrent && MacdPrevious(MACDOpenLevel*Point) && MaCurrent>MaPrevious)
        {
         ticket=OrderSend(Symbol(),OP_BUY,Lots,Ask,3,0,Ask+TakeProfit*Point,"macd sample",16384,0,Green);
         if(ticket>0)
           {
            if(OrderSelect(ticket,SELECT_BY_TICKET,MODE_TRADES))
               Print("BUY order opened : ",OrderOpenPrice());
           }
         else
            Print("Error opening BUY order : ",GetLastError());
         return;
        }
      //--- check for short position (SELL) possibility
      if(MacdCurrent>0 && MacdCurrentSignalPrevious && 
         MacdCurrent>(MACDOpenLevel*Point) && MaCurrent0)
           {
            if(OrderSelect(ticket,SELECT_BY_TICKET,MODE_TRADES))
               Print("SELL order opened : ",OrderOpenPrice());
           }
         else
            Print("Error opening SELL order : ",GetLastError());
        }
      //--- exit from the "no opened orders" block
      return;
     }
//--- it is important to enter the market correctly, but it is more important to exit it correctly...   
   for(cnt=0;cnt0 && MacdCurrentSignalPrevious && 
               MacdCurrent>(MACDCloseLevel*Point))
              {
               //--- close order and exit
               if(!OrderClose(OrderTicket(),OrderLots(),Bid,3,Violet))
                  Print("OrderClose error ",GetLastError());
               return;
              }
            //--- check for trailing stop
            if(TrailingStop>0)
              {
               if(Bid-OrderOpenPrice()>Point*TrailingStop)
                 {
                  if(OrderStopLoss()SignalCurrent && 
               MacdPrevious(MACDCloseLevel*Point))
              {
               //--- close order and exit
               if(!OrderClose(OrderTicket(),OrderLots(),Ask,3,Violet))
                  Print("OrderClose error ",GetLastError());
               return;
              }
            //--- check for trailing stop
            if(TrailingStop>0)
              {
               if((OrderOpenPrice()-Ask)>(Point*TrailingStop))
                 {
                  if((OrderStopLoss()>(Ask+Point*TrailingStop)) || (OrderStopLoss()==0))
                    {
                     //--- modify order and exit
                     if(!OrderModify(OrderTicket(),OrderOpenPrice(),Ask+Point*TrailingStop,OrderTakeProfit(),0,Red))
                        Print("OrderModify error ",GetLastError());
                     return;
                    }
                 }
              }
           }
        }
     }
//---
  }
//+------------------------------------------------------------------+
                                  
                                  

Quelles stratégies sont couramment utilisées dans les algorithmes de trading?

Ces stratégies, comme les autres, exploitent les comportements récurrents des actifs ou les failles du système de cotation. Voici quelques exemples de stratégies couramment utilisées:

  • Ordres flash: c'est l'une des techniques les plus utilisées pour anticiper le marché qui consiste à utiliser des algorithmes pour voir les ordres de vente ou d'achat en une fraction de seconde avant qu'ils ne soient visibles par le marché.
  • Trading de tendance: ceux-ci trouvent les tendances, et prennent position dans sa direction (Millionnaire Pips est l'un des meilleurs algorithmes du domaine)
  • Trading range: c'est la dernière à exploiter des actifs dont les prix évoluent dans une fourchette plus ou moins horizontale
  • Arbitrage: consiste à exploiter la différence de notation d'un même actif
  • Etc.


Avantages et inconvénients du trading algorithmique

Les algorithmes de trading placent environ 80% des ordres sur les marchés boursiers du monde entier; ce qui démontre l'enthousiasme à leur égard. En voici quelques-uns de leur avantages :

  • Ils permettre une exploitation rapide et sans faille des opportunités
  • Ils sont dépourvus d'émotions
  • Permettre de tester à partir des données précédentes, l'efficacité d'une stratégie
  • Permettre d'obtenir une juste valorisation des actifs boursiers
  • Rendre les marchés plus liquides
  • Réduction des coûts de spéculation au profit des particuliers

De nombreux particuliers, banques, fonds d'investissement, retraites, etc. dans le monde utilisent des algorithmes de trading pour ces nombreux avantages. Des sommes exorbitantes sont consacrées annuellement à leur programmation et à leurs mises à jour.

Cet intérêt croissant présente néanmoins quelques inconvénients:

  • L'augmentation de la volatilité des actifs
  • Mouvements de plus en plus incohérents
  • Crashes Flash (exemple du crash flash de 2010)

Il existe des organes chargés de réglementer l'utilisation de ces algorithmes en veillant au respect des règles de base régissant la spéculation de marché.
Aux États-Unis d'Amérique, on trouve:

  • SEC (Securities and Exchange Commission),
  • CFTC (Commodity Futures Trading Commission),
  • RSCI (Regulation Systems Compliance and Integrity),
  • FINRA (Financial Industry Regulatory Authority),
  • MIDAS ( Market Information Data Analytics System).

Plusieurs idées font l'objet de débats quotidiens comme l'envoi du détail des codes aux autorités compétentes ou la communication d'informations détaillées sur les transactions (identité de l'investisseur, ration des commandes annulées, etc.). pourrait, par exemple, permettre d'identifier d'éventuels abus de marché (bourrage de devis, usurpation d'identité, etc.).
Bref, beaucoup de travail sur la régulation du trading algorithmique est nécessaire pour garantir une utilisation sécurisée face aux nouveaux risques qu'ils génèrent sur les marchés financiers.


Ce dont vous avez besoin pour démarrer avec les robots de trading

Pour utiliser un algorithme de trading, vous devez déjà l'avoir, et choisir votre robot de trading automatique n'est pas toujours une tâche facile, car les arnaques abondent sur le terrain. Nous avons rédigé un article qui pourrait vous servir de guide pour vos choix.
Après l'avoir acquis, vous devez absolument créer un compte de trading avec un courtier qui permet l'utilisation d'algorithmes. La plateforme sur laquelle fonctionne ce dernier vous sera précisée par votre fournisseur d'algorithmes, qui vous fera en général rédiger un guide d'installation au préalable.

Si en revanche vous décidez de vous lancer dans la programmation de votre propre algorithme, je vous félicite avant tout du choix. En bref, voici une liste non exhaustive de prérequis:

  • Des bases solides dans le domaine du trading
  • Une connaissance moyenne de la programmation
  • Un ordinateur (deux moniteurs pour être plus à l'aise)
  • Un cahier (pour mieux planifier et raisonner)
  • Une connexion Internet fluide
  • Un accès aux données boursières via un courtier adapté
  • Un accès serveur pour héberger vos algorithmes

Le trading algorithmique demande du temps et de l'organisation. Lorsque vous jouez avec les indicateurs, vous devrez utiliser votre créativité et utiliser les résultats des nombreux tests pour affiner votre stratégie. Nous vous conseillons de porter une attention particulière au facteur risque / rendement. Vous devrez peut-être former une équipe et partager les tâches pour aller plus vite!



Commentaires

Je veux bien apprendre à programmer des algorithmes, mais par où commencer !? Comment obtenir des cours, et surtout du soutient en cas de difficultés?


Britania , 2020-08-22

Un petit commentaire !


Britania , 2020-08-22

Un autre petit commentaire en test !


Britania , 2020-08-22