consulente esperto - domande varie - pagina 4

Nuovo commento
 
  1. Sì, lo usano pesantemente. Tutti questi sono stati scritti quando c'erano solo valute. Ora ci sono i metalli e se la dimensione del tick è pari a un punto è completamente sbagliata.
  2. 0200:00.069 - esperto personalizzato EURUSD,H1: | _lotSize - NormalizeDouble: 0.07000000000000001
    L'OP continua a stampare un doppio a 15 cifre e non riesce a capire perché non è esattamente 0,07. Perché qualche numero non può essere rappresentato esattamente 1/8. può 1/10. non può.
 
honest_knave:
double LotCalculator(double lots)
  {
   ...
   return(NormalizeDouble(lots,2));
  }

Questo commento mi aiuta davvero molto, e questo è utile ma mi dà più decimali.
( più decimali è normale - perché ho già letto qualcosa al riguardo )

Sono ancora preoccupato per'NormalizeDouble' e sto cercando un altro modo, quale è meglio di 'NormalizeDouble'?

Grazie!

 

Grandi ringraziamenti che sono stati scritti commenti.

@whroeder1- Ricercherò ampiamente il tuo commento (/ link) grandi grazie.
@Marco- Lo userò dopo il problema LotSize LotStep. Grazie!

 
Max Enrik:

Questo commento mi aiuta molto, e questo è utile ma mi dà più decimali.
( più decimali è normale - perché ho già letto a riguardo )

Sono ancora preoccupato per'NormalizeDouble' e sto cercando un altro modo, quale è meglio di 'NormalizeDouble'?

Grazie!

Forse sarebbe meglio stabilire esattamente cosa stai cercando di ottenere.

Se vuoi una funzione che restituisca una dimensione di lotto valida per piazzare un ordine, non hai bisogno di usare NormalizeDouble(). Il mio frammento di codice originale o quello di WHRoeder lo otterranno per voi. Ci sono sottili differenze tra loro che saranno una questione di preferenze personali.

Ma, se fate una semplice Print() del valore del lotto potreste ottenere dei risultati "strani"... come il vostro 0.07000000000000001

Questo non sarà un problema per OrderSend() ma potrebbe non essere quello che vi aspettate di vedere.

Se vuoi vedere i numeri visualizzati in modo "normale", hai 2 scelte:

1. Potete usare NormalizeDouble() nella funzione. Per una stampa standard, il valore sarà come te lo aspetti. Ma se stampate (manualmente) abbastanza cifre decimali, alla fine vedrete che il numero non è esattamente quello che pensate che sia. Questo è il punto che WHRoeder sta cercando di fare (credo). Questa soluzione non è la più elegante, ma è la più semplice. Oppure...

2. Potete lasciare la dimensione del lotto così com'è (cioè non usare NormalizeDouble) e poi regolare il valore per scopi di visualizzazione quando necessario. Potreste usare DoubleToStr() o StringFormat() o printf() per ottenere questo, a seconda di ciò che vi serve. Questo è un approccio più flessibile.

Ricordate che il valore effettivo e il modo in cui quel valore viene visualizzato non devono essere gli stessi. Non sarete mai in grado di memorizzare esattamente 0,07:

   double myVal=0.07;
   printf("%.24f",myVal);

Result: 0.070000000000000006661338

Ma potete certamente visualizzare 0,07 se ne avete bisogno.
 
honest_knave:

Forse sarebbe meglio stabilire esattamente cosa si sta cercando di ottenere.
...

Wow, bello che hai scritto, ho quasi capito come il tuo commento.
Così scriverò nuovo commento, presto.

//--- seconda volta modificata

Come ho detto non ho bisogno che LotSize e LotStep siano visualizzati correttamente solo nel display, ho bisogno che LotSize e LotStep possano mostrare la stessa cosa ovunque.
Mi preoccupo solo di questo.

 

Beh, se si tratta di lottizzazione dinamica si può sempre inserire un semplice cambio.

//Gearbox//
double Lots;
Balance=AccountInfoDouble(ACCOUNT_BALANCE);

if(Balance>10000)
{Lots=10;Print(" Gear Two");}
if(Balance>100000)
{Lots=100;Print(" Gear Three");}
if(Balance>1000000)
{Lots=1000;Print(" Gear Four");}
if(Balance>10000000)
{Lots=10000;Print(" Gear Five");}

if(Balance<10000000)
{Lots=1000;Print(" Gear Four");}
if(Balance<1000000)
{Lots=100;Print(" Gear Three");}
if(Balance<100000)
{Lots=10;Print(" Gear Two");}
if(Balance<10000)
{Lots=1;Print(" Gear One");}
if(Balance>1000000000)
{Lots=0;}
 

