Overblog Suivre ce blog
Administration Créer mon blog
28 février 2008 4 28 /02 /février /2008 20:11

L'oscillateur SVAPO Price-Only  de Sylvain Vervoort.

Dans le numéro de février de S&C, il y a un article "Trading Medium-Term Divergences" où Sylvain Vervoort décrit l'utilisation de divergences entre les cours et de nombreux oscillateurs.  L'auteur présente également une moyenne exponentielle zéro-lag ainsi que l'indicateur SVAPO Price-Only.  Voici un graphe de ALL avec les 2 indicateurs et les signaux générés par les divergences :

hk93-copie-1.gif

Le code Prorealtime pour la moyenne zéro-lag :

len=20
ema1=exponentialaverage[len](close)
ema2=exponentialaverage[len](ema1)
dif=ema1-ema2
zlagema=ema1+dif
return zlagema

Edit le 29/02/08 : un lecteur du blog, Philippe, me fait remarquer que la moyenne exponentielle zéro-lag de Vervoort n'est ni plus ni moins que la moyenne Dema déjà présente sur la plateforme.

Et le code du SVAPO Price-Only :

per=8
cut=1
devh=1.5
devl=1.3
stdevper=100
/////////// heikin ashi smoothing
ap=TotalPrice
if barindex>0 then
    hao=(ap[1]+hao[1])/2
else
    hao=ap
endif
hacl=(ap+hao+max(high,max(ap,hao))+min(low,min(ap,hao)))/4
hac=TEMA[.625*per](hacl)
//////////// medium term ma of volume to limit extremes
vave=average[5*per](close[1])
///////////// basic trend
vtrend=tema[per](LinearRegressionSlope[per](close))
///////////// svapo price only
cutmul=0.001*cut
c3=(vtrend>vtrend[1] or vtrend[1]>vtrend[2])
c4=(vtrend>=vtrend[1] or vtrend[1]>=vtrend[2])
c1=(hac>hac[1]*(1+cutmul) and c4)
c2=(hac<hac[1]*(1-cutmul) and c3)
sum=0
for i=0 to per-1
    if c1[i] then
        sum=sum+close[i]
    elsif c2[i] then
        sum=sum-close[i]
    endif
next
svap=sum/(vave+1)
svapo=tema[per](svap)
ht=devh*STD[stdevper](svapo)
bs=-devl*std[stdevper](svapo)
return svapo,ht,bs,0ug_fck
Repost 0
Published by hk_lisse - dans Indicateurs
commenter cet article
21 février 2008 4 21 /02 /février /2008 19:00

La  représentation en Heikin Ashi : les codes du programme Prorealtime.

Suite à la demande  de Camille, voici les codes Prorealtime.  Tout d'abord, je crée 3 indicateurs qui renvoient les cours en Heikin Ashi : 1. la méthode originale, 2. le lissage avec la T3 de Tillson (de période 3) et 3. le lissage avec la moyenne Kaufman adaptative (KAMA de période 2).


//////////////// indicateur heikin simple //////////////
once haopen=open
haclose=(open+close+high+low)/4
if barindex> 0 then
    haopen=(haopen+haclose[1])/2
endif
halow=min(low,min(haclose,haopen))
hahigh=max(high,max(haclose,haopen))
return haopen,haclose,hahigh,halow


//////////////// indicateur heikin tillson /////////////////
period=3
price=close
vfactor=.7
x1=(exponentialaverage[period](price))*(1+vfactor)
x2=(exponentialaverage[period](exponentialaverage[period](price)))*vfactor
gd=x1-x2
x11=(exponentialaverage[period](gd))*(1+vfactor)
x21=(exponentialaverage[period](exponentialaverage[period](gd)))*vfactor
gd1=x11-x21
x12=(exponentialaverage[period](gd1))*(1+vfactor)
x22=(exponentialaverage[period](exponentialaverage[period](gd1)))*vfactor
gd2=x12-x22

