ProRealTime
Zone de développement des applications API, des logiciels et utilitaires développés par les membres du forum

Re: Aide pour développer l’équivalent de la Jurik Moving Average

par takapoto » 20 déc. 2020 10:37

C'est celle que j'ai finalement implémentée.

Je l'ai nommée "PseudoJMA" car, ayant acheté la vraie JMA, j'ai pu constater une grande différence ;)

Mais je l'utilise quand même car la vraie JMA, avec son système de protection est ch.ante à implémenter, il faut une clé spéciale pour chaque machine, clé qui change dès que l'on modifie un composant de l'ordinateur.

Dès que l'on a plusieurs machines de backtest et plusieurs VPS faisant tourner des robots, c'est mission impossible.

Re: Aide pour développer l’équivalent de la Jurik Moving Average

par bruno974 » 14 janv. 2021 18:58

Ah mince, je pensais que c'était "la vraie" :)
Celà dit pour de l'intraday, elle fait vraiment bien le boulot, à mon sens.
Peut-être en jouant sur les paramères on se rapproche de l'original ?
Pourrais-tu fournir un screenshot pour pour voir la différence avec l'indicateur original ?
Merci

Re: Aide pour développer l’équivalent de la Jurik Moving Average

par kero » 14 janv. 2021 19:02

@HellionReign: si le code source de l'indicateur est dispo dans MT4, évidemment que c'est possible.

Oups. Je m'aperçois qu'il y a eu 4 pages de discussion depuis le message auquel je réponds.

Re: Aide pour développer l’équivalent de la Jurik Moving Average

par bruno974 » 14 janv. 2021 19:11

J'ai l'impression que la "pseudo" est basée sur cet "exposé" : https://c.mql5.com/forextsd/forum/164/jurik_1.pdf
Le gars semble dire que c'est l'algo officiel...

Re: Aide pour développer l’équivalent de la Jurik Moving Average

par takapoto » 14 janv. 2021 19:17

- bruno974
Je ne peux pas poster d'exemple de la "vraie" JMA car j'ai changé de PC dernièrement et je n'ai pas pu la réinstaller.
La différence est notable, ce qui ne m'empêche pas d'utiliser et d'apprécier la "Pseudo" qui donne de meilleurs résultats que les autres moyennes traditionnelles.

Re: Aide pour développer l’équivalent de la Jurik Moving Average

par bruno974 » 15 janv. 2021 06:03

Oui, le plus important, plus que les outils en eux-même, c'est la cohérence globale de ton cadre d'analyse

Re: Aide pour développer l’équivalent de la Jurik Moving Average

par bruno974 » 03 juin 2021 21:00

J'ai trouvé quelques pistes pour la recherche de cette fameuse JMA.
Ces 2 codes revendiquent être le code original et se ressemblent (et la logique est comparable au RSX de Jurik) :
https://www.wisestocktrader.com/indicators/5965-the-real-jurik-moving-average-jma-translated-to-amibroker-for-amibroker-afl
https://ctrader.com/algos/indicators/show/191

J'ai essayé de convertir ça en ProBuilder, le code semble correct mais le temps de calcul est hallucinant et rend la chose inexpoitable. Il doit y avoir une erreur mais je ne vois pas où.

Paramètres :
Periods (default 15)
Phase (default 0)

Code : #

//SetBarsRequired( ceil( 20 + 80 * ( Periods ^ 0.36 ) ) );

// Downloaded From https://www.WiseStockTrader.com
//+------------------------------------------------------------------+
//SetBarsRequired(ceil(20+80*(r1^0.36)));
//SetBarsRequired(200,0);
//function IntPortion( Paramet )
//{
//return IIf( Paramet > 0, floor( Paramet ), ceil( Paramet ) );
//};

//+------------------------------------------------------------------+
//function JJMA( Array, Length, Phase )
//{
//----buffers

if barIndex > ceil( 20 + 80 * ( exp(log(Periods) * 0.36 ) ) ) then
Length = Periods
Array = CustomClose
fC0Buffer = 0
fC8Buffer = 0
fA8Buffer = 0
JMAValueBuffer = Array
JMAValue = 0
loopCriteria = 0
cycleDelta = 0
cycleLimit = 0
counterA = 0
counterB = 0
JMATempValue = 0
//+------------------------------------------------------------------+
//|JMAinitFlagizationfunction|
//+------------------------------------------------------------------+
//ring2 = 0
//ring1 = 0
buffer = 0
//----initialpart
limitValue = 63
startValue = 64
//----

