DocumentationSections
Référence MQL5Fonctions de TradingOrderCalcMargin 

OrderCalcMargin

La fonction calcule la marge requise pour le type d'ordre spécifié, pour le compte courant, dans l'environnement de marché courant, et sans tenir compte des ordres en attente et des positions ouvertes. Elle permet d'évaluer la marge pour l'opération de trading planifiée. La valeur est retournée dans la devise du compte.

bool  OrderCalcMargin(
   ENUM_ORDER_TYPE       action,           // type de l'ordre
   string                symbol,           // nom du symbole
   double                volume,           // volume
   double                price,            // prix d'ouverture
   double&               margin            // variable pour récupérer la valeur de la marge
   );

Paramètres

action

[in]  Le type de l'ordre, peut être l'une des valeurs de ENUM_ORDER_TYPE

symbol

[in]  Nom du symbole.

volume

[in]  Volume de l'opération de trading.

price

[in]  Prix d'ouverture.

margin

[out]  La variable dans laquelle la valeur de la marge requise sera écrite si la fonction est exécutée avec succès. Le calcul est effectué comme s'il n'y avait pas d'ordre en attente ou de position ouverte sur le compte actuel. La valeur de la marge dépend de plusieurs facteurs et peut différer dans des environnements de marché différents.

Valeur de Retour

Retourne true en cas de succès, false sinon. Pour obtenir des informations sur l'erreur, appelez la fonction GetLastError().

Exemple :

#define   VOLUME     1.0   // volume de l'ordre
#define   DEVIATION  100   // distance pour placer l'ordre en attente
#define   STOP_LIMIT 50    // distance de l'ordre StopLimit
 
//+------------------------------------------------------------------+
//| Script program start function                                    |
//+------------------------------------------------------------------+
void OnStart()
  {
   string currency=AccountInfoString(ACCOUNT_CURRENCY);
   int array_types[8]={ORDER_TYPE_BUY,
                       ORDER_TYPE_SELL,
                       ORDER_TYPE_BUY_LIMIT,
                       ORDER_TYPE_SELL_LIMIT,
                       ORDER_TYPE_BUY_STOP,
                       ORDER_TYPE_SELL_STOP,
                       ORDER_TYPE_BUY_STOP_LIMIT,
                       ORDER_TYPE_SELL_STOP_LIMIT };
                       
//--- boucle sur le tableau des types d'ordres
   for(int i=0; i<(int)array_types.Size(); i++)
     {
      //--- suivant le type de l'ordre, récupère le type ORDER_TYPE_BUY ou ORDER_TYPE_SELL
      ENUM_ORDER_TYPE type=MarketOrderByOrderType((ENUM_ORDER_TYPE)array_types[i]);
      
      //--- suivant le type de l'ordre, récupère le prix
      double price=PriceByOrderType(_Symbol, type);
      
      //--- récupère le montant de la marge requis pour le type de l'ordre spécifié dans 'action' 
      double margin=EMPTY_VALUE;
      ResetLastError();
      if(!OrderCalcMargin(type, _Symbol, VOLUME, price, margin))
        {
         Print("OrderCalcMargin() failed. Error ",GetLastError());
         continue;
        }
      //--- affiche le résultat dans le journal
      PrintFormat("Margin required for %.2f %s order at price %.*f on %s symbol: %.2f %s", VOLUME, OrderTypeDescription((ENUM_ORDER_TYPE)i), _Digits, price, _Symbol, margin, currency);
     }
   /*
   résultat :
   Margin required for 1.00 Buy order at price 1.31668 on GBPUSD symbol: 1316.68 USD
   Margin required for 1.00 Sell order at price 1.31661 on GBPUSD symbol: 1316.61 USD
   Margin required for 1.00 Buy Limit order at price 1.31568 on GBPUSD symbol: 1315.68 USD
   Margin required for 1.00 Sell Limit order at price 1.31761 on GBPUSD symbol: 1317.61 USD
   Margin required for 1.00 Buy Stop order at price 1.31768 on GBPUSD symbol: 1317.68 USD
   Margin required for 1.00 Sell Stop order at price 1.31561 on GBPUSD symbol: 1315.61 USD
   Margin required for 1.00 Buy Stop Limit order at price 1.31718 on GBPUSD symbol: 1317.18 USD
   Margin required for 1.00 Sell Stop Limit order at price 1.31611 on GBPUSD symbol: 1316.11 USD
   */
  }