once haopen=open
haclose=gd2
if barindex> 12 then
    haopen=(haopen+haclose[1])/2
endif
halow=min(low,min(haopen,haclose))
hahigh=max(high,max(haopen,haclose))
return haopen,haclose,hahigh,halow

///////////////////// indicateur heikin kama /////////////////
p=2
ONCE ama = UNDEFINED
signal = ABS(MOMENTUM[p])
noise = SUMMATION[p](ABS(MOMENTUM[1]))
IF noise>0 THEN
    er = signal / noise
ELSE
    er=1
ENDIF
fastsc = 2 / (2+ 1)
slowsc = 2 / (20 + 1)
factor = SQUARE(er * (fastsc - slowsc) + slowsc)
IF BARINDEX = p THEN
    ama = CLOSE
ELSIF BARINDEX > p THEN
    ama = ama + factor * (CLOSE - ama)
ENDIF

once haopen=open
haclose=ama
if barindex> 12 then
    haopen=(haopen+haclose[1])/2
endif
halow=min(low,min(haopen,haclose))
hahigh=max(high,max(haopen,haclose))
return haopen,haclose,hahigh,halow

Puis de nouveau, je crée 3 indicateurs pour dessiner les bougies en Heikin Ashi : 1. la mèche basse, 2. la mèche haute et 3. le corps de la bougie. 

////////////////// indicateur mèche basse heikin /////////////
haopen,haclose,ignored,bas = CALL "heikin tillson"
c2=min(haopen,haclose)
r=abs(c2-bas)
r=(r)/29
b1=bas
c=1
b2=b1+r
b3=b2+r
b4=b3+r
b5=b4+r
b6=b5+r
b7=b6+r
b8=b7+r
b9=b8+r
b10=b9+r
b11=b10+r
b12=b11+r
b13=b12+r
b14=b13+r
b15=b14+r
b16=b15+r
b17=b16+r
b18=b17+r
b19=b18+r
b20=b19+r
b21=b20+r
b22=b21+r
b23=b22+r
b24=b23+r
b25=b24+r
b26=b25+r
b27=b26+r
b28=b27+r
b29=b28+r
b30=b29+r

return b1 coloured by c,b2 coloured by c,b3 coloured by c,b4 coloured by c,b5 coloured by c,b6 coloured by c,b7 coloured by c,b8 coloured by c,b9 coloured by c,b10 coloured by c,b11 coloured by c,b12 coloured by c,b13 coloured by c,b14 coloured by c,b15 coloured by c,b16 coloured by c,b17 coloured by c,b18 coloured by c,b19 coloured by c,b20 coloured by c,b21 coloured by c,b22 coloured by c,b23 coloured by c,b24 coloured by c,b25 coloured by c,b26 coloured by c,b27 coloured by c,b28 coloured by c,b29 coloured by c,b30 coloured by c

///////////////////////// indicateur mèche haute heikin /////////////////////
haopen,haclose,haut,ignored = CALL "heikin tillson"
c2=max(haopen,haclose)
r=abs(haut-c2)
r=(r)/29
b1=c2
c=1
b2=b1+r
b3=b2+r
b4=b3+r
b5=b4+r
b6=b5+r
b7=b6+r
b8=b7+r
b9=b8+r
b10=b9+r
b11=b10+r
b12=b11+r
b13=b12+r
b14=b13+r
b15=b14+r
b16=b15+r
b17=b16+r
b18=b17+r
b19=b18+r
b20=b19+r
b21=b20+r
b22=b21+r
b23=b22+r
b24=b23+r
b25=b24+r
b26=b25+r
b27=b26+r
b28=b27+r
b29=b28+r
b30=b29+r

