Skip to content
TheChatArchiveThe Chat Archive
gpt-4-1106-preview· openaiHugging Face Suzhen/CodeChat

questo indicatore mt4 non ha errori, eppure non disegna lo stocastico nel grafico…

  1. User

    questo indicatore mt4 non ha errori, eppure non disegna lo stocastico nel grafico separato e neppure le frecce sul grafico principale. sai dirmi perchè? //+------------------------------------------------------------------+ //| MTF Stochastic.mq4 | //| 2007, Christof Risch (iya) | //| Stochastic indicator from any timeframe. | //+------------------------------------------------------------------+ // Change Log: // 2.1 2012 07 24 Modified to display only the Signal line (smoothed sma) // cr: 2012 07 20 Added NextHigherAuto to automatically seletc the next higher time frame // Added HidePctD to suppress the Slow line, prn

    #property link "http://www.forexfactory.com/showthread.php?t=30109" #property indicator_separate_window #property indicator_buffers 6 #property indicator_color1 Green //C'255,255,255' // White // %K line #property indicator_color2 Red //Yellow // DimGray // %D line #property indicator_color3 Green // C'255,255,255' // White // %K line of the current candle #property indicator_color4 Red //Yellow // DimGray // %D line of the current candle #property indicator_level1 80 #property indicator_level2 20 #property indicator_level3 50 #property indicator_levelcolor DarkSlateGray #property indicator_maximum 100 #property indicator_minimum 0

    //---- input parameters extern bool NextHigherAuto = true; extern bool HidePctK = false; extern bool HidePctD = false; extern int TimeFrame = 0, // {1=M1, 5=M5, 15=M15, ..., 1440=D1, 10080=W1, 43200=MN1} KPeriod = 11, DPeriod = 3, Slowing = 3, MAMethod = 0, // {0=SMA, 1=EMA, 2=SMMA, 3=LWMA} PriceField = 0; // {0=Hi/Low, 1=Close/Close} extern bool ShowClock = false; // display time to candle close countdown extern color ClockColor = Red;

    //---- indicator buffers double BufferK[], BufferD[], BufferK_Curr[], BufferD_Curr[];

    double ArrowUpBuffer[]; double ArrowDownBuffer[]; //---- string IndicatorName = "", TimeLabelName = "";

    //+------------------------------------------------------------------+ //| Custom indicator initialization function | //+------------------------------------------------------------------+ int init() { if ( TimeFrame == 0 ) TimeFrame = Period(); if ( NextHigherAuto ) TimeFrame = GetHigherTimeFrame( TimeFrame ) ; //---- name for DataWindow and indicator subwindow label switch(TimeFrame) { case 1: IndicatorName="Period M1"; break; case 5: IndicatorName="Period M5"; break; case 15: IndicatorName="Period M15"; break; case 30: IndicatorName="Period M30"; break; case 60: IndicatorName="Period H1"; break; case 240: IndicatorName="Period H4"; break; case 1440: IndicatorName="Period D1"; break; case 10080: IndicatorName="Period W1"; break; case 43200: IndicatorName="Period MN1"; break; default: {TimeFrame = Period(); init(); return(0);} }

    IndicatorName = IndicatorName+" Stoch("+KPeriod+","+DPeriod+","+Slowing+")";
    IndicatorShortName(IndicatorName);  
    IndicatorDigits(1);
    

    string TimeFrameStr = TF2Str(TimeFrame);

    //---- indicator lines SetIndexBuffer(0,BufferK); SetIndexBuffer(1,BufferD); SetIndexBuffer(2,BufferK_Curr); SetIndexBuffer(3,BufferD_Curr); SetIndexStyle(0,DRAW_LINE,EMPTY,1); //SetIndexStyle(0,DRAW_NONE); SetIndexStyle(2,DRAW_LINE,EMPTY,1); //SetIndexStyle(2,DRAW_NONE); if ( ! HidePctK ) { SetIndexStyle(0,DRAW_LINE,EMPTY,1); SetIndexStyle(2,DRAW_LINE,EMPTY,1); SetIndexLabel(0,TimeFrameStr+" %K line"); SetIndexLabel(2,TimeFrameStr+" %K CurrBar"); } else { SetIndexStyle(0,DRAW_NONE); SetIndexStyle(2,DRAW_NONE); SetIndexLabel(0,NULL); SetIndexLabel(2,NULL); }

    if ( ! HidePctD ) { SetIndexStyle(1,DRAW_LINE,EMPTY,1); SetIndexStyle(3,DRAW_LINE,EMPTY,1); SetIndexLabel(1,TimeFrameStr+" %D Signal"); SetIndexLabel(3,TimeFrameStr+" %D CurrBar"); } else { SetIndexStyle(1,DRAW_NONE); SetIndexStyle(3,DRAW_NONE); SetIndexLabel(1,NULL); SetIndexLabel(3,NULL); } // Aggiunta dei nuovi buffer per le frecce SetIndexBuffer(4, ArrowUpBuffer); SetIndexArrow(4, SYMBOL_ARROWUP); // Parametro per l’icona freccia verso l’alto (puoi usare l’icona che preferisci) SetIndexStyle(4, DRAW_ARROW); SetIndexLabel(4, "Stochastic Arrow Up"); ArraySetAsSeries(ArrowUpBuffer, true);

    SetIndexBuffer(5, ArrowDownBuffer); SetIndexArrow(5, SYMBOL_ARROWDOWN); // Parametro per l’icona freccia verso il basso SetIndexStyle(5, DRAW_ARROW); SetIndexLabel(5, "Stochastic Arrow Down"); ArraySetAsSeries(ArrowDownBuffer, true);

    } //+------------------------------------------------------------------+ int deinit() { if(TimeLabelName!="") if(ObjectFind (TimeLabelName) != -1) ObjectDelete(TimeLabelName); }

    //+------------------------------------------------------------------+ //| MTF Stochastic | //+------------------------------------------------------------------+ int start() { //---- // counted bars from indicator time frame static int countedBars1 = 0;

    //---- // counted bars from display time frame if(Bars-1-IndicatorCounted() > 1 && countedBars1!=0) countedBars1 = 0;

    int bars1 = iBars(NULL,TimeFrame),
    	 start1 = bars1-1-countedBars1,
    	 limit1 = iBarShift(NULL,TimeFrame,Time[Bars-1]);
    
    if(countedBars1 != bars1-1)
    {
    	countedBars1  = bars1-1;
    	ArrayInitialize(BufferK_Curr,EMPTY_VALUE);
    	ArrayInitialize(BufferD_Curr,EMPTY_VALUE);
    	if(TimeLabelName!="")
    	if(ObjectFind	(TimeLabelName) != -1)
    		ObjectDelete(TimeLabelName);
    }
    
    if(start1 > limit1 && limit1 != -1)
    	start1 = limit1;
    

    ArrayInitialize(ArrowUpBuffer, EMPTY_VALUE); ArrayInitialize(ArrowDownBuffer, EMPTY_VALUE); //---- // 3... 2... 1... GO! for(int i = start1; i >= 0; i--) { int shift1 = i;

    	if(TimeFrame < Period())
    		shift1 = iBarShift(NULL,TimeFrame,Time[i]);
    
    	int time1  = iTime    (NULL,TimeFrame,shift1),
    		 shift2 = iBarShift(NULL,0,time1);
    
    	double stochK = iStochastic(NULL,TimeFrame,KPeriod,DPeriod,Slowing,MAMethod,PriceField,0,shift1),
    			 stochD = iStochastic(NULL,TimeFrame,KPeriod,DPeriod,Slowing,MAMethod,PriceField,1,shift1);
    
    //----
    //	old (closed) candles
    	if(shift1>=1)
    	{
    		BufferK[shift2] = stochK;
    		BufferD[shift2] = stochD;
    	}
    
    //----
    //	current candle
    	if((TimeFrame >=Period() && shift1<=1)
    	|| (TimeFrame < Period() &&(shift1==0||shift2==1)))
    	{
    		BufferK_Curr[shift2] = stochK;
    		BufferD_Curr[shift2] = stochD;
    	}
    
    //----
    //	linear interpolatior for the number of intermediate bars, between two higher timeframe candles.
    	int n = 1;
    	if(TimeFrame > Period())
    	{
    		int shift2prev = iBarShift(NULL,0,iTime(NULL,TimeFrame,shift1+1));
    
    		if(shift2prev!=-1 && shift2prev!=shift2)
    			n = shift2prev - shift2;
    	}
    
    //----
    //	apply interpolation
    	double factor = 1.0 / n;
    	if(shift1>=1)
    	if(BufferK[shift2+n]!=EMPTY_VALUE && BufferK[shift2]!=EMPTY_VALUE)
    	{
    		for(int k = 1; k < n; k++)
    		{
    			BufferK[shift2+k] = k*factor*BufferK[shift2+n] + (1.0-k*factor)*BufferK[shift2];
    			BufferD[shift2+k] = k*factor*BufferD[shift2+n] + (1.0-k*factor)*BufferD[shift2];
    		}
    	}
    
    //----
    //	current candle
    	if(shift1==0)
    	if(BufferK_Curr[shift2+n]!=EMPTY_VALUE && BufferK_Curr[shift2]!=EMPTY_VALUE)
    	{
    		for(k = 1; k < n; k++)
    		{
    			BufferK_Curr[shift2+k] = k*factor*BufferK_Curr[shift2+n] + (1.0-k*factor)*BufferK_Curr[shift2];
    			BufferD_Curr[shift2+k] = k*factor*BufferD_Curr[shift2+n] + (1.0-k*factor)*BufferD_Curr[shift2];
    		}
    
    	//----
    	//	candle time countdown
    		if(ShowClock)
    		{
    			int m,s;
    
    			s = iTime(NULL,TimeFrame,0)+TimeFrame*60 - TimeCurrent();
    			m = (s-s%60)/60;
    			s = s%60;
    
    			string text;
    			if(s<10)	text = "0"+s;
    			else		text = ""+s;
    			text = "            "+m+":"+text;
    
    			int window = WindowFind(IndicatorName);
    			if(window==-1)
    				window = WindowOnDropped() ;
    
    			TimeLabelName = IndicatorName+" Time Counter "+window;
    
    			if(ObjectFind	(TimeLabelName) == -1)
    				ObjectCreate(TimeLabelName, OBJ_TEXT, window, Time[shift2], BufferK_Curr[shift2]+3);
    			else
    				ObjectMove	(TimeLabelName, 0, Time[shift2], BufferK_Curr[shift2]+3);
    
    			ObjectSetText	(TimeLabelName, text, 8, "Verdana", ClockColor);
    		}
    	}
    }
    

    // Rileva gli incroci e disegna le frecce for(int j = Bars - countedBars1 - 1; j >= 0; j--) { if(j == 0) continue; // Saltare la barra corrente

    double currentK = BufferK_Curr[j];
    double currentD = BufferD_Curr[j];
    double previousK = BufferK_Curr[j + 1];
    double previousD = BufferD_Curr[j + 1];
    
    // Incrocio dal basso verso l’alto
    if(previousK < previousD && currentK > currentD) {
        ArrowUpBuffer[j] = Low[j] - (4 * Point); // Regola il valore in base alla tua necessità dello spazio tra la freccia e il prezzo
    }
    
    // Incrocio dall’alto verso il basso
    if(previousK > previousD && currentK < currentD) {
        ArrowDownBuffer[j] = High[j] + (4 * Point); // Regola il valore in base alla tua necessità dello spazio tra la freccia e il prezzo
    }
    

    }

    return(0); }

    string TF2Str(int iPeriod) { switch(iPeriod) { case PERIOD_M1: return("M1"); case PERIOD_M5: return("M5"); case PERIOD_M15: return("M15"); case PERIOD_M30: return("M30"); case PERIOD_H1: return("H1"); case PERIOD_H4: return("H4"); case PERIOD_D1: return("D1"); case PERIOD_W1: return("W1"); case PERIOD_MN1: return("MN1"); default: return("M"+iPeriod); } return(0); }

    int GetHigherTimeFrame(int CurrentPeriod ) { if ( CurrentPeriod == 0 ) CurrentPeriod = Period(); if( CurrentPeriod == 1 ) { return(5); } else if( CurrentPeriod == 5 ) { return(15); } else if( CurrentPeriod == 15 ) { return(30); } else if( CurrentPeriod == 30 ) { return(60); } else if( CurrentPeriod == 60 ) { return(240); } else if( CurrentPeriod == 240 ) { return(1440); } else if( CurrentPeriod == 1440 ) { return(10080); } else if( CurrentPeriod == 10080 ) { return(43200); } else if( CurrentPeriod == 43200 ) { return(43200); } } // int GetHigherTimeFrame()

  2. Assistant

    Dal codice fornito, non sembra esserci un errore evidente che potrebbe causare il mancato disegno dello stocastico o delle frecce. Tuttavia, ci potrebbero essere varie ragioni per cui i risultati attesi non si verificano. Ecco alcuni punti che potresti considerare per risolvere il problema:

    1. Valori EMPTY_VALUE: Assicurati che i buffer BufferK, BufferD, BufferK_Curr, BufferD_Curr, ArrowUpBuffer e ArrowDownBuffer siano correttamente popolati per ciascuna barra. Se ci sono dei valori EMPTY_VALUE, questi non saranno visualizzati.

    2. Indicatore Conteggio Barre: Controlla se il calcolo per countedBars1 è corretto e assicurati che i buffer siano riconteggiati correttamente ad ogni tick nuovo o ad ogni aggiornamento del grafico.

    3. Controllo del Flusso nel Ciclo: Verifica che il ciclo for per disegnare le frecce abbia l'indice giusto e che i buffer delle frecce vengano impostati correttamente.

    4. Confronto dei Valori nel Buffer: Per la logica di rilevamento degli incroci, assicurati che i valori di BufferK_Curr e BufferD_Curr siano stati calcolati correttamente.

    5. Verifica dei Periodi: Il tuo codice gestisce diversi timeframe e fa affidamento su Period() e TimeFrame per determinare correttamente i valori dello stocastico. Accertati che i periodi usati nelle funzioni iStochastic e iBarShift siano quelli che ti aspetti.

    6. Compilazione: Prova a ricompilare il codice su MT4 per essere sicuro che stia eseguendo l'ultima versione del tuo script senza warning o errori.

    7. Impostazioni Grafiche: Assicurati che le impostazioni grafiche dell'indicatore come SetIndexStyle e SetIndexArrow siano corrette e che i colori scelti siano visibili sul grafico.

    8. Visibilità di Stili e Oggetti: Potrebbe succedere che se gli stili sono settati su DRAW_NONE, questi non verranno mostrati. Inoltre, verifica che l'altezza delle frecce sia sufficientemente distante dal prezzo per essere visibile.

    9. Valore di Point: Quando regoli la posizione delle frecce con ArrowUpBuffer[j] = Low[j] - (4 * Point); e ArrowDownBuffer[j] = High[j] + (4 * Point);, assicurati che il valore di Point sia corretto per il simbolo corrente e che la distanza sia adeguata.

    Se dopo aver controllato questi aspetti l'indicatore non funziona ancora correttamente, potrebbe essere utile eseguire il debug passo dopo passo o visualizzare dei messaggi di log nella finestra dell'esperto per avere ulteriori informazioni sullo stato dei calcoli e dei buffer.

  3. User

    hai tutto il codice, controlla tu

  4. Assistant

    Chiedo scusa per l'inconveniente. Ho esaminato nuovamente il codice che hai condiviso. Ho notato che nella tua implementazione, due buffer dell'indicatore sono inizialmente impostati con lo stile DRAW_LINE, ma successivamente, a seconda del valore di HidePctK e HidePctD, lo stile può essere impostato su DRAW_NONE, il che potrebbe effettivamente nascondere le linee dell'oscillatore Stocastico all'interno del grafico separato.

    Per quanto riguarda le frecce, il codice per le frecce sembra corretto. Tuttavia, ci sono alcune considerazioni da tenere a mente:

    1. Presenza di un continue; inappropriato nel ciclo: Un continue; all'inizio della sezione di rilevamento delle intersezioni può causare la mancata valutazione della prima barra dopo l'ultima barra conteggiata, ma al di là di questo, non dovrebbe impedire la visualizzazione delle frecce.

    2. Pulizia dei buffer delle frecce: I buffer vengono ripuliti ad ogni chiamata della funzione start(), cosa che dovrebbe essere corretta ma potrebbe generare problemi se le condizioni per disegnare le frecce non si verificano nella barra più recente.

    3. init() viene chiamato all'interno di se stesso: Questa riga default: {TimeFrame = Period(); init(); return(0);} dentro lo switch-case potrebbe causare un ciclo di chiamate a init(), potenzialmente portando all'uscita precoce dal processo di inizializzazione. Una soluzione potrebbe essere di rimuovere la chiamata ricorsiva a init() e gestire la situazione in modo diverso.

    Con questi punti in considerazione, vorrei suggerire le seguenti correzioni nel codice e vedere se risolve il problema:

    1. Rimuovi la chiamata ricorsiva a init() e gestiscila piuttosto stabilendo un valore predefinito accettabile o notificando l'errore.

      Sostituisci:

      default: {TimeFrame = Period(); init(); return(0);}
      

      Con qualcosa del tipo:

      default: Print("TimeFrame non valido: " + TimeFrame); return(INIT_FAILED);
      
    2. Assicurati che le condizioni per disegnare le frecce non dipendano solo dalla barra corrente, ma anche dai dati storici disponibili. Ad esempio, se la logica attuale richiede che la condizione si verifichi nell'ultima barra disponibile, potrebbe essere necessario espandere questa logica per includere più barre.

    3. Verifica che il valore di Point sia congruente con il simbolo corrente nel grafico e che le linee e le frecce siano visibili.

    Inoltre, il seguente controllo nel ciclo delle frecce sembra essere non richiesto, a meno che non vogliate ignorare esplicitamente l'ultima barra (la barra 0, che è la barra corrente in costruzione):

    if(j == 0) continue; // Saltare la barra corrente
    

    Se vuoi controllare per la barra corrente, è meglio farlo all'interno del ciclo precedente dove gestisci sia le candele chiuse che la candela corrente.

    Se dopo aver esaminato e aggiornato queste aree del codice l'indicatore ancora non mostra le frecce né le linee dello stocastico come previsto, potrebbe essere utile inserire alcune istruzioni di stampa (Print()) per il debug, permettendo di visualizzare il flusso di esecuzione e i valori delle variabili durante l'esecuzione. Questo può aiutarti a individuare dove le aspettative non corrispondono ai risultati attuali.

  5. User

    può esserci un problema con i buffers?

  6. Assistant

    Ci potrebbe effettivamente essere un problema con i buffer dell'indicatore se non vengono gestiti correttamente. Ecco alcuni punti chiave da verificare:

    1. Buffer Initialization: Assicurati che tutti i buffer siano inizializzati correttamente. Nel codice fornito, i buffer BufferK, BufferD, BufferK_Curr e BufferD_Curr sono inizializzati nella funzione init(). I buffer delle frecce ArrowUpBuffer e ArrowDownBuffer sono anch'essi inizializzati nella funzione init(). Questo è corretto.

    2. Array as Series: I buffer dell'indicatore devono essere impostati come serie usando ArraySetAsSeries() prima di utilizzarli. Nel tuo codice, questa istruzione è presente per i buffer delle frecce, ma non per i buffer principali. Verifica se questo è intenzionale e, se necessario, aggiungi ArraySetAsSeries() anche per gli altri buffer, come segue:

      ArraySetAsSeries(BufferK, true);
      ArraySetAsSeries(BufferD, true);
      ArraySetAsSeries(BufferK_Curr, true);
      ArraySetAsSeries(BufferD_Curr, true);
      
    3. Operazioni di Assegnazione Buffer: Prima di utilizzare i buffer per tracciare i valori sul grafico, devi assegnarli correttamente. Nella funzione start(), i valori dello stocastico sono calcolati e assegnati ai buffer appropriati. Assicurati che questi valori siano assegnati correttamente e che le barre non siano contate più di una volta tra gli aggiornamenti.

    4. L'Uso di EMPTY_VALUE: I buffer sono spesso inizializzati con EMPTY_VALUE per evitare di disegnare dove non ci sono valori da tracciare. Il codice dovrebbe gestire opportunamente l'assegnazione di EMPTY_VALUE quando i valori non sono disponibili.

    5. Limiti di Indicizzazione dei Buffer: Assicurati di non accedere ai buffer al di fuori dei loro limiti, il che potrebbe causare errori o comportamenti inaspettati.

    6. Buffer Pulizia nel Posto Giusto: Nel tuo codice, c'è una pulizia dei buffer delle frecce con ArrayInitialize() all'inizio di start(). Questo azzera i buffer ad ogni tick, quindi le frecce tracciate potrebbero essere rimosse immediatamente. Per evitare ciò, la pulizia dei buffer dovrebbe essere eseguita in un punto appropriato, ad esempio solo quando è necessario inizializzare o ripulire prima di un riempimento.

    7. Validità delle Condizioni di Business Logic: Verifica che i tuoi buffer vengano riempiti correttamente in base alla logica di business che desideri implementare. Le condizioni che attivano la popolazione dei buffer delle frecce dovrebbero essere rispettate come previsto.

    Se dopo aver verificato e corretto questi aspetti, i buffer sembrano essere gestiti correttamente ma le linee e le frecce continuano a non apparire, dovresti utilizzare il debugger o inserire istruzioni di diagnostica (Print() o Comment()) per individuare dove i valori vengono persi o sovrascritti erroneamente. Questi messaggi possono fornire una visione dettagliata su quali buffer vengono popolati e quali valori contengono in tempo reale durante l'esecuzione dell'indicatore.

  7. User

    puoi verificarli tu, hai il codice. fallo grazie

  8. Assistant

    I buffer nell'indicatore sono dichiarati e configurati nella funzione init(). Sembra che manchi l'inizializzazione delle serie per i buffer principali BufferK, BufferD, BufferK_Curr, e BufferD_Curr. La mancata definizione come serie potrebbe portare a problemi di allineamento quando i buffer vengono aggiornati e potrebbe causare il mancato disegno nel grafico.

    Per risolvere questo, devi aggiungere ArraySetAsSeries() immediatamente dopo la definizione di ciascun buffer nell'indicatore init() per assicurare la corretta indicizzazione dei buffer. Il codice modificato nella init() dovrebbe assomigliare a questo:

    //---- indicator buffers
    SetIndexBuffer(0, BufferK);
    ArraySetAsSeries(BufferK, true); // Aggiungi questa riga per BufferK
    SetIndexBuffer(1, BufferD);
    ArraySetAsSeries(BufferD, true); // Aggiungi questa riga per BufferD
    SetIndexBuffer(2, BufferK_Curr);
    ArraySetAsSeries(BufferK_Curr, true); // Aggiungi questa riga per BufferK_Curr
    SetIndexBuffer(3, BufferD_Curr);
    ArraySetAsSeries(BufferD_Curr, true); // Aggiungi questa riga per BufferD_Curr
    SetIndexBuffer(4, ArrowUpBuffer);
    ArraySetAsSeries(ArrowUpBuffer, true);
    SetIndexBuffer(5, ArrowDownBuffer);
    ArraySetAsSeries(ArrowDownBuffer, true);
    

    Da notare che per i buffer delle frecce, ArrowUpBuffer e ArrowDownBuffer, l'inizializzazione come serie è già presente nel codice che hai fornito.

    Ho anche notato che nella funzione start(), c'è una chiamata a ArrayInitialize() per ArrowUpBuffer e ArrowDownBuffer prima di entrare nel ciclo. Questo pulisce il buffer ad ogni tick, il che è inadatto se ti aspetti che le frecce rimangano visibili. Questa parte del codice può essere rimossa, dato che la popolazione dei buffer delle frecce dovrebbe già gestire correttamente i loro valori.

    Infine, il ciclo di controllo per le condizioni di incrocio delle linee stocastiche e la creazione delle frecce dovrebbe avvenire dopo che i buffer dello stocastico sono stati pienamente calcolati e non prima.

    Il ciclio finale dove le frecce vengono calcolate potrebbe rimanere così:

    // Rileva gli incroci e disegna le frecce
    for(int j = Bars - countedBars1 - 1; j >= 0; j--) {
        // Verifica la presenza di valori validi prima di disegnare le frecce
        if(BufferK_Curr[j] == EMPTY_VALUE || BufferD_Curr[j] == EMPTY_VALUE)
            continue; // Se uno dei valori è EMPTY_VALUE, salta alla prossima iterazione
    
        double currentK = BufferK_Curr[j];
        double currentD = BufferD_Curr[j];
        double previousK = BufferK_Curr[j + 1];
        double previousD = BufferD_Curr[j + 1];
    
        // Incrocio dal basso verso l’alto
        if(previousK < previousD && currentK > currentD) {
            ArrowUpBuffer[j] = Low[j] - (4 * Point); // Regola il valore in base alla tua necessità dello spazio tra la freccia e il prezzo
        }
    
        // Incrocio dall’alto verso il basso
        if(previousK > previousD && currentK < currentD) {
            ArrowDownBuffer[j] = High[j] + (4 * Point); // Regola il valore in base alla tua necessità dello spazio tra la freccia e il prezzo
        }
    }
    

    Queste correzioni dovrebbero aiutare a garantire che i buffer siano gestiti correttamente e che le frecce e le linee dello stocastico vengano disegnate sul grafico. Ricompila il codice in MT4 e verifica se le modifiche risolvono il problema.

  9. User

    così è corretto secondo le tue indicazioni? //+------------------------------------------------------------------+ //| MTF Stochastic.mq4 | //| 2007, Christof Risch (iya) | //| Stochastic indicator from any timeframe. | //+------------------------------------------------------------------+ // Change Log: // 2.1 2012 07 24 Modified to display only the Signal line (smoothed sma) // cr: 2012 07 20 Added NextHigherAuto to automatically seletc the next higher time frame // Added HidePctD to suppress the Slow line, prn

    #property link "http://www.forexfactory.com/showthread.php?t=30109" #property indicator_separate_window #property indicator_buffers 6 #property indicator_color1 Green //C'255,255,255' // White // %K line #property indicator_color2 Red //Yellow // DimGray // %D line #property indicator_color3 Green // C'255,255,255' // White // %K line of the current candle #property indicator_color4 Red //Yellow // DimGray // %D line of the current candle #property indicator_level1 80 #property indicator_level2 20 #property indicator_level3 50 #property indicator_levelcolor DarkSlateGray #property indicator_maximum 100 #property indicator_minimum 0

    //---- input parameters extern bool NextHigherAuto = true; extern bool HidePctK = false; extern bool HidePctD = false; extern int TimeFrame = 0, // {1=M1, 5=M5, 15=M15, ..., 1440=D1, 10080=W1, 43200=MN1} KPeriod = 11, DPeriod = 3, Slowing = 3, MAMethod = 0, // {0=SMA, 1=EMA, 2=SMMA, 3=LWMA} PriceField = 0; // {0=Hi/Low, 1=Close/Close} extern bool ShowClock = false; // display time to candle close countdown extern color ClockColor = Red;

    //---- indicator buffers double BufferK[], BufferD[], BufferK_Curr[], BufferD_Curr[];

    double ArrowUpBuffer[]; double ArrowDownBuffer[]; //---- string IndicatorName = "", TimeLabelName = "";

    //+------------------------------------------------------------------+ //| Custom indicator initialization function | //+------------------------------------------------------------------+ int init() { if ( TimeFrame == 0 ) TimeFrame = Period(); if ( NextHigherAuto ) TimeFrame = GetHigherTimeFrame( TimeFrame ) ; //---- name for DataWindow and indicator subwindow label switch(TimeFrame) { case 1: IndicatorName="Period M1"; break; case 5: IndicatorName="Period M5"; break; case 15: IndicatorName="Period M15"; break; case 30: IndicatorName="Period M30"; break; case 60: IndicatorName="Period H1"; break; case 240: IndicatorName="Period H4"; break; case 1440: IndicatorName="Period D1"; break; case 10080: IndicatorName="Period W1"; break; case 43200: IndicatorName="Period MN1"; break; default: {TimeFrame = Period(); init(); return(0);} }

    IndicatorName = IndicatorName+" Stoch("+KPeriod+","+DPeriod+","+Slowing+")";
    IndicatorShortName(IndicatorName);  
    IndicatorDigits(1);
    

    string TimeFrameStr = TF2Str(TimeFrame);

    //---- indicator lines SetIndexBuffer(0,BufferK); SetIndexBuffer(1,BufferD); SetIndexBuffer(2,BufferK_Curr); SetIndexBuffer(3,BufferD_Curr); SetIndexStyle(0,DRAW_LINE,EMPTY,1); //SetIndexStyle(0,DRAW_NONE); SetIndexStyle(2,DRAW_LINE,EMPTY,1); //SetIndexStyle(2,DRAW_NONE); if ( ! HidePctK ) { SetIndexStyle(0,DRAW_LINE,EMPTY,1); SetIndexStyle(2,DRAW_LINE,EMPTY,1); SetIndexLabel(0,TimeFrameStr+" %K line"); SetIndexLabel(2,TimeFrameStr+" %K CurrBar"); } else { SetIndexStyle(0,DRAW_NONE); SetIndexStyle(2,DRAW_NONE); SetIndexLabel(0,NULL); SetIndexLabel(2,NULL); }

    if ( ! HidePctD ) { SetIndexStyle(1,DRAW_LINE,EMPTY,1); SetIndexStyle(3,DRAW_LINE,EMPTY,1); SetIndexLabel(1,TimeFrameStr+" %D Signal"); SetIndexLabel(3,TimeFrameStr+" %D CurrBar"); } else { SetIndexStyle(1,DRAW_NONE); SetIndexStyle(3,DRAW_NONE); SetIndexLabel(1,NULL); SetIndexLabel(3,NULL); } // Aggiunta dei nuovi buffer per le frecce SetIndexBuffer(4, ArrowUpBuffer); SetIndexArrow(4, SYMBOL_ARROWUP); // Parametro per l’icona freccia verso l’alto (puoi usare l’icona che preferisci) SetIndexStyle(4, DRAW_ARROW); SetIndexLabel(4, "Stochastic Arrow Up");

    SetIndexBuffer(5, ArrowDownBuffer); SetIndexArrow(5, SYMBOL_ARROWDOWN); // Parametro per l’icona freccia verso il basso SetIndexStyle(5, DRAW_ARROW); SetIndexLabel(5, "Stochastic Arrow Down");

    //---- indicator buffers SetIndexBuffer(0, BufferK); ArraySetAsSeries(BufferK, true); // Aggiungi questa riga per BufferK SetIndexBuffer(1, BufferD); ArraySetAsSeries(BufferD, true); // Aggiungi questa riga per BufferD SetIndexBuffer(2, BufferK_Curr); ArraySetAsSeries(BufferK_Curr, true); // Aggiungi questa riga per BufferK_Curr SetIndexBuffer(3, BufferD_Curr); ArraySetAsSeries(BufferD_Curr, true); // Aggiungi questa riga per BufferD_Curr SetIndexBuffer(4, ArrowUpBuffer); ArraySetAsSeries(ArrowUpBuffer, true); SetIndexBuffer(5, ArrowDownBuffer); ArraySetAsSeries(ArrowDownBuffer, true); } //+------------------------------------------------------------------+ int deinit() { if(TimeLabelName!="") if(ObjectFind (TimeLabelName) != -1) ObjectDelete(TimeLabelName); }

    //+------------------------------------------------------------------+ //| MTF Stochastic | //+------------------------------------------------------------------+ int start() { //---- // counted bars from indicator time frame static int countedBars1 = 0;

    //---- // counted bars from display time frame if(Bars-1-IndicatorCounted() > 1 && countedBars1!=0) countedBars1 = 0;

    int bars1 = iBars(NULL,TimeFrame),
    	 start1 = bars1-1-countedBars1,
    	 limit1 = iBarShift(NULL,TimeFrame,Time[Bars-1]);
    
    if(countedBars1 != bars1-1)
    {
    	countedBars1  = bars1-1;
    	ArrayInitialize(BufferK_Curr,EMPTY_VALUE);
    	ArrayInitialize(BufferD_Curr,EMPTY_VALUE);
    	if(TimeLabelName!="")
    	if(ObjectFind	(TimeLabelName) != -1)
    		ObjectDelete(TimeLabelName);
    }
    
    if(start1 > limit1 && limit1 != -1)
    	start1 = limit1;
    

    //---- // 3... 2... 1... GO! for(int i = start1; i >= 0; i--) { int shift1 = i;

    	if(TimeFrame < Period())
    		shift1 = iBarShift(NULL,TimeFrame,Time[i]);
    
    	int time1  = iTime    (NULL,TimeFrame,shift1),
    		 shift2 = iBarShift(NULL,0,time1);
    
    	double stochK = iStochastic(NULL,TimeFrame,KPeriod,DPeriod,Slowing,MAMethod,PriceField,0,shift1),
    			 stochD = iStochastic(NULL,TimeFrame,KPeriod,DPeriod,Slowing,MAMethod,PriceField,1,shift1);
    
    //----
    //	old (closed) candles
    	if(shift1>=1)
    	{
    		BufferK[shift2] = stochK;
    		BufferD[shift2] = stochD;
    	}
    
    //----
    //	current candle
    	if((TimeFrame >=Period() && shift1<=1)
    	|| (TimeFrame < Period() &&(shift1==0||shift2==1)))
    	{
    		BufferK_Curr[shift2] = stochK;
    		BufferD_Curr[shift2] = stochD;
    	}
    
    //----
    //	linear interpolatior for the number of intermediate bars, between two higher timeframe candles.
    	int n = 1;
    	if(TimeFrame > Period())
    	{
    		int shift2prev = iBarShift(NULL,0,iTime(NULL,TimeFrame,shift1+1));
    
    		if(shift2prev!=-1 && shift2prev!=shift2)
    			n = shift2prev - shift2;
    	}
    
    //----
    //	apply interpolation
    	double factor = 1.0 / n;
    	if(shift1>=1)
    	if(BufferK[shift2+n]!=EMPTY_VALUE && BufferK[shift2]!=EMPTY_VALUE)
    	{
    		for(int k = 1; k < n; k++)
    		{
    			BufferK[shift2+k] = k*factor*BufferK[shift2+n] + (1.0-k*factor)*BufferK[shift2];
    			BufferD[shift2+k] = k*factor*BufferD[shift2+n] + (1.0-k*factor)*BufferD[shift2];
    		}
    	}
    
    //----
    //	current candle
    	if(shift1==0)
    	if(BufferK_Curr[shift2+n]!=EMPTY_VALUE && BufferK_Curr[shift2]!=EMPTY_VALUE)
    	{
    		for(k = 1; k < n; k++)
    		{
    			BufferK_Curr[shift2+k] = k*factor*BufferK_Curr[shift2+n] + (1.0-k*factor)*BufferK_Curr[shift2];
    			BufferD_Curr[shift2+k] = k*factor*BufferD_Curr[shift2+n] + (1.0-k*factor)*BufferD_Curr[shift2];
    		}
    
    	//----
    	//	candle time countdown
    		if(ShowClock)
    		{
    			int m,s;
    
    			s = iTime(NULL,TimeFrame,0)+TimeFrame*60 - TimeCurrent();
    			m = (s-s%60)/60;
    			s = s%60;
    
    			string text;
    			if(s<10)	text = "0"+s;
    			else		text = ""+s;
    			text = "            "+m+":"+text;
    
    			int window = WindowFind(IndicatorName);
    			if(window==-1)
    				window = WindowOnDropped() ;
    
    			TimeLabelName = IndicatorName+" Time Counter "+window;
    
    			if(ObjectFind	(TimeLabelName) == -1)
    				ObjectCreate(TimeLabelName, OBJ_TEXT, window, Time[shift2], BufferK_Curr[shift2]+3);
    			else
    				ObjectMove	(TimeLabelName, 0, Time[shift2], BufferK_Curr[shift2]+3);
    
    			ObjectSetText	(TimeLabelName, text, 8, "Verdana", ClockColor);
    		}
    	}
    }
    

    // Rileva gli incroci e disegna le frecce for(int j = Bars - countedBars1 - 1; j >= 0; j--) { // Verifica la presenza di valori validi prima di disegnare le frecce if(BufferK_Curr[j] == EMPTY_VALUE || BufferD_Curr[j] == EMPTY_VALUE) continue; // Se uno dei valori è EMPTY_VALUE, salta alla prossima iterazione

    double currentK = BufferK_Curr[j];
    double currentD = BufferD_Curr[j];
    double previousK = BufferK_Curr[j + 1];
    double previousD = BufferD_Curr[j + 1];
    
    // Incrocio dal basso verso l’alto
    if(previousK < previousD && currentK > currentD) {
        ArrowUpBuffer[j] = Low[j] - (4 * Point); // Regola il valore in base alla tua necessità dello spazio tra la freccia e il prezzo
    }
    
    // Incrocio dall’alto verso il basso
    if(previousK > previousD && currentK < currentD) {
        ArrowDownBuffer[j] = High[j] + (4 * Point); // Regola il valore in base alla tua necessità dello spazio tra la freccia e il prezzo
    }
    

    }

    return(0); }

    string TF2Str(int iPeriod) { switch(iPeriod) { case PERIOD_M1: return("M1"); case PERIOD_M5: return("M5"); case PERIOD_M15: return("M15"); case PERIOD_M30: return("M30"); case PERIOD_H1: return("H1"); case PERIOD_H4: return("H4"); case PERIOD_D1: return("D1"); case PERIOD_W1: return("W1"); case PERIOD_MN1: return("MN1"); default: return("M"+iPeriod); } return(0); }

    int GetHigherTimeFrame(int CurrentPeriod ) { if ( CurrentPeriod == 0 ) CurrentPeriod = Period(); if( CurrentPeriod == 1 ) { return(5); } else if( CurrentPeriod == 5 ) { return(15); } else if( CurrentPeriod == 15 ) { return(30); } else if( CurrentPeriod == 30 ) { return(60); } else if( CurrentPeriod == 60 ) { return(240); } else if( CurrentPeriod == 240 ) { return(1440); } else if( CurrentPeriod == 1440 ) { return(10080); } else if( CurrentPeriod == 10080 ) { return(43200); } else if( CurrentPeriod == 43200 ) { return(43200); } } // int GetHigherTimeFrame()

  10. Assistant

    The code you've included is mostly correct, but there are a few issues that need to be addressed:

    1. Duplicate Buffer Definitions: You have defined the indicator buffers twice. Each buffer is assigned with SetIndexBuffer two times, which is unnecessary and may cause confusion. You only need to set the index buffer for each buffer once and then call ArraySetAsSeries right after each buffer is assigned.

    2. Recursive Call in init(): There's still a recursive call to init() in the switch-case statement. If you intend to keep it for some reason, be very cautious as this may not work as intended in MT4 and can lead to stack overflow or undefined behavior.

    Here is the cleaned-up version of the init() function with the corrections:

    int init()
    {
      if ( TimeFrame == 0 )
        TimeFrame = Period();
      if ( NextHigherAuto ) TimeFrame = GetHigherTimeFrame( TimeFrame );
    
      switch(TimeFrame)
      {
        case 1:		IndicatorName="Period M1";	break;
        case 5:		IndicatorName="Period M5"; break;
        case 15:		IndicatorName="Period M15"; break;
        case 30:		IndicatorName="Period M30"; break;
        case 60:		IndicatorName="Period H1"; break;
        case 240:	IndicatorName="Period H4"; break;
        case 1440:	IndicatorName="Period D1"; break;
        case 10080:	IndicatorName="Period W1"; break;
        case 43200:	IndicatorName="Period MN1"; break;
        default:	Print("TimeFrame non valido: " + TimeFrame); return(INIT_FAILED);
      }
    
      IndicatorName = IndicatorName+" Stoch("+KPeriod+","+DPeriod+","+Slowing+")";
      IndicatorShortName(IndicatorName);  
      IndicatorDigits(1);
      string TimeFrameStr = TF2Str(TimeFrame);
    
      // Assign buffers
      SetIndexBuffer(0, BufferK);
      ArraySetAsSeries(BufferK, true);
      SetIndexBuffer(1, BufferD);
      ArraySetAsSeries(BufferD, true);
      SetIndexBuffer(2, BufferK_Curr);
      ArraySetAsSeries(BufferK_Curr, true);
      SetIndexBuffer(3, BufferD_Curr);
      ArraySetAsSeries(BufferD_Curr, true);
      SetIndexBuffer(4, ArrowUpBuffer);
      ArraySetAsSeries(ArrowUpBuffer, true);
      SetIndexBuffer(5, ArrowDownBuffer);
      ArraySetAsSeries(ArrowDownBuffer, true);
    
      // Define styles and labels based on user settings
      if (!HidePctK )
      {
        SetIndexStyle(0, DRAW_LINE);
        SetIndexLabel(0, TimeFrameStr + " %K line");
        SetIndexStyle(2, DRAW_LINE);
        SetIndexLabel(2, TimeFrameStr + " %K CurrBar");
      }
      else
      {
      	// Do not display the '%K' line if hidden.
        SetIndexStyle(0, DRAW_NONE);
        SetIndexLabel(0, NULL);
        SetIndexStyle(2, DRAW_NONE);
        SetIndexLabel(2, NULL);
      }
    
      if (!HidePctD )
      {
        SetIndexStyle(1, DRAW_LINE);
        SetIndexLabel(1, TimeFrameStr + " %D Signal");
        SetIndexStyle(3, DRAW_LINE);
        SetIndexLabel(3, TimeFrameStr + " %D CurrBar");
      }
      else
      {
        // Do not display the '%D' line if hidden.
        SetIndexStyle(1, DRAW_NONE);
        SetIndexLabel(1, NULL);
        SetIndexStyle(3, DRAW_NONE);
        SetIndexLabel(3, NULL);
      }
    
      // Define arrow styles
      SetIndexStyle(4, DRAW_ARROW);
      SetIndexArrow(4, SYMBOL_ARROWUP); // Up arrow
      SetIndexLabel(4, "Stochastic Arrow Up");
    
      SetIndexStyle(5, DRAW_ARROW);
      SetIndexArrow(5, SYMBOL_ARROWDOWN); // Down arrow
      SetIndexLabel(5, "Stochastic Arrow Down");
    
      return(INIT_SUCCEEDED);
    }
    

    Remove the extra SetIndexBuffer and ArraySetAsSeries calls, and make sure that the buffer assignment and series declaration only happen once at the beginning of the init() function.

  11. User

    //+------------------------------------------------------------------+ //| MTF Stochastic.mq4 | //| 2007, Christof Risch (iya) | //| Stochastic indicator from any timeframe. | //+------------------------------------------------------------------+ // Change Log: // 2.1 2012 07 24 Modified to display only the Signal line (smoothed sma) // cr: 2012 07 20 Added NextHigherAuto to automatically seletc the next higher time frame // Added HidePctD to suppress the Slow line, prn

    #property link "http://www.forexfactory.com/showthread.php?t=30109" #property indicator_separate_window #property indicator_buffers 6 #property indicator_color1 Green //C'255,255,255' // White // %K line #property indicator_color2 Red //Yellow // DimGray // %D line #property indicator_color3 Green // C'255,255,255' // White // %K line of the current candle #property indicator_color4 Red //Yellow // DimGray // %D line of the current candle #property indicator_level1 80 #property indicator_level2 20 #property indicator_level3 50 #property indicator_levelcolor DarkSlateGray #property indicator_maximum 100 #property indicator_minimum 0

    //---- input parameters extern bool NextHigherAuto = true; extern bool HidePctK = false; extern bool HidePctD = false; extern int TimeFrame = 0, // {1=M1, 5=M5, 15=M15, ..., 1440=D1, 10080=W1, 43200=MN1} KPeriod = 11, DPeriod = 3, Slowing = 3, MAMethod = 0, // {0=SMA, 1=EMA, 2=SMMA, 3=LWMA} PriceField = 0; // {0=Hi/Low, 1=Close/Close} extern bool ShowClock = false; // display time to candle close countdown extern color ClockColor = Red;

    //---- indicator buffers double BufferK[], BufferD[], BufferK_Curr[], BufferD_Curr[], ArrowUpBuffer[], ArrowDownBuffer[];

    //---- string IndicatorName = "", TimeLabelName = "";

    //+------------------------------------------------------------------+ //| Custom indicator initialization function | //+------------------------------------------------------------------+ int init() { if ( TimeFrame == 0 ) TimeFrame = Period(); if ( NextHigherAuto ) TimeFrame = GetHigherTimeFrame( TimeFrame ) ; //---- name for DataWindow and indicator subwindow label switch(TimeFrame) { case 1: IndicatorName="Period M1"; break; case 5: IndicatorName="Period M5"; break; case 15: IndicatorName="Period M15"; break; case 30: IndicatorName="Period M30"; break; case 60: IndicatorName="Period H1"; break; case 240: IndicatorName="Period H4"; break; case 1440: IndicatorName="Period D1"; break; case 10080: IndicatorName="Period W1"; break; case 43200: IndicatorName="Period MN1"; break; default: {TimeFrame = Period(); init(); return(0);} }

    IndicatorName = IndicatorName+" Stoch("+KPeriod+","+DPeriod+","+Slowing+")";
    IndicatorShortName(IndicatorName);  
    IndicatorDigits(1);
    

    string TimeFrameStr = TF2Str(TimeFrame);

    //---- indicator lines

    SetIndexBuffer(0,BufferK);
    SetIndexBuffer(1,BufferD);
    SetIndexBuffer(2,BufferK_Curr);
    SetIndexBuffer(3,BufferD_Curr);
    SetIndexStyle(0,DRAW_LINE,EMPTY,1);
    //SetIndexStyle(0,DRAW_NONE);
    SetIndexStyle(2,DRAW_LINE,EMPTY,1);
    //SetIndexStyle(2,DRAW_NONE);
    if ( ! HidePctK )
    {
      SetIndexStyle(0,DRAW_LINE,EMPTY,1);
      SetIndexStyle(2,DRAW_LINE,EMPTY,1);
     SetIndexLabel(0,TimeFrameStr+" %K line");
      SetIndexLabel(2,TimeFrameStr+" %K CurrBar");
    }
    else
    {
      SetIndexStyle(0,DRAW_NONE);
      SetIndexStyle(2,DRAW_NONE);
     SetIndexLabel(0,NULL);
      SetIndexLabel(2,NULL);
    }
    

    if ( ! HidePctD ) { SetIndexStyle(1,DRAW_LINE,EMPTY,1); SetIndexStyle(3,DRAW_LINE,EMPTY,1); SetIndexLabel(1,TimeFrameStr+" %D Signal"); SetIndexLabel(3,TimeFrameStr+" %D CurrBar"); } else { SetIndexStyle(1,DRAW_NONE); SetIndexStyle(3,DRAW_NONE); SetIndexLabel(1,NULL); SetIndexLabel(3,NULL); }

    SetIndexBuffer(4, ArrowUpBuffer);
    

    SetIndexArrow(4, SYMBOL_ARROWUP); // Parametro per l’icona freccia verso l’alto (puoi usare l’icona che preferisci) SetIndexStyle(4, DRAW_ARROW); SetIndexLabel(4, "Stochastic Arrow Up"); ArraySetAsSeries(ArrowUpBuffer, true);

    SetIndexBuffer(5, ArrowDownBuffer); SetIndexArrow(5, SYMBOL_ARROWDOWN); // Parametro per l’icona freccia verso il basso SetIndexStyle(5, DRAW_ARROW); SetIndexLabel(5, "Stochastic Arrow Down"); ArraySetAsSeries(ArrowDownBuffer, true); }

    //+------------------------------------------------------------------+ int deinit() { if(TimeLabelName!="") if(ObjectFind (TimeLabelName) != -1) ObjectDelete(TimeLabelName); }

    //+------------------------------------------------------------------+ //| MTF Stochastic | //+------------------------------------------------------------------+ int start() { //---- // counted bars from indicator time frame static int countedBars1 = 0;

    //---- // counted bars from display time frame if(Bars-1-IndicatorCounted() > 1 && countedBars1!=0) countedBars1 = 0;

    int bars1 = iBars(NULL,TimeFrame),
    	 start1 = bars1-1-countedBars1,
    	 limit1 = iBarShift(NULL,TimeFrame,Time[Bars-1]);
    
    if(countedBars1 != bars1-1)
    {
    	countedBars1  = bars1-1;
    	ArrayInitialize(BufferK_Curr,EMPTY_VALUE);
    	ArrayInitialize(BufferD_Curr,EMPTY_VALUE);
    	if(TimeLabelName!="")
    	if(ObjectFind	(TimeLabelName) != -1)
    		ObjectDelete(TimeLabelName);
    }
    
    if(start1 > limit1 && limit1 != -1)
    	start1 = limit1;
    

    //---- // 3... 2... 1... GO! for(int i = start1; i >= 0; i--) { int shift1 = i;

    	if(TimeFrame < Period())
    		shift1 = iBarShift(NULL,TimeFrame,Time[i]);
    
    	int time1  = iTime    (NULL,TimeFrame,shift1),
    		 shift2 = iBarShift(NULL,0,time1);
    
    	double stochK = iStochastic(NULL,TimeFrame,KPeriod,DPeriod,Slowing,MAMethod,PriceField,0,shift1),
    			 stochD = iStochastic(NULL,TimeFrame,KPeriod,DPeriod,Slowing,MAMethod,PriceField,1,shift1);
    
    //----
    //	old (closed) candles
    	if(shift1>=1)
    	{
    		BufferK[shift2] = stochK;
    		BufferD[shift2] = stochD;
    	}
    
    //----
    //	current candle
    	if((TimeFrame >=Period() && shift1<=1)
    	|| (TimeFrame < Period() &&(shift1==0||shift2==1)))
    	{
    		BufferK_Curr[shift2] = stochK;
    		BufferD_Curr[shift2] = stochD;
    	}
    
    //----
    //	linear interpolatior for the number of intermediate bars, between two higher timeframe candles.
    	int n = 1;
    	if(TimeFrame > Period())
    	{
    		int shift2prev = iBarShift(NULL,0,iTime(NULL,TimeFrame,shift1+1));
    
    		if(shift2prev!=-1 && shift2prev!=shift2)
    			n = shift2prev - shift2;
    	}
    
    //----
    //	apply interpolation
    	double factor = 1.0 / n;
    	if(shift1>=1)
    	if(BufferK[shift2+n]!=EMPTY_VALUE && BufferK[shift2]!=EMPTY_VALUE)
    	{
    		for(int k = 1; k < n; k++)
    		{
    			BufferK[shift2+k] = k*factor*BufferK[shift2+n] + (1.0-k*factor)*BufferK[shift2];
    			BufferD[shift2+k] = k*factor*BufferD[shift2+n] + (1.0-k*factor)*BufferD[shift2];
    		}
    	}
    
    //----
    //	current candle
    	if(shift1==0)
    	if(BufferK_Curr[shift2+n]!=EMPTY_VALUE && BufferK_Curr[shift2]!=EMPTY_VALUE)
    	{
    		for(k = 1; k < n; k++)
    		{
    			BufferK_Curr[shift2+k] = k*factor*BufferK_Curr[shift2+n] + (1.0-k*factor)*BufferK_Curr[shift2];
    			BufferD_Curr[shift2+k] = k*factor*BufferD_Curr[shift2+n] + (1.0-k*factor)*BufferD_Curr[shift2];
    		}
    
    	//----
    	//	candle time countdown
    		if(ShowClock)
    		{
    			int m,s;
    
    			s = iTime(NULL,TimeFrame,0)+TimeFrame*60 - TimeCurrent();
    			m = (s-s%60)/60;
    			s = s%60;
    
    			string text;
    			if(s<10)	text = "0"+s;
    			else		text = ""+s;
    			text = "            "+m+":"+text;
    
    			int window = WindowFind(IndicatorName);
    			if(window==-1)
    				window = WindowOnDropped() ;
    
    			TimeLabelName = IndicatorName+" Time Counter "+window;
    
    			if(ObjectFind	(TimeLabelName) == -1)
    				ObjectCreate(TimeLabelName, OBJ_TEXT, window, Time[shift2], BufferK_Curr[shift2]+3);
    			else
    				ObjectMove	(TimeLabelName, 0, Time[shift2], BufferK_Curr[shift2]+3);
    
    			ObjectSetText	(TimeLabelName, text, 8, "Verdana", ClockColor);
    		}
    	}
    }
    

    // Rileva gli incroci e disegna le frecce for(int j = Bars - countedBars1 - 1; j >= 0; j--) { if(j == 0) continue; // Saltare la barra corrente

    double currentK = BufferK_Curr[j];
    double currentD = BufferD_Curr[j];
    double previousK = BufferK_Curr[j + 1];
    double previousD = BufferD_Curr[j + 1];
    
    // Incrocio dal basso verso l’alto
    if(previousK < previousD && currentK > currentD) {
        ArrowUpBuffer[j] = Low[j] - (4 * Point); // Regola il valore in base alla tua necessità dello spazio tra la freccia e il prezzo
    }
    
    // Incrocio dall’alto verso il basso
    if(previousK > previousD && currentK < currentD) {
        ArrowDownBuffer[j] = High[j] + (4 * Point); // Regola il valore in base alla tua necessità dello spazio tra la freccia e il prezzo
    }
    

    } return(0); }

    string TF2Str(int iPeriod) { switch(iPeriod) { case PERIOD_M1: return("M1"); case PERIOD_M5: return("M5"); case PERIOD_M15: return("M15"); case PERIOD_M30: return("M30"); case PERIOD_H1: return("H1"); case PERIOD_H4: return("H4"); case PERIOD_D1: return("D1"); case PERIOD_W1: return("W1"); case PERIOD_MN1: return("MN1"); default: return("M"+iPeriod); } return(0); }

    int GetHigherTimeFrame(int CurrentPeriod ) { if ( CurrentPeriod == 0 ) CurrentPeriod = Period(); if( CurrentPeriod == 1 ) { return(5); } else if( CurrentPeriod == 5 ) { return(15); } else if( CurrentPeriod == 15 ) { return(30); } else if( CurrentPeriod == 30 ) { return(60); } else if( CurrentPeriod == 60 ) { return(240); } else if( CurrentPeriod == 240 ) { return(1440); } else if( CurrentPeriod == 1440 ) { return(10080); } else if( CurrentPeriod == 10080 ) { return(43200); } else if( CurrentPeriod == 43200 ) { return(43200); } } // int GetHigherTimeFrame()

    non mostra nulla sul grafico

  12. Assistant

    Dopo aver analizzato nuovamente il tuo codice, ecco alcune possibili ragioni per cui l'indicatore potrebbe non mostrare nulla sul grafico di MetaTrader 4 (MT4):

    1. Settings di TimeFrame non corretti: Il seguente pezzo di codice all'interno della funzione init() può potenzialmente causare un ciclo infinito se il TimeFrame fornito dal parametro esterno non corrisponde a nessuno dei casi:

      default: {TimeFrame = Period(); init(); return(0);}
      

      Questo chiamerà init() ricorsivamente, fino a quando TimeFrame corrisponde a un valore accettato. Tieni presente che i timeframe personalizzati non standard possono non funzionare correttamente con questo codice.

    2. Il mancato uso di ArraySetAsSeries(): Manca la chiamata di ArraySetAsSeries() per i buffer BufferK, BufferD, BufferK_Curr, e BufferD_Curr.

      I buffer devono essere impostati come serie cronologica per assicurarsi che l'indicizzazione funzioni correttamente all'interno delle funzioni di MT4, soprattutto se lavori con i dati delle barre precedenti. Pertanto, aggiungi dopo ogni chiamata SetIndexBuffer in init():

      ArraySetAsSeries(BufferK, true);
      ArraySetAsSeries(BufferD, true);
      ArraySetAsSeries(BufferK_Curr, true);
      ArraySetAsSeries(BufferD_Curr, true);
      
    3. Errore di logica durante il rilevamento delle incroci:

      È possibile che la logica utilizzata per identificare gli incroci e posizionare le frecce non sia corretta o che le condizioni non vengano mai soddisfatte. Assicurati che le condizioni per il posizionamento delle frecce seguano le corrette regole dello Stocastico e che ci siano effettivamente incroci.

    4. Punto di inserimento delle frecce:

      Le frecce vengono posizionate a una distanza troppo lontana dal prezzo corrente (4 punti sopra o sotto). Se il valore del simbolo è grande, le frecce potrebbero risultare fuori dallo schermo. Prova a ridurre questa distanza o adattarla in base alla scala del prezzo del simbolo in esame.

      ArrowUpBuffer[j] = Low[j] - (0.001 * Point); // Adatta questa distanza
      ArrowDownBuffer[j] = High[j] + (0.001 * Point); // Adatta questa distanza
      
    5. Possibile errore di sincronizzazione tra i timeframe:

      Potrebbe esserci un errore nella sincronizzazione tra il timeframe del grafico e quello che l'indicatore sta cercando di utilizzare per il calcolo dello Stocastico. Ciò può accadere se iBarShift o altre funzioni correlate non vengono utilizzate correttamente.

    Risolvere questi problemi potrebbe già essere sufficiente per ottenere un funzionamento corretto dell'indicatore. Ricontrolla il codice con attenzione e assicurati che tutto sia in ordine. Se persistono problemi, considera di fare un debugging più approfondito o di usare messaggi di log (Print()) per tracciare i valori intermedi e comprendere meglio cosa non funziona.

  13. User

    scrivi il blocco del codice contentente la correzione al punto 2

  14. Assistant

    Certo, ecco le correzioni al punto 2 per l'inizializzazione dei buffer. Devi aggiungere le chiamate ArraySetAsSeries subito dopo aver impostato ciascun buffer con SetIndexBuffer nella funzione init().

    Ecco il blocco di codice corretto:

    int init()
    {
        //...[omitted rest of the init code before the buffers]...
    
        //---- indicator lines
        SetIndexBuffer(0, BufferK);
        ArraySetAsSeries(BufferK, true); // Set BufferK as a time series
        SetIndexBuffer(1, BufferD);
        ArraySetAsSeries(BufferD, true); // Set BufferD as a time series
        SetIndexBuffer(2, BufferK_Curr);
        ArraySetAsSeries(BufferK_Curr, true); // Set BufferK_Curr as a time series
        SetIndexBuffer(3, BufferD_Curr);
        ArraySetAsSeries(BufferD_Curr, true); // Set BufferD_Curr as a time series
    
        // Set Index Styles and properties for %K and %D lines (will continue from your code)
        //...[omitted rest of the init code after the buffers]...
    
        return(INIT_SUCCEEDED);
    }
    

    Assicurati di includere queste righe nel giusto punto della funzione init(), subito dopo aver impostato ciascun buffer con la funzione SetIndexBuffer(). Non saranno necessarie ulteriori modifiche a meno che tu non stia riscontrando altri problemi specifici con il tuo indicatore. Ricompila dopo aver effettuato queste modifiche e verifica se il comportamento dell'indicatore migliora.

  15. User

    riscrivi tutto int init

  16. Assistant

    Ecco la funzione init() rivista includendo le correzioni necessarie secondo la tua richiesta, inclusa l'inizializzazione corretta dei buffer con ArraySetAsSeries():

    int init()
    {
        if (TimeFrame == 0)
            TimeFrame = Period();
        if (NextHigherAuto) TimeFrame = GetHigherTimeFrame(TimeFrame);
        
        // name for DataWindow and indicator subwindow label
        switch(TimeFrame)
        {
            case PERIOD_M1:    IndicatorName="Period M1";    break;
            case PERIOD_M5:    IndicatorName="Period M5";    break;
            case PERIOD_M15:   IndicatorName="Period M15";   break;
            case PERIOD_M30:   IndicatorName="Period M30";   break;
            case PERIOD_H1:    IndicatorName="Period H1";    break;
            case PERIOD_H4:    IndicatorName="Period H4";    break;
            case PERIOD_D1:    IndicatorName="Period D1";    break;
            case PERIOD_W1:    IndicatorName="Period W1";    break;
            case PERIOD_MN1:   IndicatorName="Period MN1";   break;
            default: 
                Print("TimeFrame non valido: " + TimeFrame);
                return(INIT_FAILED); // Removed the recursive call to init() for safety.
        }
        
        IndicatorName = IndicatorName + " Stoch(" + KPeriod + "," + DPeriod + "," + Slowing + ")";
        IndicatorShortName(IndicatorName);
        IndicatorDigits(1);
        
        string TimeFrameStr = TF2Str(TimeFrame);
        
        //---- set indicator buffers
        SetIndexBuffer(0, BufferK);
        ArraySetAsSeries(BufferK, true);
        SetIndexBuffer(1, BufferD);
        ArraySetAsSeries(BufferD, true);
        SetIndexBuffer(2, BufferK_Curr);
        ArraySetAsSeries(BufferK_Curr, true);
        SetIndexBuffer(3, BufferD_Curr);
        ArraySetAsSeries(BufferD_Curr, true);
        SetIndexBuffer(4, ArrowUpBuffer);
        ArraySetAsSeries(ArrowUpBuffer, true);
        SetIndexBuffer(5, ArrowDownBuffer);
        ArraySetAsSeries(ArrowDownBuffer, true);
        
        //---- set index draw begin and styles according to HidePctK and HidePctD
        if (!HidePctK)
        {
            SetIndexStyle(0, DRAW_LINE, EMPTY, 1);
            SetIndexLabel(0, TimeFrameStr + " %K line");
            SetIndexStyle(2, DRAW_LINE, EMPTY, 1);
            SetIndexLabel(2, TimeFrameStr + " %K CurrBar");
        }
        else
        {
            SetIndexStyle(0, DRAW_NONE);
            SetIndexLabel(0, NULL);
            SetIndexStyle(2, DRAW_NONE);
            SetIndexLabel(2, NULL);
        }
        
        if (!HidePctD)
        {
            SetIndexStyle(1, DRAW_LINE, EMPTY, 1);
            SetIndexLabel(1, TimeFrameStr + " %D Signal");
            SetIndexStyle(3, DRAW_LINE, EMPTY, 1);
            SetIndexLabel(3, TimeFrameStr + " %D CurrBar");
        }
        else
        {
            SetIndexStyle(1, DRAW_NONE);
            SetIndexLabel(1, NULL);
            SetIndexStyle(3, DRAW_NONE);
            SetIndexLabel(3, NULL);
        }
        
        //---- arrows settings
        SetIndexArrow(4, SYMBOL_ARROWUP);
        SetIndexStyle(4, DRAW_ARROW);
        SetIndexLabel(4, "Stochastic Arrow Up");
        
        SetIndexArrow(5, SYMBOL_ARROWDOWN);
        SetIndexStyle(5, DRAW_ARROW);
        SetIndexLabel(5, "Stochastic Arrow Down");
        
        return(INIT_SUCCEEDED);
    }
    

    Assicurati di integrare correttamente questo codice con il resto delle tue funzioni nel file dell'indicatore. Ricompila l'indicatore dopo aver effettuato le modifiche per verificarne il funzionamento.

  17. User

    questo era il codice originale funzionante. trova le differenze, il mio non disegna nulla //+------------------------------------------------------------------+ //| MTF Stochastic.mq4 | //| 2007, Christof Risch (iya) | //| Stochastic indicator from any timeframe. | //+------------------------------------------------------------------+ // Change Log: // 2.1 2012 07 24 Modified to display only the Signal line (smoothed sma) // cr: 2012 07 20 Added NextHigherAuto to automatically seletc the next higher time frame // Added HidePctD to suppress the Slow line, prn

    #property link "http://www.forexfactory.com/showthread.php?t=30109" #property indicator_separate_window #property indicator_buffers 4 #property indicator_color1 Green //C'255,255,255' // White // %K line #property indicator_color2 Red //Yellow // DimGray // %D line #property indicator_color3 Green // C'255,255,255' // White // %K line of the current candle #property indicator_color4 Red //Yellow // DimGray // %D line of the current candle #property indicator_level1 80 #property indicator_level2 20 #property indicator_level3 50 #property indicator_levelcolor DarkSlateGray #property indicator_maximum 100 #property indicator_minimum 0

    //---- input parameters extern bool NextHigherAuto = true; extern bool HidePctK = false; extern bool HidePctD = false; extern int TimeFrame = 0, // {1=M1, 5=M5, 15=M15, ..., 1440=D1, 10080=W1, 43200=MN1} KPeriod = 11, DPeriod = 3, Slowing = 3, MAMethod = 0, // {0=SMA, 1=EMA, 2=SMMA, 3=LWMA} PriceField = 0; // {0=Hi/Low, 1=Close/Close} extern bool ShowClock = false; // display time to candle close countdown extern color ClockColor = Red;

    //---- indicator buffers double BufferK[], BufferD[], BufferK_Curr[], BufferD_Curr[];

    //---- string IndicatorName = "", TimeLabelName = "";

    //+------------------------------------------------------------------+ //| Custom indicator initialization function | //+------------------------------------------------------------------+ int init() { if ( TimeFrame == 0 ) TimeFrame = Period(); if ( NextHigherAuto ) TimeFrame = GetHigherTimeFrame( TimeFrame ) ; //---- name for DataWindow and indicator subwindow label switch(TimeFrame) { case 1: IndicatorName="Period M1"; break; case 5: IndicatorName="Period M5"; break; case 15: IndicatorName="Period M15"; break; case 30: IndicatorName="Period M30"; break; case 60: IndicatorName="Period H1"; break; case 240: IndicatorName="Period H4"; break; case 1440: IndicatorName="Period D1"; break; case 10080: IndicatorName="Period W1"; break; case 43200: IndicatorName="Period MN1"; break; default: {TimeFrame = Period(); init(); return(0);} }

    IndicatorName = IndicatorName+" Stoch("+KPeriod+","+DPeriod+","+Slowing+")";
    IndicatorShortName(IndicatorName);  
    IndicatorDigits(1);
    

    string TimeFrameStr = TF2Str(TimeFrame);

    //---- indicator lines SetIndexBuffer(0,BufferK); SetIndexBuffer(1,BufferD); SetIndexBuffer(2,BufferK_Curr); SetIndexBuffer(3,BufferD_Curr); SetIndexStyle(0,DRAW_LINE,EMPTY,1); //SetIndexStyle(0,DRAW_NONE); SetIndexStyle(2,DRAW_LINE,EMPTY,1); //SetIndexStyle(2,DRAW_NONE); if ( ! HidePctK ) { SetIndexStyle(0,DRAW_LINE,EMPTY,1); SetIndexStyle(2,DRAW_LINE,EMPTY,1); SetIndexLabel(0,TimeFrameStr+" %K line"); SetIndexLabel(2,TimeFrameStr+" %K CurrBar"); } else { SetIndexStyle(0,DRAW_NONE); SetIndexStyle(2,DRAW_NONE); SetIndexLabel(0,NULL); SetIndexLabel(2,NULL); }

    if ( ! HidePctD ) { SetIndexStyle(1,DRAW_LINE,EMPTY,1); SetIndexStyle(3,DRAW_LINE,EMPTY,1); SetIndexLabel(1,TimeFrameStr+" %D Signal"); SetIndexLabel(3,TimeFrameStr+" %D CurrBar"); } else { SetIndexStyle(1,DRAW_NONE); SetIndexStyle(3,DRAW_NONE); SetIndexLabel(1,NULL); SetIndexLabel(3,NULL); } }

    //+------------------------------------------------------------------+ int deinit() { if(TimeLabelName!="") if(ObjectFind (TimeLabelName) != -1) ObjectDelete(TimeLabelName); }

    //+------------------------------------------------------------------+ //| MTF Stochastic | //+------------------------------------------------------------------+ int start() { //---- // counted bars from indicator time frame static int countedBars1 = 0;

    //---- // counted bars from display time frame if(Bars-1-IndicatorCounted() > 1 && countedBars1!=0) countedBars1 = 0;

    int bars1 = iBars(NULL,TimeFrame),
    	 start1 = bars1-1-countedBars1,
    	 limit1 = iBarShift(NULL,TimeFrame,Time[Bars-1]);
    
    if(countedBars1 != bars1-1)
    {
    	countedBars1  = bars1-1;
    	ArrayInitialize(BufferK_Curr,EMPTY_VALUE);
    	ArrayInitialize(BufferD_Curr,EMPTY_VALUE);
    	if(TimeLabelName!="")
    	if(ObjectFind	(TimeLabelName) != -1)
    		ObjectDelete(TimeLabelName);
    }
    
    if(start1 > limit1 && limit1 != -1)
    	start1 = limit1;
    

    //---- // 3... 2... 1... GO! for(int i = start1; i >= 0; i--) { int shift1 = i;

    	if(TimeFrame < Period())
    		shift1 = iBarShift(NULL,TimeFrame,Time[i]);
    
    	int time1  = iTime    (NULL,TimeFrame,shift1),
    		 shift2 = iBarShift(NULL,0,time1);
    
    	double stochK = iStochastic(NULL,TimeFrame,KPeriod,DPeriod,Slowing,MAMethod,PriceField,0,shift1),
    			 stochD = iStochastic(NULL,TimeFrame,KPeriod,DPeriod,Slowing,MAMethod,PriceField,1,shift1);
    
    //----
    //	old (closed) candles
    	if(shift1>=1)
    	{
    		BufferK[shift2] = stochK;
    		BufferD[shift2] = stochD;
    	}
    
    //----
    //	current candle
    	if((TimeFrame >=Period() && shift1<=1)
    	|| (TimeFrame < Period() &&(shift1==0||shift2==1)))
    	{
    		BufferK_Curr[shift2] = stochK;
    		BufferD_Curr[shift2] = stochD;
    	}
    
    //----
    //	linear interpolatior for the number of intermediate bars, between two higher timeframe candles.
    	int n = 1;
    	if(TimeFrame > Period())
    	{
    		int shift2prev = iBarShift(NULL,0,iTime(NULL,TimeFrame,shift1+1));
    
    		if(shift2prev!=-1 && shift2prev!=shift2)
    			n = shift2prev - shift2;
    	}
    
    //----
    //	apply interpolation
    	double factor = 1.0 / n;
    	if(shift1>=1)
    	if(BufferK[shift2+n]!=EMPTY_VALUE && BufferK[shift2]!=EMPTY_VALUE)
    	{
    		for(int k = 1; k < n; k++)
    		{
    			BufferK[shift2+k] = k*factor*BufferK[shift2+n] + (1.0-k*factor)*BufferK[shift2];
    			BufferD[shift2+k] = k*factor*BufferD[shift2+n] + (1.0-k*factor)*BufferD[shift2];
    		}
    	}
    
    //----
    //	current candle
    	if(shift1==0)
    	if(BufferK_Curr[shift2+n]!=EMPTY_VALUE && BufferK_Curr[shift2]!=EMPTY_VALUE)
    	{
    		for(k = 1; k < n; k++)
    		{
    			BufferK_Curr[shift2+k] = k*factor*BufferK_Curr[shift2+n] + (1.0-k*factor)*BufferK_Curr[shift2];
    			BufferD_Curr[shift2+k] = k*factor*BufferD_Curr[shift2+n] + (1.0-k*factor)*BufferD_Curr[shift2];
    		}
    
    	//----
    	//	candle time countdown
    		if(ShowClock)
    		{
    			int m,s;
    
    			s = iTime(NULL,TimeFrame,0)+TimeFrame*60 - TimeCurrent();
    			m = (s-s%60)/60;
    			s = s%60;
    
    			string text;
    			if(s<10)	text = "0"+s;
    			else		text = ""+s;
    			text = "            "+m+":"+text;
    
    			int window = WindowFind(IndicatorName);
    			if(window==-1)
    				window = WindowOnDropped() ;
    
    			TimeLabelName = IndicatorName+" Time Counter "+window;
    
    			if(ObjectFind	(TimeLabelName) == -1)
    				ObjectCreate(TimeLabelName, OBJ_TEXT, window, Time[shift2], BufferK_Curr[shift2]+3);
    			else
    				ObjectMove	(TimeLabelName, 0, Time[shift2], BufferK_Curr[shift2]+3);
    
    			ObjectSetText	(TimeLabelName, text, 8, "Verdana", ClockColor);
    		}
    	}
    }
    
    return(0);
    

    }

    string TF2Str(int iPeriod) { switch(iPeriod) { case PERIOD_M1: return("M1"); case PERIOD_M5: return("M5"); case PERIOD_M15: return("M15"); case PERIOD_M30: return("M30"); case PERIOD_H1: return("H1"); case PERIOD_H4: return("H4"); case PERIOD_D1: return("D1"); case PERIOD_W1: return("W1"); case PERIOD_MN1: return("MN1"); default: return("M"+iPeriod); } return(0); }

    int GetHigherTimeFrame(int CurrentPeriod ) { if ( CurrentPeriod == 0 ) CurrentPeriod = Period(); if( CurrentPeriod == 1 ) { return(5); } else if( CurrentPeriod == 5 ) { return(15); } else if( CurrentPeriod == 15 ) { return(30); } else if( CurrentPeriod == 30 ) { return(60); } else if( CurrentPeriod == 60 ) { return(240); } else if( CurrentPeriod == 240 ) { return(1440); } else if( CurrentPeriod == 1440 ) { return(10080); } else if( CurrentPeriod == 10080 ) { return(43200); } else if( CurrentPeriod == 43200 ) { return(43200); } } // int GetHigherTimeFrame()

  18. Assistant

    Analizzando il codice funzionante del tuo indicatore MTF Stochastic rispetto ai tentativi di modifica precedenti, ecco le differenze e le possibili ragioni per cui l'indicatore modificato non disegna nulla sul grafico:

    1. Numero di buffer: Il codice originale dichiara #property indicator_buffers 4 mentre le versioni modificate hanno #property indicator_buffers 6. L'aumento dei buffer potrebbe essere stato una modifica non necessaria se non hai aggiunto funzionalità che richiedono buffer aggiuntivi.

    2. Chiamata ricorsiva: La funzione init() nel codice originale ha una chiamata ricorsiva a se stessa con la riga default: {TimeFrame = Period(); init(); return(0);} all'interno dello switch-case per impostare il TimeFrame. Ciò può essere pericoloso poiché potrebbe causare un loop infinito, tuttavia, se il codice originale era funzionante, significa che questa chiamata ricorsiva non ha causato problemi. Nelle versioni modificate, questa chiamata è stata rimossa o modificata.

    3. ArraySetAsSeries(): Il codice originale non utilizza ArraySetAsSeries() per i buffer BufferK, BufferD, BufferK_Curr e BufferD_Curr, il che suggerisce che l'indicatore originale funzionava senza che questi buffer fossero trattati esplicitamente come serie temporali. Questo può essere perché la piattaforma MT4 potrebbe gestire correttamente i buffer senza bisogno di questa chiamata in alcune situazioni.

    4. Mancato aggiornamento del buffer delle frecce: Nel tentativo di modifica del codice, sono stati aggiunti due nuovi buffer per le frecce (ArrowUpBuffer e ArrowDownBuffer), ma non c'è la logica per aggiornarli nel corpo della funzione start(). Se l'obiettivo era aggiungere frecce al grafico, avresti dovuto includere il codice per settare i valori di questi buffer quando avviene un incrocio dello Stochastic.

    5. Init dei buffer nel ciclo: Un'altra differenza nel codice originale è che i buffer BufferK_Curr e BufferD_Curr sono inizializzati a EMPTY_VALUE all'inizio di ogni chiamata alla funzione start(), mentre nei tentativi di modifica, questo è stato rimosso.

    Per riportare l'indicatore a uno stato funzionante simile al codice originale, dovrai:

    • Cambiare #property indicator_buffers al numero corretto di buffer che stai effettivamente utilizzando.
    • Rimuovere i buffer extra se non sono necessari.
    • Assicurarti che eventuali nuove funzionalità, come le frecce, vengano implementate correttamente.
    • Valuta se è necessario o meno utilizzare ArraySetAsSeries basandoti sulla versione MT4 e sul comportamento osservato. In generale, è buona pratica utilizzare ArraySetAsSeries quando si lavora con buffer, ma se rimuovi quella logica, l'indicatore deve comportarsi come il codice originale.

    Se la versione modificata dell'indicatore deve includere funzionalità aggiuntive (come le frecce), assicurati di completare la logica nella funzione start() per gestire correttamente i nuovi buffer.

  19. User

    ok. scrivi la funzione start per intero con l'aggiunta delle frecce

  20. Assistant

    Per aggiungere frecce all'indicatore esistente, dobbiamo prima stabilire in quali condizioni queste frecce dovrebbero essere mostrate. Tipicamente, le frecce stocastiche sono mostrate quando il %K incrocia il %D da sopra a sotto per una freccia verso il basso (vendita) e da sotto a sopra per una freccia verso l'alto (acquisto). Il seguente esempio di codice implementa questa logica nella funzione start():

    int start()
    {
        int counted_bars = IndicatorCounted();
        if(counted_bars < 0) return(-1);
        if(counted_bars > 0) counted_bars--;
    
        int limit = Bars - counted_bars;
    
        for(int i = limit; i >= 0; i--)
        {
            double currentK = iStochastic(NULL, TimeFrame, KPeriod, DPeriod, Slowing, MAMethod, PriceField, MODE_MAIN, i);
            double currentD = iStochastic(NULL, TimeFrame, KPeriod, DPeriod, Slowing, MAMethod, PriceField, MODE_SIGNAL, i);
    
            // Per evitare valori di buffer non validi nei calcoli successivi
            if(i == 0 || i == 1)
            {
                BufferK_Curr[i] = currentK;
                BufferD_Curr[i] = currentD;
                continue;
            }
    
            // Salva i valori precendenti per confronto
            double previousK = BufferK_Curr[i + 1];
            double previousD = BufferD_Curr[i + 1];
    
            // Popolare il buffer
            BufferK[i] = currentK;
            BufferD[i] = currentD;
    
            // Questo è per la barra attuale (0) e la barra appena chiusa (1)
            BufferK_Curr[i] = currentK;
            BufferD_Curr[i] = currentD;
    
            // Incrocio dal basso verso l'alto (%K incrocia %D verso l'alto)
            if(currentK > currentD && previousK <= previousD)
            {
                ArrowUpBuffer[i] = Low[i] - (4 * Point);
            }
            // Incrocio dall'alto verso il basso (%K incrocia %D verso il basso)
            else if(currentK < currentD && previousK >= previousD)
            {
                ArrowDownBuffer[i] = High[i] + (4 * Point);
            }
            // Se non c'è un incrocio, assicurarsi che il buffer delle frecce sia EMPTY_VALUE
            else
            {
                ArrowUpBuffer[i] = EMPTY_VALUE;
                ArrowDownBuffer[i] = EMPTY_VALUE;
            }
        }
    
        return(0);
    }
    

    Assicurati che le seguenti righe siano presenti nel tuo metodo init() per essere in grado di vedere queste frecce:

    SetIndexBuffer(4, ArrowUpBuffer);
    SetIndexBuffer(5, ArrowDownBuffer);
    SetIndexArrow(4, SYMBOL_ARROWUP);
    SetIndexArrow(5, SYMBOL_ARROWDOWN);
    

    L'uso della variabile counted_bars e del “limit” è stato fatto per garantire l'efficienza durante il calcolo, evitando di ricalcolare valori per barre che sono già state contate in precedenti tick.

    Questo codice di esempio ha un valore arbitrario di distanza (4 volte il Point) per la posizione delle frecce al di sotto del minimo e al di sopra del massimo delle barre. Potresti dover regolare questi valori a seconda della scala dei prezzi del tuo grafico e della dimensione del punto per la coppia di valute che stai scambiando.

  21. User

    questa è la funzione start originale, mi sembra manchi qualche pezzo int start() { //---- // counted bars from indicator time frame static int countedBars1 = 0;

    //---- // counted bars from display time frame if(Bars-1-IndicatorCounted() > 1 && countedBars1!=0) countedBars1 = 0;

    int bars1 = iBars(NULL,TimeFrame),
    	 start1 = bars1-1-countedBars1,
    	 limit1 = iBarShift(NULL,TimeFrame,Time[Bars-1]);
    
    if(countedBars1 != bars1-1)
    {
    	countedBars1  = bars1-1;
    	ArrayInitialize(BufferK_Curr,EMPTY_VALUE);
    	ArrayInitialize(BufferD_Curr,EMPTY_VALUE);
    	if(TimeLabelName!="")
    	if(ObjectFind	(TimeLabelName) != -1)
    		ObjectDelete(TimeLabelName);
    }
    
    if(start1 > limit1 && limit1 != -1)
    	start1 = limit1;
    

    //---- // 3... 2... 1... GO! for(int i = start1; i >= 0; i--) { int shift1 = i;

    	if(TimeFrame < Period())
    		shift1 = iBarShift(NULL,TimeFrame,Time[i]);
    
    	int time1  = iTime    (NULL,TimeFrame,shift1),
    		 shift2 = iBarShift(NULL,0,time1);
    
    	double stochK = iStochastic(NULL,TimeFrame,KPeriod,DPeriod,Slowing,MAMethod,PriceField,0,shift1),
    			 stochD = iStochastic(NULL,TimeFrame,KPeriod,DPeriod,Slowing,MAMethod,PriceField,1,shift1);
    
    //----
    //	old (closed) candles
    	if(shift1>=1)
    	{
    		BufferK[shift2] = stochK;
    		BufferD[shift2] = stochD;
    	}
    
    //----
    //	current candle
    	if((TimeFrame >=Period() && shift1<=1)
    	|| (TimeFrame < Period() &&(shift1==0||shift2==1)))
    	{
    		BufferK_Curr[shift2] = stochK;
    		BufferD_Curr[shift2] = stochD;
    	}
    
    //----
    //	linear interpolatior for the number of intermediate bars, between two higher timeframe candles.
    	int n = 1;
    	if(TimeFrame > Period())
    	{
    		int shift2prev = iBarShift(NULL,0,iTime(NULL,TimeFrame,shift1+1));
    
    		if(shift2prev!=-1 && shift2prev!=shift2)
    			n = shift2prev - shift2;
    	}
    
    //----
    //	apply interpolation
    	double factor = 1.0 / n;
    	if(shift1>=1)
    	if(BufferK[shift2+n]!=EMPTY_VALUE && BufferK[shift2]!=EMPTY_VALUE)
    	{
    		for(int k = 1; k < n; k++)
    		{
    			BufferK[shift2+k] = k*factor*BufferK[shift2+n] + (1.0-k*factor)*BufferK[shift2];
    			BufferD[shift2+k] = k*factor*BufferD[shift2+n] + (1.0-k*factor)*BufferD[shift2];
    		}
    	}
    
    //----
    //	current candle
    	if(shift1==0)
    	if(BufferK_Curr[shift2+n]!=EMPTY_VALUE && BufferK_Curr[shift2]!=EMPTY_VALUE)
    	{
    		for(k = 1; k < n; k++)
    		{
    			BufferK_Curr[shift2+k] = k*factor*BufferK_Curr[shift2+n] + (1.0-k*factor)*BufferK_Curr[shift2];
    			BufferD_Curr[shift2+k] = k*factor*BufferD_Curr[shift2+n] + (1.0-k*factor)*BufferD_Curr[shift2];
    		}
    
    	//----
    	//	candle time countdown
    		if(ShowClock)
    		{
    			int m,s;
    
    			s = iTime(NULL,TimeFrame,0)+TimeFrame*60 - TimeCurrent();
    			m = (s-s%60)/60;
    			s = s%60;
    
    			string text;
    			if(s<10)	text = "0"+s;
    			else		text = ""+s;
    			text = "            "+m+":"+text;
    
    			int window = WindowFind(IndicatorName);
    			if(window==-1)
    				window = WindowOnDropped() ;
    
    			TimeLabelName = IndicatorName+" Time Counter "+window;
    
    			if(ObjectFind	(TimeLabelName) == -1)
    				ObjectCreate(TimeLabelName, OBJ_TEXT, window, Time[shift2], BufferK_Curr[shift2]+3);
    			else
    				ObjectMove	(TimeLabelName, 0, Time[shift2], BufferK_Curr[shift2]+3);
    
    			ObjectSetText	(TimeLabelName, text, 8, "Verdana", ClockColor);
    		}
    	}
    }
    

    // Rileva gli incroci e disegna le frecce for(int j = Bars - countedBars1 - 1; j >= 0; j--) { // Verifica la presenza di valori validi prima di disegnare le frecce if(BufferK_Curr[j] == EMPTY_VALUE || BufferD_Curr[j] == EMPTY_VALUE) continue; // Se uno dei valori è EMPTY_VALUE, salta alla prossima iterazione

    double currentK = BufferK_Curr[j];
    double currentD = BufferD_Curr[j];
    double previousK = BufferK_Curr[j + 1];
    double previousD = BufferD_Curr[j + 1];
    
    // Incrocio dal basso verso l’alto
    if(previousK < previousD && currentK > currentD) {
        ArrowUpBuffer[j] = Low[j] - (4 * Point); // Regola il valore in base alla tua necessità dello spazio tra la freccia e il prezzo
    }
    
    // Incrocio dall’alto verso il basso
    if(previousK > previousD && currentK < currentD) {
        ArrowDownBuffer[j] = High[j] + (4 * Point); // Regola il valore in base alla tua necessità dello spazio tra la freccia e il prezzo
    }
    

    }

    return(0); }

  22. Assistant

    Alla fine della funzione start() fornita, è presente un segmento di codice che tenta di identificare gli incroci tra la linea %K e la linea %D dello stocastico e di disegnare le frecce di conseguenza. Tuttavia, per far sì che le frecce siano visibili sul grafico, è necessario che i buffer ArrowUpBuffer e ArrowDownBuffer siano configurati correttamente nella funzione init(). Dovresti anche dichiarare i buffer delle frecce nel tuo codice.

    Ecco il codice completo di start() modificato per includere correttamente le frecce:

    int start()
    {
        // Variabile per conteggiare il numero di barre già calcolate
        int counted_bars = IndicatorCounted();
        // Se c'è un errore, esce
        if(counted_bars < 0) return(-1);
        // Riduce il numero di barre per il calcolo se è stata aggiunta una nuova barra
        if(counted_bars > 0) counted_bars--;
        int limit = Bars - counted_bars;
    
        // Ciclo attraverso le barre non conteggiate
        for(int i = limit; i >= 0; i--)
        {
            BufferK[i] = iStochastic(NULL, TimeFrame, KPeriod, DPeriod, Slowing, MAMethod, PriceField, MODE_MAIN, i);
            BufferD[i] = iStochastic(NULL, TimeFrame, KPeriod, DPeriod, Slowing, MAMethod, PriceField, MODE_SIGNAL, i);
    
            // Per evitare l'accesso a valori non esistenti ad i-1 quando i è 0
            if(i == 0) continue;
    
            // Regola per le frecce verso l’alto
            if(BufferK[i] > BufferD[i] && BufferK[i-1] <= BufferD[i-1])
            {
                ArrowUpBuffer[i] = Low[i] - (4 * Point); // Valori di esempio, regolare se necessario
                ArrowDownBuffer[i] = EMPTY_VALUE; // Assicurarsi di svuotare il buffer delle frecce verso il basso
            }
            // Regola per le frecce verso il basso
            else if(BufferK[i] < BufferD[i] && BufferK[i-1] >= BufferD[i-1])
            {
                ArrowDownBuffer[i] = High[i] + (4 * Point); // Valori di esempio, regolare se necessario
                ArrowUpBuffer[i] = EMPTY_VALUE; // Assicurarsi di svuotare il buffer delle frecce verso l'alto
            }
            else
            {
                // Se non c'è incrocio, svuotiamo i buffer delle frecce
                ArrowUpBuffer[i] = EMPTY_VALUE;
                ArrowDownBuffer[i] = EMPTY_VALUE;
            }
        }
        
        return(0);
    }
    

    Nota che in questo codice, ho incluso la logica per disegnare le frecce all'interno del ciclo principale in cui vengono calcolati i valori dello stocastico. Ho anche aggiunto una condizione per non eseguire il controllo sull'ultima barra (quando i == 0) dal momento che in MT4 l'ultima barra è in formazione e può causare segnali falsi o errati.

    Se l'obiettivo è visualizzare le frecce rispetto alla barra in corso (current bar), sarà necessario considerare un approccio leggermente diverso che analizzi la barra corrente rispetto al comportamento dello stocastico.

    Inoltre, assicurati che i buffer ArrowUpBuffer e ArrowDownBuffer siano impostati nella funzione init() come segue:

    SetIndexBuffer(4, ArrowUpBuffer);
    SetIndexBuffer(5, ArrowDownBuffer);
    

    Senza questi completamenti, le frecce non saranno visibili sul grafico.

  23. User

    la tua funzione start non è completa. riscrivila completa

  24. Assistant

    Chiedo scusa per l'inconveniente. Ti fornirò la versione completa e corretta della funzione start() che include l'aggiunta delle frecce sulla base del codice originale e della logica fornita precedentemente:

    int start()
    {
        // Conteggio di barre già elaborate
        static int countedBars1 = 0;
    
        // Controlla il necessario aggiornamento dei dati
        if(Bars - IndicatorCounted() > 1 && countedBars1 != 0)
            countedBars1 = 0;
    
        // Calcolo delle barre necessario per il time frame dell'indicatore
        int bars1 = iBars(NULL, TimeFrame),
            start1 = bars1 - 1 - countedBars1,
            limit1 = iBarShift(NULL, TimeFrame, Time[Bars - 1]);
    
        if(countedBars1 != bars1 - 1)
        {
            countedBars1 = bars1 - 1;
            ArrayInitialize(BufferK_Curr, EMPTY_VALUE);
            ArrayInitialize(BufferD_Curr, EMPTY_VALUE);
            if(TimeLabelName != "")
                if(ObjectFind(TimeLabelName) != -1)
                    ObjectDelete(TimeLabelName);
        }
    
        if(start1 > limit1 && limit1 != -1)
            start1 = limit1;
    
        // Calcolo degli indicatori per ogni barra conforme al TimeFrame
        for(int i = start1; i >= 0; i--)
        {
            int shift1 = i;
    
            if(TimeFrame < Period())
                shift1 = iBarShift(NULL, TimeFrame, Time[i]);
    
            int time1  = iTime(NULL, TimeFrame, shift1),
                shift2 = iBarShift(NULL, 0, time1);
    
            double stochK = iStochastic(NULL, TimeFrame, KPeriod, DPeriod, Slowing, MAMethod, PriceField, MODE_MAIN, shift1),
                   stochD = iStochastic(NULL, TimeFrame, KPeriod, DPeriod, Slowing, MAMethod, PriceField, MODE_SIGNAL, shift1);
    
            // Aggiorna i buffer per le barre concluse
            if(shift1 >= 1)
            {
                BufferK[shift2] = stochK;
                BufferD[shift2] = stochD;
            }
    
            // Aggiorna i buffer per la barra corrente
            if((TimeFrame >= Period() && shift1 <= 1) || (TimeFrame < Period() && (shift1 == 0 || shift2 == 1)))
            {
                BufferK_Curr[shift2] = stochK;
                BufferD_Curr[shift2] = stochD;
            }
    
            // Interpolazione per le barre intermedie
            int n = 1;
            if(TimeFrame > Period())
            {
                int shift2prev = iBarShift(NULL, 0, iTime(NULL, TimeFrame, shift1 + 1));
    
                if(shift2prev != -1 && shift2prev != shift2)
                    n = shift2prev - shift2;
            }
    
            // Applica l'interpolazione
            if(shift1 >= 1 && BufferK[shift2 + n] != EMPTY_VALUE && BufferK[shift2] != EMPTY_VALUE)
            {
                double factor = 1.0 / n;
                for(int k = 1; k < n; k++)
                {
                    BufferK[shift2 + k] = k * factor * BufferK[shift2 + n] + (1.0 - k * factor) * BufferK[shift2];
                    BufferD[shift2 + k] = k * factor * BufferD[shift2 + n] + (1.0 - k * factor) * BufferD[shift2];
                }
            }
    
            // Aggiornamento buffer e controllo delle frecce
            if(i > 0)  // Non controlliamo l'ultima barra in fluttuazione
            {
                if(BufferK_Curr[shift2 + n] != EMPTY_VALUE && BufferK_Curr[shift2] != EMPTY_VALUE)
                {
                    double factor = 1.0 / n;
                    for(int k = 1; k < n; k++)
                    {
                        BufferK_Curr[shift2 + k] = k * factor * BufferK_Curr[shift2 + n] + (1.0 - k * factor) * BufferK_Curr[shift2];
                        BufferD_Curr[shift2 + k] = k * factor * BufferD_Curr[shift2 + n] + (1.0 - k * factor) * BufferD_Curr[shift2];
                    }
                }
            }
        }
    
        // Rilevamento degli incroci e disegno delle frecce sul grafico principale
        for(int j = Bars - countedBars1 - 1; j >= 0; j--) 
        {
            // Salta la barra corrente in costruzione
            if(j == 0) 
                continue;
            
            // Condizioni per disegnare una freccia verso l'alto
            if(BufferK_Curr[j] < BufferD_Curr[j] && BufferK_Curr[j + 1] > BufferD_Curr[j + 1]) 
            {
                ArrowUpBuffer[j] = Low[j] - MathMax(MathAbs(Low[j] - High[j]), 4) * Point;
                ArrowDownBuffer[j] = EMPTY_VALUE;
            }
            // Condizioni per disegnare una freccia verso il basso
            else if(BufferK_Curr[j] > BufferD_Curr[j] && BufferK_Curr[j + 1] < BufferD_Curr[j + 1]) 
            {
                ArrowDownBuffer[j] = High[j] + MathMax(MathAbs(Low[j] - High[j]), 4) * Point;
                ArrowUpBuffer[j] = EMPTY_VALUE;
            }
            else 
            {
                // Non ci sono incroci
                ArrowUpBuffer[j] = EMPTY_VALUE;
                ArrowDownBuffer[j] = EMPTY_VALUE;
            }
        }
    
        return(0);
    }
    

    Il codice ora include il segmento finale per disegnare le frecce quando si verifica un incrocio tra le linee %K e %D. Ho utilizzato una funzione MathMax per la dimensione delle frecce per garantire che la distanza dalla barra sia proporzionale alla dimensione della barra stessa. Puoi regolare questo per far sì che le frecce siano visibili bene sul tuo grafico o cambiare il coefficiente numerico per allontanarle ulteriormente dalle barre.

  25. User

    ci sono errori: 'factor' - variable already defined #MTF Stochastic v2.1_2.mq4 229 24 'k' - variable already defined #MTF Stochastic v2.1_2.mq4 230 25 'j–' - undeclared identifier #MTF Stochastic v2.1_2.mq4 240 50

  26. Assistant

    Chiedo scusa per l'errore. Parrebbe che all'interno del ciclo di interpolazione, la variabile factor fosse stata ridefinita e la variabile k fosse stata usata senza dichiararla correttamente. Inoltre, c'è un errore di battitura in j–. Vediamo di correggere questi problemi.

    Ecco come dovrebbe essere scritto correttamente il ciclo all'interno di start():

    // Dopo aver calcolato stochK e stochD nel ciclo...
    
    //---- apply interpolation for the number of intermediate bars (n) between two higher timeframe candles
    if (shift1 >= 1) {
        int shift2next = iBarShift(NULL, 0, iTime(NULL, TimeFrame, shift1 - 1));
        int n = shift2next - shift2; // n is the number of lower timeframe bars within the current higher timeframe bar period
        double kFactor = (n > 1) ? 1.0 / n : 1;
    
        // Interpolate between shift2 and shift2next (the previous bar in the higher timeframe)
        for (int k = 1; k < n; k++) {
            if (BufferK[shift2 + k] == EMPTY_VALUE && BufferK[shift2] != EMPTY_VALUE && BufferK[shift2next] != EMPTY_VALUE) {
                BufferK[shift2 + k] = BufferK[shift2] + k * kFactor * (BufferK[shift2next] - BufferK[shift2]);
                BufferD[shift2 + k] = BufferD[shift2] + k * kFactor * (BufferD[shift2next] - BufferD[shift2]);
            }
        }
    }
    
    // Rilevamento degli incroci e disegno delle frecce...
    for (int j = Bars - countedBars1 - 1; j >= 1; j--) { // Start from the second bar to avoid accessing non-existent array elements
        // Process logic for drawing arrows...
        // Previous logic for arrows...
    }
    

    Questa versione modifica i nomi delle variabili per evitare conflitti ed elimina qualsiasi definizione duplicata. Inoltre, il ciclo per rilevare gli incroci e disegnare le frecce dovrebbe iniziare da 1 anziché 0 per evitare un errore quando si accede a j + 1 nell'array.

    Ricorda di definire correttamente i buffer per le frecce nella funzione init() come segue:

    SetIndexBuffer(4, ArrowUpBuffer);
    SetIndexBuffer(5, ArrowDownBuffer);
    ArrayInitialize(ArrowUpBuffer, EMPTY_VALUE); // Initialize arrow buffers with EMPTY_VALUE
    ArrayInitialize(ArrowDownBuffer, EMPTY_VALUE);
    

    E per coerenza, assicurati che i buffer delle frecce siano dichiarati nella parte superiore del tuo file MQ4:

    //---- indicator buffers
    double BufferK[], BufferD[], BufferK_Curr[], BufferD_Curr[], ArrowUpBuffer[], ArrowDownBuffer[];
    

    Dopo aver apportato queste modifiche, compila di nuovo l'indicatore in MT4 e testa per assicurarti che tutto funzioni come previsto.

  27. User

    riscrivi tutto start

  28. Assistant

    Vediamo una versione corretta della funzione start() includendo le frecce e correggendo gli errori menzionati:

    int start()
    {
        // Conteggio delle barre già processate dal precedente update
        static int countedBars1 = 0;
    
        if(Bars <= countedBars1) return(0);
        int limit = Bars - countedBars1;
    
        for(int i = limit; i >= 0; i--)
        {
            // Calcolo degli indici per il timeframe corrente e quello superiore
            int shift1 = i;
            
            // Se il timeframe dell'indicatore è inferiore a quello del grafico corrente
            if(TimeFrame < Period())
                shift1 = iBarShift(NULL, TimeFrame, Time[i]);
            
            // Calcola il valore dello Stocastico per l'indice calcolato
            double stochK = iStochastic(NULL, TimeFrame, KPeriod, DPeriod, Slowing, MAMethod, PriceField, MODE_MAIN, shift1);
            double stochD = iStochastic(NULL, TimeFrame, KPeriod, DPeriod, Slowing, MAMethod, PriceField, MODE_SIGNAL, shift1);
    
            // Assicuriamoci che lo shift sia valido
            int shift2 = iBarShift(NULL, 0, iTime(NULL, TimeFrame, shift1));
            if(shift2 == -1) continue;
    
            BufferK[shift2] = stochK;
            BufferD[shift2] = stochD;
    
            // Interpolazione se necessario
            if(shift1 > 0) // Se non stiamo guardando l'ultima (corrente) barra
            {
                double prevStochK = iStochastic(NULL, TimeFrame, KPeriod, DPeriod, Slowing, MAMethod, PriceField, MODE_MAIN, shift1 - 1);
                double prevStochD = iStochastic(NULL, TimeFrame, KPeriod, DPeriod, Slowing, MAMethod, PriceField, MODE_SIGNAL, shift1 - 1);
                int shift2prev = iBarShift(NULL, 0, iTime(NULL, TimeFrame, shift1 - 1));
    
                if(shift2prev != -1 && shift2prev > shift2) // Controllo degli indici
                {
                    // Interpolazione lineare di valori tra shift2 e shift2prev
                    int n = shift2prev - shift2;
                    for(int k = 1; k < n; k++)
                    {
                        BufferK[shift2 + k] = stochK + ((prevStochK - stochK) / n) * k;
                        BufferD[shift2 + k] = stochD + ((prevStochD - stochD) / n) * k;
                    }
                }
            }
    
            // Non processare le frecce per la barra corrente (i==0) o per la prima barra storica
            if(i == limit || i == 0) continue;
    
            // Rileva gli incroci e imposta le frecce
            if(BufferK[shift2] < BufferD[shift2] && BufferK[shift2 - 1] > BufferD[shift2 - 1])
            {
                // Incrocio verso l'alto (segnale di acquisto)
                ArrowUpBuffer[shift2] = Low[shift2] - (4 * Point); // Valore a cui posizionare la freccia verso l'alto
                ArrowDownBuffer[shift2] = EMPTY_VALUE; // Pulisce l'altro buffer per evitare sovrapposizioni di segnali
            }
            else if(BufferK[shift2] > BufferD[shift2] && BufferK[shift2 - 1] < BufferD[shift2 - 1])
            {
                // Incrocio verso il basso (segnale di vendita)
                ArrowDownBuffer[shift2] = High[shift2] + (4 * Point); // Valore a cui posizionare la freccia verso il basso
                ArrowUpBuffer[shift2] = EMPTY_VALUE; // Pulisce l'altro buffer per evitare sovrapposizioni di segnali
            }
            else
            {
                // Nessun incrocio rilevato
                ArrowUpBuffer[shift2] = EMPTY_VALUE;
                ArrowDownBuffer[shift2] = EMPTY_VALUE;
            }
        }
    
        // Aggiorna il numero di barre contate dopo il calcolo
        countedBars1 = Bars;
    
        return(0);
    }
    

    Ecco cosa fa il codice:

    • Imposta countedBars1 a zero se il numero di barre nel grafico è maggiore di countedBars1.
    • Il ciclo for itera attraverso le barre inverse a partire dall'ultima barra non contata.
    • Per ogni barra, calcola i valori stocastici per il time frame attuale.
    • Esegue l'interpolazione se necessario per le barre intermedie.
    • Esclude l'elaborazione delle frecce per l'ultima barra corrente e per la prima barra storica.
    • Rileva gli incroci tra K e D, posizionando frecce verso l'alto o il basso secondo la condizione.
    • Aggiorna la variabile countedBars1 al numero attuale di barre.

    Fai attenzione nel codice MQL4 quando lavori con gli indici di array e con i calcoli che riguardano la sincronizzazione tra differenti timeframe di barre. Assicurati di testare l'indicatore in MT4 per confermare che funzioni come previsto.

  29. User

    //+------------------------------------------------------------------+ //| MTF Stochastic.mq4 | //| 2007, Christof Risch (iya) | //| Stochastic indicator from any timeframe. | //+------------------------------------------------------------------+ // Change Log: // 2.1 2012 07 24 Modified to display only the Signal line (smoothed sma) // cr: 2012 07 20 Added NextHigherAuto to automatically seletc the next higher time frame // Added HidePctD to suppress the Slow line, prn

    #property link "http://www.forexfactory.com/showthread.php?t=30109" #property indicator_separate_window #property indicator_buffers 4 #property indicator_color1 Green //C'255,255,255' // White // %K line #property indicator_color2 Red //Yellow // DimGray // %D line #property indicator_color3 Green // C'255,255,255' // White // %K line of the current candle #property indicator_color4 Red //Yellow // DimGray // %D line of the current candle #property indicator_level1 80 #property indicator_level2 20 #property indicator_level3 50 #property indicator_levelcolor DarkSlateGray #property indicator_maximum 100 #property indicator_minimum 0

    //---- input parameters extern bool NextHigherAuto = true; extern bool HidePctK = false; extern bool HidePctD = false; extern int TimeFrame = 0, // {1=M1, 5=M5, 15=M15, ..., 1440=D1, 10080=W1, 43200=MN1} KPeriod = 11, DPeriod = 3, Slowing = 3, MAMethod = 0, // {0=SMA, 1=EMA, 2=SMMA, 3=LWMA} PriceField = 0; // {0=Hi/Low, 1=Close/Close} extern bool ShowClock = false; // display time to candle close countdown extern color ClockColor = Red;

    //---- indicator buffers double BufferK[], BufferD[], BufferK_Curr[], BufferD_Curr[];

    double ArrowUpBuffer[]; double ArrowDownBuffer[]; //---- string IndicatorName = "", TimeLabelName = "";

    //+------------------------------------------------------------------+ //| Custom indicator initialization function | //+------------------------------------------------------------------+ int init() { if (TimeFrame == 0) TimeFrame = Period(); if (NextHigherAuto) TimeFrame = GetHigherTimeFrame(TimeFrame);

    // name for DataWindow and indicator subwindow label
    switch(TimeFrame)
    {
        case PERIOD_M1:    IndicatorName="Period M1";    break;
        case PERIOD_M5:    IndicatorName="Period M5";    break;
        case PERIOD_M15:   IndicatorName="Period M15";   break;
        case PERIOD_M30:   IndicatorName="Period M30";   break;
        case PERIOD_H1:    IndicatorName="Period H1";    break;
        case PERIOD_H4:    IndicatorName="Period H4";    break;
        case PERIOD_D1:    IndicatorName="Period D1";    break;
        case PERIOD_W1:    IndicatorName="Period W1";    break;
        case PERIOD_MN1:   IndicatorName="Period MN1";   break;
    	default:	  {TimeFrame = Period(); init(); return(0);}
    }
    
    IndicatorName = IndicatorName + " Stoch(" + KPeriod + "," + DPeriod + "," + Slowing + ")";
    IndicatorShortName(IndicatorName);
    IndicatorDigits(1);
    
    string TimeFrameStr = TF2Str(TimeFrame);
    
    //---- set indicator buffers
    SetIndexBuffer(0, BufferK);
    ArraySetAsSeries(BufferK, true);
    SetIndexBuffer(1, BufferD);
    ArraySetAsSeries(BufferD, true);
    SetIndexBuffer(2, BufferK_Curr);
    ArraySetAsSeries(BufferK_Curr, true);
    SetIndexBuffer(3, BufferD_Curr);
    ArraySetAsSeries(BufferD_Curr, true);
    SetIndexBuffer(4, ArrowUpBuffer);
    ArraySetAsSeries(ArrowUpBuffer, true);
    SetIndexBuffer(5, ArrowDownBuffer);
    ArraySetAsSeries(ArrowDownBuffer, true);
    
    //---- set index draw begin and styles according to HidePctK and HidePctD
    if (!HidePctK)
    {
        SetIndexStyle(0, DRAW_LINE, EMPTY, 1);
        SetIndexLabel(0, TimeFrameStr + " %K line");
        SetIndexStyle(2, DRAW_LINE, EMPTY, 1);
        SetIndexLabel(2, TimeFrameStr + " %K CurrBar");
    }
    else
    {
        SetIndexStyle(0, DRAW_NONE);
        SetIndexLabel(0, NULL);
        SetIndexStyle(2, DRAW_NONE);
        SetIndexLabel(2, NULL);
    }
    
    if (!HidePctD)
    {
        SetIndexStyle(1, DRAW_LINE, EMPTY, 1);
        SetIndexLabel(1, TimeFrameStr + " %D Signal");
        SetIndexStyle(3, DRAW_LINE, EMPTY, 1);
        SetIndexLabel(3, TimeFrameStr + " %D CurrBar");
    }
    else
    {
        SetIndexStyle(1, DRAW_NONE);
        SetIndexLabel(1, NULL);
        SetIndexStyle(3, DRAW_NONE);
        SetIndexLabel(3, NULL);
    }
    
    //---- arrows settings
    SetIndexArrow(4, SYMBOL_ARROWUP);
    SetIndexStyle(4, DRAW_ARROW);
    SetIndexLabel(4, "Stochastic Arrow Up");
    
    SetIndexArrow(5, SYMBOL_ARROWDOWN);
    SetIndexStyle(5, DRAW_ARROW);
    SetIndexLabel(5, "Stochastic Arrow Down");
    
    return(INIT_SUCCEEDED);
    

    } //+------------------------------------------------------------------+ int deinit() { if(TimeLabelName!="") if(ObjectFind (TimeLabelName) != -1) ObjectDelete(TimeLabelName); }

    //+------------------------------------------------------------------+ //| MTF Stochastic | //+------------------------------------------------------------------+ int start() { // Conteggio delle barre già processate dal precedente update static int countedBars1 = 0;

    if(Bars <= countedBars1) return(0);
    int limit = Bars - countedBars1;
    
    for(int i = limit; i >= 0; i--)
    {
        // Calcolo degli indici per il timeframe corrente e quello superiore
        int shift1 = i;
        
        // Se il timeframe dell’indicatore è inferiore a quello del grafico corrente
        if(TimeFrame < Period())
            shift1 = iBarShift(NULL, TimeFrame, Time[i]);
        
        // Calcola il valore dello Stocastico per l’indice calcolato
        double stochK = iStochastic(NULL, TimeFrame, KPeriod, DPeriod, Slowing, MAMethod, PriceField, MODE_MAIN, shift1);
        double stochD = iStochastic(NULL, TimeFrame, KPeriod, DPeriod, Slowing, MAMethod, PriceField, MODE_SIGNAL, shift1);
    
        // Assicuriamoci che lo shift sia valido
        int shift2 = iBarShift(NULL, 0, iTime(NULL, TimeFrame, shift1));
        if(shift2 == -1) continue;
    
        BufferK[shift2] = stochK;
        BufferD[shift2] = stochD;
    
        // Interpolazione se necessario
        if(shift1 > 0) // Se non stiamo guardando l’ultima (corrente) barra
        {
            double prevStochK = iStochastic(NULL, TimeFrame, KPeriod, DPeriod, Slowing, MAMethod, PriceField, MODE_MAIN, shift1 - 1);
            double prevStochD = iStochastic(NULL, TimeFrame, KPeriod, DPeriod, Slowing, MAMethod, PriceField, MODE_SIGNAL, shift1 - 1);
            int shift2prev = iBarShift(NULL, 0, iTime(NULL, TimeFrame, shift1 - 1));
    
            if(shift2prev != -1 && shift2prev > shift2) // Controllo degli indici
            {
                // Interpolazione lineare di valori tra shift2 e shift2prev
                int n = shift2prev - shift2;
                for(int k = 1; k < n; k++)
                {
                    BufferK[shift2 + k] = stochK + ((prevStochK - stochK) / n) * k;
                    BufferD[shift2 + k] = stochD + ((prevStochD - stochD) / n) * k;
                }
            }
        }
    
        // Non processare le frecce per la barra corrente (i==0) o per la prima barra storica
        if(i == limit || i == 0) continue;
    
        // Rileva gli incroci e imposta le frecce
        if(BufferK[shift2] < BufferD[shift2] && BufferK[shift2 - 1] > BufferD[shift2 - 1])
        {
            // Incrocio verso l’alto (segnale di acquisto)
            ArrowUpBuffer[shift2] = Low[shift2] - (4 * Point); // Valore a cui posizionare la freccia verso l’alto
            ArrowDownBuffer[shift2] = EMPTY_VALUE; // Pulisce l’altro buffer per evitare sovrapposizioni di segnali
        }
        else if(BufferK[shift2] > BufferD[shift2] && BufferK[shift2 - 1] < BufferD[shift2 - 1])
        {
            // Incrocio verso il basso (segnale di vendita)
            ArrowDownBuffer[shift2] = High[shift2] + (4 * Point); // Valore a cui posizionare la freccia verso il basso
            ArrowUpBuffer[shift2] = EMPTY_VALUE; // Pulisce l’altro buffer per evitare sovrapposizioni di segnali
        }
        else
        {
            // Nessun incrocio rilevato
            ArrowUpBuffer[shift2] = EMPTY_VALUE;
            ArrowDownBuffer[shift2] = EMPTY_VALUE;
        }
    }
    
    // Aggiorna il numero di barre contate dopo il calcolo
    countedBars1 = Bars;
    
    return(0);
    

    }

    string TF2Str(int iPeriod) { switch(iPeriod) { case PERIOD_M1: return("M1"); case PERIOD_M5: return("M5"); case PERIOD_M15: return("M15"); case PERIOD_M30: return("M30"); case PERIOD_H1: return("H1"); case PERIOD_H4: return("H4"); case PERIOD_D1: return("D1"); case PERIOD_W1: return("W1"); case PERIOD_MN1: return("MN1"); default: return("M"+iPeriod); } return(0); }

    int GetHigherTimeFrame(int CurrentPeriod ) { if ( CurrentPeriod == 0 ) CurrentPeriod = Period(); if( CurrentPeriod == 1 ) { return(5); } else if( CurrentPeriod == 5 ) { return(15); } else if( CurrentPeriod == 15 ) { return(30); } else if( CurrentPeriod == 30 ) { return(60); } else if( CurrentPeriod == 60 ) { return(240); } else if( CurrentPeriod == 240 ) { return(1440); } else if( CurrentPeriod == 1440 ) { return(10080); } else if( CurrentPeriod == 10080 ) { return(43200); } else if( CurrentPeriod == 43200 ) { return(43200); } } // int GetHigherTimeFrame()

    continua a non esserci nulla, ne lo stocastico ne le frecce

  30. Assistant

    Dall'analisi del tuo codice completo, sembra che ci siano alcune discordanze tra la definizione e l'uso dei buffer. Innanzitutto, nell'intestazione del tuo codice, definisci 6 buffer tramite la direttiva #property indicator_buffers 4, ma effettivamente usi 6 buffer, poiché hai anche aggiunto ArrowUpBuffer[] e ArrowDownBuffer[].

    Per risolvere questo, la direttiva #property indicator_buffers 4 dovrebbe essere cambiata a #property indicator_buffers 6 per accomodare tutti i 6 buffer che usi:

    #property indicator_buffers 6
    

    Successivamente, ci sono alcuni errori che potrebbero influire sul funzionamento dell'indicatore, incluso l'uso di due buffer aggiuntivi che non sono stati definiti in precedenza. Quindi, nella funzione init() dovresti inizializzare questi buffer aggiuntivi come array di serie:

    SetIndexBuffer(4, ArrowUpBuffer);
    ArraySetAsSeries(ArrowUpBuffer, true);
    SetIndexBuffer(5, ArrowDownBuffer);
    ArraySetAsSeries(ArrowDownBuffer, true);
    

    Inoltre, devi definire gli stili e i segni delle frecce sempre nella funzione init():

    SetIndexStyle(4, DRAW_ARROW);
    SetIndexArrow(4, SYMBOL_ARROWUP); // or the code number for the arrow symbol
    SetIndexLabel(4, "Up Arrow");
    
    SetIndexStyle(5, DRAW_ARROW);
    SetIndexArrow(5, SYMBOL_ARROWDOWN); // or the code number for the arrow symbol
    SetIndexLabel(5, "Down Arrow");
    

    Una volta che hai aggiornato la direttiva #property e i buffer nella funzione init(), assicurati che la funzione start() calcoli e utilizzi correttamente tutti i buffer, inclusi quelli per le frecce.

    Quindi, riprova a compilare l'indicatore e a caricarlo su un grafico in MT4. Se i calcoli degli stocastici e le condizioni per le frecce sono corretti, e se hai inserito correttamente gli indici dei buffer, dovresti vedere sia le linee dello stocastico che le frecce disegnate sul grafico.

    Se continui a non vedere risultati, potrebbe essere utile ripassare la logica di calcolo delle frecce nella funzione start() e assicurarti che le condizioni di crossover siano soddisfatte durante i periodi di test. Di seguito è riportato un esempio di come potresti implementare il rilevamento degli incroci e il posizionamento delle frecce nella funzione start():

    int start()
    {
        // ... (il resto della funzione start come nel tuo ultimo codice)
    
        // Il ciclo finale per il rilevamento degli incroci e il disegno delle frecce:
        for(int i = Bars - countedBars1 - 1; i >= 1; i--) { // Bisogna iniziare da 1 (seconda barra dall'ultima)
            if(BufferK_Curr[i] == EMPTY_VALUE || BufferD_Curr[i] == EMPTY_VALUE) continue;
    
            double currentK = BufferK_Curr[i];
            double currentD = BufferD_Curr[i];
            double previousK = BufferK_Curr[i + 1];
            double previousD = BufferD_Curr[i + 1];
    
            // Incrocio dal basso verso l’alto
            if(previousK < previousD && currentK > currentD) {
                ArrowUpBuffer[i] = Low[i] - (4 * Point); // Imposta qui il valore in base allo spazio desiderato tra la freccia e il prezzo
                ArrowDownBuffer[i] = EMPTY_VALUE;
            }
            // Incrocio dall’alto verso il basso
            else if(previousK > previousD && currentK < currentD) {
                ArrowDownBuffer[i] = High[i] + (4 * Point); // Imposta qui il valore in base allo spazio desiderato tra la freccia e il prezzo
                ArrowUpBuffer[i] = EMPTY_VALUE;
            }
            else {
                ArrowUpBuffer[i] = EMPTY_VALUE;
                ArrowDownBuffer[i] = EMPTY_VALUE;
            }
        }
    
        return(0);
    }
    

    Verifica che le direttive #property, la logica di calcolo e la logica di rilevamento degli incroci abbiano tutte le configurazioni corrette, come mostrato sopra.