¿Cómo se calcula el tamaño del lote? - página 2

Nuevo comentario
 
Ais wrote >>
Hello.
Correct code must be able to produce any valid result.
Examples.




Best regards,
Ais.

He duplicado con éxito las respuestas que usted proporcionó (dentro de .01) y tengo una pregunta sobre los valores para ald.MinimalMargin.

Utilizando mi cuenta estándar de IBFX, mi ald.MinimalMargin es siempre de 10 dólares, tanto para el GBPJPY como para el EURUSD, mientras que sus cantidades varían (como 185,785 o 147,6).

¿Tienes alguna idea de por qué tus cantidades de margen mínimo varían pero las mías no?

 

He duplicado las cantidades de su ald.OperationVolume (dentro de 0,01) y tengo una pregunta.

Cuando el cálculo se ejecuta en su cuenta, el ald.MinimalMargin varía.

Cuando el cálculo se ejecuta en mi cuenta estándar de IBFX, el ald.MinimalMargin es siempre $10.

PREGUNTA: ¿Alguna idea de por qué?

Aquí están los valores de alerta en mi sistema utilizando la cuenta estándar de IDFX. Observe que ald.MinimalMargin = 10 USD.

aas.Symbol = GBPJPY
aad.VARLimit = 3155 USD
aai.VARPoints = 50 puntos
aai.Command = 0

Procesamiento:
ald.MinimalMargin = 10 USD
ald.MinimalPoint = 0.0942 USD
ali.PositionPoints = 106 puntos
aai.VARPoints = 50 puntos
ald.VARPositions = 0.4717 posiciones
aad.VARLimit = 3155 USD
ald.PositionLimit = 6688.6 USD
ald.VolumeLimit = 6.6886 lotes
ald.VolumeStep = 0.01 lotes
ald.NominalMargin = 1000 margen requerido (inserté esta línea)
ald.MinimalVolume = 0.01 lotes

Salida:
ald.OperationVolume = 6.68

 
Hello.
According to MQL4 documentation "MODE_LOTSIZE" must return "Lot size in the base currency".
However, some brokers indicate "MODE_LOTSIZE" as "Lot size in the account currency".
 In this case, "MODE_MARGINREQUIRED" means 1 lot size in the account currency divided by constant "AccountLeverage ()".
 Thank you for effective collaboration.
Best regards,
Ais.
  
Hello.
The revised sample of the operation volume computing:

double avd.OperationVolume    ;

double avd.VARLimit  = 200.00 ;
int    avi.VARPoints = 50     ;

//<init>
int    init
 (//<0>
){//<1>
 
avd.OperationVolume = amd.OperationVolume ( Symbol () , avd.VARLimit , avi.VARPoints ) ;

}//</init> 

