Overblog Suivre ce blog
Administration Créer mon blog
12 février 2009 4 12 /02 /février /2009 20:41

Les mots sont lachés.

Voici un petit site génial : http://www.wordle.net/



Je posterai dorénavant sous cette forme .

Repost 0
Published by hk_lisse - dans Commentaires
commenter cet article
20 janvier 2009 2 20 /01 /janvier /2009 13:09

La Saisonnalité du CAC.

Voici 2 petits programmes qui permettent de superposer les cours de différentes périodes.  Le premier démarre avec une base 100 au 1er janvier alors que le second donne la courbe brute.

Ci-après une vue du CAC :
- En noir 2008.
- En vert 2007
- En blanc 2006
- En rouge foncé 2005
- En jaune 2004
- En orange 2003
- En bleu 2002
- En turquoise 2001
- En olive 2000
- En rouge 1999
- En violet 1998




On peut ainsi comparer le bear market précédent et la période actuelle.  On peut également faire une analyse de la saisonnalité.

Les codes des programmes pour Prorealtime :  Il faut introduire période (intervalle de temps passé) et compa (intervalle sur lequel on superpose le précédent) en variables.  Par exemple : période=2006 et compa=2008 donne l'année 2006 superposée sur l'année 2008. 

/////////////// prgm indicateur /////////////////
once a=0
if year>=periode then
    a=a+1
endif
if year=compa  then
    a=a-1
    c=close[a]
else
    c=undefined
endif
dif= (c-c[1])/c[1]
if year=compa and year[1]<>compa then
    gg=1
    base=100
else
    gg=dif+1
    base=base[1]*gg
endif
return base

/////////////// prgm sur les prix /////////////////
once a=0
if year>=periode then
    a=a+1
endif
if year=compa  then
    a=a-1
    c=close[a]
else
    c=undefined
endif
return c
Repost 0
Published by hk_lisse - dans Indicateurs
commenter cet article
15 décembre 2008 1 15 /12 /décembre /2008 15:43

Over / Under Divergence : Part II.

Voici donc la version baissière de "l'Over / Under Divergence".  Le premier article se trouve ICI (avec les conditions de validation).
Le screener a sorti GDI sur le NYSE, dont voici une vue :



Et le code pour Prorealtime :

x=stochastic[7,3](close)
z=stochastic[21,10](close)
if x>x[1] then
    hi=max(hi,x)
    hico=max(hico,max(high,high[1]))
endif
if x<x[1] and x[1]>x[2] then
    zt1=zt
    zt=z[1]
    sto2=sto1
    sto1=hi
    hi=0
    p3=p1
    p2=max(p1,hico)
    p1=max(highest[3](high),hico)
    if p2=p1 then
        p2=max(p3,p4)
    endif
    hico=0
    hico1=0
endif
if x<x[1] then
    p4=hico1
    hico1=max(hico1,high)
endif
c1=(p1>p2 and sto1<sto2 and x<x[1] and x[1]>x[2])
c2=(c1 and sto2>zt1 and sto1<zt)
if c2 and high[1]=highest[7](high) and low<low[1] and close<open then
    divi=3
else
    divi=0
endif
return divi
Repost 0
Published by hk_lisse - dans Les Divergences
commenter cet article
14 décembre 2008 7 14 /12 /décembre /2008 10:47

Divergences baissières Stochastic et MACD.

A la demande de Jean-Michel, voici les codes convertis pour les divergences baissières Stochastic et MACD.  Le premier article, sur les divergences haussières, se trouve ICI.
Voici une vue de ADM, détectée par le screener :



Et les codes pour Prorealtime :

//////////////// divergence baissière stochastic ////////////////
x=stochastic[14,3](close)
y=average[5](x)
if x>y then
    hi=max(hi,x)
    hico=max(hico,max(high,high[1]))
endif
if x crosses under y then
    sto2=sto1
    sto1=hi
    hi=0
    p3=p1
    p2=max(p1,hico1)
    p1=max(highest[3](high),hico)
    if p2=p1 then
        p2=max(p3,p4)
    endif
    hico=0
    hico1=0
endif
if x<y then
    p4=hico1
    hico1=max(hico1,high)
endif
if p1>p2 and sto1<sto2 and x crosses under y and x<x[1] then
    sign=10
else
    sign=0
endif
return sign

///////////// divergence baissière MACD /////////////
m=macdline[9,19,6](close)
s=exponentialaverage[6](m)
if m>s then
    hi1=max(hi1,m)
    hico=max(hico,high)
endif
if m<s then
    hico1=max(hico1,high)
endif
if m crosses under s then
    a=hi1
    hi1=0
    c=max(hico,hico1)
    hico=0
    hico1=0
    a1=a0
    a0=a
    c1=c0
    c0=c
endif
if m crosses under s and a0<a1 and c0>c1 then
    sign=1
else
    sign=0
endif
maxmac=highest[4](m)
maxco=highest[5](high)
if m>s and maxco>c0 and maxmac<a0 then
    pre=.5
else
    pre=0
endif
return sign,pre
Repost 0
Published by hk_lisse - dans Les Divergences
commenter cet article
9 décembre 2008 2 09 /12 /décembre /2008 16:27

Boîtes de Darvas et Stratégies.

La stratégie employée par Darvas est une technique de breakout : achat lorsque le haut de la boîte est cassé, à cela on peut encore ajouter des filtres.  J'ai testé le système sur les actions US, celui-ci fonctionne mieux sur celles du Nasdaq que sur celles composant le Dow Jones (question de volatilité, valeur de croissance.....).  La majeure partie des gains s'effectue lors de la période 1999/2000 pour la plupart des valeurs.  Pour une première approche, il n'y a pas de slippage, ni de frais.  Le capital est de 20000, la portion investie de 10000, il n'y a pas de pyramidage.

Il y a comparaison entre les systèmes "bearish" et "bullish", ainsi qu'une variation de la validation de la cassure : par la cloture ou simplement par le high.  La condition de sortie du trade est une cassure par le bas d'une boîte.

Voici une vue de VRSN avec les EC's des différents systèmes :



Une autre vue avec OXY :



Le système 1 est le "bearish" + cloture.
Le système 2 est le "bearish" + high/low.
Le système 3 est le "bullish" + cloture.
Le système 4 est le "bullish" + high/low.

D'une façon générale, le système "bearish" est plus performant.  C'est curieux, j'aurais parié le contraire.  Je n'en ai pas analysé la raison, peut-être les sorties.  Sinon, pas de grosses différences entre les systèmes "cloture" et "high/low".  Suivant le support, c'est tantôt l'un, tantôt l'autre.

Voici les codes pour Prorealtime :

//////////////// système 1 /////////////////
if box=1 and (high>tth or low<ttl) then
    box=0
    flag=0
endif
if box=0 and flag=0 and low>low[3] and low[1]>low[3] and low[2]>low[3] then
    th=low[3]
    flag=1
endif
if flag=1 and box=0 and low<th then
    flag=0
endif
if flag=1 and box=0 and high<high[3] and high[1]<high[3] and high[2]<high[3] then
    tth=high[3]
    ttl=th
    box=1
endif
once tth=undefined
once ttl=undefined
if close>tth then
    buy 50 %CAPITAL at market thisbaronclose
endif
if close<ttl then
    sell at market thisbaronclose
endif

//////////////////// système 2 ////////////////
if box=1 and (high>tth or low<ttl) then
    box=0
    flag=0
endif
if box=0 and flag=0 and low>low[3] and low[1]>low[3] and low[2]>low[3] then
    th=low[3]
    flag=1
endif
if flag=1 and box=0 and low<th then
    flag=0
endif
if flag=1 and box=0 and high<high[3] and high[1]<high[3] and high[2]<high[3] then
    tth=high[3]
    ttl=th
    box=1
endif
once tth=undefined
once ttl=undefined
buy 50 %capital at tth stop
sell at ttl stop

////////////////// système 3 ///////////////////
if box=1 and (high>tth or low<ttl) then
    box=0
    flag=0
endif
if box=0 and flag=0 and high<high[3] and high[1]<high[3] and high[2]<high[3] then
    th=high[3]
    flag=1
endif
if flag=1 and box=0 and high>th then
    flag=0
endif
if flag=1 and box=0 and low>low[3] and low[1]>low[3] and low[2]>low[3] then
    ttl=low[3]
    tth=th
    box=1
endif
once tth=undefined
once ttl=undefined
if close>tth then
    buy 50 %CAPITAL at market thisbaronclose
endif
if close<ttl then
    sell at market thisbaronclose
endif

////////////////// système 4 ///////////////////
if box=1 and (high>tth or low<ttl) then
    box=0
    flag=0
endif
if box=0 and flag=0 and high<high[3] and high[1]<high[3] and high[2]<high[3] then
    th=high[3]
    flag=1
endif
if flag=1 and box=0 and high>th then
    flag=0
endif
if flag=1 and box=0 and low>low[3] and low[1]>low[3] and low[2]>low[3] then
    ttl=low[3]
    tth=th
    box=1
endif
once tth=undefined
once ttl=undefined
buy 50 %CAPITAL at tth stop
sell at ttl stop

Remarque : si vous voulez afficher pour contrôle, l'indicateur utilisé, il faut ajouter "return tth, ttl" à la place des instructions d'achat/vente.
Repost 0
10 novembre 2008 1 10 /11 /novembre /2008 18:19

The Bearish Darvas Boxes.

Voici donc, en prolongement de l'article précédent, les "Bearish Darvas Boxes".  Ici, les boîtes sont construites à partir d'un creux, ce qui devrait être plus efficace dans un marché baissier.  Ci-dessous une vue de GOOG, avec en fenêtre 1, les boîtes ordinaires et en fenêtre 2, les "bearish boxes".




Le résultat est complètement différent !  On voit bien que lorsque la tendance est baissière, le nouveau code est plus approprié : les boîtes sont plus étroites.

Et le code pour Prorealtime :

k=48
once tth=undefined
once ttl=undefined
n=(k*2)-4
p=(n/2)-1
h1=dpo[n](high)
moyh=high-h1
hi=(moyh-moyh[1]+(high[p])/n)*n
hi=(round(hi*100))/100
l1=dpo[n](low)
moyl=low-l1
lo=(moyl-moyl[1]+(low[p])/n)*n
lo=(round(lo*100))/100
low1=(round(low*100))/100
high1=(round(high*100))/100
if barindex > 100 then
    if box=1 and (high1>tth or low1<ttl) then
        box=0
        flag=0
    endif
    if box=0 and flag=0 and low1<=lo[46] and low1<=lo[45] and low1<=lo[44] then
        th=low1
        flag=1
    endif
    if box=0 and flag=1 then
        for zz=0 to 44
            if  lo[47-zz-1]<th or lo[47-zz-2]<th or lo[47-zz-3]<th then
                flag=0
                break
            endif
            if hi[47-zz]>hi[47-zz-1] and hi[47-zz]>hi[47-zz-2] and hi[47-zz]>hi[47-zz-3] then
                box=1
                ttl=th
                tth=hi[47-zz]
                break
            endif
        next
    endif
else
    tth=undefined
    ttl=undefined
endif
if box=1 then
    ba=ttl
else
    ba=tth
endif
return ba coloured by box-1, tth coloured by box-1, ttl coloured by box-1
Repost 0
Published by hk_lisse - dans Indicateurs
commenter cet article
5 novembre 2008 3 05 /11 /novembre /2008 10:08

Les Boîtes de Darvas.

Suite à la demande de Pierre, voici donc un programme permettant de représenter les boîtes de Darvas sur Prorealtime.  Les boîtes dessinent des zones de range, une sortie par le haut ou le bas donne un signal d'achat ou de vente.  Ce signal doit être confirmé par d'autres indicateurs.  Par exemple, Darvas utilisait une cassure du plus haut de l'année pour rentrer à l'achat.

Les règles pour l'établissement des boîtes sont les suivantes :
 - 1. Un TOP est trouvé s'il marque un sommet pour les 3 barres qui le suivent.
 - 2. Ensuite, un BOTTOM est trouvé s'il marque un creux pour les 3 barres qui le suivent.
 - 3. La recherche du point bas commence à la même barre que celle du TOP, pendant celle-ci, le point haut ne peut être dépassé.
La boîte démarre avec le sommet et se termine dès que les cours en sortent.

Comme je l'ai signalé dans la rubrique "contact", l'indicateur introduit un biais haussier de par sa construction.  En effet les boîtes sont plus larges à la baisse qu'à la hausse puisque l'on commence par un sommet.  L'idéal serait, comme le suggère Pierre, de créer des "bearish boxes" débutant par un point bas..........  A tester.

Je n'ai pas retrouvé les programmes de l'époque, j'ai donc réécrit les codes.  Il se peut qu'il reste quelques bugs (notamment avec les arrondis).  De même pour la représentation à l'écran, vous pouvez faire montre d'imagination.

Voici une vue de GOOG, les points verts signalent la boîte valide, les points rouges une sortie :



Le code pour Prorealtime :

k=48
once tth=undefined
once ttl=undefined
n=(k*2)-4
p=(n/2)-1
h1=dpo[n](high)
moyh=high-h1
hi=(moyh-moyh[1]+(high[p])/n)*n
hi=(round(hi*100))/100
l1=dpo[n](low)
moyl=low-l1
lo=(moyl-moyl[1]+(low[p])/n)*n
lo=(round(lo*100))/100
low1=(round(low*100))/100
high1=(round(high*100))/100
if barindex > 100 then
    if box=1 and (high1>tth or low1<ttl) then
        box=0
        flag=0
    endif
    if box=0 and flag=0 and high1>=hi[46] and high1>=hi[45] and high1>=hi[44] then
        th=high1
        flag=1
    endif
    if box=0 and flag=1 then
        for zz=0 to 44
            if  hi[47-zz-1]>th or hi[47-zz-2]>th or hi[47-zz-3]>th then
                flag=0
                break
            endif
            if lo[47-zz]<lo[47-zz-1] and lo[47-zz]<lo[47-zz-2] and lo[47-zz]<lo[47-zz-3] then
                box=1
                tth=th
                ttl=lo[47-zz]
                break
            endif
        next
    endif
else
    tth=undefined
    ttl=undefined
endif
if box=1 then
    ba=ttl
else
    ba=tth
endif
return ba coloured by box-1, tth coloured by box-1, ttl coloured by box-1

Il faut mettre un remplissage entre l'output 1 et le 2.  Paramètrer le 1 en points fins, le 2 en gros points (+couleur vert/rouge), idem pour le 3.  D'autres combinaisons sont possibles.
Le programme fait appel aux données futures et n'est utilisable, sous cette forme, que lorsque les cours sont figés.
Je ferai un prochain article avec une version temps réel, pour un screener.
Repost 0
Published by hk_lisse - dans Indicateurs
commenter cet article
21 octobre 2008 2 21 /10 /octobre /2008 10:04

Algorithme de Goertzel et analyse du signal.

Dans un papier (MESA vs Goertzel), Dennis Meyers compare l'utilisation de l'algorithme de Goertzel avec la méthode de Ehlers pour l'analyse du signal : trouver le cycle dominant.  Dans l'article qui suit, je me base sur la publication de Meyers pour tester, comme il l'a fait, les 2 méthodes.  Cela m'a également été utile pour voir si les codes programmés sur PRT donnaient des résultats corrects.

J'ai donc créé, comme Meyers, un signal fictif :  1 sinusoïde de période 11 ajoutée à une sinusoïde de période 19 avec un décalage de phase, le tout avec une pincée de bruit.  Voici ce que cela donne, en fenêtre 1, le signal sans bruit (les 2 sinusoïdes mélangées) en fenêtre 2, le bruit (variant de -1 à +1), et en fenêtre 3, le signal avec le bruit.



Sur ce signal, j'applique l'algorithme de Goertzel et le programme de Ehlers pour essayer de retrouver les cycles dominants : soit les périodes 11 et 19.  Ci-dessous, le résultat avec l'algo de Goertzel.  Il y a bien une détection du cycle de période 11, mais elle n'est pas continuelle.  Pour le cycle de période 19, l'affichage est continu mais varie de 19 à 20.  Le programme retourne les deux fréquences qui ont la meilleure réponse.



Voici une vue du programme de Elhers "brut" (une seule fréquence est affichée), la détection des périodes 11 et 19 est moins évidente :



Et une autre vue avec le code bidouillé pour avoir 2 fréquences en sortie :



Le même, en élargissant la fenêtre d'analyse de 50 à 100 barres :



Conclusions : 
- Les codes ont l'air corrects, les cycles 11 et 19 apparaissent.
- La précision de la détection dépend pour les 2 programmes, de la longueur de le fenêtre de calcul.  Plus elle est longue, plus le calcul dure longtemps, et plus il est précis.  Meyers préconise 3 fois la longueur du cycle estimé, mais 5 ou 6 fois me paraît indispensable d'après les tests.
- Pour les 2 méthodes, il y a des périodes où le cycle 11 n'est pas détecté.  Par contre, le cycle 19 est toujours présent avec plus ou moins de précision.
- La structure des programmes est similaire, avec une subroutine, et donc c'est assez lourd à faire tourner.
- Reste à appliquer la détection sur les cours, préalablement "detrented", pour un prochain article.

Voici les différents codes pour Prorealtime, utilisés dans l'article :

/////////// signal sans bruit ////////////
b=barindex
sig=sin(360*b/11)+sin(360*b/19+90)
return sig,0

/////////////// bruit //////////////////
b=SQRT(barindex*(b+1))
b=abs((b-ROUND(b))*4)
c=b-1
return c,0

////////////////// sous prgm goertzel ////////////
a=barindex
sig=sin(360*a/11)+sin(360*a/19+90)
b=SQRT(barindex*(b+1))
b=abs((b-ROUND(b))*4)
c=b-1
sig=sig+c

pr=sig
alpha=2*cos(360*1/k)
q1=0
q2=0
for i=200 downto 0//fenêtre de 200 barres
    q3=pr[i]+alpha*q1-q2
    q2=q1
    q1=q3
next
amp=sqrt(square(q1)+square(q2)-alpha*q1*q2)
return amp

/////////////////// prgm goertzel ///////////////////
l=0
maxi=l
maxo=0
for p=5 to 25//détection de cycle de période de 5 à 25
    my = CALL "goertzel sous"[p]
    if my>maxi then
        per=p
        maxi=my
    endif
    if my>maxo and my<maxi then
        peri=p
        maxo=my
    endif
next
return max(per,peri),min(per,peri)

////////////// sous prgm ehlers ////////////////
a=barindex
sig=sin(360*a/11)+sin(360*a/19+90)
b=SQRT(barindex*(b+1))
b=abs((b-ROUND(b))*4)
c=b-1
sig=sig+c
cl=sig

cospart=0
sinpart=0
for n=0 to 99// fenetre de 100 barres
    cycper=(360*n)/peri
    cospart=cospart+cl[n]*cos(cycper)
    sinpart=sinpart+cl[n]*sin(cycper)
next
pwr=square(cospart)+square(sinpart)
return pwr

/////////////// prgm ehlers ///////////////
mix=0
maxpwr = CALL "sousprog dft"[8]
pero=8

for ki=9 to 30//détection de cycle de période de 9 à 30
    mys=call "sousprog dft"[ki]
    if mys>maxpwr then
        maxpwr=mys
        pero=ki
    endif
    if mys>mix and mys<maxpwr then
        mix=mys
        por=ki
    endif
next
return pero,por


Repost 0
Published by hk_lisse - dans Les Cycles
commenter cet article
11 octobre 2008 6 11 /10 /octobre /2008 21:23

La distribution des cours à l'intérieur des bandes de Bollinger.

Voici donc, toujours inspiré du RSI Generator de Elhers, la distribution des cours à l'intérieur des bandes de Bollinger, fondement de l'Analyse Dynamique.  Je ne m'attendais pas à ce genre de courbe après tout ce que j'en avais lu.  Qu'en penser ?

En pratique, je me suis servi du %Bollinger comme indicateur borné.  La valeur -1 représente le cours sous la bande basse alors que le niveau 100 donne le cours supérieur ou égal à la bande haute.  Pour le CAC : 4905 barres vues, 305 en - et  354 en +, soit 6,2% et 7,2%.



Pour le S&P 500 : 14722 barres vues, 945 en - et 1183 en +, soit 6,4% et 8%



Et pour changer de secteur, l'EURUSD : 7446 barres vues, 589 en - et 668 en +, soit 7,9% et 8,9%.



Ci-dessous les codes utilisés avec Prorealtime.  Il faut d'abord créer un sous programme avec zz en variable (50 par défaut), puis le programme lui-même.  Attention, il faut permettre pour la variable zz , une valeur de -1 (dans la subroutine) !

/////////// sous prgm ////////////
lb=BollingerDown[20](typicalprice)
ub=BollingerUp[20](typicalprice)
psn=(close-lb)/(ub-lb)*100
if zz=-1 then
    cond=psn<zz+1
elsif zz=100 then
    cond=psn>=zz
else
    cond=psn>=zz and psn<zz+1
endif
if cond=1 then
    count=count+1
endif
return count

//////////// programme /////////////////
once zz=-1
dip=dpo[204](close)
if dip=dip[1] and dip[1]=dip[2] and dip[2]<>dip[3] then
    flag=1
    endif
test= CALL "sous prgm"[zz]
if flag=1 then
    total=test
    zz=zz+1
else
    total=undefined
endif
if total>0 then
    zx=zx+total
endif
if (zz-1) mod 10 =0 then
    col=1
else
    col=-1
endif
return total coloured by col,zx/15

Repost 0
10 octobre 2008 5 10 /10 /octobre /2008 16:52

Gaussian Filter, Kalman Filter.

Dérivés de codes Tradestation, je vous présente 2 petits programmes pour lisser les cours : le filtre de Gauss et le filtre de Kalman.  Après une brève recherche sur la toile, je ne sais pas s'il sont vraiment "de Gauss" ou "de Kalman".  Il y aurait apparemment plusieurs variantes....

Voici le code du filtre de Gauss pour Prorealtime, il faut introduire "pol" (nombre de pôles, de 1 à 4) et "per" (période, par défaut 20) comme variables :

///////////// Gaussian Filter /////////////
pr=medianprice
pi=3.141592654
if pol>4 then
    pol=4
endif
if pol=2 then
    sq=SQRT(2)
elsif pol=1 then
    sq=2
elsif pol=3 then
    sq=1.12246
elsif pol=4 then
    sq=sqrt(sqrt(2))
endif
if barindex=0 then
    w=2*pi/per
    w=180*w/pi
    b=(1-cos(w))/(sq-1)
    aa=-b+sqrt(b*b+2*b)
    a1=1-aa
    a12=a1*a1
    a13=a1*a1*a1
    a14=a12*a12
    a2=aa*aa
    a3=aa*aa*aa
    a4=a2*a2
    y1=pr
    y2=y1
    y3=y2
    y4=y3
endif
if pol=1 then
    y=aa*pr+a1*y1
elsif pol=2 then
    y=a2*pr+2*a1*y1-a12*y2
elsif pol=3 then
    y=a3*pr+3*a1*y1-3*a12*y2+a13*y3
elsif pol=4 then
    y=a4*pr+4*a1*y1-6*a12*y2+4*a13*y3-a14*y4
endif
y4=y3
y3=y2
y2=y1
y1=y
gauss=y
return gauss


Et le filtre de Kalman, il faut encoder "gain" en variable (de 5 à 2000?, 500 par défaut) :

///////////// Kalman Filter ///////////////////
pr=medianprice
once pred=pr
if barindex>0 then
    dk=pr-pred
    smooth=pred+dk*SQRT((gain/10000)*2)
    velo=velo+((gain/10000)*dk)
    pred=smooth+velo
    kf=pred
endif
return kf

Ci-dessous, un vue du CAC et son joli doji, avec le filtre de Gauss (4, 20) en bleu, le filtre de Kalman (500) en vert et la version d'Elhers du filtre Kalman en rouge. 



////////////// Kalman version Ehlers ///////////////////
prix=totalprice
once kil=prix
if barindex>4 then
    kil=.33*(prix+.5*(prix-prix[3]))+.67*kil[1]
endif
return  kil
Repost 0
Published by hk_lisse - dans Indicateurs
commenter cet article