DocumentaciónSecciones
Manual de referencia de MQL5Funciones comercialesOrderCalcMargin 

OrderCalcMargin

Calcula el margen requerido para el tipo de orden especificado , en la cuenta actual, en el entorno del mercado actual y sin tener en cuenta las órdenes pendientes actuales y posiciones abiertas. Permite evaluar el margen requerido para la operación comercial planeada. El valor se devuelve en la moneda de la cuenta.

bool  OrderCalcMargin(
   ENUM_ORDER_TYPE       action,           // tipo de orden
   string                symbol,           // nombre del símbolo
   double                volume,           // volumen
   double                price,            // precio de apertura
   double&               margin            // variable para la obtención del valor del margen
   );

Parámetros

action

[in]  Tipo de orden, puede ser uno de los valores de la enumeración ENUM_ORDER_TYPE.

symbol

[in]  Nombre del símbolo.

volume

[in]  Volumen de la operación comercial a evaluar.

price

[in]  Precio de apertura.

margin

[out]  Variable en la que se recibirá el valor del margen requerido si la función se ejecuta con éxito. El cálculo se realiza sin tomar en consideración las órdenes pendientes ni las posiciones abiertas que pudieran haber en la cuenta actual. El valor del margen depende de muchos factores y puede ser diferente en diferentes entornos del mercado.

Valor devuelto

Devuelve true en caso de éxito. De lo contrario, la función devuelve false. Para obtener la información acerca del error, se debe usar la función GetLastError().

Ejemplo:

#define   VOLUME     1.0   // volumen de la orden
#define   DEVIATION  100   // distancia de colocación de la orden pendiente
#define   STOP_LIMIT 50    // distancia StopLimit de la orden
 
//+------------------------------------------------------------------+
//| 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 };
                       
//--- en un ciclo por el array de los tipos de órdenes
   for(int i=0; i<(int)array_types.Size(); i++)
     {
      //--- dependiendo del tipo de la orden, obtenemos el tipo ORDER_TYPE_BUY o ORDER_TYPE_SELL
      ENUM_ORDER_TYPE type=MarketOrderByOrderType((ENUM_ORDER_TYPE)array_types[i]);
      
      //--- dependiendo del tipo de orden, obtenemos el precio
      double price=PriceByOrderType(_Symbol, type);
      
      //--- obtenemos el tamaño del margen necesario para el tipo de orden indicado en action 
      double margin=EMPTY_VALUE;
      ResetLastError();
      if(!OrderCalcMargin(type, _Symbol, VOLUME, price, margin))
        {
         Print("OrderCalcMargin() failed. Error ",GetLastError());
         continue;
        }
      //--- imprimimos el resultado en el registro
      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);
     }
   /*
   resultado:
   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
   */
  }
//+------------------------------------------------------------------+
//| Retornamos el tipo de orden Buy o Sell según el tipo de orden    |
//+------------------------------------------------------------------+
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);
  }
//+------------------------------------------------------------------+
//| Retorna el tipo de precio de apertura según el tipo de orden     |
//+------------------------------------------------------------------+
double PriceByOrderType(const string symbol, const ENUM_ORDER_TYPE order_type)
  {
   int     digits=0;
   double  point=0;
   MqlTick tick={};
 
//--- obtenemos el valor Point del símbolo
   ResetLastError();
   if(!SymbolInfoDouble(symbol, SYMBOL_POINT, point))
     {
      Print("SymbolInfoDouble() failed. Error ", GetLastError());
      return 0;
     }
     
//--- obtenemos el valor Digits del símbolo
   long value=0;
   if(!SymbolInfoInteger(symbol, SYMBOL_DIGITS, value))
     {
      Print("SymbolInfoInteger() failed. Error ", GetLastError());
      return 0;
     }
   digits=(int)value;
   
//--- obtenemos los últimos precios del símbolo
   if(!SymbolInfoTick(symbol, tick))
     {
      Print("SymbolInfoTick() failed. Error ", GetLastError());
      return 0;
     }
     
//--- dependiendo del tipo de orden, retornamos el precio
   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));
      case ORDER_TYPE_SELL_STOP_LIMIT  :  return(NormalizeDouble(tick.bid - DEVIATION * point + STOP_LIMIT * point, digits));
      default                          :  return(0);
     }
  }
//+------------------------------------------------------------------+
//| Retorna la descripción del tipo de orden                         |
//+------------------------------------------------------------------+
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");
     }
  }
//+------------------------------------------------------------------+

Véase también

OrderSend(), Propiedades de órdenes, Tipos de operaciones comerciales