//<amd.OperationVolume>
double amd.OperationVolume
 (//<3>
       string aas.Symbol    ,
       double aad.VARLimit  ,
       int    aai.VARPoints
){//<31>

double ald.VolumeStep      = MarketInfo ( aas.Symbol , MODE_LOTSTEP        )                        ;
double ald.MinimalVolume   = MarketInfo ( aas.Symbol , MODE_MINLOT         )                        ;
double ald.NominalLot      = MarketInfo ( aas.Symbol , MODE_LOTSIZE        )                        ;
double ald.NominalMargin   = MarketInfo ( aas.Symbol , MODE_MARGINREQUIRED )                        ;
double ald.NominalTick     = MarketInfo ( aas.Symbol , MODE_TICKVALUE      )                        ;
double ald.QuoteTick       = MarketInfo ( aas.Symbol , MODE_TICKSIZE       )                        ;
double ald.QuotePoint      = MarketInfo ( aas.Symbol , MODE_POINT          )                        ;

double ald.MinimalMargin   = ald.NominalMargin       * ald.MinimalVolume                            ;
double ald.MinimalTick     = ald.NominalTick         * ald.MinimalVolume                            ;
double ald.MinimalPoint    = ald.MinimalTick         * ald.QuotePoint    / ald.QuoteTick            ;
int    ali.PositionPoints  = MathRound               ( ald.MinimalMargin / ald.MinimalPoint )       ;

double ald.VARPositions    = aai.VARPoints * 1.0     / ali.PositionPoints                           ;
double ald.MarginLimit     = avd.VARLimit            / ald.VARPositions                             ;
double ald.VolumeLimit     = ald.MarginLimit         / ald.NominalMargin                            ;
 
double ald.OperationVolume = 0                                                                      ;

if   ( ald.VolumeLimit    >= ald.MinimalVolume )
     { int ali.Steps       = MathFloor ( ( ald.VolumeLimit - ald.MinimalVolume ) / ald.VolumeStep ) ;
       ald.OperationVolume = ald.MinimalVolume + ald.VolumeStep * ali.Steps                         ; }

string als.LotMeasure      , als.BaseCurrency                                                       ;

if   ( AccountLeverage () != NormalizeDouble ( ald.NominalLot / ald.NominalMargin , 1 ) )
     { als.BaseCurrency    = StringSubstr    ( aas.Symbol , 0 , 3 )                                 ;
       als.LotMeasure      = als.BaseCurrency                                                       ; }
else   als.LotMeasure      = AccountCurrency ()                                                     ;

Alert  ( " "                                                                                      ) ;
Alert  ( "ald.OperationVolume = " , ald.OperationVolume , " " , "lots"                            ) ;
Alert  ( "Output :"                                                                               ) ;
Alert  ( " "                                                                                      ) ;
Alert  ( "ald.MinimalVolume   = " , ald.MinimalVolume   , " " , "lots"                            ) ;
Alert  ( "ald.VolumeStep      = " , ald.VolumeStep      , " " , "lots"                            ) ;
Alert  ( "ald.VolumeLimit     = " , ald.VolumeLimit     , " " , "lots"                            ) ;
Alert  ( "ald.MarginLimit     = " , ald.MarginLimit     , " " , AccountCurrency ()                ) ;
Alert  ( "aad.VARLimit        = " , aad.VARLimit        , " " , AccountCurrency ()                ) ;
Alert  ( "ald.VARPositions    = " , ald.VARPositions    , " " , "positions"                       ) ;
Alert  ( "aai.VARPoints       = " , aai.VARPoints       , " " , "points"                          ) ;
Alert  ( "ali.PositionPoints  = " , ali.PositionPoints  , " " , "points"                          ) ;
Alert  ( "ald.MinimalPoint    = " , ald.MinimalPoint    , " " , AccountCurrency ()                ) ;
Alert  ( "ald.MinimalMargin   = " , ald.MinimalMargin   , " " , AccountCurrency ()                ) ;
Alert  ( "ald.NominalMargin   = " , ald.NominalMargin   , " " , AccountCurrency ()                ) ;
Alert  ( "ald.NominalLot      = " , ald.NominalLot      , " " , als.LotMeasure                    ) ;
Alert  ( "Processing :"                                                                           ) ;
Alert  ( " "                                                                                      ) ;
Alert  ( "aai.VARPoints       = " , aai.VARPoints       , " " , "points"                          ) ;
Alert  ( "aad.VARLimit        = " , aad.VARLimit        , " " , AccountCurrency ()                ) ;
Alert  ( "aas.Symbol          = " , aas.Symbol                                                    ) ;
Alert  ( "Input :"                                                                                ) ;
Alert  ( " "                                                                                      ) ;
Alert  ( "AccountLeverage ()  = " , AccountLeverage ()                                            ) ;
Alert  ( "AccountCurrency ()  = " , AccountCurrency ()                                            ) ;
 
return ( ald.OperationVolume )                                                                      ;

}//</amd.OperationVolume>



Best regards,
Ais.
 
