Indicatore Domanda - pagina 3

Nuovo commento
 
Agent86:
.

Comunque, stavo cercando di fare in modo che i frattali alti si formino solo quando si verifica un'altra condizione come gli incroci di iMACD, o gli incroci di EMA o qualche altro indicatore.
In modo che i frattali vengano visualizzati sull'indicatore solo quando tutte le condizioni sono soddisfatte.


Non ero sicuro di quello che stavate cercando di fare, ma provate questo, notate gli ingressi esterni.

#property indicator_chart_window      extern bool condition1 = true;
#property indicator_buffers 3         extern bool condition2 = true;
#property indicator_color1 Red
#property indicator_color2 Blue
#property indicator_color3 White

//---- buffers
double v1[];
double v2[];
double v3[];
double val1;
double val2;
double val3;
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int init()
  {
//----
   IndicatorBuffers(3);

   SetIndexArrow(0, 111);
   SetIndexStyle(0,DRAW_ARROW,STYLE_DOT,1,Blue);
   SetIndexBuffer(0, v1);
   SetIndexLabel(0,"Resistance");

   SetIndexArrow(1, 111);
   SetIndexStyle(1,DRAW_ARROW,STYLE_DOT,1,Red);
   SetIndexBuffer(1, v2);
   SetIndexLabel(1,"Support");

   SetIndexArrow(2, 111);
   SetIndexStyle(2,DRAW_ARROW,STYLE_DOT,1,White);
   SetIndexBuffer(2, v3);
   SetIndexLabel(2,"High A"); 
//----
   return(0);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int start()
  {
    
   double   faster = iMACD(NULL,0,12,26,9,PRICE_CLOSE,MODE_MAIN,1), //MODE_MAIN
            slower = iMACD(NULL,0,12,26,9,PRICE_CLOSE,MODE_SIGNAL,1); //MODE_SIGNAL
           
            
   int bars = Bars;
//----
  
   for(int i=bars; i>=0; i--)
    {
     if(condition1)
       {
        val1=iFractals(NULL, 0, MODE_UPPER,i);
        if (val1 > 0) v1[i]=High[i];       
       }   
     if(condition2)
       {      
        val2=iFractals(NULL, 0, MODE_LOWER,i);
        if (val2 > 0) v2[i]=Low[i];
       }
     }    
//----
   return(0);
  }
//+------------------------------------------------------------------+
 
WHRoeder:
Esattamente come sei arrivato a questa conclusione e qual è la differenza funzionale?

Sono arrivato a questa conclusione, perché probabilmente, stavo guardando da prospettive OOP. sì, questo non è vero per il caso di MQL4, ora ricordo. Anche se può essere una buona pratica?



 

O forse qualcosa del genere?

dovresti davvero usare IndicatorCounted(), perché se lo fai così il tuo indicatore sta ridisegnando tutti quegli oggetti ad ogni nuovo tick invece di disegnarli tutti una sola volta e aggiungerne di nuovi quando si formano nuove barre 

#property indicator_chart_window
#property indicator_buffers 3
#property indicator_color1 Red
#property indicator_color2 Blue
#property indicator_color3 White

//---- buffers
double v1[];
double v2[];
double v3[];
double val1;
double val2;
double val3;
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int init()
  {
//----
   IndicatorBuffers(3);

   SetIndexArrow(0, 111);
   SetIndexStyle(0,DRAW_ARROW,STYLE_DOT,1,Blue);
   SetIndexBuffer(0, v1);
   SetIndexLabel(0,"Resistance");

   SetIndexArrow(1, 111);
   SetIndexStyle(1,DRAW_ARROW,STYLE_DOT,1,Red);
   SetIndexBuffer(1, v2);
   SetIndexLabel(1,"Support");

   SetIndexArrow(2, 111);
   SetIndexStyle(2,DRAW_ARROW,STYLE_DOT,1,White);
   SetIndexBuffer(2, v3);
   SetIndexLabel(2,"High A"); 
//----
   return(0);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int start()
  {
    
   double   faster=0;
   double   slower=0;         
   int      bars = Bars;
//----
  
   for(int i=bars; i>=0; i--)
    {
     faster = iMACD(NULL,0,12,26,9,PRICE_CLOSE,MODE_MAIN,i); //MODE_MAIN
     slower = iMACD(NULL,0,12,26,9,PRICE_CLOSE,MODE_SIGNAL,i); //MODE_SIGNAL
     val1=iFractals(NULL, 0, MODE_UPPER,i);
     val2=iFractals(NULL, 0, MODE_LOWER,i);
     
     if(faster > 0)
      {
       if (val1 > 0) v1[i]=High[i];
      }
      
     if(faster < 0)
      {
       if (val2 > 0) v2[i]=Low[i];
      }        
    }   
//----
   return(0);
  }
//+------------------------------------------------------------------+
 
diostar:
Sono arrivato a questa conclusione, perché probabilmente, stavo guardando da prospettive OOP. sì, questo non è vero per il caso di MQL4, ora ricordo. Anche se può essere una buona pratica?

È sempre una buona pratica limitare l'ambito. è sempre una buona pratica definire la variabile/oggetto dove viene usata e inizializzarla a quel punto.

La definizione di un oggetto al di fuori del ciclo si traduce in una costruzione predefinita più N assegnazioni. Definito all'interno del ciclo risulta in N costruzioni con valore - di solito più veloce.

Non preoccupatevi mai delle ottimizzazioni finché non potete dimostrare che il cambiamento fa la differenza.

 
WHRoeder:

È sempre una buona pratica limitare l'ambito. è sempre una buona pratica definire la variabile/oggetto dove viene usata e inizializzarla in quel punto.

La definizione di un oggetto al di fuori del ciclo si traduce in una costruzione predefinita più N assegnazioni. Definito all'interno del ciclo risulta in N costruzioni con valore - di solito più veloce.

Non preoccupatevi mai delle ottimizzazioni finché non potete dimostrare che il cambiamento fa la differenza.

Questo dovrebbe valere anche per il suo iteratore. for (int i=0;. ..
 
diostar:
Questo dovrebbe applicarsi anche al suo iteratore. for (int i=0;. ..
Sono d'accordo, ma non ho scritto quel codice.
 
Ok, mi sembra di avere alcune varianti di un codice funzionante ora grazie.

Anche se sono leggermente confuso sul perché la dichiarazione delle variabili (più veloce e più lenta) fuori dal ciclo non va bene mentre va bene dentro il ciclo

E ancora l'int i = Bars funzionerà fuori dal ciclo o dentro il ciclo?


Comunque è bello vedere che alcune delle mie idee su cui stavo lavorando sono già state postate in questo thread, quindi questa è una buona notizia e significa che mi sto avvicinando un po' di più al fatto che un giorno sarò in grado di scrivere qualcosa per conto mio. Quindi un piccolo progresso è meglio di niente. Grazie

Così ora posso lavorare sul confronto di alcuni dei tempi dell'indicatore, cercherò di capire questo ora.

Ad esempio:
Confronta v1[i] a v2[i] Indicatore attualmente formato Tempi && / || if(v1[i] tempo è > v2[i] tempo) e altri confronti come questo.

Grazie per tutti i suggerimenti, è stato di grande aiuto.
 
WHRoeder:

È sempre una buona pratica limitare l'ambito. è sempre una buona pratica definire la variabile/oggetto dove viene usata e inizializzarla in quel punto.

La definizione di un oggetto al di fuori del ciclo si traduce in una costruzione predefinita più N assegnazioni. Definito all'interno del ciclo risulta in N costruzioni con valore - di solito più veloce.

Non preoccupatevi mai delle ottimizzazioni finché non potete dimostrare che il cambiamento fa la differenza.

Presumo che questo sia vero per tutti, e non solo per gli indicatori / indicatori personalizzati?
 
Agent86:
Ok, mi sembra di avere alcune variazioni di un codice funzionante ora, grazie.

Anche se sono leggermente confuso sul perché la dichiarazione delle variabili (più veloce e più lenta) al di fuori del ciclo non va bene mentre va bene all'interno del ciclo

E ancora l'int i = Bars funzionerà fuori dal ciclo o dentro il ciclo?


Devi considerare cosa stai facendo, quando crei un indicatore stai applicando il tuo codice ad ogni singola barra del grafico, questo significa che hai bisogno di ottenere il valore dell'indicatore macd come era per ognuna di quelle barre storiche.

Nel tuo codice originale l'hai fatto:

double   faster = iMACD(NULL,0,12,26,9,PRICE_CLOSE,MODE_MAIN,1),
l'ultimo parametro 1 è il valore del macd come era alla barra 1 del grafico, la barra precedente a quella attuale che è indicizzata come barra 0

Ovviamente non vuoi usare quel singolo valore del macd nel tuo operatore condizionale su tutto il grafico storico.

Hai bisogno di indicizzare il macd allo stesso indice di barra di ogni barra, quindi per esempio alla barra 500 hai bisogno di questo

faster = iMACD(NULL,0,12,26,9,PRICE_CLOSE,MODE_MAIN,500)

l'ultimo parametro deve cambiare per corrispondere al numero della barra a cui il tuo indicatore sta applicando i suoi algoritmi.

Questo è il motivo per cui ne hai bisogno all'interno del ciclo, così puoi usare l'iteratore del ciclo del ciclo ( i ) per l'ultimo parametro e quindi ottieni il tuo valore macd come era per ogni barra del grafico storico.

faster = iMACD(NULL,0,12,26,9,PRICE_CLOSE,MODE_MAIN,i),

Spero che questo aiuti a chiarire un po' le cose.

 
WHRoeder:
Prova questo cambiamento
Perché for(int i = Bars-1 ?

E perché questo è meglio di for(int i = Bars?

Si prega di consigliare grazie

12345678
Nuovo commento