for i = 0 to limitValue do
$list[i] = -1000000
next

for i = startValue to 127 do
$list[i] = 1000000
next

//----
initFlag = 1
if Length < 1.0000000002 then
lengthParam = 0.0000000001
else
lengthParam = ( Length - 1 ) / 2.0
endif

//----
if Phase < -100 then
phaseParam = 0.5
elsif Phase > 100  then
phaseParam = 2.5
else
phaseParam = Phase / 100.0 + 1.5
endif

//----
logParam = log( sqrt( lengthParam ) ) / log( 2.0 )

//----
if ( logParam + 2.0 ) < 0 then
logParam = 0
else
logParam = logParam + 2.0
endif
//----
sqrtParam = sqrt( lengthParam ) * logParam

lengthParam = lengthParam * 0.9

lengthDivider = lengthParam / ( lengthParam + 2.0 )

//----
//+------------------------------------------------------------------+
//|JMAiterationfunction|
//+------------------------------------------------------------------+
//----maincycle
loopParam = 0

for shift = 0 to BarIndex - 1 do
series = Array[shift]

if loopParam < 61 then
loopParam = loopParam + 1
$buffer[loopParam] = series
endif

if loopParam > 30 then
if initFlag > 0 then
initFlag = 0
diffFlag = 0
for i = 1 to 29 do
if $buffer[i + 1] <> $buffer[i] then
diffFlag = 1
endif
next

highLimit = diffFlag * 30

if highLimit = 0 then
paramB = series
else
paramB = $buffer[1]
endif

paramA = paramB

if highLimit > 29 then
highLimit = 29
endif
else
highLimit = 0
endif

//----bigcycle
for i = highLimit downto 0 do
if i = 0 then
sValue = series
else
sValue = $buffer[31 - i]
endif

if abs( sValue - paramA ) > abs( sValue - paramB ) then
absValue = abs( sValue - paramA )
else
absValue = abs( sValue - paramB )
endif

dValue = absValue + 0.0000000001 //1.0e-10;

if counterA <= 1 then
counterA = 127
else
counterA = counterA - 1
endif

if counterB <= 1 then
counterB = 10
else
counterB = counterB - 1
endif

if cycleLimit < 128 then
cycleLimit = cycleLimit + 1
endif

cycleDelta = cycleDelta + ( dValue - $ring2[counterB] )

$ring2[counterB] = dValue

if cycleLimit > 10 then
highDValue = cycleDelta / 10.0
else
highDValue = cycleDelta / cycleLimit
endif

if cycleLimit > 127 then
dValue = $ring1[counterA]
$ring1[counterA] = highDValue
s68 = 64
s58 = s68

while s68 > 1 do
if $list[s58] < dValue then
s68 = s68 / 2.0
s58 = s58 + s68
elsif $list[s58] <= dValue then
s68 = 1
else
s68 = s68 / 2.0
s58 = s58 - s68
endif
wend
else
$ring1[counterA] = highDValue
if ( limitValue + startValue ) > 127 then
startValue = startValue - 1
s58 = startValue
else
limitValue = limitValue + 1
s58 = limitValue
endif

if limitValue > 96 then
s38 = 96
else
s38 = limitValue
endif

if startValue < 32 then
s40 = 32
else
s40 = startValue
endif
endif

//----
s68 = 64

s60 = s68

while s68 > 1 do
if $list[s60] >= highDValue then
if $list[s60 - 1] <= highDValue then
s68 = 1
else
s68 = s68 / 2.0
s60 = s60 - s68
endif
else
s68 = s68 / 2.0
s60 = s60 + s68
endif

if ( s60 = 127 ) and ( highDValue > $list[127] ) then
s60 = 128
endif
wend

if cycleLimit > 127 then
if s58 >= s60 then
if( ( ( s38 + 1 ) > s60 ) and ( ( s40 - 1 ) < s60 ) ) then
lowDValue = lowDValue + highDValue
elsif( ( s40 > s60 ) and ( ( s40 - 1 ) < s58 ) ) then
lowDValue = lowDValue + $list[s40 - 1]
endif
else
if( s40 >= s60 ) then
if( ( ( s38 + 1 ) < s60 ) and ( ( s38 + 1 ) > s58 ) ) then
lowDValue = lowDValue + $list[s38 + 1]
else
if( ( s38 + 2 ) > s60 ) then
lowDValue = lowDValue + highDValue
else
if( ( ( s38 + 1 ) < s60 ) and ( ( s38 + 1 ) > s58 ) ) then
lowDValue = lowDValue + $list[s38 + 1]
endif
endif
endif
endif
endif

