Impulso - pagina 32

Nuovo commento
 
Artyom Trishkin:
Qui ho pensato: probabilmente il vostro desiderio di semplificare tutto, di ridurre a MA, e di fare veloce, e porta a conclusioni affrettate - "non funzionerà". Te l'ho detto - prima conta la differenza tra zecche vicine. Riempiamo la matrice con le differenze di prezzo, non con i prezzi. Ma stiamo cercando di sfuggita il MA. Correzione.

Tesoro, ho sistemato questa cosa da molto tempo ormai. Ti sto istruendo in modo che tu non abbia un indicatore inutile qui.

Ora, riguardo a quello che hai ottenuto alla fine:

- la media della velocità.

Anche se non hai ottenuto un MA in prezzo, hai ottenuto un MA in velocità, che differenza fa?

Se non sai cos'è il bug della media, allora guarda bene:

(5+1)/2=3 //cade

(1+5)/2=3 //aumenta

OK, pensa per te, matematico...

 
new-rena:

Tesoro, ho sistemato questa cosa da molto tempo ormai. Ti sto istruendo in modo che tu non abbia un indicatore inutile qui.

Ora, riguardo a quello che hai ottenuto alla fine:

- la media della velocità.

Anche se non hai ottenuto un MA in prezzo, hai ottenuto un MA in velocità, che differenza fa?

Se non sai cos'è il bug della media, allora guarda bene:

(5+1)/2=3

(1+5)/2=3 //aumenta

Beh, pensa per te, matematico...

Questo è un po' un boccone, amico. Essere scortesi non fa fare bella figura.

Ora dimmi cosa c'è nelle tue formule a cosa, mentore ...

ZS. Capisco la tua aggressività - qualcuno non ti ha dato i loro calcoli, e tu stesso non capisci, contando tutti nel mondo MAK, matematico ... Ma non c'è bisogno di prendersela con la gente per questo - sembri stupido.

 
Artyom Trishkin:

Questa è un'esagerazione, amico. Essere scortesi non fa fare bella figura.

Ora dimmi cosa c'è nelle tue formule a cosa, mentore...

ZS. Capisco la tua aggressività - qualcuno non ti ha dato i loro calcoli, e non si capisce, considerando tutto nel mondo come mashki, matematico ... Non devi scattare contro le persone per questo motivo - sembri stupido.

La maleducazione era reciproca. E il fatto che qualcuno non abbia dato qualcosa, non influisce sulla creazione di ciò che sta accadendo qui. Dove l'ho chiesto, ho già spiegato tutto e quella persona fa pubblicità su tutti i forum, non solo qui. La gente scrive che non ne può più.

Ora veniamo al punto.

Ho dato il link ieri ed è quasi la parte principale dell'indicatore, il suo punto forte, per così dire.

Cioè il numero di tick e la direzione del movimento del prezzo è determinato per lo stesso intervallo di tempo e sulla sua base si ottiene un segnale di trading. Cosa non è chiaro qui?

La cosa principale è non fare la media.

Così, dalla quantità di tick giudichiamo la volatilità, e dalla somma del delta per lo stesso intervallo di tempo (come hai scritto correttamente sopra, il delta è la differenza dei prezzi tra tick successivi) giudichiamo la direzione del movimento dei prezzi, cioè la tendenza. E il delta può essere negativo o positivo. Sommiamo quello che abbiamo.

In effetti, per calcolare questo indicatore e per funzionare, abbiamo bisogno e abbiamo bisogno solo di un numero N di ultimi tick. Scrivere le zecche nella storia non è veramente necessario, tranne che per i test.

Gli analoghi esistenti di questo indicatore sono progettati come un tachimetro.

 
new-rena:

Riguardo alla maleducazione - era reciproca. E il fatto che qualcuno non abbia dato qualcosa, non ha alcun effetto sulla creazione di ciò che sta succedendo qui. Dove l'ho chiesto, ho già spiegato tutto e quell'uomo fa pubblicità su tutti i forum, non solo qui. La gente scrive che non ne può più.

