Caratteristiche utili da KimIV - pagina 8

Nuovo commento
 

Ci sono molte domande...
Voglio dire, vengono fuori di continuo, ma caso per caso.

Per quelle funzioni che sono pubblicate ora non ci sono domande, perché guardo solo senza "sentire" nell'unità.
Inoltre, oltre a loro, ci sono domande sui codici precedenti, in particolare sul trailing, che ha qualcosa a che fare con
con sopra scritto: come, perché passare alle funzioni, per esempio, questa sezione finale mi ha lasciato perplesso:

//+------------------------------------------------------------------+
//| Перенос уровня StopLoss                                          |
//| Параметры:                                                       |
//|   ldStopLoss - уровень StopLoss                                  |
//+------------------------------------------------------------------+
void ModifyStopLoss(double ldStopLoss) {
  bool fm;
  fm=OrderModify(OrderTicket(),OrderOpenPrice(),ldStopLoss,OrderTakeProfit(),0,CLR_NONE);
  if (fm) PlaySound("expert.wav");
}
Il ruolo di ldStopLoss non è chiaro ...
 

oooo... :-) è una funzione così antica. È stato progettato per cambiare il livello di stop di una posizione aperta o di un ordine impostato. C'era anche una funzione simile per il take profit. Sono stati entrambi sostituiti da un migliore e più funzionale ModifyOrder().

kombat:
Il ruolo di ldStopLoss non è chiaro ...

Questa è una variabile locale, per mezzo della quale il livello di prezzo, al quale StopLoss dovrebbe essere impostato, viene passato alla funzione ModifyStopLoss. Per esempio, chiamiamo la funzione ModifyStopLoss in questo modo:

ModifyStopLoss(1,5662);

Allora la variabile locale ldStopLoss assumerà il valore 1,5662. Potete controllare in questo modo:

//+------------------------------------------------------------------+
//| Перенос уровня StopLoss                                          |
//| Параметры:                                                       |
//|   ldStopLoss - уровень StopLoss                                  |
//+------------------------------------------------------------------+
void ModifyStopLoss(double ldStopLoss) {
  bool fm;
 
  Print("ldStopLoss=",ldStopLoss);
 
  fm=OrderModify(OrderTicket(),OrderOpenPrice(),ldStopLoss,OrderTakeProfit(),0,CLR_NONE);
  if (fm) PlaySound("expert.wav");
}

Il registro conterrà questo record:

<Время> <Эксперт> <Инструмент>,<таймфрейм>: ldStopLoss=1.5662
 
KimIV:

oooo... :-) è una funzione così antica. È stato progettato per cambiare il livello di stop di una posizione aperta o di un ordine impostato. C'era anche una funzione simile per il take profit. Sono stati entrambi sostituiti da una più perfetta e funzionale ModifyOrder().


Quindi... antico ... (un po' imbarazzato :)))
Ho dato un'occhiata alle cartelle, il file più vecchio è datato 22.01.2006.
E sembra che non sia stato nemmeno manomesso dalle mie manovelle...
Mi dispiace, ho praticato cose semplici per molto tempo, cambiare un numero per esempio.
Calcolatrici semplici, ecc...

Tutto questo è iniziato con una richiesta di scrivere un Expert Advisor su uno dei forum PRDC, ma...
I miei centesimi non sono sufficienti, ma devo comprarli sul mercato.
Ora ne sono dipendente... ;) io? È conveniente... c'è tutto... unitor, ecc, compatto, portatile.

Ricordo il mio primo e ultimo tentativo di Delphi 6... Rabbrividisco.
Ho ancora un paio di quei dischi sullo scaffale... :))) scusate per l'offtop.


Allora, cosa c'è dentro le parentesi di function(), è una specie di "modulo" per passargli dei parametri?


Perché per qualche motivo ho in testa che è un parametro che la funzione restituisce come risultato dell'elaborazione.
Ed è anche che la funzione riceve parametri da elaborare dentro parentesi graffe...{} 