if( s58 > s60 ) then
if( ( ( s40 - 1 ) < s58 ) and ( ( s38 + 1 ) > s58 ) ) then
lowDValue = lowDValue - $list[s58]
else
if( ( s38 < s58 ) and ( ( s38 + 1 ) > s60 ) ) then
lowDValue = lowDValue - $list[s38]
endif
endif
else
if( ( ( s38 + 1 ) > s58 ) and ( ( s40 - 1 ) < s58 ) ) then
lowDValue = lowDValue - $list[s58]
else
if( ( s40 > s58 ) and ( s40 < s60 ) ) then
lowDValue = lowDValue - $list[s40]
endif
endif
endif
endif

if( s58 <= s60 ) then
if( s58 >= s60 ) then
$list[s60] = highDValue
else
for j = s58 + 1 to s60 - 1 do
$list[j - 1] = $list[j]
next

$list[s60 - 1] = highDValue
endif
else
for j = s58 - 1 downto s60 do
$list[j + 1] = $list[j]
next

$list[s60] = highDValue
endif

if( cycleLimit <= 127 ) then
lowDValue = 0

for j = s40 to s38 do
lowDValue = lowDValue + $list[j]
next
endif

//----
if( ( loopCriteria + 1 ) > 31 ) then
loopCriteria = 31
else
loopCriteria = loopCriteria + 1
endif

JMATempValue = sqrtParam / ( sqrtParam + 1.0 )
sqrtDivider = JMATempValue

if( loopCriteria <= 30 ) then
if( sValue - paramA > 0 ) then
paramA = sValue
else
paramA = sValue - ( sValue - paramA ) * sqrtDivider
endif

if( sValue - paramB < 0 ) then
paramB = sValue
else
paramB = sValue - ( sValue - paramB ) * sqrtDivider
endif

JMATempValue = series

if( loopCriteria = 30 ) then
$fC0Buffer[shift] = series

if( ceil( sqrtParam ) >= 1 ) then
intPart = ceil( sqrtParam )
else
intPart = 1
endif

if intPart > 0 then
leftInt = floor(intPart)
else
leftInt = ceil(intPart)
endif

if( floor( sqrtParam ) >= 1 ) then
intPart = floor( sqrtParam )
else
intPart = 1
endif

if intPart > 0 then
rightPart = floor(intPart)
else
rightPart = ceil(intPart)
endif

if( leftInt = rightPart ) then
dValue = 1.0
else
dValue = ( sqrtParam - rightPart ) / ( leftInt - rightPart )
endif

if( rightPart <= 29 ) then
upShift = rightPart
else
upShift = 29
endif

if( leftInt <= 29 ) then
dnShift = leftInt
else
dnShift = 29
endif

$fA8Buffer[shift] = ( series - $buffer[loopParam - upShift] ) * ( 1 - dValue ) / rightPart + ( series - $buffer[loopParam - dnShift] ) * dValue / leftInt
endif
else
dValue = lowDValue / ( s38 - s40 + 1 )

if( 0.5 <= logParam - 2.0 ) then
powerValue = logParam - 2.0
else
powerValue = 0.5
endif

// a^Pow = EXP(LOG(a)*Pow)
if( logParam >= exp(log(absValue / dValue) * powerValue) ) then
dValue = exp(log(absValue / dValue) * powerValue)
else
dValue = logParam
endif

if( dValue < 1 ) then
dValue = 1
endif

powerValue = exp(log(sqrtDivider) * ( sqrt( dValue ) ))

if( sValue - paramA > 0 ) then
paramA = sValue
else
paramA = sValue - ( sValue - paramA ) * powerValue
endif

if( sValue - paramB < 0 ) then
paramB = sValue
else
paramB = sValue - ( sValue - paramB ) * powerValue
endif
endif
next

//----endofbigcycle
if( loopCriteria > 30 ) then
JMATempValue = $JMAValueBuffer[shift - 1]
powerValue = exp(log(lengthDivider) * dValue)
squareValue = powerValue * powerValue