Ora veniamo al punto.

Ho postato il link qui ieri, quindi questa è praticamente la parte principale dell'indicatore, il suo clou, per così dire.

Cioè il numero di tick e la direzione del movimento del prezzo sono determinati per lo stesso intervallo di tempo e sulla sua base si ottiene un segnale di trading. Cosa non è chiaro qui?

La cosa principale è non fare la media.

Così, dalla quantità di tick giudichiamo la volatilità, e dalla somma del delta per lo stesso intervallo di tempo (come hai scritto correttamente sopra, il delta è la differenza dei prezzi tra tick successivi) giudichiamo la direzione del movimento dei prezzi, cioè la tendenza. E il delta può essere negativo o positivo. Sommiamo quello che abbiamo.

In effetti, per calcolare questo indicatore e per funzionare, abbiamo bisogno e abbiamo bisogno solo di un numero N di ultimi tick. Scrivere le zecche nella storia non è davvero necessario, forse solo per un test.

Gli analoghi esistenti di un tale indicatore sono sotto forma di un tachimetro.

È questo il link? https://www.mql5.com/ru/forum/61389/page30#comment_1776762

ZS. Riguardo alla maleducazione reciproca - sei tu per niente. Non sono stato scortese con te per primo.

Импульс
Импульс
  • www.mql5.com
Форум по трейдингу, автоматическим торговым системам и тестированию торговых стратегий. - Страница 30 - Категория: автоматические торговые системы
 
Artyom Trishkin:

È questo il link? https://www.mql5.com/ru/forum/61389/page30#comment_1776762

ZS. Ti sbagli sulla maleducazione reciproca. Non sono stato scortese con te per primo.

Sì, ma questo è in 4 pezzi. Da quello che ho capito facciamo in 5.
 
Karputov Vladimir:

La base per registrare le zecche è lì.


Formato del nome del file:

Ci sono quattro colonne nel file:


Rimane la questione di quanto spesso debbano essere avviati nuovi file. Penso che ogni ora si dovrebbe avviare ogni file. Sarà più facile da analizzare.

aggiungere High, Low (o contare immediatamente i cambiamenti di prezzo) - quando si perde un tick (per ragioni tecniche) essi cambiano... cioè è possibile una situazione in cui all'interno di M1 Bid è sceso, e High è salito

Penso che succeda durante gli impulsi e quando il terminale/computer sta lavorando su qualcos'altro :-)

 
Karputov Vladimir:

C'è stata una registrazione di 600 zecche. Questo record (100 ciascuno) è stato distribuito su sei classifiche. I grafici mostrano il prezzo e il tasso di variazione dei tick (EMA10). Tutto sommato c'è un motivo per studiare le cifre:







stai guardando un po', cioè per niente... sui grafici hai una specie di funzione di errore di differenziazione. Cioè, prima leggi la velocità come derivata (dx/dt), poi la integri (con un metodo diverso) e la confronti con l'originale.

suggerimento: qualsiasi MA è di fatto una funzione integrale

suggerimento2: per vedere se ti stai muovendo nella giusta direzione - prendi una semplice SMA e spostala indietro di mezzo periodo. Se vedi qualcosa di utile nella storia, significa che la velocità e lo slancio sono contati per una ragione e puoi scavare più a fondo

 
new-rena:
Sì, ma è scritto in 4 pezzi. Da quello che ho capito facciamo in 5.

Non fa differenza quale piattaforma usare. Ho chiesto a Roman lì, e gli ho scritto dei codici in privato, ma non sono riuscito a capire perché imposta la dimensione dell'array a due milioni in init(), poi ridimensiona l'array a zero in start(), poi cerca di riempirlo con indice -1 (!!!), e solo dopo aumenta la variabile SIZE di 1, che dovrebbe indicizzare l'array. Confronta, questo è quello che ho suggerito:

//+------------------------------------------------------------------+
//|                                                   FillArrays.mq4 |
//|              Copyright 2015, Artem A. Trishkin, Skype artmedia70 |
//|                       https://login.mql5.com/ru/users/artmedia70 |
//+------------------------------------------------------------------+
#property copyright "Copyright 2015, Artem A. Trishkin, Skype artmedia70"
#property link      "https://login.mql5.com/ru/users/artmedia70"
#property version   "1.00"
#property strict
//+------------------------------------------------------------------+
//|   Input variables                                                |
//+------------------------------------------------------------------+
input int NumberOfStorableTicks=20;       // Количество сохраняемых тиков
int numberOfStorableTicks; // Количество сохраняемых тиков
input int PeriodOfMA=5;                   // Период сглаживания
int periodOfMA; // Период сглаживания
input ENUM_MA_METHOD MaMethod=MODE_SMA;   // Метод усреднения МА

//+------------------------------------------------------------------+
//|   Global variables                                               |
//+------------------------------------------------------------------+
string symbol;    // Symbol()
int digits;       // Digits
//+------------------------------------------------------------------+
//|   Arrays                                                         |
//+------------------------------------------------------------------+
double      Mass_ticks[];
double      Mass_smoothed_values[];
//+------------------------------------------------------------------+
//|   Structures                                                     |
//+------------------------------------------------------------------+
   MqlTick struct_tick;
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//---
   symbol=Symbol();
   digits=(int)SymbolInfoInteger(symbol,SYMBOL_DIGITS);
   //---
   numberOfStorableTicks=(NumberOfStorableTicks<1)?1:NumberOfStorableTicks;
   periodOfMA=(PeriodOfMA<1)?1:PeriodOfMA;
   //---
   ArrayResize(Mass_ticks,numberOfStorableTicks);
   ArrayInitialize(Mass_ticks,0.0);
   ArrayResize(Mass_smoothed_values,numberOfStorableTicks);
   ArrayInitialize(Mass_smoothed_values,0.0);
//---
   return(INIT_SUCCEEDED);
  }
//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
//---
   Comment("");
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//---
   if(SymbolInfoTick(symbol,struct_tick)) {
      double tick_bid=struct_tick.bid;
      FillArrays(numberOfStorableTicks,tick_bid,Mass_ticks);
      }
   string txt="";
   for(int i=numberOfStorableTicks-1; i>=0; i--) {
      string itxt=IntegerToString(i);
      txt+="\nmass["+itxt+"]: "+DoubleToString(Mass_ticks[i],digits);
      }
   Comment(txt);
  }
//+------------------------------------------------------------------+
void FillArrays(int array_size, double price, double &mass_price[]) {
   //--- сместим данные в массиве влево
   for(int i=array_size-1; i>0; i--) {
      mass_price[i]=mass_price[i-1];
      }
   //--- запишем новый тик в массив
   mass_price[0]=price;
}
//+------------------------------------------------------------------+
void SmoothingDataArray(int array_size, int ma_period, int ma_shift, ENUM_MA_METHOD ma_method, double &mass_price[], double &mass_smoothing[]) {
   for(int i=array_size-1; i>=0; i--) {
      mass_smoothing[i]=iMAOnArray(mass_price,array_size,ma_period,ma_shift,ma_method,i);
      }
   }
//+------------------------------------------------------------------+

Tuttavia, iMAOnArray() si rifiuta di smussarlo. Non importa quanto sia contorto, è avanti e indietro. Ma non è necessario per lo scopo previsto qui. Immagino...

Sì, ho dimenticato. Questo è quello che ha suggerito Roman:

//---------------------
extern int MaxDrawTicks=100;
extern int Num_Aver_of_Ticks=5;  
double     xBuffer_Time []; // Массив значений   динамический
                            // В котором индекс - номер тика, значение - это бид 
