Outils de non-lagage - page 48

 
zilliq:
Nous utilisons aussi le radian

Il y a peut-être une explication : Dans le code MT4 nous multiplions alfa avec le prix.

Je suppose que c'est le prix, i périods avant, non ?

Et donc on doit ajouter, par exemple avec une len de 5

alfa*close[4]+alfa*close[3]+alfa*close[2]+alfa*close[1] and alfa*close

ou

alfa[4]*fermeture[4]+alfa[3]*fermeture[3]+alfa[2]*fermeture[2]+alfa[1]*fermeture[1] et alfa*fermeture ?

Et c'est étrange, car avec une longueur de 1, le len est égal à 4 (4*1+0) et donc le nonlagma ne peut pas être égal à close car on ajoute l'alfa*prix des 4 dernières périodes.

Merci pour vos prochains commentaires

Zilliq

J'utilise votre code, mais pour mieux comprendre, j'utilise le code le plus simple du NonlagMav3.

double pi = 3.1415926535 ;

double Coeff = 3*pi ;

int Phase = Length-1 ;

double Len = Length*Cycle + Phase ;

si ( counted_bars > 0 ) limit=Bars-counted_bars ;

si ( barres comptées < 0 ) retour(0) ;

si ( counted_bars ==0 ) limit=Bars-Len-1 ;

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

