Overblog Suivre ce blog
Editer l'article Administration Créer mon blog
22 mai 2008 4 22 /05 /mai /2008 08:13


Digressions autour du filtre LOWESS.

Lors d'un article précédent, je faisais remarquer que dans le programme du filtre LOWESS, Smallcaps90 traitait les derniers cas différament par rapport au code mis sur le Blog.  Alors qu'il réduisait progressivement la longueur du filtre à l'approche du dernier cours, je gardais une longueur constante mais multipliais la dernière clôture à l'infini.  Voici une vue du filtre de paramètre 51, appliqué au DAX future, avec les 2 courbes pour comparaison (en blanc, le code hk et en vert/rouge le code Smallcaps90) :

 

On constate bien que progressivement pour les 25 derniers cours, les courbes divergent.  La courbe blanche est plus réactive alors que la verte a plus d'inertie.

Voici le code pour Prorealtime de la version Graphe AT-pro, il faut introduire p3 en variable :

k=p3
de48=DPO[k*2](close)
if de48=de48[1] and de48[1]=de48[2] and de48[2]<>de48[3] then
    flag=1
endif
n=(k*2)-4
p=(n/2)-1
d100=DPO[n](close)
moy100=close-d100
co=(moy100-moy100[1]+(close[p])/n)*n
if flag[1]=1 and flag[2]=0 then
    hh=co[1]
endif
if flag[1]=1 then
    co=hh
    tra=tra+1
endif
n=p3 mod 2
p=(p3-n)/2
p3=(2*p)+1
once x=0
w=abs((p-x)/p)
w=w*w*w
w=(1-w)
w=w*w*w
x=x+1
if tra[p]=0 then
    if barindex=p3 then
        a=0
        b=0
        e=0
        for i=1 to p3
            z=barindex-i+1
            a=a+w[z]
            b=b+w[z]*(i)
            e=e+(i)*(i)*w[z]
        next
    endif
    if barindex>p3 then
        c=0
        d=0
        for i=1 to p3
            z=barindex-i+1
            c=c+co[p3+p-i]*w[z]
            d=d+co[p3+p-i]*w[z]*(i)
        next
    endif
else
    a=0
    b=0
    e=0
    for i=1 to p3-tra[p]
        z=barindex-i+1
        a=a+w[z]
        b=b+w[z]*(i)
        e=e+(i)*(i)*w[z]
    next
    c=0
    d=0
    for i=1 to p3-tra[p]
        z=barindex-i+1
        c=c+co[p3+p-i]*w[z]
        d=d+co[p3+p-i]*w[z]*(i)
    next
endif
alpha=(a*d-b*c)/(a*e-b*b)
beta=(c*e-b*d)/(a*e-b*b)
lowess=alpha*(p+1)+beta
if barindex<p3*2 then
    lowess=undefined
endif
return lowess

Une autre façon d'utiliser le filtre LOWESS est de créer une fonction "endpoint" qui affiche la valeur de la courbe à l'instant "t" comme si on se retrouvait sur le dernier cours.  Voici une vue avec la fonction "endpoint" appliquée à la version Graphe AT-pro :



On voit que pour le dernier cours les valeurs sont identiques et que d'autre part la courbe "tient compte des données futures" puisque les valeurs divergent à gauche  de la dernière clôture.  En effet, il faut bien comprendre que normalement à l'instant "t", la courbe vient se poser sur le point.  La couleur des points est définie par la courbure du filtre à cet instant : c'est ce qu'il y a de plus intéressant dans cette approche, pouvoir capter le moment où la régression change de direction.

Voici une autre vue avec pour comparaison les codes hk et Smallcaps90 en version "endpoint" :



Aucune des 2 versions ne s'approche vraiment de la courbe.  Le dessin fait par le code hk est plus chaotique mais plus réactif alors que la version Graphe AT-pro est plus linéaire mais marque un certain éloignement par rapport à la courbe.

Une autre façon de comparer les 2 codes est d'afficher la courbure de la régression (valeur - valeur[1]) à l'instant "t".  Ci-dessous, l'indicateur version hk en blanc/noir et version Smallcaps en rouge/vert, mêmes conclusions :



Comme affiché dans l'article précédent, la courbe de la régression non-paramétrique est proche de la moyenne de Hurst.  J'ai donc appliqué la méthode pour essayer de sortir les cycles : calculer la différence entre 2 filtres LOWESS, le second étant de longueur égale à la moitié du premier.  Voici une vue avec, en fenêtre 1, le DAX future, en 2, le cycle "version PRT", en 3 le cycle "LOWESS" et en 4 le cycle "LOWESS endpoint" (filtre LOWESS de paramètres 51 et 25) :




Sur la dernière fenêtre j'ai ajouté une moyenne mobile pour lisser la courbe.  Voilà peut-être un indicateur de "cycle à longueur variable" et un moyen de calculer l'amplitude pour les enveloppes ?

Edit le 21 novembre 2008 :


Suite à la demande de Karl, voici les codes de la version "endpoint" noire/blanche :


///////////// programme de la courbe noire et blanche ///////////
/////////// il faut introduire a en variable (51 par défaut) /////////////
myke1 = CALL "kernel endpoint "[a]
myke2 = CALL "kernel endpoint veille"[a]
c=myke1-myke2
return myke1 coloured by c

/////////// programme kernel endpoint ////////////
//////////// il faut mettre p3 en variable (51 par défaut) ///////////
n=p3 mod 2
p=(p3-n)/2
p3=(2*p)+1
once x=0
w=abs((p-x)/p)
w=w*w*w
w=(1-w)
w=w*w*w
x=x+1
if barindex=p3 then
    a=0
    b=0
    e=0
    for i=1 to p+1
        z=barindex-i+1
        a=a+w[z]
        b=b+w[z]*(i)
        e=e+(i)*(i)*w[z]
    next
endif
if barindex>p3 then
    c=0
    d=0
    for i=1 to p+1
        z=barindex-i+1
        c=c+close[p+1-i]*w[z]
        d=d+close[p+1-i]*w[z]*i
    next
endif
alpha=(a*d-b*c)/(a*e-b*b)
beta=(c*e-b*d)/(a*e-b*b)
lowess=alpha*(p+1)+beta
if barindex<p3*2 then
    lowess=undefined
endif
return lowess

//////////// programme kernel endpoint veille ///////////
/////////// il faut introduire p3 en variable (51 par défaut) ///////////
n=p3 mod 2
p=(p3-n)/2
p3=(2*p)+1
once x=0
w=abs((p-x)/p)
w=w*w*w
w=(1-w)
w=w*w*w
x=x+1
if barindex=p3 then
    a=0
    b=0
    e=0
    for i=1 to p+2
        z=barindex-i+1
        a=a+w[z]
        b=b+w[z]*(i)
        e=e+(i)*(i)*w[z]
    next
endif
if barindex>p3 then
    c=0
    d=0
    for i=1 to p+2
        z=barindex-i+1
        c=c+close[p+2-i]*w[z]
        d=d+close[p+2-i]*w[z]*i
    next
endif
alpha=(a*d-b*c)/(a*e-b*b)
beta=(c*e-b*d)/(a*e-b*b)
lowess=alpha*(p+1)+beta
if barindex<p3*2 then
    lowess=undefined
endif
return lowess

Partager cet article

Repost 0

commentaires