Je veux transplanter l'indice zigzag dans MT4 pour analyser la forme dans SQ.

J'aime l'index d'analyse morphologique en zigzag dans MT4, je veux transplanter l'index en zigzag dans MT4 pour analyser la forme dans SQ, mais il n'y a pas de problème avec le code. Il semble qu'il y ait un problème dans le graphique SQ.

 

paquet SQ.Blocks.Indicators.ZIGZAG ;

import SQ.Calculators.HighestCalculator ;
import SQ.Calculators.LowestCalculator ;
import com.strategyquant.lib.* ;
import com.strategyquant.datalib.* ;
import com.strategyquant.tradinglib.* ;

import SQ.Internal.IndicatorBlock ;

/**
* Nom de l'indicateur tel qu'il sera affiché dans l'interface utilisateur, et son type de retour.
* Types de retour possibles :
* ReturnTypes.Price - l'indicateur est dessiné sur le graphique des prix, comme les SMA, les bandes de Bollinger, etc.
* ReturnTypes.Number - l'indicateur est dessiné sur un graphique séparé, comme CCI, RSI, MACD
* ReturnTypes.PriceRange - l'indicateur est une fourchette de prix, comme l'ATR.
*/
@BuildingBlock(name="(ZIGZAG) ZIGZAG", display="ZIGZAG(#InpDepth#,#InpDeviation#,#InpBackstep#)[#Shift#]", returnType = ReturnTypes.Price)