{

Poids=0 ; Somme=0 ; t=0 ;

pour (i=0;i<=Len-1;i++)

{

g = 1.0/(Coeff*t+1) ;

si (t <= 0.5 ) g = 1 ;

beta = MathCos(pi*t) ;

alfa = g * beta ;

prix = iMA(NULL,0,1,0,MODE_SMA,Prix,shift+i) ;

Somme += alfa*prix ;

Poids += alfa ;

si ( t < 1 ) t += 1.0/(Phase-1) ;

else if ( t < Len-1 ) t += (2*Cycle-1)/(Cycle*Length-1) ;

}

si (Poids > 0) MABuffer[shift] = Somme/Poids ;

Vous devez utiliser la forme alfa[4]*close[4]+alfa[3]*close[3]+alfa[2]*close[2]+alfa[1]*close[1] et alfa*close (alpha est différent pour chaque élément).

Pourquoi ne pas faire une version simple qui affiche les valeurs des alphas et les comparer aux valeurs des alphas dans metatrader 4 ?

 

Merci Mladen,

Je vais essayer ceci

En fait, sur MT4, j'ai le prix cfd de mon courtier (Activtrade), et sur Prorealtime c'est un autre flux en Cash, donc il y a de grandes différences.

Merci beaucoup et à plus tard

Zilliq

 

J'ai essayé beaucoup de choses différentes, mais ça ne marche pas et je ne sais pas pourquoi.

Mon code semble être correct :

****************************

poids=0

sum=0

for i=0 to Len

si i<=Phase-1 alors

t = 1.0*i/(Phase-1)

sinon

t = 1,0 + (i-Phase+1)*(2,0*Cyclee-1,0)/(Cyclee*Longueur-1,0)

endif

beta = Cos(pi*t)

g = 1,0/(Coeff*t+1)

si t <= 0,5 alors

g = 1

endif

alfa = g * beta

sum=sum+alfa*close

poids=poids+alfa

suivant

nonlagma=sum/weight

***************************

Et similaire au vôtre mais comme vous le voyez sur mon graphique, le nonlagma est très éloigné du close.

Avez-vous une idée de pourquoi, et avez-vous le code de NonlagMa en langage simple (souvent plus facile à transcrire) ?

Merci beaucoup Mladen, je suis fatigué...

Voir U

Zilliq

Dossiers :
 
zilliq:
Bon, j'ai essayé beaucoup de choses différentes mais ça ne marche pas et je ne sais définitivement pas pourquoi

Mon code semble être correct :

****************************

poids=0

sum=0

for i=0 to Len

si i<=Phase-1 alors

t = 1.0*i/(Phase-1)

sinon

t = 1,0 + (i-Phase+1)*(2,0*Cyclee-1,0)/(Cyclee*Longueur-1,0)

endif

beta = Cos(pi*t)

g = 1,0/(Coeff*t+1)

si t <= 0,5 alors

g = 1

endif

alfa = g * beta

sum=sum+alfa*close

poids=poids+alfa

suivant

nonlagma=sum/weight

***************************

Et similaire au vôtre mais comme vous le voyez sur mon graphique, le nonlagma est très éloigné du close.

Avez-vous une idée de pourquoi, et avez-vous le code de NonlagMa en langage simple (souvent plus facile à transcrire) ?

Merci beaucoup Mladen, je suis fatigué...

Voir U

Zilliq

Voici une version qui ne calcule que les alphas : _nonlag_ma_alphas.mq4

Faites quelque chose comme ça dans protrader. Une fois qu'ils sont identiques, il devrait être facile de faire en sorte que le ma non lag soit également identique. L'exemple est pour la période 50

Dossiers :
 

Merci beaucoup Mladen,

Je vais tester avec cette première étape

Voir U

Zilliq

 

Bien,

Premièrement : bonne nouvelle, j'ai le même EUR/USD que vous, ce sera plus facile de comparer.

Mais je n'y arrive pas vraiment.

Votre code pour calculer l'alpha est :

double Cycle = 4.0 ;

double Coeff = 3.0*Pi ;

int Phase = NlmPeriod-1 ;

int len = NlmPeriod*4 + Phase ;

if (ArraySize(alphas) != len) ArrayResize(alphas,len) ;

for (int k=0 ; k<len ; k++)

{

si (k<=Phase-1)

double t = 1.0 * k/(Phase-1) ;

sinon t = 1,0 + (k-Phase+1)*(2,0*Cycle-1,0)/(Cycle*NlmPeriod-1,0) ;

double beta = MathCos(Pi*t) ;

double g = 1,0/(Coeff*t+1) ; if (t <= 0,5 ) g = 1 ;

alphas[k] = g * beta ;

}

for(int i=len-1 ; i>=0 ; i--) nlm = alphas ;

Donc, si j'ai bien compris :

1/ Première étape : On calcule tous les alphas de 0 à len-1.

C'est :

alphas[k] = g * beta ;

2/ Deuxième étape, il ajoute tous les alphas de 0 à len-1

La formule est la suivante

for(int i=len-1 ; i>=0 ; i--) nlm = alphas ;

Le problème est que j'ai toujours le même alpha sur mon graphique ? Comment pouvez-vous avoir un alpha différent pour chaque bougie alors que k, t et ainsi de suite sont toujours les mêmes pour chaque bougie, et ne dépendent pas de la clôture ?

Le code que j'ai sur Prorealtime semble être le même :

Pi=3.14159265358979323846264338327950288

Cyclee = 4.0

Coeff = 3.0*Pi

Phase = NlmPeriod-1

len = NlmPeriod*4 + Phase

alph=0

pour k=0 à len-1

t=0

si (k<=Phase-1) alors

t = 1,0 * k/(Phase-1)

sinon

t = 1,0 + (k-Phase+1)*(2,0*Cyclee-1,0)/(Cyclee*NlmPeriod-1,0)

endif

beta = Cos(Pi*t)

g = 1,0/(Coeff*t+1)

si (t <= 0,5 ) alors

g = 1

endif

alphas= g * beta

alph=alph+alphas

suivant

 
zilliq:
Bien,

Premièrement : bonne nouvelle, j'ai le même EUR/USD que vous, ce qui facilitera la comparaison.

Mais je n'y arrive pas en fait

Votre code pour calculer l'alpha est le suivant :

double Cycle = 4.0 ;

double Coeff = 3.0*Pi ;

int Phase = NlmPeriod-1 ;

int len = NlmPeriod*4 + Phase ;

if (ArraySize(alphas) != len) ArrayResize(alphas,len) ;

for (int k=0 ; k<len ; k++)

{

si (k<=Phase-1)

double t = 1.0 * k/(Phase-1) ;

sinon t = 1,0 + (k-Phase+1)*(2,0*Cycle-1,0)/(Cycle*NlmPeriod-1,0) ;

double beta = MathCos(Pi*t) ;

double g = 1,0/(Coeff*t+1) ; if (t <= 0,5 ) g = 1 ;

alphas[k] = g * beta ;

}

for(int i=len-1 ; i>=0 ; i--) nlm = alphas ;

Donc, si j'ai bien compris :

1/ Première étape : On calcule tous les alphas de 0 à len-1.

C'est :

alphas[k] = g * beta ;

2/ Deuxième étape, il ajoute tous les alphas de 0 à len-1

La formule est la suivante

for(int i=len-1 ; i>=0 ; i--) nlm = alphas ;

Le problème est que j'ai toujours le même alpha sur mon graphique ? Comment pouvez-vous avoir un alpha différent pour chaque bougie alors que k, t et ainsi de suite sont toujours les mêmes pour chaque bougie, et ne dépendent pas de la clôture ?

Le code que j'ai sur Prorealtime semble être le même :

Pi=3.14159265358979323846264338327950288

Cyclee = 4.0

Coeff = 3.0*Pi

Phase = NlmPeriod-1

len = NlmPeriod*4 + Phase

alph=0

pour k=0 à len-1

t=0

si (k<=Phase-1) alors

t = 1,0 * k/(Phase-1)

sinon

t = 1,0 + (k-Phase+1)*(2,0*Cyclee-1,0)/(Cyclee*NlmPeriod-1,0)

endif

beta = Cos(Pi*t)

g = 1,0/(Coeff*t+1)

si (t <= 0,5 ) alors

g = 1

endif

alphas= g * beta

alph=alph+alphas

suivant

Zilliq

Comme je l'ai dit : il y a un tableau d'alphas.

Ce que j'ai affiché, c'est un tableau d'alphas - sans tenir compte de la composante temporelle. Ce sont les valeurs de chaque valeur alpha dans le tableau des alphas, ce sont les poids qui sont appliqués à chaque élément de prix que vous utilisez pour le calcul.

 

Je ne comprends probablement pas ce que vous appelez un tableau d'alphas (je comprends des alphas différents pour chaque bougie), désolé.

Je vais essayer encore une fois...

 
zilliq:

Je ne comprends probablement pas ce que vous appelez un tableau d'alphas (je comprends des alphas différents pour chaque bougie), désolé.

Je vais essayer encore une fois...

Zilliq

Coefficient (alpha) pour le prix 0 == 1

Coefficient (alpha) pour le prix 1 == 0.9nnnnn

et ainsi de suite (comme il est affiché par l'indicateur alphas non lag ma) et tout cela utilisé pour les prix len pour obtenir la valeur non lag ma actuelle.

 

Ok, je pense avoir compris tes explications (tu es génial ) et j'ai fait différents tests sur MT4 avec ton code

les alpha qui ont une valeur différente de 1 à len-1 pondèrent le prix et à la fin on divise par la somme des alpha.

C'est pourquoi la première valeur des alphas à droite est toujours 1 et c'est pourquoi même si on change la valeur de len-1 l'aspect des alphas sur le graphique est toujours le même (sorte de serpent).

Bon, je sais que je dois chercher comment faire ça sur Prorealtime...