Vous manquez des opportunités de trading :
- Applications de trading gratuites
- Plus de 8 000 signaux à copier
- Actualités économiques pour explorer les marchés financiers
Inscription
Se connecter
Vous acceptez la politique du site Web et les conditions d'utilisation
Si vous n'avez pas de compte, veuillez vous inscrire
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
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
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
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
suivantZilliq
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...
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...