int SIZE=0;                 // Вспомогательная переменная для массива                                  
int tickCounter, tickCounter_Current; 
//+------------------------------------------------------------------+
int init()
  {   
//--- устанавливаем размер динамического массива
   if(ArrayResize(xBuffer_Time,2000000)<0) {Alert(" Ошибка в изменении размера массива времени поступления тиков "); return(false);}
//--- установим индексацию для буфера как в таймсерии для динамического массива
  // ArraySetAsSeries(xBuffer_Time,true);    
//---   Возвращает количество элементов указанного массива. 
   int S=ArraySize(xBuffer_Time);
   if (S>=0) Alert("Размер массива: ",S);
   else Print("Ошибка. Массив не создан ",S);        
   ArrayInitialize(xBuffer_Time, 0);
   return(0);
  }  
//+------------------------------------------------------------------+
int start()
  {  
   //ArrayResize(ValueArr,size);
   //ValueArr[size-1] = GetValue();
   //size++; 
 //----------------------------------------  
   ArrayResize(xBuffer_Time,SIZE);
   xBuffer_Time[SIZE-1] = Bid; //NormalizeDouble((iTime (_Symbol,1,0)-_start), 2); 
  
   if ( SIZE >= 0 && ArraySize(xBuffer_Time) < 2147483647)
      {
      Alert (" Значение xBuffer_Time[SIZE-1] = ", DoubleToStr(xBuffer_Time[SIZE-1],Digits) );
      Alert (" Значение SIZE = ", DoubleToStr(SIZE,2) );  
      } 
    SIZE ++;   
 //---------------------------------------      
//------------
   return(0);
  }
 
Artyom Trishkin:

Proverò un tableau:

tick 10
tick 9
tick 8
tick 7
tick 6
tick 5
tick 4
tick 3 tick 2
tick 1 tick 0
Futuro ticchettio
X10
X9
X8
X7
X6
X5
X4
X3
X2
X1X0
XN0
X9X8
X7X6X5
X4X3
X2
X1
X0XN0
XN1

x0, x1, x2 definiscono lo stato attuale (rosa), il resto definisce lo stato passato (verde chiaro). I dati nella matrice si spostano costantemente, e il nuovo arrivato xn0 prende il posto dello zero tick. Così ora lo stato attuale sarà contato da x1, x0, xn0, e il tick x2 dell'ultima volta è spostato nelle celle che definiscono lo stato precedente, facendo una piccola correzione per quello stato. Se contiamo tutto insieme, allora tutte le prime tre zecche saranno corrette, il che mi sembra piuttosto rozzo.

C'è qualcosa di vero. Ecco uno screenshot del grafico in tick:

Schermata di un grafico a tick

Notate l'area racchiusa dalle grandi frecce.

Ed ecco l'elaborazione della condizione quando l'incremento medio dei tick (tick0, tick1, tick2) è maggiore dell'incremento medio (tick3, tick4, tick5, tick6, tick7, tick8, tick9, tick10) e l'incremento è maggiore di zero:

Elaborazione della condizione

 
Artyom Trishkin:

Non fa differenza quale piattaforma usare. Ho chiesto a Roman lì, e gli ho scritto dei codici in privato, ma non sono riuscito a capire perché imposta la dimensione dell'array a due milioni in init(), poi ridimensiona l'array a zero in start(), poi cerca di riempirlo con indice -1 (!!!), e solo dopo aumenta la variabile SIZE di 1, che dovrebbe indicizzare l'array. Confronta, questo è quello che ho suggerito:

Tuttavia, iMAOnArray() si rifiuta di smussarlo. Non importa quanto duramente lo giri, va avanti e indietro. Ma non è necessario per gli scopi previsti qui. Immagino...

OK. E dov'è l'analisi dell'intervallo di tempo nel tuo codice e perché è apparsa la MA?

Anch'io ho trovato un bug nella mia cosa. Non è lo stesso numero di tic durante uno stesso intervallo di tempo. Non dovremmo perdere un tale indicatore.

Forse mi sbaglio, visto che non ho ancora usato 5-Rka per molto tempo.

1...252627282930313233343536373839...48
Nuovo commento