$fC0Buffer[shift] = ( 1 - powerValue ) * series + powerValue * $fC0Buffer[shift - 1]
$fC8Buffer[shift] = ( series - $fC0Buffer[shift] ) * ( 1 - lengthDivider ) + lengthDivider * $fC8Buffer[shift - 1]

$fA8Buffer[shift] = ( phaseParam * $fC8Buffer[shift] + $fC0Buffer[shift] - JMATempValue ) * ( powerValue * ( -2.0 ) + squareValue + 1 ) + squareValue * $fA8Buffer[shift - 1]
JMATempValue = JMATempValue + $fA8Buffer[shift]
endif

JMAValue = JMATempValue
endif

if( loopParam <= 30 ) then
JMAValue = close[BarIndex - 1]
endif

$JMAValueBuffer[shift] = JMAValue
//----Endofmaincycle
next
endif

return $JMAValueBuffer[0]

Re: Aide pour développer l’équivalent de la Jurik Moving Average

par takapoto » 03 juin 2021 21:23

Merci Bruno,
Je vais creuser ces pistes de mon côté quand j'aurais un peu de temps.
Je te tiendrais au courant :)

Re: Aide pour développer l’équivalent de la Jurik Moving Average

par takapoto » 05 juin 2021 21:09

J'ai retrouvé un vieux fichier avec quelques prix et les valeurs de la "vraie" JMA associées.

Voilà ce que ça donne :
Capture d’écran 2021-06-05 à 20.52.33.png
Capture d’écran 2021-06-05 à 20.52.33.png (82.99 Kio) Vu 186 fois

En y ajoutant la "pseudo" JMA que j'évoque dans les posts précédents, on a :
Capture d’écran 2021-06-05 à 20.53.18.png
Capture d’écran 2021-06-05 à 20.53.18.png (93.48 Kio) Vu 186 fois

Si on y met la JMA calculée avec les liens donnés par Bruno, on a :
Capture d’écran 2021-06-05 à 20.54.08.png
Capture d’écran 2021-06-05 à 20.54.08.png (83.34 Kio) Vu 186 fois

Pour information, avec une MMA simple, cela donne :
Capture d’écran 2021-06-05 à 20.55.06.png
Capture d’écran 2021-06-05 à 20.55.06.png (81.96 Kio) Vu 186 fois

Comparaison des 3 JMA :
Capture d’écran 2021-06-05 à 20.57.10.png
Capture d’écran 2021-06-05 à 20.57.10.png (93.37 Kio) Vu 186 fois

Conclusion :
- La "pseudo" JMA et la JMA de Bruno sont très proches.
- Aucune des deux n'est aussi performante que la "vraie.


NB :
Les JMA et la MMA on été calculées avec les paramètres qui leur permettent de "coller" au plus près de la "vraie" JMA.

Re: Aide pour développer l’équivalent de la Jurik Moving Average

par HellionReign » 06 juin 2021 10:06

:merci: Kero ;),
:roll: Désoler Je Viens Tout Juste De Voir Ton Message :?,
Prends Soin De Toi :mercichinois:.



:merci: Taka :mercichinois:,
Effectivement Impressionnante Cette JMA :top: :top: :top:,
Dommage Quelle Ne Soit Pas Sur prt :?,
Bon Courage Pour Tes Recherches :mercichinois:.

Sujets similaires
DAX 200 weekly moving average
Fichier(s) joint(s) par ManiakTrader » 21 oct. 2018 13:07 (0 Réponses)
Un équivalent du tracker BX4 sur le Nasdaq ?
par helio » 18 mars 2018 23:05 (12 Réponses)
Équivalent à "position forcée" sur futures
par Benoist Rousseau » 27 juin 2018 11:10 (3 Réponses)
Site équivalent à l'EUREX pour le DJ
par Daeiondf » 29 nov. 2018 10:16 (2 Réponses)
panne cotation équivalent fermeture du marché ?
par ChristelleP » 17 juin 2021 16:24 (2 Réponses)
Average Lifetime Performance
par LLivingstone » 13 mai 2014 20:19 (5 Réponses)
Average Directional Movement Index (ADMI) sur PRT ?
par Clive » 10 déc. 2016 23:11 (5 Réponses)
Creation indicateur OPVA (On Price Volume Average)
par Amarantine » 02 nov. 2021 19:53 (1 Réponses)
Comment développer un système de trading?
par Edd » 23 avr. 2016 22:04 (16 Réponses)