//+------------------------------------------------------------------+
//| Retourne le type de l'ordre Buy ou Sell                          |
//+------------------------------------------------------------------+
ENUM_ORDER_TYPE MarketOrderByOrderType(ENUM_ORDER_TYPE type)
  {
   switch(type)
     {
      case ORDER_TYPE_BUY  : case ORDER_TYPE_BUY_LIMIT  : case ORDER_TYPE_BUY_STOP  : case ORDER_TYPE_BUY_STOP_LIMIT  :
        return(ORDER_TYPE_BUY);
      case ORDER_TYPE_SELL : case ORDER_TYPE_SELL_LIMIT : case ORDER_TYPE_SELL_STOP : case ORDER_TYPE_SELL_STOP_LIMIT :
        return(ORDER_TYPE_SELL);
     }
   return(WRONG_VALUE);
  }
//+------------------------------------------------------------------+
//| Retourne le prix d'ouverture selon le type de l'ordre            |
//+------------------------------------------------------------------+
double PriceByOrderType(const string symbol, const ENUM_ORDER_TYPE order_type)
  {
   int     digits=0;
   double  point=0;
   MqlTick tick={};
 
//--- récupère la valeur du symbole Point
   ResetLastError();
   if(!SymbolInfoDouble(symbol, SYMBOL_POINT, point))
     {
      Print("SymbolInfoDouble() failed. Error ", GetLastError());
      return 0;
     }
     
//--- récupère la valeur du symbole Digits
   long value=0;
   if(!SymbolInfoInteger(symbol, SYMBOL_DIGITS, value))
     {
      Print("SymbolInfoInteger() failed. Error ", GetLastError());
      return 0;
     }
   digits=(int)value;
   
//--- récupère les derniers prix par symbole
   if(!SymbolInfoTick(symbol, tick))
     {
      Print("SymbolInfoTick() failed. Error ", GetLastError());
      return 0;
     }
     
//--- renvoie le prix en fonction du type de l'ordre
   switch(order_type)
     {
      case ORDER_TYPE_BUY              :  return(tick.ask);
      case ORDER_TYPE_SELL             :  return(tick.bid);
      case ORDER_TYPE_BUY_LIMIT        :  return(NormalizeDouble(tick.ask - DEVIATION * point, digits));
      case ORDER_TYPE_SELL_LIMIT       :  return(NormalizeDouble(tick.bid + DEVIATION * point, digits));
      case ORDER_TYPE_BUY_STOP         :  return(NormalizeDouble(tick.ask + DEVIATION * point, digits));
      case ORDER_TYPE_SELL_STOP        :  return(NormalizeDouble(tick.bid - DEVIATION * point, digits));
      case ORDER_TYPE_BUY_STOP_LIMIT   :  return(NormalizeDouble(tick.ask + DEVIATION * point - STOP_LIMIT * point, digits));
Q      case ORDER_TYPE_SELL_STOP_LIMIT  :  return(NormalizeDouble(tick.bid - DEVIATION * point + STOP_LIMIT * point, digits));
      default                          :  return(0);
     }
  }
//+------------------------------------------------------------------+
//| Retourne la description du type de l'ordre                       |
//+------------------------------------------------------------------+
string OrderTypeDescription(const ENUM_ORDER_TYPE order_type)
  {
   switch(order_type)
     {
      case ORDER_TYPE_BUY              :  return("Buy");
      case ORDER_TYPE_SELL             :  return("Sell");
      case ORDER_TYPE_BUY_LIMIT        :  return("Buy Limit");
      case ORDER_TYPE_SELL_LIMIT       :  return("Sell Limit");
      case ORDER_TYPE_BUY_STOP         :  return("Buy Stop");
      case ORDER_TYPE_SELL_STOP        :  return("Sell Stop");
      case ORDER_TYPE_BUY_STOP_LIMIT   :  return("Buy Stop Limit");
      case ORDER_TYPE_SELL_STOP_LIMIT  :  return("Sell Stop Limit");
      case ORDER_TYPE_CLOSE_BY         :  return("Close By");
      default                          :  return("Unknown order type");
     }
  }

Voir également

OrderSend(), Propriétés d'un Ordre, Types des Opérations de Trading