El cálculo del tamaño del lote es el cálculo de la pérdida máxima permitida. El riesgo es el precio abierto - el stop loss inicial (Compra: Ask-SL, Venta: SL-Bid) La pérdida máxima es el riesgo multiplicado por la pérdida por pip. Eso es lo que usted quiere que sea el 2% del saldo de la cuenta. Nada que ver con el margen. Calcule dónde estarán su apertura y sus paradas, entonces el tamaño del lote se desprende de eso.
//+------------------------------------------------------------------+
//| Lot size computation.                                            |
//+------------------------------------------------------------------+
double  LotSize(double SLpoints){
/*double    TEF.value,                          // Import from ComputeTEF
//double    at.risk;                            // Export to init/start
//bool      need2refresh;                       // Import from RelTradeContext
//int       op.code; // -1/OP_BUY/OP_SELL       // Import from setDIR */
    /* This function computes the lot size for a trade.
     * Explicit inputs are SL relative to bid/ask (E.G. SL=30*points,)
     * Implicit inputs are the MM mode, the MM multiplier, count currently
     * filled orders by all EA's vs this EA/pair/period count and history.
     * Implicit inputs are all used to reduce available balance the maximum
     * dollar risk allowed. StopLoss determines the maximum dollar risk possible
     * per lot. Lots=maxRisk/maxRiskPerLot
     **************************************************************************/
    if (need2refresh)   Refresh();
    /*++++ Compute lot size based on account balance and MM mode*/{
    double  ab  = AccountBalance();
    switch(Money.Management.F0M1G2){
    case MMMODE_FIXED:
        at.risk = Money.Management.Multiplier;
        break;
    case MMMODE_MODERATE:
        // See https://www.mql5.com/en/articles/1526 Fallacies, Part 1: Money
        // Management is Secondary and Not Very Important.       // %used/trade=
        at.risk = MathSqrt(Money.Management.Multiplier * ab)/ab; // ~const rate.
        at.risk = MathSqrt(Money.Management.Multiplier * ab
                            * MathPow( 1 - at.risk, OrdersTotal() ));
        break;
    case MMMODE_GEOMETRICAL:
        at.risk = Money.Management.Multiplier * ab *
                MathPow(1 - Money.Management.Multiplier, OrdersTotal());
        break;
    }
    double  maxLossPerLot   = SLpoints * PointValuePerLot(),
    /* Number of lots wanted = at.risk / maxLossPerLot rounded/truncated to
     * nearest lotStep size.
     *
     * However, the broker doesn't care about the at.risk/account balance. They
     * care about margin. Margin used=lots used*marginPerLot and that must be
     * less than free margin available. */
            marginFree      = AccountFreeMargin(),
            marginPerLot    = MarketInfo( Symbol(), MODE_MARGINREQUIRED ),
    // So I use, the lesser of either.
            size = MathMin(marginFree / marginPerLot, at.risk / maxLossPerLot),
            minLot  = MarketInfo(Symbol(), MODE_MINLOT),
            LotStep = MarketInfo(Symbol(), MODE_LOTSTEP);
    /*---- Compute lot size based on account balance and MM mode*/}
    double  adjFact = IfD(MathMin(1, TEF.value), 1, TEF.Enable01);
    while (true){   // Adjust for broker, test for margin, combine with TEF
        size =  MathFloor(size/LotStep)*LotStep;
        if (size < minLot){ // Insufficient margin.
            Print(
            "LotSize(SL=", DoubleToStr(SLpoints/pips2dbl, Digits.pips), ")=",
            size, " [risk=", at.risk, AccountCurrency(),    "/", maxLossPerLot,
                    ", margin=",    marginFree,             "/", marginPerLot,
                    ", MMM=",       Money.Management.F0M1G2,"x",
                    Money.Management.Multiplier,
                    ", ExtraOO=",   OrdersTotal(),
                "]" );
            size=0; break;  }
        /* size<minLot should be sufficient, but the tester was generating error
         * 134 even when marginFree should have been OK. So I also use
         * AccountFreeMarginCheck which aggrees with the tester.
         * https://forum.mql4.com/35056 */
        double AFMC = AccountFreeMarginCheck(Symbol(), op.code, size);
        /**/ if (AFMC < 0)      size *= 0.95;
        else if (adjFact < 1){  size  = MathMax(minLot,size*adjFact);adjFact=1;}
        else break; // We're good to go.
    }
    at.risk = size * maxLossPerLot;                     // Export for Comment
    return(size);
}   // LotSize
double PointValuePerLot() { // Value in account currency of a Point of Symbol.
    /* In tester I had a sale: open=1.35883 close=1.35736 (0.00147)
     * gain$=97.32/6.62 lots/147 points=$0.10/point or $1.00/pip.
     * IBFX demo/mini       EURUSD TICKVALUE=0.1 MAXLOT=50 LOTSIZE=10,000
     * IBFX demo/standard   EURUSD TICKVALUE=1.0 MAXLOT=50 LOTSIZE=100,000
     *                                  $1.00/point or $10.00/pip.
     *
     * https://forum.mql4.com/33975 CB: MODE_TICKSIZE will usually return the
     * same value as MODE_POINT (or Point for the current symbol), however, an
     * example of where to use MODE_TICKSIZE would be as part of a ratio with
     * MODE_TICKVALUE when performing money management calculations which need
     * to take account of the pair and the account currency. The reason I use
     * this ratio is that although TV and TS may constantly be returned as
     * something like 7.00 and 0.00001 respectively, I've seen this
     * (intermittently) change to 14.00 and 0.00002 respectively (just example
     * tick values to illustrate). */
    return(  MarketInfo(Symbol(), MODE_TICKVALUE)
           / MarketInfo(Symbol(), MODE_TICKSIZE) ); // Not Point.
}
 

Usted sigue publicando este código una y otra vez en el foro, y en este caso usted thread-necro'ed un hilo de 2 años de edad para hacerlo, y sólo es correcto para los pares de div isas que tienen la denominación de la cuenta como la contra-divisa en el par de divisas.

(Si la denominación de la cuenta = USD y el par de divisas EURUSD entonces su código es correcto...pero es incorrecto para USDJPY, EURJPY, etc)

Yo sigo señalando esto, tú sigues ignorándolo.

 

WHRoeder, ¿tienes una versión actualizada de este código que sea válida para todos los pares de divisas, independientemente de la denominación de la cuenta o de que sea contra-divisa?


Gracias.

 
Por lo que sé AQUÍ encontrarás su última colección completa de códigos básicos. Desplácese hacia abajo a su puesto con el archivo adjunto.
 
  1. roy7:
    WHRoeder, ¿tienes una versión actualizada de este código que sea válida para todos los pares de divisas, independientemente de la denominación de la cuenta o de ser contra-divisa?

    Ese código ES válido para cualquier par.
    return(  MarketInfo(Symbol(), MODE_TICKVALUE)
      / MarketInfo(Symbol(), MODE_TICKSIZE) ); // Not Point.
    Devuelve el cambio de la moneda de la cuenta para un tick del par, cualquier par. No se necesitan cambios, a menos que sus paradas son tan grandes que tickValue cambia significativamente (I.E. 2000 pip SL.)
  2. 1005phillip 2010.09.18 17:29
    Sigo señalando esto y lo sigues ignorando.
    Porque se equivoca.
  3. ForexCoder 2011.06.01 06:42
    Por lo que sé AQUÍ encontrarás su última colección de código básico completo. Baja hasta su post con el archivo adjunto.
    AutoScroll
 

Gracias.

1234
Nuevo comentario