@Help(“ZIGZAG help text”)
public class ZIGZAG extends IndicatorBlock {

@Paramètre
public ChartData Chart ;

@Parameter(defaultValue="12″)
public int InpDepth ;

@Parameter(defaultValue="5″)
public int InpDeviation ;

@Parameter(defaultValue="3″)
public int InpBackstep ;

@Output(name = "ExtZigzagBuffer", color = Colors.Green)
public DataSeries ExtZigzagBuffer ;

@Sortie
public DataSeries ExtHighBuffer ;
@Sortie
public DataSeries ExtLowBuffer ;

@Override
protected void OnInit() throws TradingException {
ExtZigzagBuffer.set(0,0) ;
ExtHighBuffer.set(0,0.00) ;
ExtLowBuffer.set(0,0.00) ;

}

//————————————————————————
//————————————————————————
//————————————————————————

/**
* Cette méthode est appelée à chaque mise à jour de la barre et la valeur de l'indicateur est calculée ici.
*
* Contrairement à MT4, vous ne calculez pas les valeurs de l'indicateur pour plusieurs barres dans une boucle,
* Vous ne devez calculer la valeur que pour la dernière barre (actuelle).
* Le moteur de trading se chargera d'appeler cette méthode pour chaque barre du graphique.
*
* La barre actuelle pour laquelle la valeur de l'indicateur est calculée est stockée dans la variable CurrentBar.
* Si 0, cela signifie qu'il s'agit de la toute première barre du graphique.
*/
@Override
protected void OnBarUpdate() throws TradingException {

int i ;
int counterZ,whatlookfor=0 ;
int back,pos,lasthighpos=0,lastlowpos=0 ;
double extremum=0 ;
double curlow=0.0,curhigh=0.0,lasthigh=0.0,lastlow=0.0 ;
double val ;
double Point1=0.00001 ;
//Chart.getInstrumentInfo.pointValue ;
int limit=0 ;

for(i=limit ; i>=0 ; i-)

{

//- boucle principale

//- trouver la valeur la plus basse dans la profondeur des barres

val= Chart.Low(InpDepth+i) ;

for(int j = InpDepth+i-1 ; j>=i;j-) {
val = Math.min(val, Chart.Low(j)) ;
}

extremum= val ;

//- cette valeur la plus basse a déjà été trouvée
si(extremum==lastlow)
extremum=0.0 ;
autre
{
//- nouvelle dernière baisse
lastlow=extremum ;
//- écarter l'extremum si la valeur basse actuelle est trop élevée
if(Chart.Low(i)-extremum>InpDeviation*Point1)
extremum=0.0 ;
autre
{
//- effacer les extremums précédents dans les barres de pas en arrière
for(back=1 ; back<=InpBackstep ; back++)
{
pos=i+back ;
if(ExtLowBuffer.get(pos)!=0 && ExtLowBuffer.get(pos)>extremum)
ExtLowBuffer.set(pos,0.0) ;
}
}
}
//- l'extremum trouvé est le niveau le plus bas actuel
if(Chart.Low(i)==extremum)

ExtLowBuffer.set(i,extremum) ;
// ExtLowBuffer[i]=extremum ;
autre
ExtLowBuffer.set(i,0.00) ;

val= Chart.High(InpDepth+i) ;

for(int j = InpDepth+i-1 ; j>=i;j-){
val = Math.max(val, Chart.High(j)) ;
}

//- trouver la valeur la plus élevée dans la profondeur des barres
extremum=val ;
//- cette valeur la plus élevée a déjà été trouvée
if(extremum==lasthigh)
extremum=0.0 ;
autre
{
//- nouveau dernier sommet
lasthigh=extremum ;
//- écarter l'extremum si le niveau actuel est trop bas
if(extremum-Chart.High(i)>InpDeviation*Point1)
extremum=0.0 ;
autre
{
//- effacer les extremums précédents dans les barres de pas en arrière
for(back=1 ; back<=InpBackstep ; back++)
{
pos=i+back ;
if(ExtHighBuffer.get(pos)!=0 && ExtHighBuffer.get(pos)<extremum)
ExtHighBuffer.set(pos,0.00) ;
//ExtHighBuffe.set(pos,0.0) ;
}
}
}
//- l'extremum trouvé est l'extremum actuel
if(Chart.High(i)==extremum)
ExtHighBuffer.set(i,extremum) ;
autre
// ExtHighBufferr.set(i,0.00) ;
ExtHighBuffer.set(i,0.00) ;

}

//- découpe finale
if(whatlookfor==0)
{
lastlow=0.0 ;
lasthigh=0.0 ;
}
autre
{
lastlow=curlow ;
lasthigh=curhigh ;
}

for(i=limit ; i>=0 ; i-)

{

switch(whatlookfor)
{
case 0 : // recherche d'un pic ou d'une pelouse
if(lastlow==0.0 && lasthigh==0.0)
{
if(ExtHighBuffer.get(i)!=0.0)
{
lasthigh=Chart.High(i) ;
lasthighpos=i ;
whatlookfor=-1 ;
ExtZigzagBuffer.set(i,lasthigh) ;
}
if(ExtLowBuffer.get(i)!=0.0)
{
lastlow=Chart.Low(i) ;
lastlowpos=i ;
whatlookfor=1 ;
ExtZigzagBuffer.set(i,lastlow) ;
}
}
pause ;
case 1 : // recherche d'un pic
if(ExtLowBuffer.get(i)!=0.0 && ExtLowBuffer.get(i)<lastlow && ExtHighBuffer.get(i)==0.0)
{
ExtZigzagBuffer.set(lastlowpos,0.0) ;
lastlowpos=i ;
lastlow=ExtLowBuffer.get(i) ;
ExtZigzagBuffer.set(i,lastlow) ;
}
if(ExtHighBuffer.get(i)!=0.0 && ExtLowBuffer.get(i)==0.0)
{
lasthigh=ExtHighBuffer.get(i) ;
lasthighpos=i ;
ExtZigzagBuffer.set(i,lasthigh) ;
whatlookfor=-1 ;
}
pause ;
cas -1 : // recherche d'une pelouse
if(ExtHighBuffer.get(i)!=0.0 && ExtHighBuffer.get(i)>lasthigh && ExtLowBuffer.get(i)==0.0)
{
ExtZigzagBuffer.set(lasthighpos,0.0) ;
lasthighpos=i ;
lasthigh=ExtHighBuffer.get(i) ;
ExtZigzagBuffer.set(i,lasthigh) ;
}
if(ExtLowBuffer.get(i)!=0.0 && ExtHighBuffer.get(i)==0.0)
{
lastlow=ExtLowBuffer.get(i) ;
lastlowpos=i ;
ExtZigzagBuffer.set(i,lastlow) ;
whatlookfor=1 ;
}
pause ;

}
}

}

}