return b1 coloured by c,b2 coloured by c,b3 coloured by c,b4 coloured by c,b5 coloured by c,b6 coloured by c,b7 coloured by c,b8 coloured by c,b9 coloured by c,b10 coloured by c,b11 coloured by c,b12 coloured by c,b13 coloured by c,b14 coloured by c,b15 coloured by c,b16 coloured by c,b17 coloured by c,b18 coloured by c,b19 coloured by c,b20 coloured by c,b21 coloured by c,b22 coloured by c,b23 coloured by c,b24 coloured by c,b25 coloured by c,b26 coloured by c,b27 coloured by c,b28 coloured by c,b29 coloured by c,b30 coloured by c

//////////////////// indicateur corps heikin ///////////////
haopen,haclose,ignored,ignored = CALL "heikin tillson"
c1=(haopen<haclose)
if c1 then
    c=1
else
    c=-1
endif
r=abs(haopen-haclose)
r=(r)/29
if haopen<haclose then
    b1=haopen
else
    b1=haclose
endif
b2=b1+r
b3=b2+r
b4=b3+r
b5=b4+r
b6=b5+r
b7=b6+r
b8=b7+r
b9=b8+r
b10=b9+r
b11=b10+r
b12=b11+r
b13=b12+r
b14=b13+r
b15=b14+r
b16=b15+r
b17=b16+r
b18=b17+r
b19=b18+r
b20=b19+r
b21=b20+r
b22=b21+r
b23=b22+r
b24=b23+r
b25=b24+r
b26=b25+r
b27=b26+r
b28=b27+r
b29=b28+r
b30=b29+r

return b1 coloured by c,b2 coloured by c,b3 coloured by c,b4 coloured by c,b5 coloured by c,b6 coloured by c,b7 coloured by c,b8 coloured by c,b9 coloured by c,b10 coloured by c,b11 coloured by c,b12 coloured by c,b13 coloured by c,b14 coloured by c,b15 coloured by c,b16 coloured by c,b17 coloured by c,b18 coloured by c,b19 coloured by c,b20 coloured by c,b21 coloured by c,b22 coloured by c,b23 coloured by c,b24 coloured by c,b25 coloured by c,b26 coloured by c,b27 coloured by c,b28 coloured by c,b29 coloured by c,b30 coloured by c


J'ouvre une fenêtre avec l'indicateur de mèche basse, j'y ajoute l'indicateur de mèche haute puis l'indicateur de corps (tout cela dans la même fenêtre).  Tous les indicateurs sont à mettre en points, épaisseur 2 pour les mèches et maximum pour le corps.  Couleur noire pour les mèches et vert/rouge pour le corps.  c'est assez fastidieux à faire mais une fois paramètré, le résultat à l'écran est exellent.

Sur la deuxième ligne du programme, on peut appeler "heikin simple" ou "heikin kama" à la place de "heikin tillson".

Voici un lien (page 14) où est expliqué un système basé sur le Heikin Ashi modifié, en plus d'utiliser une moyenne pour lisser les cours, le cours est modifié par la formule : cclose=((open+close)/2+(((close-open)/(high-low))*abs(close-open)/2)). 