void TrPos() {
if (OrderType()==OP_BUY) {
    if ( (Bid-OrderOpenPrice())>TrailingStop*Point) {
      if (OrderStopLoss()<Bid-TrailingStop*Point) {
        ModifyStopLoss(Bid-TrailingStop*Point);
        return;
      }
    }
  }
// в качестве примера !!! просто выдраный кусок кода!

Cioè tutti questi Bid, Point e così via sono parametri di input.

Devo essermi sbagliato di grosso... E ciò che è dentro le parentesi graffe() permette di passare parametri a una funzione,
mentre la funzione stessa può essere situata in qualsiasi (o altro) posto del codice proprio dello script...

Giusto?

 
La domanda è perché, a differenza di OpenPosition, non c'è una gestione degli errori in ModifyOrder? Ci sono tutti i tipi di errori anche durante la modifica. Mi piacerebbe avere funzioni separate per l'installazione, la modifica e la chiusura, e un'unità di gestione degli errori separata per tutte - meno codice, più facile da scrivere, e funzionerebbe più velocemente... Se mi sbaglio, correggetemi...
 
Buon giorno, Igor! Ho problemi ad utilizzare i tuoi Expert Advisors e gli script che utilizzano qualsiasi forma di trawls su real (Alpari DC). In particolare sono interessato a e-News-Lucky$ (ideale per il mio sistema), e-TFL_v2, Set2StopOrders, e-SotTrailing. Funziona su demo (anche Alpari). Nessun messaggio di errore. Cosa può essere? E un'altra domanda. Come disabilitare il time binding in e-News-Lucky$ per entrare e uscire in qualsiasi momento? Grazie!
 
ag-forex писал (а):
Buongiorno Igor, ho dei problemi ad utilizzare i tuoi EAs e scripts che utilizzano trawls di qualsiasi forma sul mio conto reale (Alpari DC). In particolare sono interessato a e-News-Lucky$ (ideale per il mio sistema), e-TFL_v2, Set2StopOrders, e-SotTrailing. Funziona su demo (anche Alpari). Nessun messaggio di errore. Cosa può essere?
Il problema è stato risolto molte volte contattando il supporto tecnico di questa società di intermediazione.
 
kombat писал (а):
 Quindi, quello che c 'è dentro le parentesi di function() è una specie di "modulo" per passarle dei parametri?

Sì... una specie di contenitore :-)

kombat ha scritto (a):
 Perché per qualche motivo ho in testa il contrario: questo è il parametro che la funzione restituisce come risultato dell'elaborazione.

Ciò che la funzione restituisce è il valore di ritorno. Ecco un semplice esempio. Definiamo una funzione che aggiunge due numeri:

int f(int a, int b) {
  int x;
  x=a+b;
  return(x);
}

Ora, se chiamiamo questa funzione in questo modo

int y;
y=f(3, 5);

allora i numeri 3 e 5 sono i parametri della funzione f. I parametri della funzione possono essere numeri, variabili o espressioni. Le variabili a e b sono variabili locali che prendono i valori dei parametri e li danno alla funzione. La variabile x è il valore di ritorno della funzione f, cioè dopo la nostra chiamata alla funzione f, la variabile y prenderà il valore passatogli dalla variabile x, cioè 8.

kombat:

E anche il fatto che la funzione riceve parametri da gestire dentro parentesi graffe...{} 