Ho bisogno di postare parte del mio EA con voi, quindi spero che vi aiuti a capirmi meglio.
Quindi, ho bisogno di sapere se è un buon codice o cosa?

Vi prego di darmi un buon consiglio (chiaramente) o aiuto, grazie in anticipo.

void OnChartEvent(const int      id     , // Event ID
                  const long   & lparam , // Parameter of type long event
                  const double & dparam , // Parameter of type double event
                  const string & sparam   // Parameter of type string events
                  )
{

    _lotCalc();
    //-------Process Button---------------------------------------------------------|
    if ( sparam == _btnLotMinus )
    {
        ObjectSetInteger( 0, _btnLotMinus, OBJPROP_STATE, false );
        _lotSize -= _lotStep;

        if ( NormalizeDouble( _lotSize, 2 ) <= 0 ) _lotSize = _lotMin;
        _calcUpdade( CALC_CHANGE_LOT );

        Print( " | Lot:   ", _lotSize );
        return;
    }   //---if Close
    //                          ...
}

double _lotCalc()
{
    //---
    _lotMin  = SymbolInfoDouble( _Symbol, SYMBOL_VOLUME_MIN  );
    _lotMax  = SymbolInfoDouble( _Symbol, SYMBOL_VOLUME_MAX  );
    _lotStep = SymbolInfoDouble( _Symbol, SYMBOL_VOLUME_STEP );

    //---
    return( NormalizeDouble( _lotSize, 2 ) );
}
 
Max Enrik:

Ho bisogno di postare una parte del mio EA con voi, spero che vi aiuti a capirmi meglio.
Quindi, ho bisogno di sapere se è un buon codice o cosa?

Per favore datemi un buon consiglio (chiaramente) o aiuto, grazie in anticipo.

A notte fonda, non compilato, non testato.

Non possiamo vedere dove hai impostato _lotSize... ricorda che dovrai assicurarti che _lotSize sia sempre un multiplo di _lotStep.

IMHO sarebbe meglio se tenessi tutti i tuoi calcoli di lotto insieme, piuttosto che dividerli tra OnChartEvent() e _lotCalc(). Una funzione che controlla min / max / step e fa l'incremento / decremento.

void OnChartEvent(const int      id     , // Event ID
                  const long   & lparam , // Parameter of type long event
                  const double & dparam , // Parameter of type double event
                  const string & sparam   // Parameter of type string events
                  )
{
    _lotCalc();
    //-------Process Button---------------------------------------------------------|
    if ( sparam == _btnLotMinus )
    {
        ObjectSetInteger( 0, sparam, OBJPROP_STATE, false );
        _lotSize = fmax(_lotMin, _lotSize-_lotStep);
        _calcUpdade( CALC_CHANGE_LOT );
        printf( " | Lot: %.2f  ", _lotSize );
        return;
    }   //---if Close
    //                          ...
}

void _lotCalc()
{
    //---
    _lotMin  = SymbolInfoDouble( _Symbol, SYMBOL_VOLUME_MIN  );
    _lotMax  = SymbolInfoDouble( _Symbol, SYMBOL_VOLUME_MAX  );
    _lotStep = SymbolInfoDouble( _Symbol, SYMBOL_VOLUME_STEP );

    //---
}
 
honest_knave:

A notte fonda, non compilato, non testato.
Non possiamo vedere dove hai impostato _lotSize per la prima volta... ricorda che dovrai assicurarti che _lotSize sia sempre un multiplo di _lotStep.
IMHO sarebbe meglio se tenessi tutti i tuoi calcoli di lotto insieme, piuttosto che dividerli tra OnChartEvent() e _lotCalc(). Una funzione che controlla min / max / step e fa l'incremento / decremento.

Questo mi ha aiutato molto, cioè ha risolto i miei problemi di lotSize e losStep.
Grazie mille amico.

#Lot 0 (zero) & (tra il problema risolto di Lot Size e Lot Step) - Chiuso

 

Sì, ho dimenticato il codice lotSize, quindi lo uso nella funzioneinit.
È un buon posto per _lotSize?

Grazie!

int OnInit()
{
    _pip = Point;
    if( Digits == 0 || Digits == 2 || Digits == 3 || Digits == 5 ) _pip = 10 * Point;
    _lotSize = _lotValue * MarketInfo( Symbol(), MODE_MINLOT );

    //...
}
1234567891011...43
Nuovo commento