Les informations sont tirées du forum Aktienboard dédié à la programmation Prorealtime (c'est  ici)..  fck
Repost 0
Published by hk_lisse - dans Heikin Ashi
commenter cet article
17 février 2008 7 17 /02 /février /2008 15:31

Le filtre Laguerre.


Dans le document "Time Warp Without Space Travel", téléchargeable sur le site mesasoftware.com, J. Ehlers (arriverais-je à en faire le tour ?) présente le filtre Laguerre.  Voici une vue  du future DAX avec un coéfficient  de 0.8 :

hk91.gif


Un filtre FIR est ajouté pour comparaison, un coéfficient de 0 rend le filtre Laguerre identique au filtre FIR.


Voici le code pour Prorealtime, il faut mettre gamma en variable :

pr=medianprice
once l0=pr
once l1=pr
once l2=pr
once l3=pr
if barindex>0 then
    l0=(1-gamma)*pr+gamma*l0[1]
    l1=-gamma*l0+l0[1]+gamma*l1[1]
    l2=-gamma*l1+l1[1]+gamma*l2[1]
    l3=-gamma*l2+l2[1]+gamma*l3[1]
endif
filtre=(l0+2*l1+2*l2+l3)/6
fir=(pr+2*pr[1]+2*pr[2]+pr[3])/6

return filtre,fir

Le Laguerre RSI.

Dans le même document, Ehlers présente également le Laguerre RSI qui d'après l'auteur, donne de très bons signaux.  L'indicateur a l'air populaire sur le Forex comme en témoigne ce système.  Voici une vue de l'EURUSD avec l'indicateur (coéfficient 0.5) :

hk92.gif

Les signaux d'achat sont donnés par un croisement à la hause de la ligne 0.2 et les signaux de vente par un croisement de la ligne 0.8 à la baisse.  On peut faire varier ces différents niveaux ainsi que le coéfficient, tout cela à backtester bien évidemment.

Voici le code pour Prorealtime, il faut toujours introduire gamma en variable :

pr=medianprice
once l0=pr
once l1=pr
once l2=pr
once l3=pr
once rsil=undefined
if barindex>0 then
    l0=(1-gamma)*pr+gamma*l0[1]
    l1=-gamma*l0+l0[1]+gamma*l1[1]
    l2=-gamma*l1+l1[1]+gamma*l2[1]
    l3=-gamma*l2+l2[1]+gamma*l3[1]
    cu=0
    cd=0
    if l0>=l1 then
        cu=l0-l1
    else
        cd=l1-l0
    endif
    if l1>=l2 then
        cu=cu+l1-l2
    else
        cd=cd+l2-l1
    endif
    if l2>=l3 then
        cu=cu+l2-l3
    else
        cd=cd+l3-l2
    endif
    rsil=cu/(cu+cd)
endif

return rsil,0.2,0.8

sbug_fck
Repost 0
Published by hk_lisse - dans Indicateurs
commenter cet article
15 février 2008 5 15 /02 /février /2008 15:47

La représentation des cours en Heikin Ashi.


La méthode Heikin Ashi de représentation des cours a été popularisée par Dan Valcu.  Elle permet de mieux visualiser la tendance.  Les bougies sont construites avec les règles suivantes :

 - cloture_HA = (open+close+high+low)/4

 - ouverture_HA = (ouverture_HA[1]+cloture_HA[1])/2,  en fait, on prend le médian du corps de la bougie Heikin Ashi précédente.

 - haut_HA = maximum de cloture_HA,  ouverture_HA et high.

 - bas_HA = minimum de cloture_HA, ouverture_HA et low.


La plateforme Prorealtime permet de représenter les cours en Heikin Ashi, j'ai quand même créé un indicateur qui a une fonction similaire afin de pouvoir jouer sur la formule de représentation.  Voici une vue du NASDAQ COMP  avec les bougies classiques (en fenêtre 1), avec la représentation Prorealtime (en fenêtre 2) et avec le système que j'ai créé en utilisant l'indicateur de coloriage (en fenêtre 3).


hk86.gif
hk87.gif
hk88.gif


En utilisant le nouveau système, je peux donc bidouiller les données de la représentation en Heikin Ashi.  Par exemple en lissant le point d'entrée avec une moyenne T3 de Tillson (Smoothed Heikin Ashi).  Voici le nouveau graphe où quelques faux signaux disparaissent (le code se trouve ici) :


hk89.gif


Une autre utilisation du lissage Heikin Ashi, serait d'y appliquer des indicateurs.  Voici une comparaison entre un stochastic 7,3,3 appliqué aux données Heikin Ashi (fenêtre du haut) et un autre avec les données ordinaires.  A première vue, pas trop de différences.

hk90.gif


Voici le code pour info, il faut introduire p,q et r en variable pour respectivement la période, le %k et le %d :

once haopen=open
haclose=(close+open+high+low)/4
if barindex>0 then
    haopen=(haopen[1]+haclose[1])/2
endif
haut=max(high,max(haopen,haclose))
bas=min(low,min(haopen,haclose))


REM Détermine les plus hauts et plus bas sur p barres

plusHaut = highest[p](haut)
plusBas = lowest[p](bas)

REM Construit l'oscillateur

oscillateur = (haclose - plusBas) / (plusHaut - plusBas) * 100

REM En déduit les lignes du stochastic

ligneK = ExponentialAverage[q](oscillateur)
ligneD = average[r](ligneK)

return ligneK as "%K", ligneD as "%D",20,80






Repost 0
Published by hk_lisse - dans Heikin Ashi
commenter cet article
15 février 2008 5 15 /02 /février /2008 11:40

Le lissage de Butterworth.


J. Ehlers fait mention du filtre de Butterworth dans ses travaux.  Voici une vue de BA avec l'indicateur, en vert le filtre à 2 pôles de paramètre 10, en rouge le filtre à 3 pôles de paramètre 10, en jaune le filtre à 2 pôles de paramètre 20 et en bleu le filtre à 3 pôles de paramètre 20.


hk85.gif


Voici le code pour Prorealtime, il faut introduire per en variable :


p1=per
pr=close
pi=3.14159265
// filtre à 2 pôles
a1=exp(-sqrt(2)*pi/p1)
b1=2*a1*cos(sqrt(2)*180/p1)
cf1=(1-b1+a1*a1)/4
cf2=b1
cf3=-a1*a1
if barindex>1 then
    but2=cf1*(pr+2*pr[1]+pr[2])+cf2*but2[1]+cf3*but2[2]
endif
// filtre à 3 pôles
a1=exp(-pi/p1)
b1=2*a1*cos(1.738*180/p1)
c1=a1*a1
cf1=(1-b1+c1)*(1-c1)/8
cf2=b1+c1
cf3=-(c1+b1*c1)
cf4=c1*c1
if barindex>2 then
    but3=cf1*(pr+3*pr[1]+3*pr[2]+pr[3])+cf2*but3[1]+cf3*but3[2]+cf4*but3[3]
endif

return but2,but3nti_bug_fck
Repost 0
Published by hk_lisse - dans Indicateurs
commenter cet article
14 février 2008 4 14 /02 /février /2008 18:11

Changement de crèmerie.


Je termine à l'instant le transfert des articles publiés sur l'ancien blog, hors archives.  Désormais, l'aventure hk-lisse se poursuit sur Over-Blog.com.  Certes, le référencement web y est moins bon et la taille des images plus réduite mais le sourire de la crémière a fait la différence.  Et puis si vous lisez ce message, c'est que vous avez quand même réussi à me retrouver.

i_bug_fck
Repost 0
Published by hk_lisse - dans Commentaires
commenter cet article
14 février 2008 4 14 /02 /février /2008 16:20

Fourier Transform for Traders, by John Ehlers.

 

Dans le numéro de janvier 2007 de S&C, on retrouve un dernier article de John Ehlers sur la façon d'utiliser les cycles pour le trading.  Il propose d'utiliser la "Discrete Fourier Transform" (DFT) pour le tuning des indicateurs.  Il prend en exemple un RSI où la période est fonction du cycle dominant calculé par la DFT.  Je ne suis pas un fan du RSI, j'ai rentré la période adaptative dans un système de moyennes mobiles (exemple proposé par le développeur de WEALTH-LAB).  Les signaux sont donnés par le croisement de la courbe de régression linéaire (de période = 1/4 cycle) avec la moyenne mobile simple (de période = 1/2 cycle).  Voici une vue de KO avec les 2 moyennes et dans la fenêtre du bas, l'indicateur qui retourne le cycle dominant.

 

hk84.gif

 

Plusieurs remarques :

 - Je ne suis pas certain de l'exactitude des calculs, après une rapide comparaison avec le graphe d'IBM présenté dans l'article.  J'éditerai le programme au besoin (vous pouvez toujours laisser un commentaire dans la file dédiée si vous trouvez un bug).

 - Le logiciel Prorealtime montre une nouvelle fois toutes ses limites avec l'impossibilité d'inclure des boucles dans des boucles.........  Message de boucle sans fin !  Après avoir planché pendant plus d'une semaine, je vous donne le résultat même si comme je l'ai signalé plus haut, je ne suis pas sûr de celui-ci.

 - Le programme rame, il faut près de 40 minutes pour afficher un graphe de 150 barres !  Il est donc inexploitable dans sa forme actuelle, j'imagine le temps nécessaire pour un screener ou un backtest !

 - Prochaines étapes : essayer de rendre le programme plus rapide et le comparer avec la méthode proposée par Dennis Meyers (Mesa Vs Goertzel DFT).

 

Voici le code pour Prorealtime de l'indicateur de cycle dominant :

 

maxpwr = CALL "sousprog dft"[8]
for kk=9 to 50
    mys=call "sousprog dft"[kk]
    if mys>maxpwr then
        maxpwr=mys
    endif
next
if barindex <60 then
    maxpwr=undefined
endif
num=0
denom=0
for kk=8 to 50
    mys=call"sousprog dft"[kk]
    db=-10*log(0.01/(1-0.99*mys/maxpwr))/log(10)
    if db>20 then
        db=20
    endif
    if db<3 then
        thre=3-db
        num=num+kk*thre
        denom=denom+thre
    endif
next
if barindex>60 then
    cyc=num/denom
else
    cyc=undefined
endif

return cyc

 

Ainsi que le code du sous-programme utilisé pour contourner les faiblesses du logiciel, il faut introduire la période en variable (peri) :

 

pr=medianprice
if barindex<=5 then
    hp=pr
    cl=pr
else
    per=360/40
    cosper=cos(per)
    alph=(1-sin(per))/cosper
    hp=0.5*(1+alph)*(pr-pr[1])+alph*hp[1]
    cl=(hp+2*hp[1]+3*hp[2]+3*hp[3]+2*hp[4]+hp[5])/12
endif
cospart=0
sinpart=0
for n=0 to 49
    cycper=(360*n)/peri
    cospart=cospart+cl[n]*cos(cycper)
    sinpart=sinpart+cl[n]*sin(cycper)
next
pwr=square(cospart)+square(sinpart)

return pwr

Repost 0
Published by hk_lisse - dans Les Cycles
commenter cet article
14 février 2008 4 14 /02 /février /2008 15:21

Comment visionner la longueur et l'amplitude du cycle d'une action ?

 

Tout d'abord, un petit graphe pour bien illustrer le caractère changeant du tracé des courbes dessinées pour l'instant avec le programme.  Dans le dernier article, je postais un graphe d'INTC en pariant sur un rebond vers le haut du canal mauve.  Sur le nouveau graphe, on voit que le pronostic était bien correct mais surtout que j'ai été bien aidé par le déplacement des courbes !  En effet, si vous comparez les 2 vues (ça fait un peu jeu des 7 erreurs ), vous constaterez que les courbures ont changé.

 

hk81.gif

 

Dans le dernier message, je disais également chercher à automatiser les longueurs et largeurs des enveloppes de Hurst.  Alors que Bressert prétendait qu'il n'y avait qu'un cycle et identifiait celui-ci avec une moyenne 20 centrée, Hurst avance le fait qu'il y a plusieurs cycles qui se superposent.  Dès lors mon programme "Detrend20" présenté le 21/10 basé sur la théorie de Bressert ne me suffit plus.

 

B. J. Millard, dans son livre "Channels & Cycles - A Tribute to J. M. Hurst", décrit un moyen d'identifier les différents cycles.  Il soustrait à une moyenne centrée de longueur égale au cycle à isoler, une seconde moyenne centrée de longueur égale à la moitié de la première.  J'ai trouvé une version "Amibroker" de l'indicateur, je l'ai adapté.  Voici une vue de HG avec l'indicateur en fenêtre 1 et le cours en fenêtre 2.

 

hk82.gif

 

D'une part, l'indicateur est beaucoup plus propre, et d'autre part, il permet de visualiser plusieurs cycles.

 

Je m'essaye à une petite analyse, voici une vue de l'indice Dow Jones avec l'indicateur de cycles :

 

hk83.gif

 

On peut voir que le cycle à 6 mois (noir/blanc) est toujours présent et que son amplitude a augmenté depuis 1996, que le cycle à 2 ans était bien défini jusque 1999 et que l'on aurait un cycle de 3 ans qui se dessine depuis 2003.  Cette semaine (14/02/08), le cycle à 6 mois se retournerait mais en allant contre les cycles plus longs.

 

Reste maintenant à trouver, comme pour le RSI3M3, un indicateur qui colle en temps réel pour me permettre une extrapolation convenable.

Repost 0
Published by hk_lisse - dans Les Cycles
commenter cet article
14 février 2008 4 14 /02 /février /2008 15:02

Cycles : le point sur les enveloppes.

 

Comme je vois que certains sont impatients de lire la suite des articles consacrés aux cycles, je vous poste ce petit compte rendu qui vous montre où j'en suis.  Voici le graphe d'INTC.

 

hk80.gif

 

Pour l'instant, j'arrive à tracer les enveloppes qui sont décrites par Hurst et Millard.  J'ai encore quelques problèmes d'ajustements : en A, B,  et C, la courbe inférieure long terme devrait se décaler vers le haut, par contre en D, c'est la courbe supérieure qui est trop basse.  Les courbes sont tracées par tâtonnement, j'essaye d'automatiser la longueur et la largeur de celles-ci.

 

Si l'analyse des cycles est correcte, on devrait avoir un rebond d'INTC vers le haut du canal mauve.  N'oubliez toujours pas que les courbes sont tracées avec les données futures connues et qu'elles changent !

Repost 0
Published by hk_lisse - dans Les Cycles
commenter cet article
14 février 2008 4 14 /02 /février /2008 14:34

Cycles : au début, il y eut J. M. Hurst.

 

J. M. Hurst est l'auteur de "The Profit Magic Of Stock Transaction Timing", écrit à la fin des années 60.  Ce livre fut un des premiers à parler de cyclicité des marchés financiers.  W.Bressert, J. Tillman, P. Eliades, R. Zukowski...   poursuivent dans cette voie et ont utilisé les travaux de Hurst.  Par exemple, beaucoup de ce que J. Ehlers publie, est déjà dans le livre de Hurst.

 

Dans les premiers chapitres de son livre, Hurst construit des enveloppes de largeurs constantes autour des cours.  il s'en sert pour  illustrer une partie de sa théorie sur l'importance du timing dans le trading.  Un exemple de graphique utilisant les bandes, se trouve ici

 

Voici pour l'instant ce à quoi j'arrive avec Prorealtime en me basant sur un code Metastock (graphique de AAPL) :

 

hk77.gif

 

Il faut savoir que ce genre de représentation ne peut être utilisée pour le trading car elle fait appel aux données du futur.  Ainsi, les courbes qui apparaissent en même temps que la ligne jaune, sont susceptibles de changer.  Il y a deux défis à relever : d'abord, avoir  des enveloppes et une courbe correctes pour les données "établies" et ensuite essayer de trouver un moyen d'extrapoler les courbes de façon la plus exacte possible.

 

Voici une autre vue pour illustrer le principe (SNDK) :

 

hk78.gifhk79.gif

 

On voit que le programme prend une moyenne mobile triangulaire, y ajoute 2 enveloppes à +/- 7% et recentre le tout 11 barres en arrière.  Les coéfficients dépendent des cycles et sont donc propres à chaque graphe.  Les bandes peuvent être construites également avec un montant fixe (exemple : 2$) ou un multiple de l'ATR.  Les channels dessinées depuis la barre -11 sont, par nature, pure fiction !  Je continue l'exploration.....

Repost 0
Published by hk_lisse - dans Les Cycles
commenter cet article