Overblog Suivre ce blog
Administration Créer mon blog
15 mai 2009 5 15 /05 /mai /2009 14:05

Tracer la droite de régression linéaire en automatique, version 2.

Voici une version améliorée du premier programme (c'est ici) qui traçait en automatique la droite de régression linéaire des k dernières bougies.  Ce nouveau code est beaucoup plus rapide (suppression des boucles) et n'est plus limité pour la longueur de la droite.  Une vue de YHOO avec k=50, puis k=1000.




Pourquoi faire simple quand on peut faire compliqué ?  Comment ne pas avoir pensé plus tôt à utiliser la commande "LinearRegression" ?  Voici le code pour Prorealtime, il faut introduire k en variable :

///////////// regression automatique v.02 /////////
once j=0
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 and flag[1]=0 then
    test=linearregression[k](co)
    test1=linearregressionslope[k](co)
    a=test1
    b=test-test1*k
endif
if flag=0 then
    reg=undefined
else
    j=j+1
    reg=a*j+b
endif
return reg
Repost 0
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

Repost 0
15 mai 2008 4 15 /05 /mai /2008 07:33

Filtre LOWESS : le programme définitif pour Prorealtime.

Grâce au concours de Smallcaps90, j'ai pu mettre le doigt sur le problème d'indexation qui différenciait légèrement les courbes (voir article précédent).  Les derniers cas sont toujours traités autrement, la longueur maximum pour la régression est de 195.  Voici une vue du CAC avec le tracé pour un paramètre de 51 :



Et le code pour Prorealtime, 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
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 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
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

Voici une comparaison sur le CAC du tracé des enveloppes de Hurst de paramètre 100 (en blanc), et de la courbe du filtre LOWESS de paramètre 83 (en pointillé noir) :



Maintenant il suffit d'ajouter le Value Charts et vous aussi, vous pourrez mettre des vidéos d'analyses très convaincantes sur la toile !
Repost 0
8 mai 2008 4 08 /05 /mai /2008 18:52

Filtre LOWESS, Centre de gravité, Régression non-paramétrique et tutti quanti.

Il y a pour l'instant un peu de remue-ménage autour des indicateurs cités dans le titre, plusieurs lecteurs me demandant de les aider.  Je me suis basé sur le programme de Smallcaps90 que l'on trouve ici.  Je n'ai pas tout à fait le même tracé, et je cherche un bonne âme qui me transmettrait les valeurs de l'indicateur utilisé avec Graphe AT-PRO pour une période de 51 sur une valeur du CAC40 en daily, sur un historique de 150 jours afin de déterminer d'où provient la différence.  Voici une vue de VIE avec l'indicateur de paramètre 51, pour la période 07/2004 à 09/2004 :



Même si il est normal que les courbes divergent pour les 25 dernières valeurs, j'ai quand même une légère différence pour le début du tracé.  Le programme pour Prorealtime est très simple mais limité pour l'instant à une valeur maximum de 193.  Je traite également les derniers cas d'une autre façon, je ferai une comparaison entre les 2 méthodes si j'arrive à retrouver exactement les valeurs originales de graphe AT-PRO.

Je vous donne le code pour Prorealtime dans la version actuelle, 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
endif
n=p3 mod 2
p=(p3-n)/2
p3=(2*p)+1//p3=p3+n
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=0 to p3-1
        z=barindex-i
        a=a+w[z]
        b=b+w[z]*(i+1)//b=b+w[z]*i
        e=e+(i+1)*(i+1)*w[z]//e=e+i*i*w[z]
    next
endif
if barindex>p3 then
    c=0
    d=0
    for i=0 to p3-1
        z=barindex-i
        c=c+co[p3+p-i]*w[z]
        d=d+co[p3+p-i]*w[z]*(i+1)//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+beta
if barindex<p3*2 then
    lowess=undefined
endif
return lowess

Edit le 9/5 : j'ai corrigé i par i+1 mais cela accentue la différence avec la courbe originale.  Pour avoir un tracé similaire, il faudrait mettre i-1, ce qui me paraît illogique.  Je continue de vérifier le code.....

Edit le 12/5 : j'ai changé la valeur de p3, je ne sais vraiment pas où j'avais été chercher cette ligne de code !  Mais la courbe ne correspond toujours pas, je continue........
Repost 0
3 mars 2008 1 03 /03 /mars /2008 15:54

Le canal de Raff.

Le canal de Raff trace 2 droites équidistantes de la droite de régression linéaire.  L'écart est fixé par l'extrême le plus éloigné.  Je vous présente 3 indicateurs liés au canal de Raff :

 - L'enveloppe du canal, qui trace l'évolution des 2 droites du canal pour une longueur fixée.
 - L'oscillateur, qui situe la clôture dans l'enveloppe.
 - La largeur de l'enveloppe, qui permet de mesurer une certaine volatilité.

Voici une vue de CSCO avec les 3 indicateurs pour une longueur de 20 de la droite de régression linéaire :

hk94.gif
hk95.gif

Pour vérification, j'ai mis en rose, le canal de longueur 20 et en jaune la courbe de régression de même paramètre.  On constate bien que les enveloppes correspondent au canal.  Le second indicateur dessine une courbe qui ressemble à un stochastic de par sa construction.  Le troisième indicateur, avec une valeur proche/inférieure à 5, alerte sur des périodes de très basse volatilité.

Voici les codes pour Prorealtime, il faut introduire k en variable pour la longueur de la droite de régression linéaire :

//////////// bandes Raff ////////////
somx=0
somy=0
somxx=0
somxy=0
co=close
hi=high
lo=low
maxh=0
maxl=0
for i=1 to k
    somx=somx+i
next
for i=0 to k-1
    somy=somy+co[i]
next
for i=1 to k
    somxx=somxx+(i*i)
next
for i=0 to k-1
    somxy=somxy+(co[i]*(k-i))
next
a=(k*somxy-somx*somy)/(k*somxx-somx*somx)
b=(somy-a*somx)/k
for i=0 to k-1
    ecah=hi[i]-a*(k-i)-b
    maxh=max(maxh,ecah)
    ecal=a*(k-i)+b-lo[i]
    maxl=max(maxl,ecal)
next
reg=a*k+b
raff=max(maxh,maxl)
raffl=reg-raff
raffh=reg+raff
return raffl,raffh


/////////// Raff oscillator //////////
somx=0
somy=0
somxx=0
somxy=0
co=close
hi=high
lo=low
maxh=0
maxl=0
for i=1 to k
    somx=somx+i
next
for i=0 to k-1
    somy=somy+co[i]
next
for i=1 to k
    somxx=somxx+(i*i)
next
for i=0 to k-1
    somxy=somxy+(co[i]*(k-i))
next
a=(k*somxy-somx*somy)/(k*somxx-somx*somx)
b=(somy-a*somx)/k
for i=0 to k-1
    ecah=hi[i]-a*(k-i)-b
    maxh=max(maxh,ecah)
    ecal=a*(k-i)+b-lo[i]
    maxl=max(maxl,ecal)
next
reg=a*k+b
raff=max(maxh,maxl)
raffl=reg-raff
raffh=reg+raff
osc=(co-raffl)/(raffh-raffl)*100
return osc,80,20


///////////// Raff bandwidth /////////////
somx=0
somy=0
somxx=0
somxy=0
co=close
hi=high
lo=low
maxh=0
maxl=0
for i=1 to k
    somx=somx+i
next
for i=0 to k-1
    somy=somy+co[i]
next
for i=1 to k
    somxx=somxx+(i*i)
next
for i=0 to k-1
    somxy=somxy+(co[i]*(k-i))
next
a=(k*somxy-somx*somy)/(k*somxx-somx*somx)
b=(somy-a*somx)/k
for i=0 to k-1
    ecah=hi[i]-a*(k-i)-b
    maxh=max(maxh,ecah)
    ecal=a*(k-i)+b-lo[i]
    maxl=max(maxl,ecal)
next
reg=a*k+b
raff=max(maxh,maxl)
raffl=reg-raff
raffh=reg+raff
wi=(raffh-raffl)/(raffh+raffl)*200
return wi,5
Repost 0
10 février 2008 7 10 /02 /février /2008 17:22

Le canal de régression linéaire ou canal de Raff.

 

Dans la continuité du code Prorealtime permettant le traçage de la droite de régression linéaire, voici les programmes pour les différents canaux.  En premier le canal de Raff, avec une vue du CAC, pour une droite de longueur=50.  Normalement, le canal de Raff trace 2 droites parallèles passant par l'extrême le plus éloigné de la droite (droites bleues).   Dans le programme, j'ai rajouté les parallèles passant par l'extrême le plus proche (droites jaunes).  Sur le graphe du CAC, c'est assez parlant.

 

hk19.gif

 

Il faut toujours définir K en variable pour la longeur du canal, le code :

 

det=DPO[k*2](close)
if det=det[1] and det[1]=det[2] and det[2]<>det[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
h100=dpo[n](high)
moyh=high-h100
hi=(moyh-moyh[1]+(high[p])/n)*n
l100=dpo[n](low)
moyl=low-l100
lo=(moyl-moyl[1]+(low[p])/n)*n
if flag=1 and flag[1]=0 then
    somx=0
    somy=0
    somxx=0
    somxy=0
    for i=1 to k
        somx=somx+i
    next
    for i=0 to k-1
        somy=somy+co[i]
    next
    for i=1 to k
        somxx=somxx+(i*i)
    next
    for i=0 to k-1
        somxy=somxy+(co[i]*(k-i))
    next
    a=(k*somxy-somx*somy)/(k*somxx-somx*somx)
    b=(somy-a*somx)/k
    for i=0 to k-1
        ecah=hi[i]-a*(k-i)-b
        maxh=max(maxh,ecah)
        ecal=a*(k-i)+b-lo[i]
        maxl=max(maxl,ecal)
    next
endif
if flag=0 then
    reg=undefined
else
    j=j+1
    reg=a*j+b
endif
raff=max(maxh,maxl)
raffl=reg-raff
raffh=reg+raff
riff=min(maxh,maxl)
riffh=reg+riff
riffl=reg-riff
return reg,riffl,riffh,raffl,raffh

 

Le canal d'écart type.

 

hk20.gif

 

Le graphe du CAC avec le canal d'écart type, la longueur de la droite est toujours de 50 et le coéfficient pour l'écart type est de 1.50.  Il faut définir 2 variables, K pour la longueur du canal et Z pour le coéfficient de l'écart type.  Le code :

 

once j=0
det=DPO[k*2](close)
if det=det[1] and det[1]=det[2] and det[2]<>det[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 and flag[1]=0 then
    somx=0
    somy=0
    somxx=0
    somxy=0
    for i=1 to k
        somx=somx+i
    next
    for i=0 to k-1
        somy=somy+co[i]
    next
    for i=1 to k
        somxx=somxx+(i*i)
    next
    for i=0 to k-1
        somxy=somxy+(co[i]*(k-i))
    next
    a=(k*somxy-somx*somy)/(k*somxx-somx*somx)
    b=(somy-a*somx)/k
    eca=STD[k](co)
endif
if flag=0 then
    reg=undefined
else
    j=j+1
    reg=a*j+b
endif
return reg,reg+z*eca,reg-z*eca

 

Le canal d'erreur type.

 

hk21.gif

 

Toujours une vue du CAC avec le canal d'erreur type de longueur 50 et de coéfficient 1.50.  Comme pour le programme précédent, il faut définir 2 variables, K pour la longueur du canal et Z pour le coéfficient multiplicateur de l'erreur type.  Le code :

 

once j=0
det=DPO[k*2](close)
if det=det[1] and det[1]=det[2] and det[2]<>det[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 and flag[1]=0 then
    somx=0
    somy=0
    somxx=0
    somxy=0
    for i=1 to k
        somx=somx+i
    next
    for i=0 to k-1
        somy=somy+co[i]
    next
    for i=1 to k
        somxx=somxx+(i*i)
    next
    for i=0 to k-1
        somxy=somxy+(co[i]*(k-i))
    next
    a=(k*somxy-somx*somy)/(k*somxx-somx*somx)
    b=(somy-a*somx)/k
    eca=STe[k](co)
endif
if flag=0 then
    reg=undefined
else
    j=j+1
    reg=a*j+b
endif
return reg,reg+z*eca,reg-z*eca

edit le 04/03/08 : suite à l'amélioration apportée par un lecteur, le code est modifié (en rose).

Repost 0
10 février 2008 7 10 /02 /février /2008 17:14

Tracer en automatique la droite de régression linéaire avec Prorealtime.

 

Voici un programme pour Prorealtime qui trace la droite de régression linéaire sur les dernières bougies.  Une vue du CAC, avec la période=60.

 

hk18.gif

 

Le programme retourne une courbe qui représente la droite de régression linéaire pour les 60 dernières bougies.  Pour les barres précédentes, on a la moyenne 20 simple (à modifier si vous le souhaitez), je superpose donc une seconde moyenne 20 simple pour masquer la courbe avant les 60 bougies utilisées pour la droite (vous suivez ?).  Il faut rentrer K comme variable pour la longueur de la droite.

 

Le code :

 

once j=0
det=DPO[k*2](close)
if det=det[1] and det[1]=det[2] and det[2]<>det[3] then
    flag=1
endif
n=(k*2)-4
p=(n/2)-1
d1=DPO[n](close)
moy=close-d1
co=(moy-moy[1]+(close[p])/n)*n
if flag=1 and flag[1]=0 then
    somx=0
    somy=0
    somxx=0
    somxy=0
    for i=1 to k
        somx=somx+i
    next
    for i=0 to k-1
        somy=somy+co[i]
    next
    for i=1 to k
        somxx=somxx+(i*i)
    next
    for i=0 to k-1
        somxy=somxy+(co[i]*(k-i))
    next
    a=(k*somxy-somx*somy)/(k*somxx-somx*somx)
    b=(somy-a*somx)/k
endif
if flag=0 then
    reg=undefined
else
    j=j+1
    reg=a*j+b
endif
return reg

edit le 04/03/08 : suite à l'amélioration apportée par un lecteur, le code est modifié (en rose)

Repost 0