void TrPos() {
if (OrderType()==OP_BUY) {
    if ( (Bid-OrderOpenPrice())>TrailingStop*Point) {
      if (OrderStopLoss()<Bid-TrailingStop*Point) {
        ModifyStopLoss(Bid-TrailingStop*Point);
        return;
      }
    }
  }
// в качестве примера !!! просто выдраный кусок кода!

cioè tutti questi Bid, Point e così via sono i parametri di input.

no... il parametro della funzione ModifyStopLoss sarà il valore dell'espressione Bid-TrailingStop*Point.

kombat:

Devo aver fatto un errore grossolano... e ciò che è tra parentesi() permette di passare dei parametri da elaborare nella funzione,
la funzione stessa può essere situata in qualsiasi (o altro) posto del codice dello script stesso...

Giusto?

sì

 
sasa999:
La domanda è: perché, a differenza di OpenPosition, ModifyOrder non ha una gestione degli errori?

Ho sentito dire da qualche parte che le regole della strada sono state scritte col sangue. E non c'è nulla di superfluo in essi. Dietro ogni parola c'è quasi una vita persa in un incidente.

Scrivo le mie funzioni, secondo la mia esperienza, e includo l'elaborazione degli errori che si sono verificati nella mia pratica, e non c'è modo di evitarli. Cerco di essere il più "educato" possibile (gestione degli errori) quando cerco di entrare nel mercato. Durante la modifica, la maggior parte degli errori sono eliminati dalla normalizzazione dei prezzi e dai semplici controlli dei valori. Se si verifica qualche errore durante la modifica, è OK al prossimo tick. Lo stesso accade alla chiusura.

 

Qual è lo scopo di inviare pp - prezzo di apertura dell'ordine a questa funzione? 

void ModifyOrder(double pp=-1, double sl=0, double tp=0, color cl=CLR_NONE)

È come se il colore fosse già impostato all'inizio... test_ModifyOrder.mq4 (12,14 KB) ... perché non lo usi, ma lo invii di nuovo alla funzione

color clModifyBuy = Aqua; // Цвет значка модификации покупки
color clModifySell = Tomato; // Цвет значка модификации продажи
qual è il vantaggio di 
int dg=MarketInfo(OrderSymbol(), MODE_DIGITS), er, it;
pp=NormalizeDouble(pp, dg);

prima della forma breve

pp=NormalizeDouble(pp, Digits);

perché avete bisogno di normalizzare OrderOpenPrice()? non è nello stesso formato dell'ordine?

op=NormalizeDouble(OrderOpenPrice() , dg);
Finora, non ho notato alcun errore se la stessa cosa viene inserita quando si modifica. lo stesso con OrderStopLoss(), e OrderTakeProfit()
 
sasa999:

Qual è lo scopo di inviare pp - prezzo di apertura dell'ordine a questa funzione? 

void ModifyOrder(double pp=-1, double sl=0, double tp=0, color cl=CLR_NONE)

Gli ordini OP_BUYLIMIT, OP_BUYSTOP, OP_SELLLIMIT e OP_SELSTOP saranno spostati.

sasa999:

Anche il colore è in un certo senso già definito all'inizio... test_ModifyOrder.mq4 (12,14 KB) ...perché non usarlo, e re-inviare alla funzione

color clModifyBuy = Aqua; // Цвет значка модификации покупки
color clModifySell = Tomato; // Цвет значка модификации продажи

Grazie! Lo userò!

sasa999:
qual è il vantaggio 
int dg=MarketInfo(OrderSymbol(), MODE_DIGITS), er, it;
pp=NormalizeDouble(pp, dg);

prima di una forma breve

pp=NormalizeDouble(pp, Digits);

La versatilità che permette all'EA di lavorare con posizioni e ordini non solo per il simbolo corrente, ma anche per altri simboli. Per esempio, l'EA lavora sul grafico EURUSD. Una variante con Cifre non permetterà di lavorare con posizioni aperte su USDJPY.

sasa999:

Perché l'OrderOpenPrice() deve essere normalizzato?

op=NormalizeDouble(OrderOpenPrice() , dg);

Per confrontare con successo valori di tipo doppio. Se non è normalizzato, il confronto è impossibile o piuttosto privo di senso.

sasa999:
Non ho notato un errore se si rimette lo stesso quando si modifica. lo stesso con OrderStopLoss(), e OrderTakeProfit()
Senza normalizzazione, la funzione genera l'errore 1(OrderModify cerca di cambiare valori già impostati con gli stessi valori).
123456789101112131415...128
Nuovo commento
Motivazione: